1 /* Record indices of function doc strings stored in a file.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
25 #include <sys/file.h> /* Must be after sys/types.h for USG. */
32 #include "character.h"
37 Lisp_Object Qfunction_documentation
;
39 /* Buffer used for reading from documentation file. */
40 static char *get_doc_string_buffer
;
41 static ptrdiff_t get_doc_string_buffer_size
;
43 static unsigned char *read_bytecode_pointer
;
45 static char const sibling_etc
[] = "../etc/";
47 /* `readchar' in lread.c calls back here to fetch the next byte.
48 If UNREADFLAG is 1, we unread a byte. */
51 read_bytecode_char (bool unreadflag
)
55 read_bytecode_pointer
--;
58 return *read_bytecode_pointer
++;
61 /* Extract a doc string from a file. FILEPOS says where to get it.
62 If it is an integer, use that position in the standard DOC file.
63 If it is (FILE . INTEGER), use FILE as the file name
64 and INTEGER as the position in that file.
65 But if INTEGER is negative, make it positive.
66 (A negative integer is used for user variables, so we can distinguish
67 them without actually fetching the doc string.)
69 If the location does not point to the beginning of a docstring
70 (e.g. because the file has been modified and the location is stale),
73 If UNIBYTE, always make a unibyte string.
75 If DEFINITION, assume this is for reading
76 a dynamic function definition; convert the bytestring
77 and the constants vector with appropriate byte handling,
78 and return a cons cell. */
81 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
83 char *from
, *to
, *name
, *p
, *p1
;
87 Lisp_Object file
, tem
, pos
;
91 if (INTEGERP (filepos
))
93 file
= Vdoc_file_name
;
96 else if (CONSP (filepos
))
98 file
= XCAR (filepos
);
104 position
= eabs (XINT (pos
));
106 if (!STRINGP (Vdoc_directory
))
112 /* Put the file name in NAME as a C string.
113 If it is relative, combine it with Vdoc_directory. */
115 tem
= Ffile_name_absolute_p (file
);
116 file
= ENCODE_FILE (file
);
118 = NILP (tem
) ? ENCODE_FILE (Vdoc_directory
) : empty_unibyte_string
;
119 ptrdiff_t docdir_sizemax
= SBYTES (docdir
) + 1;
121 docdir_sizemax
= max (docdir_sizemax
, sizeof sibling_etc
);
123 name
= SAFE_ALLOCA (docdir_sizemax
+ SBYTES (file
));
124 lispstpcpy (lispstpcpy (name
, docdir
), file
);
126 fd
= emacs_open (name
, O_RDONLY
, 0);
130 if (!NILP (Vpurify_flag
))
132 /* Preparing to dump; DOC file is probably not installed.
133 So check in ../etc. */
134 lispstpcpy (stpcpy (name
, sibling_etc
), file
);
136 fd
= emacs_open (name
, O_RDONLY
, 0);
142 AUTO_STRING (cannot_open
, "Cannot open doc string file \"");
143 AUTO_STRING (quote_nl
, "\"\n");
144 return concat3 (cannot_open
, file
, quote_nl
);
147 count
= SPECPDL_INDEX ();
148 record_unwind_protect_int (close_file_unwind
, fd
);
150 /* Seek only to beginning of disk block. */
151 /* Make sure we read at least 1024 bytes before `position'
152 so we can check the leading text for consistency. */
153 offset
= min (position
, max (1024, position
% (8 * 1024)));
154 if (TYPE_MAXIMUM (off_t
) < position
155 || lseek (fd
, position
- offset
, 0) < 0)
156 error ("Position %"pI
"d out of range in doc string file \"%s\"",
159 /* Read the doc string into get_doc_string_buffer.
160 P points beyond the data just read. */
162 p
= get_doc_string_buffer
;
165 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
166 - (p
- get_doc_string_buffer
));
169 /* Allocate or grow the buffer if we need to. */
172 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
173 get_doc_string_buffer
174 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
176 p
= get_doc_string_buffer
+ in_buffer
;
177 space_left
= (get_doc_string_buffer_size
- 1
178 - (p
- get_doc_string_buffer
));
181 /* Read a disk block at a time.
182 If we read the same block last time, maybe skip this? */
183 if (space_left
> 1024 * 8)
184 space_left
= 1024 * 8;
185 nread
= emacs_read (fd
, p
, space_left
);
187 report_file_error ("Read error on documentation file", file
);
191 if (p
== get_doc_string_buffer
)
192 p1
= strchr (p
+ offset
, '\037');
194 p1
= strchr (p
, '\037');
203 unbind_to (count
, Qnil
);
206 /* Sanity checking. */
210 /* A dynamic docstring should be either at the very beginning of a "#@
211 comment" or right after a dynamic docstring delimiter (in case we
212 pack several such docstrings within the same comment). */
213 if (get_doc_string_buffer
[offset
- test
] != '\037')
215 if (get_doc_string_buffer
[offset
- test
++] != ' ')
217 while (get_doc_string_buffer
[offset
- test
] >= '0'
218 && get_doc_string_buffer
[offset
- test
] <= '9')
220 if (get_doc_string_buffer
[offset
- test
++] != '@'
221 || get_doc_string_buffer
[offset
- test
] != '#')
228 if (get_doc_string_buffer
[offset
- test
++] != '\n')
230 while (get_doc_string_buffer
[offset
- test
] > ' ')
232 if (get_doc_string_buffer
[offset
- test
] != '\037')
236 /* Scan the text and perform quoting with ^A (char code 1).
237 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
238 from
= get_doc_string_buffer
+ offset
;
239 to
= get_doc_string_buffer
+ offset
;
256 unsigned char uc
= c
;
258 Invalid data in documentation file -- %c followed by code %03o",
266 /* If DEFINITION, read from this buffer
267 the same way we would read bytes from a file. */
270 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
271 return Fread (Qlambda
);
275 return make_unibyte_string (get_doc_string_buffer
+ offset
,
276 to
- (get_doc_string_buffer
+ offset
));
279 /* The data determines whether the string is multibyte. */
281 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
283 to
- (get_doc_string_buffer
+ offset
));
284 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
286 to
- (get_doc_string_buffer
+ offset
));
290 /* Get a string from position FILEPOS and pass it through the Lisp reader.
291 We use this for fetching the bytecode string and constants vector
292 of a compiled function from the .elc file. */
295 read_doc_string (Lisp_Object filepos
)
297 return get_doc_string (filepos
, 0, 1);
301 reread_doc_file (Lisp_Object file
)
304 Lisp_Object reply
, prompt
[3];
307 prompt
[0] = build_string ("File ");
308 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
309 prompt
[2] = build_string (" is out of sync. Reload? ");
310 reply
= Fy_or_n_p (Fconcat (3, prompt
));
317 Fsnarf_documentation (Vdoc_file_name
);
319 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
324 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
325 doc
: /* Return the documentation string of FUNCTION.
326 Unless a non-nil second argument RAW is given, the
327 string is passed through `substitute-command-keys'. */)
328 (Lisp_Object function
, Lisp_Object raw
)
339 if (SYMBOLP (function
))
341 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
343 return Fdocumentation_property (function
, Qfunction_documentation
,
347 fun
= Findirect_function (function
, Qnil
);
348 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
352 if (XSUBR (fun
)->doc
== 0)
354 /* FIXME: This is not portable, as it assumes that string
355 pointers have the top bit clear. */
356 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
357 doc
= build_string (XSUBR (fun
)->doc
);
359 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
361 else if (COMPILEDP (fun
))
363 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
367 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
370 else if (NATNUMP (tem
) || CONSP (tem
))
376 else if (STRINGP (fun
) || VECTORP (fun
))
378 return build_string ("Keyboard macro.");
380 else if (CONSP (fun
))
383 if (!SYMBOLP (funcar
))
384 xsignal1 (Qinvalid_function
, fun
);
385 else if (EQ (funcar
, Qkeymap
))
386 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
387 else if (EQ (funcar
, Qlambda
)
388 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
389 || EQ (funcar
, Qautoload
))
391 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
392 Lisp_Object tem
= Fcar (tem1
);
395 /* Handle a doc reference--but these never come last
396 in the function body, so reject them if they are last. */
397 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
398 && !NILP (XCDR (tem1
)))
409 xsignal1 (Qinvalid_function
, fun
);
412 /* If DOC is 0, it's typically because of a dumped file missing
413 from the DOC file (bug in src/Makefile.in). */
414 if (EQ (doc
, make_number (0)))
416 if (INTEGERP (doc
) || CONSP (doc
))
419 tem
= get_doc_string (doc
, 0, 0);
420 if (NILP (tem
) && try_reload
)
422 /* The file is newer, we need to reset the pointers. */
423 struct gcpro gcpro1
, gcpro2
;
424 GCPRO2 (function
, raw
);
425 try_reload
= reread_doc_file (Fcar_safe (doc
));
438 doc
= Fsubstitute_command_keys (doc
);
442 DEFUN ("documentation-property", Fdocumentation_property
,
443 Sdocumentation_property
, 2, 3, 0,
444 doc
: /* Return the documentation string that is SYMBOL's PROP property.
445 Third argument RAW omitted or nil means pass the result through
446 `substitute-command-keys' if it is a string.
448 This differs from `get' in that it can refer to strings stored in the
449 `etc/DOC' file; and that it evaluates documentation properties that
451 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
456 documentation_property
:
458 tem
= Fget (symbol
, prop
);
459 if (EQ (tem
, make_number (0)))
461 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
463 Lisp_Object doc
= tem
;
464 tem
= get_doc_string (tem
, 0, 0);
465 if (NILP (tem
) && try_reload
)
467 /* The file is newer, we need to reset the pointers. */
468 struct gcpro gcpro1
, gcpro2
, gcpro3
;
469 GCPRO3 (symbol
, prop
, raw
);
470 try_reload
= reread_doc_file (Fcar_safe (doc
));
475 goto documentation_property
;
479 else if (!STRINGP (tem
))
480 /* Feval protects its argument. */
481 tem
= Feval (tem
, Qnil
);
483 if (NILP (raw
) && STRINGP (tem
))
484 tem
= Fsubstitute_command_keys (tem
);
488 /* Scanning the DOC files and placing docstring offsets into functions. */
491 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
493 /* Don't use indirect_function here, or defaliases will apply their
494 docstrings to the base functions (Bug#2603). */
495 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
497 /* The type determines where the docstring is stored. */
499 /* Lisp_Subrs have a slot for it. */
502 intptr_t negative_offset
= - offset
;
503 XSUBR (fun
)->doc
= (char *) negative_offset
;
506 /* If it's a lisp form, stick it in the form. */
507 else if (CONSP (fun
))
512 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
513 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
515 tem
= Fcdr (Fcdr (fun
));
516 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
517 /* FIXME: This modifies typically pure hash-cons'd data, so its
518 correctness is quite delicate. */
519 XSETCAR (tem
, make_number (offset
));
521 else if (EQ (tem
, Qmacro
))
522 store_function_docstring (XCDR (fun
), offset
);
525 /* Bytecode objects sometimes have slots for it. */
526 else if (COMPILEDP (fun
))
528 /* This bytecode object must have a slot for the
529 docstring, since we've found a docstring for it. */
530 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
531 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
533 message ("No docstring slot for %s",
534 SYMBOLP (obj
) ? SSDATA (SYMBOL_NAME (obj
)) : "<anonymous>");
539 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
541 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
542 This searches the `etc/DOC...' file for doc strings and
543 records them in function and variable definitions.
544 The function takes one argument, FILENAME, a string;
545 it specifies the file name (without a directory) of the DOC file.
546 That file is found in `../etc' now; later, when the dumped Emacs is run,
547 the same file name is found in the `doc-directory'. */)
548 (Lisp_Object filename
)
560 /* Preloaded defcustoms using custom-initialize-delay are added to
561 this list, but kept unbound. See http://debbugs.gnu.org/11565 */
562 Lisp_Object delayed_init
=
563 find_symbol_value (intern ("custom-delayed-init-variables"));
565 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
567 CHECK_STRING (filename
);
571 (!NILP (Vpurify_flag
))
572 #else /* CANNOT_DUMP */
574 #endif /* CANNOT_DUMP */
576 dirname
= sibling_etc
;
577 dirlen
= sizeof sibling_etc
- 1;
581 CHECK_STRING (Vdoc_directory
);
582 dirname
= SSDATA (Vdoc_directory
);
583 dirlen
= SBYTES (Vdoc_directory
);
586 count
= SPECPDL_INDEX ();
588 name
= SAFE_ALLOCA (dirlen
+ SBYTES (filename
) + 1);
589 lispstpcpy (stpcpy (name
, dirname
), filename
); /*** Add this line ***/
591 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
592 if (NILP (Vbuild_files
))
594 static char const *const buildobj
[] =
596 #include "buildobj.h"
598 int i
= ARRAYELTS (buildobj
);
600 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
601 Vbuild_files
= Fpurecopy (Vbuild_files
);
604 fd
= emacs_open (name
, O_RDONLY
, 0);
607 int open_errno
= errno
;
608 report_file_errno ("Opening doc string file", build_string (name
),
611 record_unwind_protect_int (close_file_unwind
, fd
);
612 Vdoc_file_name
= filename
;
619 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
624 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
625 p
= memchr (buf
, '\037', end
- buf
);
626 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
629 end
= strchr (p
, '\n');
631 /* See if this is a file name, and if it is a file in build-files. */
635 if (end
- p
> 4 && end
[-2] == '.'
636 && (end
[-1] == 'o' || end
[-1] == 'c'))
638 ptrdiff_t len
= end
- p
- 2;
639 char *fromfile
= SAFE_ALLOCA (len
+ 1);
640 memcpy (fromfile
, &p
[2], len
);
642 if (fromfile
[len
-1] == 'c')
643 fromfile
[len
-1] = 'o';
645 skip_file
= NILP (Fmember (build_string (fromfile
),
650 sym
= oblookup (Vobarray
, p
+ 2,
651 multibyte_chars_in_text ((unsigned char *) p
+ 2,
654 /* Check skip_file so that when a function is defined several
655 times in different files (typically, once in xterm, once in
656 w32term, ...), we only pay attention to the one that
658 if (! skip_file
&& SYMBOLP (sym
))
660 /* Attach a docstring to a variable? */
663 /* Install file-position as variable-documentation property
664 and make it negative for a user-variable
665 (doc starts with a `*'). */
666 if (!NILP (Fboundp (sym
))
667 || !NILP (Fmemq (sym
, delayed_init
)))
668 Fput (sym
, Qvariable_documentation
,
669 make_number ((pos
+ end
+ 1 - buf
)
670 * (end
[1] == '*' ? -1 : 1)));
673 /* Attach a docstring to a function? */
674 else if (p
[1] == 'F')
676 if (!NILP (Ffboundp (sym
)))
677 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
679 else if (p
[1] == 'S')
680 ; /* Just a source file name boundary marker. Ignore it. */
683 error ("DOC file invalid at position %"pI
"d", pos
);
688 memmove (buf
, end
, filled
);
692 return unbind_to (count
, Qnil
);
695 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
696 Ssubstitute_command_keys
, 1, 1, 0,
697 doc
: /* Substitute key descriptions for command names in STRING.
698 Each substring of the form \\=\\[COMMAND] is replaced by either a
699 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
702 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
703 the value of MAPVAR as a keymap. This summary is similar to the one
704 produced by `describe-bindings'. The summary ends in two newlines
705 \(used by the helper function `help-make-xrefs' to find the end of the
708 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
709 as the keymap for future \\=\\[COMMAND] substrings.
710 \\=\\= quotes the following character and is discarded;
711 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
713 Return the original STRING if no substitutions are made.
714 Otherwise, return a new string. */)
725 unsigned char *start
;
726 ptrdiff_t length
, length_byte
;
728 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
735 CHECK_STRING (string
);
739 GCPRO4 (string
, tem
, keymap
, name
);
741 multibyte
= STRING_MULTIBYTE (string
);
744 /* KEYMAP is either nil (which means search all the active keymaps)
745 or a specified local map (which means search just that and the
746 global map). If non-nil, it might come from Voverriding_local_map,
747 or from a \\<mapname> construct in STRING itself.. */
748 keymap
= Voverriding_local_map
;
750 bsize
= SBYTES (string
);
751 bufp
= buf
= xmalloc (bsize
);
753 strp
= SDATA (string
);
754 while (strp
< SDATA (string
) + SBYTES (string
))
756 if (strp
[0] == '\\' && strp
[1] == '=')
758 /* \= quotes the next character;
759 thus, to put in \[ without its special meaning, use \=\[. */
766 STRING_CHAR_AND_LENGTH (strp
, len
);
770 memcpy (bufp
, strp
, len
);
776 *bufp
++ = *strp
++, nchars
++;
778 else if (strp
[0] == '\\' && strp
[1] == '[')
781 bool follow_remap
= 1;
784 strp
+= 2; /* skip \[ */
786 start_idx
= start
- SDATA (string
);
788 while ((strp
- SDATA (string
)
792 length_byte
= strp
- start
;
796 /* Save STRP in IDX. */
797 idx
= strp
- SDATA (string
);
798 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
801 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
803 if (VECTORP (tem
) && ASIZE (tem
) > 1
804 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
807 name
= AREF (tem
, 1);
812 /* Note the Fwhere_is_internal can GC, so we have to take
813 relocation of string contents into account. */
814 strp
= SDATA (string
) + idx
;
815 start
= SDATA (string
) + start_idx
;
817 if (NILP (tem
)) /* but not on any keys */
819 ptrdiff_t offset
= bufp
- buf
;
820 if (STRING_BYTES_BOUND
- 4 < bsize
)
822 buf
= xrealloc (buf
, bsize
+= 4);
824 memcpy (bufp
, "M-x ", 4);
828 length
= multibyte_chars_in_text (start
, length_byte
);
830 length
= length_byte
;
834 { /* function is on a key */
835 tem
= Fkey_description (tem
, Qnil
);
839 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
840 \<foo> just sets the keymap used for \[cmd]. */
841 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
843 struct buffer
*oldbuf
;
845 /* This is for computing the SHADOWS arg for describe_map_tree. */
846 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
847 Lisp_Object earlier_maps
;
848 ptrdiff_t count
= SPECPDL_INDEX ();
851 strp
+= 2; /* skip \{ or \< */
853 start_idx
= start
- SDATA (string
);
855 while ((strp
- SDATA (string
) < SBYTES (string
))
856 && *strp
!= '}' && *strp
!= '>')
859 length_byte
= strp
- start
;
860 strp
++; /* skip } or > */
862 /* Save STRP in IDX. */
863 idx
= strp
- SDATA (string
);
865 /* Get the value of the keymap in TEM, or nil if undefined.
866 Do this while still in the user's current buffer
867 in case it is a local variable. */
868 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
869 tem
= Fboundp (name
);
872 tem
= Fsymbol_value (name
);
875 tem
= get_keymap (tem
, 0, 1);
876 /* Note that get_keymap can GC. */
877 strp
= SDATA (string
) + idx
;
878 start
= SDATA (string
) + start_idx
;
882 /* Now switch to a temp buffer. */
883 oldbuf
= current_buffer
;
884 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
885 /* This is for an unusual case where some after-change
886 function uses 'format' or 'prin1' or something else that
887 will thrash Vprin1_to_string_buffer we are using. */
888 specbind (Qinhibit_modification_hooks
, Qt
);
892 name
= Fsymbol_name (name
);
893 insert_string ("\nUses keymap `");
894 insert_from_string (name
, 0, 0,
897 insert_string ("', which is not currently defined.\n");
898 if (start
[-1] == '<') keymap
= Qnil
;
900 else if (start
[-1] == '<')
904 /* Get the list of active keymaps that precede this one.
905 If this one's not active, get nil. */
906 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
907 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
908 Qnil
, 0, 1, 0, 0, 1);
910 tem
= Fbuffer_string ();
912 set_buffer_internal (oldbuf
);
913 unbind_to (count
, Qnil
);
917 length
= SCHARS (tem
);
918 length_byte
= SBYTES (tem
);
921 ptrdiff_t offset
= bufp
- buf
;
922 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
924 buf
= xrealloc (buf
, bsize
+= length_byte
);
926 memcpy (bufp
, start
, length_byte
);
929 /* Check STRING again in case gc relocated it. */
930 strp
= SDATA (string
) + idx
;
933 else if (! multibyte
) /* just copy other chars */
934 *bufp
++ = *strp
++, nchars
++;
939 STRING_CHAR_AND_LENGTH (strp
, len
);
943 memcpy (bufp
, strp
, len
);
950 if (changed
) /* don't bother if nothing substituted */
951 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
955 RETURN_UNGCPRO (tem
);
961 DEFSYM (Qfunction_documentation
, "function-documentation");
963 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
964 doc
: /* Name of file containing documentation strings of built-in symbols. */);
965 Vdoc_file_name
= Qnil
;
967 DEFVAR_LISP ("build-files", Vbuild_files
,
968 doc
: /* A list of files used to build this Emacs binary. */);
971 defsubr (&Sdocumentation
);
972 defsubr (&Sdocumentation_property
);
973 defsubr (&Ssnarf_documentation
);
974 defsubr (&Ssubstitute_command_keys
);