1 /* Record indices of function doc strings stored in a file.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2015 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
25 #include <sys/types.h>
26 #include <sys/file.h> /* Must be after sys/types.h for USG. */
33 #include "character.h"
38 /* Buffer used for reading from documentation file. */
39 static char *get_doc_string_buffer
;
40 static ptrdiff_t get_doc_string_buffer_size
;
42 static unsigned char *read_bytecode_pointer
;
44 static char const sibling_etc
[] = "../etc/";
46 /* `readchar' in lread.c calls back here to fetch the next byte.
47 If UNREADFLAG is 1, we unread a byte. */
50 read_bytecode_char (bool unreadflag
)
54 read_bytecode_pointer
--;
57 return *read_bytecode_pointer
++;
60 /* Extract a doc string from a file. FILEPOS says where to get it.
61 If it is an integer, use that position in the standard DOC file.
62 If it is (FILE . INTEGER), use FILE as the file name
63 and INTEGER as the position in that file.
64 But if INTEGER is negative, make it positive.
65 (A negative integer is used for user variables, so we can distinguish
66 them without actually fetching the doc string.)
68 If the location does not point to the beginning of a docstring
69 (e.g. because the file has been modified and the location is stale),
72 If UNIBYTE, always make a unibyte string.
74 If DEFINITION, assume this is for reading
75 a dynamic function definition; convert the bytestring
76 and the constants vector with appropriate byte handling,
77 and return a cons cell. */
80 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
82 char *from
, *to
, *name
, *p
, *p1
;
86 Lisp_Object file
, tem
, pos
;
90 if (INTEGERP (filepos
))
92 file
= Vdoc_file_name
;
95 else if (CONSP (filepos
))
97 file
= XCAR (filepos
);
103 position
= eabs (XINT (pos
));
105 if (!STRINGP (Vdoc_directory
))
111 /* Put the file name in NAME as a C string.
112 If it is relative, combine it with Vdoc_directory. */
114 tem
= Ffile_name_absolute_p (file
);
115 file
= ENCODE_FILE (file
);
117 = NILP (tem
) ? ENCODE_FILE (Vdoc_directory
) : empty_unibyte_string
;
118 ptrdiff_t docdir_sizemax
= SBYTES (docdir
) + 1;
120 docdir_sizemax
= max (docdir_sizemax
, sizeof sibling_etc
);
122 name
= SAFE_ALLOCA (docdir_sizemax
+ SBYTES (file
));
123 lispstpcpy (lispstpcpy (name
, docdir
), file
);
125 fd
= emacs_open (name
, O_RDONLY
, 0);
129 if (!NILP (Vpurify_flag
))
131 /* Preparing to dump; DOC file is probably not installed.
132 So check in ../etc. */
133 lispstpcpy (stpcpy (name
, sibling_etc
), file
);
135 fd
= emacs_open (name
, O_RDONLY
, 0);
141 AUTO_STRING (cannot_open
, "Cannot open doc string file \"");
142 AUTO_STRING (quote_nl
, "\"\n");
143 return concat3 (cannot_open
, file
, quote_nl
);
146 count
= SPECPDL_INDEX ();
147 record_unwind_protect_int (close_file_unwind
, fd
);
149 /* Seek only to beginning of disk block. */
150 /* Make sure we read at least 1024 bytes before `position'
151 so we can check the leading text for consistency. */
152 offset
= min (position
, max (1024, position
% (8 * 1024)));
153 if (TYPE_MAXIMUM (off_t
) < position
154 || lseek (fd
, position
- offset
, 0) < 0)
155 error ("Position %"pI
"d out of range in doc string file \"%s\"",
158 /* Read the doc string into get_doc_string_buffer.
159 P points beyond the data just read. */
161 p
= get_doc_string_buffer
;
164 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
165 - (p
- get_doc_string_buffer
));
168 /* Allocate or grow the buffer if we need to. */
171 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
172 get_doc_string_buffer
173 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
175 p
= get_doc_string_buffer
+ in_buffer
;
176 space_left
= (get_doc_string_buffer_size
- 1
177 - (p
- get_doc_string_buffer
));
180 /* Read a disk block at a time.
181 If we read the same block last time, maybe skip this? */
182 if (space_left
> 1024 * 8)
183 space_left
= 1024 * 8;
184 nread
= emacs_read (fd
, p
, space_left
);
186 report_file_error ("Read error on documentation file", file
);
190 if (p
== get_doc_string_buffer
)
191 p1
= strchr (p
+ offset
, '\037');
193 p1
= strchr (p
, '\037');
202 unbind_to (count
, Qnil
);
205 /* Sanity checking. */
209 /* A dynamic docstring should be either at the very beginning of a "#@
210 comment" or right after a dynamic docstring delimiter (in case we
211 pack several such docstrings within the same comment). */
212 if (get_doc_string_buffer
[offset
- test
] != '\037')
214 if (get_doc_string_buffer
[offset
- test
++] != ' ')
216 while (get_doc_string_buffer
[offset
- test
] >= '0'
217 && get_doc_string_buffer
[offset
- test
] <= '9')
219 if (get_doc_string_buffer
[offset
- test
++] != '@'
220 || get_doc_string_buffer
[offset
- test
] != '#')
227 if (get_doc_string_buffer
[offset
- test
++] != '\n')
229 while (get_doc_string_buffer
[offset
- test
] > ' ')
231 if (get_doc_string_buffer
[offset
- test
] != '\037')
235 /* Scan the text and perform quoting with ^A (char code 1).
236 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
237 from
= get_doc_string_buffer
+ offset
;
238 to
= get_doc_string_buffer
+ offset
;
255 unsigned char uc
= c
;
257 Invalid data in documentation file -- %c followed by code %03o",
265 /* If DEFINITION, read from this buffer
266 the same way we would read bytes from a file. */
269 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
270 return Fread (Qlambda
);
274 return make_unibyte_string (get_doc_string_buffer
+ offset
,
275 to
- (get_doc_string_buffer
+ offset
));
278 /* The data determines whether the string is multibyte. */
280 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
282 to
- (get_doc_string_buffer
+ offset
));
283 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
285 to
- (get_doc_string_buffer
+ offset
));
289 /* Get a string from position FILEPOS and pass it through the Lisp reader.
290 We use this for fetching the bytecode string and constants vector
291 of a compiled function from the .elc file. */
294 read_doc_string (Lisp_Object filepos
)
296 return get_doc_string (filepos
, 0, 1);
300 reread_doc_file (Lisp_Object file
)
303 Fsnarf_documentation (Vdoc_file_name
);
305 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
310 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
311 doc
: /* Return the documentation string of FUNCTION.
312 Unless a non-nil second argument RAW is given, the
313 string is passed through `substitute-command-keys'. */)
314 (Lisp_Object function
, Lisp_Object raw
)
325 if (SYMBOLP (function
))
327 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
329 return Fdocumentation_property (function
, Qfunction_documentation
,
333 fun
= Findirect_function (function
, Qnil
);
334 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
338 if (XSUBR (fun
)->doc
== 0)
340 /* FIXME: This is not portable, as it assumes that string
341 pointers have the top bit clear. */
342 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
343 doc
= build_string (XSUBR (fun
)->doc
);
345 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
347 else if (COMPILEDP (fun
))
349 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
353 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
356 else if (NATNUMP (tem
) || CONSP (tem
))
362 else if (STRINGP (fun
) || VECTORP (fun
))
364 return build_string ("Keyboard macro.");
366 else if (CONSP (fun
))
369 if (!SYMBOLP (funcar
))
370 xsignal1 (Qinvalid_function
, fun
);
371 else if (EQ (funcar
, Qkeymap
))
372 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
373 else if (EQ (funcar
, Qlambda
)
374 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
375 || EQ (funcar
, Qautoload
))
377 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
378 Lisp_Object tem
= Fcar (tem1
);
381 /* Handle a doc reference--but these never come last
382 in the function body, so reject them if they are last. */
383 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
384 && !NILP (XCDR (tem1
)))
395 xsignal1 (Qinvalid_function
, fun
);
398 /* If DOC is 0, it's typically because of a dumped file missing
399 from the DOC file (bug in src/Makefile.in). */
400 if (EQ (doc
, make_number (0)))
402 if (INTEGERP (doc
) || CONSP (doc
))
405 tem
= get_doc_string (doc
, 0, 0);
406 if (NILP (tem
) && try_reload
)
408 /* The file is newer, we need to reset the pointers. */
409 struct gcpro gcpro1
, gcpro2
;
410 GCPRO2 (function
, raw
);
411 try_reload
= reread_doc_file (Fcar_safe (doc
));
424 doc
= Fsubstitute_command_keys (doc
);
428 DEFUN ("documentation-property", Fdocumentation_property
,
429 Sdocumentation_property
, 2, 3, 0,
430 doc
: /* Return the documentation string that is SYMBOL's PROP property.
431 Third argument RAW omitted or nil means pass the result through
432 `substitute-command-keys' if it is a string.
434 This differs from `get' in that it can refer to strings stored in the
435 `etc/DOC' file; and that it evaluates documentation properties that
437 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
442 documentation_property
:
444 tem
= Fget (symbol
, prop
);
445 if (EQ (tem
, make_number (0)))
447 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
449 Lisp_Object doc
= tem
;
450 tem
= get_doc_string (tem
, 0, 0);
451 if (NILP (tem
) && try_reload
)
453 /* The file is newer, we need to reset the pointers. */
454 struct gcpro gcpro1
, gcpro2
, gcpro3
;
455 GCPRO3 (symbol
, prop
, raw
);
456 try_reload
= reread_doc_file (Fcar_safe (doc
));
461 goto documentation_property
;
465 else if (!STRINGP (tem
))
466 /* Feval protects its argument. */
467 tem
= Feval (tem
, Qnil
);
469 if (NILP (raw
) && STRINGP (tem
))
470 tem
= Fsubstitute_command_keys (tem
);
474 /* Scanning the DOC files and placing docstring offsets into functions. */
477 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
479 /* Don't use indirect_function here, or defaliases will apply their
480 docstrings to the base functions (Bug#2603). */
481 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
483 /* The type determines where the docstring is stored. */
485 /* Lisp_Subrs have a slot for it. */
488 intptr_t negative_offset
= - offset
;
489 XSUBR (fun
)->doc
= (char *) negative_offset
;
492 /* If it's a lisp form, stick it in the form. */
493 else if (CONSP (fun
))
498 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
499 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
501 tem
= Fcdr (Fcdr (fun
));
502 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
503 /* FIXME: This modifies typically pure hash-cons'd data, so its
504 correctness is quite delicate. */
505 XSETCAR (tem
, make_number (offset
));
507 else if (EQ (tem
, Qmacro
))
508 store_function_docstring (XCDR (fun
), offset
);
511 /* Bytecode objects sometimes have slots for it. */
512 else if (COMPILEDP (fun
))
514 /* This bytecode object must have a slot for the
515 docstring, since we've found a docstring for it. */
516 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
517 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
520 AUTO_STRING (format
, "No docstring slot for %s");
521 CALLN (Fmessage
, format
,
524 : build_string ("<anonymous>")));
530 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
532 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
533 This searches the `etc/DOC...' file for doc strings and
534 records them in function and variable definitions.
535 The function takes one argument, FILENAME, a string;
536 it specifies the file name (without a directory) of the DOC file.
537 That file is found in `../etc' now; later, when the dumped Emacs is run,
538 the same file name is found in the `doc-directory'. */)
539 (Lisp_Object filename
)
551 /* Preloaded defcustoms using custom-initialize-delay are added to
552 this list, but kept unbound. See http://debbugs.gnu.org/11565 */
553 Lisp_Object delayed_init
=
554 find_symbol_value (intern ("custom-delayed-init-variables"));
556 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
558 CHECK_STRING (filename
);
562 (!NILP (Vpurify_flag
))
563 #else /* CANNOT_DUMP */
565 #endif /* CANNOT_DUMP */
567 dirname
= sibling_etc
;
568 dirlen
= sizeof sibling_etc
- 1;
572 CHECK_STRING (Vdoc_directory
);
573 dirname
= SSDATA (Vdoc_directory
);
574 dirlen
= SBYTES (Vdoc_directory
);
577 count
= SPECPDL_INDEX ();
579 name
= SAFE_ALLOCA (dirlen
+ SBYTES (filename
) + 1);
580 lispstpcpy (stpcpy (name
, dirname
), filename
); /*** Add this line ***/
582 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
583 if (NILP (Vbuild_files
))
585 static char const *const buildobj
[] =
587 #include "buildobj.h"
589 int i
= ARRAYELTS (buildobj
);
591 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
592 Vbuild_files
= Fpurecopy (Vbuild_files
);
595 fd
= emacs_open (name
, O_RDONLY
, 0);
598 int open_errno
= errno
;
599 report_file_errno ("Opening doc string file", build_string (name
),
602 record_unwind_protect_int (close_file_unwind
, fd
);
603 Vdoc_file_name
= filename
;
610 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
615 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
616 p
= memchr (buf
, '\037', end
- buf
);
617 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
620 end
= strchr (p
, '\n');
622 /* See if this is a file name, and if it is a file in build-files. */
626 if (end
- p
> 4 && end
[-2] == '.'
627 && (end
[-1] == 'o' || end
[-1] == 'c'))
629 ptrdiff_t len
= end
- p
- 2;
630 char *fromfile
= SAFE_ALLOCA (len
+ 1);
631 memcpy (fromfile
, &p
[2], len
);
633 if (fromfile
[len
-1] == 'c')
634 fromfile
[len
-1] = 'o';
636 skip_file
= NILP (Fmember (build_string (fromfile
),
641 sym
= oblookup (Vobarray
, p
+ 2,
642 multibyte_chars_in_text ((unsigned char *) p
+ 2,
645 /* Check skip_file so that when a function is defined several
646 times in different files (typically, once in xterm, once in
647 w32term, ...), we only pay attention to the one that
649 if (! skip_file
&& SYMBOLP (sym
))
651 /* Attach a docstring to a variable? */
654 /* Install file-position as variable-documentation property
655 and make it negative for a user-variable
656 (doc starts with a `*'). */
657 if (!NILP (Fboundp (sym
))
658 || !NILP (Fmemq (sym
, delayed_init
)))
659 Fput (sym
, Qvariable_documentation
,
660 make_number ((pos
+ end
+ 1 - buf
)
661 * (end
[1] == '*' ? -1 : 1)));
664 /* Attach a docstring to a function? */
665 else if (p
[1] == 'F')
667 if (!NILP (Ffboundp (sym
)))
668 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
670 else if (p
[1] == 'S')
671 ; /* Just a source file name boundary marker. Ignore it. */
674 error ("DOC file invalid at position %"pI
"d", pos
);
679 memmove (buf
, end
, filled
);
683 return unbind_to (count
, Qnil
);
686 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
687 Ssubstitute_command_keys
, 1, 1, 0,
688 doc
: /* Substitute key descriptions for command names in STRING.
689 Each substring of the form \\=\\[COMMAND] is replaced by either a
690 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
693 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
694 the value of MAPVAR as a keymap. This summary is similar to the one
695 produced by `describe-bindings'. The summary ends in two newlines
696 \(used by the helper function `help-make-xrefs' to find the end of the
699 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
700 as the keymap for future \\=\\[COMMAND] substrings.
702 Each \\=` is replaced by ‘. Each ' preceded by \\=` and without
703 intervening ' is replaced by ’.
705 \\=\\= quotes the following character and is discarded; thus,
706 \\=\\=\\=\\= puts \\=\\= into the output, \\=\\=\\=\\[ puts \\=\\[ into the output, and
707 \\=\\=\\=` puts \\=` into the output.
709 Return the original STRING if no substitutions are made.
710 Otherwise, return a new string. */)
714 bool changed
= false;
715 bool in_quote
= false;
722 unsigned char *start
;
723 ptrdiff_t length
, length_byte
;
725 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
732 CHECK_STRING (string
);
736 GCPRO4 (string
, tem
, keymap
, name
);
738 multibyte
= STRING_MULTIBYTE (string
);
741 /* KEYMAP is either nil (which means search all the active keymaps)
742 or a specified local map (which means search just that and the
743 global map). If non-nil, it might come from Voverriding_local_map,
744 or from a \\<mapname> construct in STRING itself.. */
745 keymap
= Voverriding_local_map
;
747 bsize
= SBYTES (string
);
749 /* Add some room for expansion due to quote replacement. */
750 enum { EXTRA_ROOM
= 20 };
751 if (bsize
<= STRING_BYTES_BOUND
- EXTRA_ROOM
)
754 bufp
= buf
= xmalloc (bsize
);
756 strp
= SDATA (string
);
757 while (strp
< SDATA (string
) + SBYTES (string
))
759 if (strp
[0] == '\\' && strp
[1] == '=')
761 /* \= quotes the next character;
762 thus, to put in \[ without its special meaning, use \=\[. */
769 STRING_CHAR_AND_LENGTH (strp
, len
);
773 memcpy (bufp
, strp
, len
);
779 *bufp
++ = *strp
++, nchars
++;
781 else if (strp
[0] == '\\' && strp
[1] == '[')
784 bool follow_remap
= 1;
786 strp
+= 2; /* skip \[ */
788 start_idx
= start
- SDATA (string
);
790 while ((strp
- SDATA (string
)
794 length_byte
= strp
- start
;
798 /* Save STRP in IDX. */
799 idx
= strp
- SDATA (string
);
800 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
803 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
805 if (VECTORP (tem
) && ASIZE (tem
) > 1
806 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
809 name
= AREF (tem
, 1);
814 /* Note the Fwhere_is_internal can GC, so we have to take
815 relocation of string contents into account. */
816 strp
= SDATA (string
) + idx
;
817 start
= SDATA (string
) + start_idx
;
819 if (NILP (tem
)) /* but not on any keys */
821 ptrdiff_t offset
= bufp
- buf
;
822 if (STRING_BYTES_BOUND
- 4 < bsize
)
824 buf
= xrealloc (buf
, bsize
+= 4);
826 memcpy (bufp
, "M-x ", 4);
830 length
= multibyte_chars_in_text (start
, length_byte
);
832 length
= length_byte
;
836 { /* function is on a key */
837 tem
= Fkey_description (tem
, Qnil
);
841 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
842 \<foo> just sets the keymap used for \[cmd]. */
843 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
845 struct buffer
*oldbuf
;
847 /* This is for computing the SHADOWS arg for describe_map_tree. */
848 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
849 Lisp_Object earlier_maps
;
850 ptrdiff_t count
= SPECPDL_INDEX ();
852 strp
+= 2; /* skip \{ or \< */
854 start_idx
= start
- SDATA (string
);
856 while ((strp
- SDATA (string
) < SBYTES (string
))
857 && *strp
!= '}' && *strp
!= '>')
860 length_byte
= strp
- start
;
861 strp
++; /* skip } or > */
863 /* Save STRP in IDX. */
864 idx
= strp
- SDATA (string
);
866 /* Get the value of the keymap in TEM, or nil if undefined.
867 Do this while still in the user's current buffer
868 in case it is a local variable. */
869 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
870 tem
= Fboundp (name
);
873 tem
= Fsymbol_value (name
);
876 tem
= get_keymap (tem
, 0, 1);
877 /* Note that get_keymap can GC. */
878 strp
= SDATA (string
) + idx
;
879 start
= SDATA (string
) + start_idx
;
883 /* Now switch to a temp buffer. */
884 oldbuf
= current_buffer
;
885 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
886 /* This is for an unusual case where some after-change
887 function uses 'format' or 'prin1' or something else that
888 will thrash Vprin1_to_string_buffer we are using. */
889 specbind (Qinhibit_modification_hooks
, Qt
);
893 name
= Fsymbol_name (name
);
894 insert_string ("\nUses keymap `");
895 insert_from_string (name
, 0, 0,
898 insert_string ("', which is not currently defined.\n");
899 if (start
[-1] == '<') keymap
= Qnil
;
901 else if (start
[-1] == '<')
905 /* Get the list of active keymaps that precede this one.
906 If this one's not active, get nil. */
907 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
908 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
909 Qnil
, 0, 1, 0, 0, 1);
911 tem
= Fbuffer_string ();
913 set_buffer_internal (oldbuf
);
914 unbind_to (count
, Qnil
);
918 length
= SCHARS (tem
);
919 length_byte
= SBYTES (tem
);
923 ptrdiff_t offset
= bufp
- buf
;
924 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
926 buf
= xrealloc (buf
, bsize
+= length_byte
);
928 memcpy (bufp
, start
, length_byte
);
931 /* Check STRING again in case gc relocated it. */
932 strp
= SDATA (string
) + idx
;
935 else if (strp
[0] == '`')
938 start
= (unsigned char *) "\xE2\x80\x98"; /* ‘ */
942 idx
= strp
- SDATA (string
) + 1;
945 else if (strp
[0] == '\'' && in_quote
)
948 start
= (unsigned char *) "\xE2\x80\x99"; /* ’ */
951 else if (! multibyte
) /* just copy other chars */
952 *bufp
++ = *strp
++, nchars
++;
957 STRING_CHAR_AND_LENGTH (strp
, len
);
961 memcpy (bufp
, strp
, len
);
968 if (changed
) /* don't bother if nothing substituted */
969 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
973 RETURN_UNGCPRO (tem
);
979 DEFSYM (Qfunction_documentation
, "function-documentation");
981 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
982 doc
: /* Name of file containing documentation strings of built-in symbols. */);
983 Vdoc_file_name
= Qnil
;
985 DEFVAR_LISP ("build-files", Vbuild_files
,
986 doc
: /* A list of files used to build this Emacs binary. */);
989 defsubr (&Sdocumentation
);
990 defsubr (&Sdocumentation_property
);
991 defsubr (&Ssnarf_documentation
);
992 defsubr (&Ssubstitute_command_keys
);