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 Lisp_Object Qfunction_documentation
;
40 /* Buffer used for reading from documentation file. */
41 static char *get_doc_string_buffer
;
42 static ptrdiff_t get_doc_string_buffer_size
;
44 static unsigned char *read_bytecode_pointer
;
46 static char const sibling_etc
[] = "../etc/";
48 /* `readchar' in lread.c calls back here to fetch the next byte.
49 If UNREADFLAG is 1, we unread a byte. */
52 read_bytecode_char (bool unreadflag
)
56 read_bytecode_pointer
--;
59 return *read_bytecode_pointer
++;
62 /* Extract a doc string from a file. FILEPOS says where to get it.
63 If it is an integer, use that position in the standard DOC file.
64 If it is (FILE . INTEGER), use FILE as the file name
65 and INTEGER as the position in that file.
66 But if INTEGER is negative, make it positive.
67 (A negative integer is used for user variables, so we can distinguish
68 them without actually fetching the doc string.)
70 If the location does not point to the beginning of a docstring
71 (e.g. because the file has been modified and the location is stale),
74 If UNIBYTE, always make a unibyte string.
76 If DEFINITION, assume this is for reading
77 a dynamic function definition; convert the bytestring
78 and the constants vector with appropriate byte handling,
79 and return a cons cell. */
82 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
84 char *from
, *to
, *name
, *p
, *p1
;
88 Lisp_Object file
, tem
, pos
;
92 if (INTEGERP (filepos
))
94 file
= Vdoc_file_name
;
97 else if (CONSP (filepos
))
99 file
= XCAR (filepos
);
100 pos
= XCDR (filepos
);
105 position
= eabs (XINT (pos
));
107 if (!STRINGP (Vdoc_directory
))
113 /* Put the file name in NAME as a C string.
114 If it is relative, combine it with Vdoc_directory. */
116 tem
= Ffile_name_absolute_p (file
);
117 file
= ENCODE_FILE (file
);
119 = NILP (tem
) ? ENCODE_FILE (Vdoc_directory
) : empty_unibyte_string
;
120 ptrdiff_t docdir_sizemax
= SBYTES (docdir
) + 1;
122 docdir_sizemax
= max (docdir_sizemax
, sizeof sibling_etc
);
124 name
= SAFE_ALLOCA (docdir_sizemax
+ SBYTES (file
));
125 lispstpcpy (lispstpcpy (name
, docdir
), file
);
127 fd
= emacs_open (name
, O_RDONLY
, 0);
131 if (!NILP (Vpurify_flag
))
133 /* Preparing to dump; DOC file is probably not installed.
134 So check in ../etc. */
135 lispstpcpy (stpcpy (name
, sibling_etc
), file
);
137 fd
= emacs_open (name
, O_RDONLY
, 0);
143 AUTO_STRING (cannot_open
, "Cannot open doc string file \"");
144 AUTO_STRING (quote_nl
, "\"\n");
145 return concat3 (cannot_open
, file
, quote_nl
);
148 count
= SPECPDL_INDEX ();
149 record_unwind_protect_int (close_file_unwind
, fd
);
151 /* Seek only to beginning of disk block. */
152 /* Make sure we read at least 1024 bytes before `position'
153 so we can check the leading text for consistency. */
154 offset
= min (position
, max (1024, position
% (8 * 1024)));
155 if (TYPE_MAXIMUM (off_t
) < position
156 || lseek (fd
, position
- offset
, 0) < 0)
157 error ("Position %"pI
"d out of range in doc string file \"%s\"",
160 /* Read the doc string into get_doc_string_buffer.
161 P points beyond the data just read. */
163 p
= get_doc_string_buffer
;
166 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
167 - (p
- get_doc_string_buffer
));
170 /* Allocate or grow the buffer if we need to. */
173 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
174 get_doc_string_buffer
175 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
177 p
= get_doc_string_buffer
+ in_buffer
;
178 space_left
= (get_doc_string_buffer_size
- 1
179 - (p
- get_doc_string_buffer
));
182 /* Read a disk block at a time.
183 If we read the same block last time, maybe skip this? */
184 if (space_left
> 1024 * 8)
185 space_left
= 1024 * 8;
186 nread
= emacs_read (fd
, p
, space_left
);
188 report_file_error ("Read error on documentation file", file
);
192 if (p
== get_doc_string_buffer
)
193 p1
= strchr (p
+ offset
, '\037');
195 p1
= strchr (p
, '\037');
204 unbind_to (count
, Qnil
);
207 /* Sanity checking. */
211 /* A dynamic docstring should be either at the very beginning of a "#@
212 comment" or right after a dynamic docstring delimiter (in case we
213 pack several such docstrings within the same comment). */
214 if (get_doc_string_buffer
[offset
- test
] != '\037')
216 if (get_doc_string_buffer
[offset
- test
++] != ' ')
218 while (get_doc_string_buffer
[offset
- test
] >= '0'
219 && get_doc_string_buffer
[offset
- test
] <= '9')
221 if (get_doc_string_buffer
[offset
- test
++] != '@'
222 || get_doc_string_buffer
[offset
- test
] != '#')
229 if (get_doc_string_buffer
[offset
- test
++] != '\n')
231 while (get_doc_string_buffer
[offset
- test
] > ' ')
233 if (get_doc_string_buffer
[offset
- test
] != '\037')
237 /* Scan the text and perform quoting with ^A (char code 1).
238 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
239 from
= get_doc_string_buffer
+ offset
;
240 to
= get_doc_string_buffer
+ offset
;
257 unsigned char uc
= c
;
259 Invalid data in documentation file -- %c followed by code %03o",
267 /* If DEFINITION, read from this buffer
268 the same way we would read bytes from a file. */
271 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
272 return Fread (Qlambda
);
276 return make_unibyte_string (get_doc_string_buffer
+ offset
,
277 to
- (get_doc_string_buffer
+ offset
));
280 /* The data determines whether the string is multibyte. */
282 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
284 to
- (get_doc_string_buffer
+ offset
));
285 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
287 to
- (get_doc_string_buffer
+ offset
));
291 /* Get a string from position FILEPOS and pass it through the Lisp reader.
292 We use this for fetching the bytecode string and constants vector
293 of a compiled function from the .elc file. */
296 read_doc_string (Lisp_Object filepos
)
298 return get_doc_string (filepos
, 0, 1);
302 reread_doc_file (Lisp_Object file
)
305 Lisp_Object reply
, prompt
[3];
308 prompt
[0] = build_string ("File ");
309 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
310 prompt
[2] = build_string (" is out of sync. Reload? ");
311 reply
= Fy_or_n_p (Fconcat (3, prompt
));
318 Fsnarf_documentation (Vdoc_file_name
);
320 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
325 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
326 doc
: /* Return the documentation string of FUNCTION.
327 Unless a non-nil second argument RAW is given, the
328 string is passed through `substitute-command-keys'. */)
329 (Lisp_Object function
, Lisp_Object raw
)
340 if (SYMBOLP (function
))
342 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
344 return Fdocumentation_property (function
, Qfunction_documentation
,
348 fun
= Findirect_function (function
, Qnil
);
349 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
353 if (XSUBR (fun
)->doc
== 0)
355 /* FIXME: This is not portable, as it assumes that string
356 pointers have the top bit clear. */
357 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
358 doc
= build_string (XSUBR (fun
)->doc
);
360 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
362 else if (COMPILEDP (fun
))
364 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
368 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
371 else if (NATNUMP (tem
) || CONSP (tem
))
377 else if (STRINGP (fun
) || VECTORP (fun
))
379 return build_string ("Keyboard macro.");
381 else if (CONSP (fun
))
384 if (!SYMBOLP (funcar
))
385 xsignal1 (Qinvalid_function
, fun
);
386 else if (EQ (funcar
, Qkeymap
))
387 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
388 else if (EQ (funcar
, Qlambda
)
389 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
390 || EQ (funcar
, Qautoload
))
392 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
393 Lisp_Object tem
= Fcar (tem1
);
396 /* Handle a doc reference--but these never come last
397 in the function body, so reject them if they are last. */
398 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
399 && !NILP (XCDR (tem1
)))
410 xsignal1 (Qinvalid_function
, fun
);
413 /* If DOC is 0, it's typically because of a dumped file missing
414 from the DOC file (bug in src/Makefile.in). */
415 if (EQ (doc
, make_number (0)))
417 if (INTEGERP (doc
) || CONSP (doc
))
420 tem
= get_doc_string (doc
, 0, 0);
421 if (NILP (tem
) && try_reload
)
423 /* The file is newer, we need to reset the pointers. */
424 struct gcpro gcpro1
, gcpro2
;
425 GCPRO2 (function
, raw
);
426 try_reload
= reread_doc_file (Fcar_safe (doc
));
439 doc
= Fsubstitute_command_keys (doc
);
443 DEFUN ("documentation-property", Fdocumentation_property
,
444 Sdocumentation_property
, 2, 3, 0,
445 doc
: /* Return the documentation string that is SYMBOL's PROP property.
446 Third argument RAW omitted or nil means pass the result through
447 `substitute-command-keys' if it is a string.
449 This differs from `get' in that it can refer to strings stored in the
450 `etc/DOC' file; and that it evaluates documentation properties that
452 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
457 documentation_property
:
459 tem
= Fget (symbol
, prop
);
460 if (EQ (tem
, make_number (0)))
462 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
464 Lisp_Object doc
= tem
;
465 tem
= get_doc_string (tem
, 0, 0);
466 if (NILP (tem
) && try_reload
)
468 /* The file is newer, we need to reset the pointers. */
469 struct gcpro gcpro1
, gcpro2
, gcpro3
;
470 GCPRO3 (symbol
, prop
, raw
);
471 try_reload
= reread_doc_file (Fcar_safe (doc
));
476 goto documentation_property
;
480 else if (!STRINGP (tem
))
481 /* Feval protects its argument. */
482 tem
= Feval (tem
, Qnil
);
484 if (NILP (raw
) && STRINGP (tem
))
485 tem
= Fsubstitute_command_keys (tem
);
489 /* Scanning the DOC files and placing docstring offsets into functions. */
492 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
494 /* Don't use indirect_function here, or defaliases will apply their
495 docstrings to the base functions (Bug#2603). */
496 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
498 /* The type determines where the docstring is stored. */
500 /* Lisp_Subrs have a slot for it. */
503 intptr_t negative_offset
= - offset
;
504 XSUBR (fun
)->doc
= (char *) negative_offset
;
507 /* If it's a lisp form, stick it in the form. */
508 else if (CONSP (fun
))
513 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
514 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
516 tem
= Fcdr (Fcdr (fun
));
517 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
518 /* FIXME: This modifies typically pure hash-cons'd data, so its
519 correctness is quite delicate. */
520 XSETCAR (tem
, make_number (offset
));
522 else if (EQ (tem
, Qmacro
))
523 store_function_docstring (XCDR (fun
), offset
);
526 /* Bytecode objects sometimes have slots for it. */
527 else if (COMPILEDP (fun
))
529 /* This bytecode object must have a slot for the
530 docstring, since we've found a docstring for it. */
531 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
532 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
534 message ("No docstring slot for %s",
535 SYMBOLP (obj
) ? SSDATA (SYMBOL_NAME (obj
)) : "<anonymous>");
540 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
542 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
543 This searches the `etc/DOC...' file for doc strings and
544 records them in function and variable definitions.
545 The function takes one argument, FILENAME, a string;
546 it specifies the file name (without a directory) of the DOC file.
547 That file is found in `../etc' now; later, when the dumped Emacs is run,
548 the same file name is found in the `doc-directory'. */)
549 (Lisp_Object filename
)
561 /* Preloaded defcustoms using custom-initialize-delay are added to
562 this list, but kept unbound. See http://debbugs.gnu.org/11565 */
563 Lisp_Object delayed_init
=
564 find_symbol_value (intern ("custom-delayed-init-variables"));
566 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
568 CHECK_STRING (filename
);
572 (!NILP (Vpurify_flag
))
573 #else /* CANNOT_DUMP */
575 #endif /* CANNOT_DUMP */
577 dirname
= sibling_etc
;
578 dirlen
= sizeof sibling_etc
- 1;
582 CHECK_STRING (Vdoc_directory
);
583 dirname
= SSDATA (Vdoc_directory
);
584 dirlen
= SBYTES (Vdoc_directory
);
587 count
= SPECPDL_INDEX ();
589 name
= SAFE_ALLOCA (dirlen
+ SBYTES (filename
) + 1);
590 lispstpcpy (stpcpy (name
, dirname
), filename
); /*** Add this line ***/
592 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
593 if (NILP (Vbuild_files
))
595 static char const *const buildobj
[] =
597 #include "buildobj.h"
599 int i
= ARRAYELTS (buildobj
);
601 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
602 Vbuild_files
= Fpurecopy (Vbuild_files
);
605 fd
= emacs_open (name
, O_RDONLY
, 0);
608 int open_errno
= errno
;
609 report_file_errno ("Opening doc string file", build_string (name
),
612 record_unwind_protect_int (close_file_unwind
, fd
);
613 Vdoc_file_name
= filename
;
620 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
625 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
626 p
= memchr (buf
, '\037', end
- buf
);
627 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
630 end
= strchr (p
, '\n');
632 /* See if this is a file name, and if it is a file in build-files. */
636 if (end
- p
> 4 && end
[-2] == '.'
637 && (end
[-1] == 'o' || end
[-1] == 'c'))
639 ptrdiff_t len
= end
- p
- 2;
640 char *fromfile
= SAFE_ALLOCA (len
+ 1);
641 memcpy (fromfile
, &p
[2], len
);
643 if (fromfile
[len
-1] == 'c')
644 fromfile
[len
-1] = 'o';
646 skip_file
= NILP (Fmember (build_string (fromfile
),
651 sym
= oblookup (Vobarray
, p
+ 2,
652 multibyte_chars_in_text ((unsigned char *) p
+ 2,
655 /* Check skip_file so that when a function is defined several
656 times in different files (typically, once in xterm, once in
657 w32term, ...), we only pay attention to the one that
659 if (! skip_file
&& SYMBOLP (sym
))
661 /* Attach a docstring to a variable? */
664 /* Install file-position as variable-documentation property
665 and make it negative for a user-variable
666 (doc starts with a `*'). */
667 if (!NILP (Fboundp (sym
))
668 || !NILP (Fmemq (sym
, delayed_init
)))
669 Fput (sym
, Qvariable_documentation
,
670 make_number ((pos
+ end
+ 1 - buf
)
671 * (end
[1] == '*' ? -1 : 1)));
674 /* Attach a docstring to a function? */
675 else if (p
[1] == 'F')
677 if (!NILP (Ffboundp (sym
)))
678 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
680 else if (p
[1] == 'S')
681 ; /* Just a source file name boundary marker. Ignore it. */
684 error ("DOC file invalid at position %"pI
"d", pos
);
689 memmove (buf
, end
, filled
);
693 return unbind_to (count
, Qnil
);
696 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
697 Ssubstitute_command_keys
, 1, 1, 0,
698 doc
: /* Substitute key descriptions for command names in STRING.
699 Each substring of the form \\=\\[COMMAND] is replaced by either a
700 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
703 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
704 the value of MAPVAR as a keymap. This summary is similar to the one
705 produced by `describe-bindings'. The summary ends in two newlines
706 \(used by the helper function `help-make-xrefs' to find the end of the
709 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
710 as the keymap for future \\=\\[COMMAND] substrings.
711 \\=\\= quotes the following character and is discarded;
712 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
714 Return the original STRING if no substitutions are made.
715 Otherwise, return a new string. */)
726 unsigned char *start
;
727 ptrdiff_t length
, length_byte
;
729 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
736 CHECK_STRING (string
);
740 GCPRO4 (string
, tem
, keymap
, name
);
742 multibyte
= STRING_MULTIBYTE (string
);
745 /* KEYMAP is either nil (which means search all the active keymaps)
746 or a specified local map (which means search just that and the
747 global map). If non-nil, it might come from Voverriding_local_map,
748 or from a \\<mapname> construct in STRING itself.. */
749 keymap
= Voverriding_local_map
;
751 bsize
= SBYTES (string
);
752 bufp
= buf
= xmalloc (bsize
);
754 strp
= SDATA (string
);
755 while (strp
< SDATA (string
) + SBYTES (string
))
757 if (strp
[0] == '\\' && strp
[1] == '=')
759 /* \= quotes the next character;
760 thus, to put in \[ without its special meaning, use \=\[. */
767 STRING_CHAR_AND_LENGTH (strp
, len
);
771 memcpy (bufp
, strp
, len
);
777 *bufp
++ = *strp
++, nchars
++;
779 else if (strp
[0] == '\\' && strp
[1] == '[')
782 bool follow_remap
= 1;
785 strp
+= 2; /* skip \[ */
787 start_idx
= start
- SDATA (string
);
789 while ((strp
- SDATA (string
)
793 length_byte
= strp
- start
;
797 /* Save STRP in IDX. */
798 idx
= strp
- SDATA (string
);
799 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
802 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
804 if (VECTORP (tem
) && ASIZE (tem
) > 1
805 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
808 name
= AREF (tem
, 1);
813 /* Note the Fwhere_is_internal can GC, so we have to take
814 relocation of string contents into account. */
815 strp
= SDATA (string
) + idx
;
816 start
= SDATA (string
) + start_idx
;
818 if (NILP (tem
)) /* but not on any keys */
820 ptrdiff_t offset
= bufp
- buf
;
821 if (STRING_BYTES_BOUND
- 4 < bsize
)
823 buf
= xrealloc (buf
, bsize
+= 4);
825 memcpy (bufp
, "M-x ", 4);
829 length
= multibyte_chars_in_text (start
, length_byte
);
831 length
= length_byte
;
835 { /* function is on a key */
836 tem
= Fkey_description (tem
, Qnil
);
840 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
841 \<foo> just sets the keymap used for \[cmd]. */
842 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
844 struct buffer
*oldbuf
;
846 /* This is for computing the SHADOWS arg for describe_map_tree. */
847 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
848 Lisp_Object earlier_maps
;
849 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
);
922 ptrdiff_t offset
= bufp
- buf
;
923 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
925 buf
= xrealloc (buf
, bsize
+= length_byte
);
927 memcpy (bufp
, start
, length_byte
);
930 /* Check STRING again in case gc relocated it. */
931 strp
= SDATA (string
) + idx
;
934 else if (! multibyte
) /* just copy other chars */
935 *bufp
++ = *strp
++, nchars
++;
940 STRING_CHAR_AND_LENGTH (strp
, len
);
944 memcpy (bufp
, strp
, len
);
951 if (changed
) /* don't bother if nothing substituted */
952 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
956 RETURN_UNGCPRO (tem
);
962 DEFSYM (Qfunction_documentation
, "function-documentation");
964 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
965 doc
: /* Name of file containing documentation strings of built-in symbols. */);
966 Vdoc_file_name
= Qnil
;
968 DEFVAR_LISP ("build-files", Vbuild_files
,
969 doc
: /* A list of files used to build this Emacs binary. */);
972 defsubr (&Sdocumentation
);
973 defsubr (&Sdocumentation_property
);
974 defsubr (&Ssnarf_documentation
);
975 defsubr (&Ssubstitute_command_keys
);