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 /* `readchar' in lread.c calls back here to fetch the next byte.
46 If UNREADFLAG is 1, we unread a byte. */
49 read_bytecode_char (bool unreadflag
)
53 read_bytecode_pointer
--;
56 return *read_bytecode_pointer
++;
59 /* Extract a doc string from a file. FILEPOS says where to get it.
60 If it is an integer, use that position in the standard DOC file.
61 If it is (FILE . INTEGER), use FILE as the file name
62 and INTEGER as the position in that file.
63 But if INTEGER is negative, make it positive.
64 (A negative integer is used for user variables, so we can distinguish
65 them without actually fetching the doc string.)
67 If the location does not point to the beginning of a docstring
68 (e.g. because the file has been modified and the location is stale),
71 If UNIBYTE, always make a unibyte string.
73 If DEFINITION, assume this is for reading
74 a dynamic function definition; convert the bytestring
75 and the constants vector with appropriate byte handling,
76 and return a cons cell. */
79 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
81 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
);
118 Lisp_Object docdir
= ENCODE_FILE (Vdoc_directory
);
119 minsize
= SCHARS (docdir
);
120 /* sizeof ("../etc/") == 8 */
123 name
= SAFE_ALLOCA (minsize
+ SCHARS (file
) + 8);
124 strcpy (name
, SSDATA (docdir
));
125 strcat (name
, SSDATA (file
));
129 name
= SSDATA (file
);
132 fd
= emacs_open (name
, O_RDONLY
, 0);
136 if (!NILP (Vpurify_flag
))
138 /* Preparing to dump; DOC file is probably not installed.
139 So check in ../etc. */
140 strcpy (name
, "../etc/");
141 strcat (name
, SSDATA (file
));
143 fd
= emacs_open (name
, O_RDONLY
, 0);
149 return concat3 (build_local_string ("Cannot open doc string file \""),
150 file
, build_local_string ("\"\n"));
153 count
= SPECPDL_INDEX ();
154 record_unwind_protect_int (close_file_unwind
, fd
);
156 /* Seek only to beginning of disk block. */
157 /* Make sure we read at least 1024 bytes before `position'
158 so we can check the leading text for consistency. */
159 offset
= min (position
, max (1024, position
% (8 * 1024)));
160 if (TYPE_MAXIMUM (off_t
) < position
161 || lseek (fd
, position
- offset
, 0) < 0)
162 error ("Position %"pI
"d out of range in doc string file \"%s\"",
165 /* Read the doc string into get_doc_string_buffer.
166 P points beyond the data just read. */
168 p
= get_doc_string_buffer
;
171 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
172 - (p
- get_doc_string_buffer
));
175 /* Allocate or grow the buffer if we need to. */
178 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
179 get_doc_string_buffer
180 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
182 p
= get_doc_string_buffer
+ in_buffer
;
183 space_left
= (get_doc_string_buffer_size
- 1
184 - (p
- get_doc_string_buffer
));
187 /* Read a disk block at a time.
188 If we read the same block last time, maybe skip this? */
189 if (space_left
> 1024 * 8)
190 space_left
= 1024 * 8;
191 nread
= emacs_read (fd
, p
, space_left
);
193 report_file_error ("Read error on documentation file", file
);
197 if (p
== get_doc_string_buffer
)
198 p1
= strchr (p
+ offset
, '\037');
200 p1
= strchr (p
, '\037');
209 unbind_to (count
, Qnil
);
212 /* Sanity checking. */
216 /* A dynamic docstring should be either at the very beginning of a "#@
217 comment" or right after a dynamic docstring delimiter (in case we
218 pack several such docstrings within the same comment). */
219 if (get_doc_string_buffer
[offset
- test
] != '\037')
221 if (get_doc_string_buffer
[offset
- test
++] != ' ')
223 while (get_doc_string_buffer
[offset
- test
] >= '0'
224 && get_doc_string_buffer
[offset
- test
] <= '9')
226 if (get_doc_string_buffer
[offset
- test
++] != '@'
227 || get_doc_string_buffer
[offset
- test
] != '#')
234 if (get_doc_string_buffer
[offset
- test
++] != '\n')
236 while (get_doc_string_buffer
[offset
- test
] > ' ')
238 if (get_doc_string_buffer
[offset
- test
] != '\037')
242 /* Scan the text and perform quoting with ^A (char code 1).
243 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
244 from
= get_doc_string_buffer
+ offset
;
245 to
= get_doc_string_buffer
+ offset
;
262 unsigned char uc
= c
;
264 Invalid data in documentation file -- %c followed by code %03o",
272 /* If DEFINITION, read from this buffer
273 the same way we would read bytes from a file. */
276 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
277 return Fread (Qlambda
);
281 return make_unibyte_string (get_doc_string_buffer
+ offset
,
282 to
- (get_doc_string_buffer
+ offset
));
285 /* The data determines whether the string is multibyte. */
287 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
289 to
- (get_doc_string_buffer
+ offset
));
290 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
292 to
- (get_doc_string_buffer
+ offset
));
296 /* Get a string from position FILEPOS and pass it through the Lisp reader.
297 We use this for fetching the bytecode string and constants vector
298 of a compiled function from the .elc file. */
301 read_doc_string (Lisp_Object filepos
)
303 return get_doc_string (filepos
, 0, 1);
307 reread_doc_file (Lisp_Object file
)
310 Lisp_Object reply
, prompt
[3];
313 prompt
[0] = build_string ("File ");
314 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
315 prompt
[2] = build_string (" is out of sync. Reload? ");
316 reply
= Fy_or_n_p (Fconcat (3, prompt
));
323 Fsnarf_documentation (Vdoc_file_name
);
325 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
330 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
331 doc
: /* Return the documentation string of FUNCTION.
332 Unless a non-nil second argument RAW is given, the
333 string is passed through `substitute-command-keys'. */)
334 (Lisp_Object function
, Lisp_Object raw
)
345 if (SYMBOLP (function
))
347 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
349 return Fdocumentation_property (function
, Qfunction_documentation
,
353 fun
= Findirect_function (function
, Qnil
);
354 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
358 if (XSUBR (fun
)->doc
== 0)
360 /* FIXME: This is not portable, as it assumes that string
361 pointers have the top bit clear. */
362 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
363 doc
= build_string (XSUBR (fun
)->doc
);
365 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
367 else if (COMPILEDP (fun
))
369 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
373 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
376 else if (NATNUMP (tem
) || CONSP (tem
))
382 else if (STRINGP (fun
) || VECTORP (fun
))
384 return build_string ("Keyboard macro.");
386 else if (CONSP (fun
))
389 if (!SYMBOLP (funcar
))
390 xsignal1 (Qinvalid_function
, fun
);
391 else if (EQ (funcar
, Qkeymap
))
392 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
393 else if (EQ (funcar
, Qlambda
)
394 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
395 || EQ (funcar
, Qautoload
))
397 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
398 Lisp_Object tem
= Fcar (tem1
);
401 /* Handle a doc reference--but these never come last
402 in the function body, so reject them if they are last. */
403 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
404 && !NILP (XCDR (tem1
)))
415 xsignal1 (Qinvalid_function
, fun
);
418 /* If DOC is 0, it's typically because of a dumped file missing
419 from the DOC file (bug in src/Makefile.in). */
420 if (EQ (doc
, make_number (0)))
422 if (INTEGERP (doc
) || CONSP (doc
))
425 tem
= get_doc_string (doc
, 0, 0);
426 if (NILP (tem
) && try_reload
)
428 /* The file is newer, we need to reset the pointers. */
429 struct gcpro gcpro1
, gcpro2
;
430 GCPRO2 (function
, raw
);
431 try_reload
= reread_doc_file (Fcar_safe (doc
));
444 doc
= Fsubstitute_command_keys (doc
);
448 DEFUN ("documentation-property", Fdocumentation_property
,
449 Sdocumentation_property
, 2, 3, 0,
450 doc
: /* Return the documentation string that is SYMBOL's PROP property.
451 Third argument RAW omitted or nil means pass the result through
452 `substitute-command-keys' if it is a string.
454 This differs from `get' in that it can refer to strings stored in the
455 `etc/DOC' file; and that it evaluates documentation properties that
457 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
462 documentation_property
:
464 tem
= Fget (symbol
, prop
);
465 if (EQ (tem
, make_number (0)))
467 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
469 Lisp_Object doc
= tem
;
470 tem
= get_doc_string (tem
, 0, 0);
471 if (NILP (tem
) && try_reload
)
473 /* The file is newer, we need to reset the pointers. */
474 struct gcpro gcpro1
, gcpro2
, gcpro3
;
475 GCPRO3 (symbol
, prop
, raw
);
476 try_reload
= reread_doc_file (Fcar_safe (doc
));
481 goto documentation_property
;
485 else if (!STRINGP (tem
))
486 /* Feval protects its argument. */
487 tem
= Feval (tem
, Qnil
);
489 if (NILP (raw
) && STRINGP (tem
))
490 tem
= Fsubstitute_command_keys (tem
);
494 /* Scanning the DOC files and placing docstring offsets into functions. */
497 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
499 /* Don't use indirect_function here, or defaliases will apply their
500 docstrings to the base functions (Bug#2603). */
501 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
503 /* The type determines where the docstring is stored. */
505 /* Lisp_Subrs have a slot for it. */
508 intptr_t negative_offset
= - offset
;
509 XSUBR (fun
)->doc
= (char *) negative_offset
;
512 /* If it's a lisp form, stick it in the form. */
513 else if (CONSP (fun
))
518 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
519 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
521 tem
= Fcdr (Fcdr (fun
));
522 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
523 /* FIXME: This modifies typically pure hash-cons'd data, so its
524 correctness is quite delicate. */
525 XSETCAR (tem
, make_number (offset
));
527 else if (EQ (tem
, Qmacro
))
528 store_function_docstring (XCDR (fun
), offset
);
531 /* Bytecode objects sometimes have slots for it. */
532 else if (COMPILEDP (fun
))
534 /* This bytecode object must have a slot for the
535 docstring, since we've found a docstring for it. */
536 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
537 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
539 message ("No docstring slot for %s",
540 SYMBOLP (obj
) ? SSDATA (SYMBOL_NAME (obj
)) : "<anonymous>");
545 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
547 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
548 This searches the `etc/DOC...' file for doc strings and
549 records them in function and variable definitions.
550 The function takes one argument, FILENAME, a string;
551 it specifies the file name (without a directory) of the DOC file.
552 That file is found in `../etc' now; later, when the dumped Emacs is run,
553 the same file name is found in the `doc-directory'. */)
554 (Lisp_Object filename
)
566 /* Preloaded defcustoms using custom-initialize-delay are added to
567 this list, but kept unbound. See http://debbugs.gnu.org/11565 */
568 Lisp_Object delayed_init
=
569 find_symbol_value (intern ("custom-delayed-init-variables"));
571 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
573 CHECK_STRING (filename
);
577 (!NILP (Vpurify_flag
))
578 #else /* CANNOT_DUMP */
580 #endif /* CANNOT_DUMP */
582 static char const sibling_etc
[] = "../etc/";
583 dirname
= sibling_etc
;
584 dirlen
= sizeof sibling_etc
- 1;
588 CHECK_STRING (Vdoc_directory
);
589 dirname
= SSDATA (Vdoc_directory
);
590 dirlen
= SBYTES (Vdoc_directory
);
593 count
= SPECPDL_INDEX ();
595 name
= SAFE_ALLOCA (dirlen
+ SBYTES (filename
) + 1);
596 strcpy (name
, dirname
);
597 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
599 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
600 if (NILP (Vbuild_files
))
602 static char const *const buildobj
[] =
604 #include "buildobj.h"
606 int i
= ARRAYELTS (buildobj
);
608 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
609 Vbuild_files
= Fpurecopy (Vbuild_files
);
612 fd
= emacs_open (name
, O_RDONLY
, 0);
615 int open_errno
= errno
;
616 report_file_errno ("Opening doc string file", build_string (name
),
619 record_unwind_protect_int (close_file_unwind
, fd
);
620 Vdoc_file_name
= filename
;
627 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
632 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
633 p
= memchr (buf
, '\037', end
- buf
);
634 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
637 end
= strchr (p
, '\n');
639 /* See if this is a file name, and if it is a file in build-files. */
643 if (end
- p
> 4 && end
[-2] == '.'
644 && (end
[-1] == 'o' || end
[-1] == 'c'))
646 ptrdiff_t len
= end
- p
- 2;
647 char *fromfile
= SAFE_ALLOCA (len
+ 1);
648 memcpy (fromfile
, &p
[2], len
);
650 if (fromfile
[len
-1] == 'c')
651 fromfile
[len
-1] = 'o';
653 skip_file
= NILP (Fmember (build_string (fromfile
),
658 sym
= oblookup (Vobarray
, p
+ 2,
659 multibyte_chars_in_text ((unsigned char *) p
+ 2,
662 /* Check skip_file so that when a function is defined several
663 times in different files (typically, once in xterm, once in
664 w32term, ...), we only pay attention to the one that
666 if (! skip_file
&& SYMBOLP (sym
))
668 /* Attach a docstring to a variable? */
671 /* Install file-position as variable-documentation property
672 and make it negative for a user-variable
673 (doc starts with a `*'). */
674 if (!NILP (Fboundp (sym
))
675 || !NILP (Fmemq (sym
, delayed_init
)))
676 Fput (sym
, Qvariable_documentation
,
677 make_number ((pos
+ end
+ 1 - buf
)
678 * (end
[1] == '*' ? -1 : 1)));
681 /* Attach a docstring to a function? */
682 else if (p
[1] == 'F')
684 if (!NILP (Ffboundp (sym
)))
685 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
687 else if (p
[1] == 'S')
688 ; /* Just a source file name boundary marker. Ignore it. */
691 error ("DOC file invalid at position %"pI
"d", pos
);
696 memmove (buf
, end
, filled
);
700 return unbind_to (count
, Qnil
);
703 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
704 Ssubstitute_command_keys
, 1, 1, 0,
705 doc
: /* Substitute key descriptions for command names in STRING.
706 Each substring of the form \\=\\[COMMAND] is replaced by either a
707 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
710 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
711 the value of MAPVAR as a keymap. This summary is similar to the one
712 produced by `describe-bindings'. The summary ends in two newlines
713 \(used by the helper function `help-make-xrefs' to find the end of the
716 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
717 as the keymap for future \\=\\[COMMAND] substrings.
718 \\=\\= quotes the following character and is discarded;
719 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
721 Return the original STRING if no substitutions are made.
722 Otherwise, return a new string. */)
733 unsigned char *start
;
734 ptrdiff_t length
, length_byte
;
736 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
743 CHECK_STRING (string
);
747 GCPRO4 (string
, tem
, keymap
, name
);
749 multibyte
= STRING_MULTIBYTE (string
);
752 /* KEYMAP is either nil (which means search all the active keymaps)
753 or a specified local map (which means search just that and the
754 global map). If non-nil, it might come from Voverriding_local_map,
755 or from a \\<mapname> construct in STRING itself.. */
756 keymap
= Voverriding_local_map
;
758 bsize
= SBYTES (string
);
759 bufp
= buf
= xmalloc (bsize
);
761 strp
= SDATA (string
);
762 while (strp
< SDATA (string
) + SBYTES (string
))
764 if (strp
[0] == '\\' && strp
[1] == '=')
766 /* \= quotes the next character;
767 thus, to put in \[ without its special meaning, use \=\[. */
774 STRING_CHAR_AND_LENGTH (strp
, len
);
778 memcpy (bufp
, strp
, len
);
784 *bufp
++ = *strp
++, nchars
++;
786 else if (strp
[0] == '\\' && strp
[1] == '[')
789 bool follow_remap
= 1;
792 strp
+= 2; /* skip \[ */
794 start_idx
= start
- SDATA (string
);
796 while ((strp
- SDATA (string
)
800 length_byte
= strp
- start
;
804 /* Save STRP in IDX. */
805 idx
= strp
- SDATA (string
);
806 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
809 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
811 if (VECTORP (tem
) && ASIZE (tem
) > 1
812 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
815 name
= AREF (tem
, 1);
820 /* Note the Fwhere_is_internal can GC, so we have to take
821 relocation of string contents into account. */
822 strp
= SDATA (string
) + idx
;
823 start
= SDATA (string
) + start_idx
;
825 if (NILP (tem
)) /* but not on any keys */
827 ptrdiff_t offset
= bufp
- buf
;
828 if (STRING_BYTES_BOUND
- 4 < bsize
)
830 buf
= xrealloc (buf
, bsize
+= 4);
832 memcpy (bufp
, "M-x ", 4);
836 length
= multibyte_chars_in_text (start
, length_byte
);
838 length
= length_byte
;
842 { /* function is on a key */
843 tem
= Fkey_description (tem
, Qnil
);
847 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
848 \<foo> just sets the keymap used for \[cmd]. */
849 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
851 struct buffer
*oldbuf
;
853 /* This is for computing the SHADOWS arg for describe_map_tree. */
854 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
855 Lisp_Object earlier_maps
;
856 ptrdiff_t count
= SPECPDL_INDEX ();
859 strp
+= 2; /* skip \{ or \< */
861 start_idx
= start
- SDATA (string
);
863 while ((strp
- SDATA (string
) < SBYTES (string
))
864 && *strp
!= '}' && *strp
!= '>')
867 length_byte
= strp
- start
;
868 strp
++; /* skip } or > */
870 /* Save STRP in IDX. */
871 idx
= strp
- SDATA (string
);
873 /* Get the value of the keymap in TEM, or nil if undefined.
874 Do this while still in the user's current buffer
875 in case it is a local variable. */
876 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
877 tem
= Fboundp (name
);
880 tem
= Fsymbol_value (name
);
883 tem
= get_keymap (tem
, 0, 1);
884 /* Note that get_keymap can GC. */
885 strp
= SDATA (string
) + idx
;
886 start
= SDATA (string
) + start_idx
;
890 /* Now switch to a temp buffer. */
891 oldbuf
= current_buffer
;
892 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
893 /* This is for an unusual case where some after-change
894 function uses 'format' or 'prin1' or something else that
895 will thrash Vprin1_to_string_buffer we are using. */
896 specbind (Qinhibit_modification_hooks
, Qt
);
900 name
= Fsymbol_name (name
);
901 insert_string ("\nUses keymap `");
902 insert_from_string (name
, 0, 0,
905 insert_string ("', which is not currently defined.\n");
906 if (start
[-1] == '<') keymap
= Qnil
;
908 else if (start
[-1] == '<')
912 /* Get the list of active keymaps that precede this one.
913 If this one's not active, get nil. */
914 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
915 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
916 Qnil
, 0, 1, 0, 0, 1);
918 tem
= Fbuffer_string ();
920 set_buffer_internal (oldbuf
);
921 unbind_to (count
, Qnil
);
925 length
= SCHARS (tem
);
926 length_byte
= SBYTES (tem
);
929 ptrdiff_t offset
= bufp
- buf
;
930 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
932 buf
= xrealloc (buf
, bsize
+= length_byte
);
934 memcpy (bufp
, start
, length_byte
);
937 /* Check STRING again in case gc relocated it. */
938 strp
= SDATA (string
) + idx
;
941 else if (! multibyte
) /* just copy other chars */
942 *bufp
++ = *strp
++, nchars
++;
947 STRING_CHAR_AND_LENGTH (strp
, len
);
951 memcpy (bufp
, strp
, len
);
958 if (changed
) /* don't bother if nothing substituted */
959 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
963 RETURN_UNGCPRO (tem
);
969 DEFSYM (Qfunction_documentation
, "function-documentation");
971 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
972 doc
: /* Name of file containing documentation strings of built-in symbols. */);
973 Vdoc_file_name
= Qnil
;
975 DEFVAR_LISP ("build-files", Vbuild_files
,
976 doc
: /* A list of files used to build this Emacs binary. */);
979 defsubr (&Sdocumentation
);
980 defsubr (&Sdocumentation_property
);
981 defsubr (&Ssnarf_documentation
);
982 defsubr (&Ssubstitute_command_keys
);