1 /* Record indices of function doc strings stored in a file.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2013 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/>. */
24 #include <sys/types.h>
25 #include <sys/file.h> /* Must be after sys/types.h for USG. */
32 #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 /* `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
;
87 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);
147 return concat3 (build_string ("Cannot open doc string file \""),
148 file
, build_string ("\"\n"));
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)
159 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
);
195 error ("Read error on documentation file");
200 if (p
== get_doc_string_buffer
)
201 p1
= strchr (p
+ offset
, '\037');
203 p1
= strchr (p
, '\037');
214 /* Sanity checking. */
218 /* A dynamic docstring should be either at the very beginning of a "#@
219 comment" or right after a dynamic docstring delimiter (in case we
220 pack several such docstrings within the same comment). */
221 if (get_doc_string_buffer
[offset
- test
] != '\037')
223 if (get_doc_string_buffer
[offset
- test
++] != ' ')
225 while (get_doc_string_buffer
[offset
- test
] >= '0'
226 && get_doc_string_buffer
[offset
- test
] <= '9')
228 if (get_doc_string_buffer
[offset
- test
++] != '@'
229 || get_doc_string_buffer
[offset
- test
] != '#')
236 if (get_doc_string_buffer
[offset
- test
++] != '\n')
238 while (get_doc_string_buffer
[offset
- test
] > ' ')
240 if (get_doc_string_buffer
[offset
- test
] != '\037')
244 /* Scan the text and perform quoting with ^A (char code 1).
245 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
246 from
= get_doc_string_buffer
+ offset
;
247 to
= get_doc_string_buffer
+ offset
;
264 unsigned char uc
= c
;
266 Invalid data in documentation file -- %c followed by code %03o",
274 /* If DEFINITION, read from this buffer
275 the same way we would read bytes from a file. */
278 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
279 return Fread (Qlambda
);
283 return make_unibyte_string (get_doc_string_buffer
+ offset
,
284 to
- (get_doc_string_buffer
+ offset
));
287 /* The data determines whether the string is multibyte. */
289 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
291 to
- (get_doc_string_buffer
+ offset
));
292 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
294 to
- (get_doc_string_buffer
+ offset
));
298 /* Get a string from position FILEPOS and pass it through the Lisp reader.
299 We use this for fetching the bytecode string and constants vector
300 of a compiled function from the .elc file. */
303 read_doc_string (Lisp_Object filepos
)
305 return get_doc_string (filepos
, 0, 1);
309 reread_doc_file (Lisp_Object file
)
312 Lisp_Object reply
, prompt
[3];
315 prompt
[0] = build_string ("File ");
316 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
317 prompt
[2] = build_string (" is out of sync. Reload? ");
318 reply
= Fy_or_n_p (Fconcat (3, prompt
));
325 Fsnarf_documentation (Vdoc_file_name
);
327 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
332 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
333 doc
: /* Return the documentation string of FUNCTION.
334 Unless a non-nil second argument RAW is given, the
335 string is passed through `substitute-command-keys'. */)
336 (Lisp_Object function
, Lisp_Object raw
)
347 if (SYMBOLP (function
))
349 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
351 return Fdocumentation_property (function
, Qfunction_documentation
,
355 fun
= Findirect_function (function
, Qnil
);
356 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
360 if (XSUBR (fun
)->doc
== 0)
362 /* FIXME: This is not portable, as it assumes that string
363 pointers have the top bit clear. */
364 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
365 doc
= build_string (XSUBR (fun
)->doc
);
367 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
369 else if (COMPILEDP (fun
))
371 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
375 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
378 else if (NATNUMP (tem
) || CONSP (tem
))
384 else if (STRINGP (fun
) || VECTORP (fun
))
386 return build_string ("Keyboard macro.");
388 else if (CONSP (fun
))
391 if (!SYMBOLP (funcar
))
392 xsignal1 (Qinvalid_function
, fun
);
393 else if (EQ (funcar
, Qkeymap
))
394 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
395 else if (EQ (funcar
, Qlambda
)
396 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
397 || EQ (funcar
, Qautoload
))
399 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
400 Lisp_Object tem
= Fcar (tem1
);
403 /* Handle a doc reference--but these never come last
404 in the function body, so reject them if they are last. */
405 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
406 && !NILP (XCDR (tem1
)))
417 xsignal1 (Qinvalid_function
, fun
);
420 /* Check for a dynamic docstring. These come with
421 a dynamic-docstring-function text property. */
425 = Fget_text_property (make_number (0),
426 intern ("dynamic-docstring-function"),
429 /* Pass both `doc' and `function' since `function' can be needed, and
430 finding `doc' can be annoying: calling `documentation' is not an
431 option because it would infloop. */
432 doc
= call2 (func
, doc
, function
);
435 /* If DOC is 0, it's typically because of a dumped file missing
436 from the DOC file (bug in src/Makefile.in). */
437 if (EQ (doc
, make_number (0)))
439 if (INTEGERP (doc
) || CONSP (doc
))
442 tem
= get_doc_string (doc
, 0, 0);
443 if (NILP (tem
) && try_reload
)
445 /* The file is newer, we need to reset the pointers. */
446 struct gcpro gcpro1
, gcpro2
;
447 GCPRO2 (function
, raw
);
448 try_reload
= reread_doc_file (Fcar_safe (doc
));
461 doc
= Fsubstitute_command_keys (doc
);
465 DEFUN ("documentation-property", Fdocumentation_property
,
466 Sdocumentation_property
, 2, 3, 0,
467 doc
: /* Return the documentation string that is SYMBOL's PROP property.
468 Third argument RAW omitted or nil means pass the result through
469 `substitute-command-keys' if it is a string.
471 This differs from `get' in that it can refer to strings stored in the
472 `etc/DOC' file; and that it evaluates documentation properties that
474 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
479 documentation_property
:
481 tem
= Fget (symbol
, prop
);
482 if (EQ (tem
, make_number (0)))
484 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
486 Lisp_Object doc
= tem
;
487 tem
= get_doc_string (tem
, 0, 0);
488 if (NILP (tem
) && try_reload
)
490 /* The file is newer, we need to reset the pointers. */
491 struct gcpro gcpro1
, gcpro2
, gcpro3
;
492 GCPRO3 (symbol
, prop
, raw
);
493 try_reload
= reread_doc_file (Fcar_safe (doc
));
498 goto documentation_property
;
502 else if (!STRINGP (tem
))
503 /* Feval protects its argument. */
504 tem
= Feval (tem
, Qnil
);
506 if (NILP (raw
) && STRINGP (tem
))
507 tem
= Fsubstitute_command_keys (tem
);
511 /* Scanning the DOC files and placing docstring offsets into functions. */
514 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
516 /* Don't use indirect_function here, or defaliases will apply their
517 docstrings to the base functions (Bug#2603). */
518 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
520 /* The type determines where the docstring is stored. */
522 /* Lisp_Subrs have a slot for it. */
525 intptr_t negative_offset
= - offset
;
526 XSUBR (fun
)->doc
= (char *) negative_offset
;
529 /* If it's a lisp form, stick it in the form. */
530 else if (CONSP (fun
))
535 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
536 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
538 tem
= Fcdr (Fcdr (fun
));
539 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
540 /* FIXME: This modifies typically pure hash-cons'd data, so its
541 correctness is quite delicate. */
542 XSETCAR (tem
, make_number (offset
));
544 else if (EQ (tem
, Qmacro
))
545 store_function_docstring (XCDR (fun
), offset
);
548 /* Bytecode objects sometimes have slots for it. */
549 else if (COMPILEDP (fun
))
551 /* This bytecode object must have a slot for the
552 docstring, since we've found a docstring for it. */
553 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
554 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
558 static const char buildobj
[] = BUILDOBJ
;
560 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
562 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
563 This searches the `etc/DOC...' file for doc strings and
564 records them in function and variable definitions.
565 The function takes one argument, FILENAME, a string;
566 it specifies the file name (without a directory) of the DOC file.
567 That file is found in `../etc' now; later, when the dumped Emacs is run,
568 the same file name is found in the `doc-directory'. */)
569 (Lisp_Object filename
)
579 CHECK_STRING (filename
);
583 (!NILP (Vpurify_flag
))
584 #else /* CANNOT_DUMP */
586 #endif /* CANNOT_DUMP */
588 name
= alloca (SCHARS (filename
) + 14);
589 strcpy (name
, "../etc/");
593 CHECK_STRING (Vdoc_directory
);
594 name
= alloca (SCHARS (filename
) + SCHARS (Vdoc_directory
) + 1);
595 strcpy (name
, SSDATA (Vdoc_directory
));
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 const char *beg
, *end
;
604 for (beg
= buildobj
; *beg
; beg
= end
)
608 while (*beg
&& c_isspace (*beg
)) ++beg
;
610 for (end
= beg
; *end
&& ! c_isspace (*end
); ++end
)
611 if (*end
== '/') beg
= end
+ 1; /* Skip directory part. */
614 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
615 len
-= 2; /* Just take .o if it ends in .obj */
618 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
620 Vbuild_files
= Fpurecopy (Vbuild_files
);
623 fd
= emacs_open (name
, O_RDONLY
, 0);
625 report_file_error ("Opening doc string file",
626 Fcons (build_string (name
), Qnil
));
627 Vdoc_file_name
= filename
;
634 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
639 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
640 p
= memchr (buf
, '\037', end
- buf
);
641 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
644 end
= strchr (p
, '\n');
646 /* See if this is a file name, and if it is a file in build-files. */
650 if (end
- p
> 4 && end
[-2] == '.'
651 && (end
[-1] == 'o' || end
[-1] == 'c'))
653 ptrdiff_t len
= end
- p
- 2;
654 char *fromfile
= alloca (len
+ 1);
655 memcpy (fromfile
, &p
[2], len
);
657 if (fromfile
[len
-1] == 'c')
658 fromfile
[len
-1] = 'o';
660 skip_file
= NILP (Fmember (build_string (fromfile
),
665 sym
= oblookup (Vobarray
, p
+ 2,
666 multibyte_chars_in_text ((unsigned char *) p
+ 2,
669 /* Check skip_file so that when a function is defined several
670 times in different files (typically, once in xterm, once in
671 w32term, ...), we only pay attention to the one that
673 if (! skip_file
&& SYMBOLP (sym
))
675 /* Attach a docstring to a variable? */
678 /* Install file-position as variable-documentation property
679 and make it negative for a user-variable
680 (doc starts with a `*'). */
681 if (!NILP (Fboundp (sym
)))
682 Fput (sym
, Qvariable_documentation
,
683 make_number ((pos
+ end
+ 1 - buf
)
684 * (end
[1] == '*' ? -1 : 1)));
687 /* Attach a docstring to a function? */
688 else if (p
[1] == 'F')
690 if (!NILP (Ffboundp (sym
)))
691 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
693 else if (p
[1] == 'S')
694 ; /* Just a source file name boundary marker. Ignore it. */
697 error ("DOC file invalid at position %"pI
"d", pos
);
702 memmove (buf
, end
, filled
);
708 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
709 Ssubstitute_command_keys
, 1, 1, 0,
710 doc
: /* Substitute key descriptions for command names in STRING.
711 Each substring of the form \\=\\[COMMAND] is replaced by either a
712 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
715 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
716 the value of MAPVAR as a keymap. This summary is similar to the one
717 produced by `describe-bindings'. The summary ends in two newlines
718 \(used by the helper function `help-make-xrefs' to find the end of the
721 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
722 as the keymap for future \\=\\[COMMAND] substrings.
723 \\=\\= quotes the following character and is discarded;
724 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
726 Return the original STRING if no substitutions are made.
727 Otherwise, return a new string, without any text properties. */)
738 unsigned char *start
;
739 ptrdiff_t length
, length_byte
;
741 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
748 CHECK_STRING (string
);
752 GCPRO4 (string
, tem
, keymap
, name
);
754 multibyte
= STRING_MULTIBYTE (string
);
757 /* KEYMAP is either nil (which means search all the active keymaps)
758 or a specified local map (which means search just that and the
759 global map). If non-nil, it might come from Voverriding_local_map,
760 or from a \\<mapname> construct in STRING itself.. */
761 keymap
= Voverriding_local_map
;
763 bsize
= SBYTES (string
);
764 bufp
= buf
= xmalloc (bsize
);
766 strp
= SDATA (string
);
767 while (strp
< SDATA (string
) + SBYTES (string
))
769 if (strp
[0] == '\\' && strp
[1] == '=')
771 /* \= quotes the next character;
772 thus, to put in \[ without its special meaning, use \=\[. */
779 STRING_CHAR_AND_LENGTH (strp
, len
);
783 memcpy (bufp
, strp
, len
);
789 *bufp
++ = *strp
++, nchars
++;
791 else if (strp
[0] == '\\' && strp
[1] == '[')
794 bool follow_remap
= 1;
797 strp
+= 2; /* skip \[ */
799 start_idx
= start
- SDATA (string
);
801 while ((strp
- SDATA (string
)
805 length_byte
= strp
- start
;
809 /* Save STRP in IDX. */
810 idx
= strp
- SDATA (string
);
811 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
814 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
816 if (VECTORP (tem
) && ASIZE (tem
) > 1
817 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
820 name
= AREF (tem
, 1);
825 /* Note the Fwhere_is_internal can GC, so we have to take
826 relocation of string contents into account. */
827 strp
= SDATA (string
) + idx
;
828 start
= SDATA (string
) + start_idx
;
830 if (NILP (tem
)) /* but not on any keys */
832 ptrdiff_t offset
= bufp
- buf
;
833 if (STRING_BYTES_BOUND
- 4 < bsize
)
835 buf
= xrealloc (buf
, bsize
+= 4);
837 memcpy (bufp
, "M-x ", 4);
841 length
= multibyte_chars_in_text (start
, length_byte
);
843 length
= length_byte
;
847 { /* function is on a key */
848 tem
= Fkey_description (tem
, Qnil
);
852 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
853 \<foo> just sets the keymap used for \[cmd]. */
854 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
856 struct buffer
*oldbuf
;
858 /* This is for computing the SHADOWS arg for describe_map_tree. */
859 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
860 Lisp_Object earlier_maps
;
863 strp
+= 2; /* skip \{ or \< */
865 start_idx
= start
- SDATA (string
);
867 while ((strp
- SDATA (string
) < SBYTES (string
))
868 && *strp
!= '}' && *strp
!= '>')
871 length_byte
= strp
- start
;
872 strp
++; /* skip } or > */
874 /* Save STRP in IDX. */
875 idx
= strp
- SDATA (string
);
877 /* Get the value of the keymap in TEM, or nil if undefined.
878 Do this while still in the user's current buffer
879 in case it is a local variable. */
880 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
881 tem
= Fboundp (name
);
884 tem
= Fsymbol_value (name
);
887 tem
= get_keymap (tem
, 0, 1);
888 /* Note that get_keymap can GC. */
889 strp
= SDATA (string
) + idx
;
890 start
= SDATA (string
) + start_idx
;
894 /* Now switch to a temp buffer. */
895 oldbuf
= current_buffer
;
896 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
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
, (char *)0, 1, 0, 0, 1);
918 tem
= Fbuffer_string ();
920 set_buffer_internal (oldbuf
);
924 length
= SCHARS (tem
);
925 length_byte
= SBYTES (tem
);
928 ptrdiff_t offset
= bufp
- buf
;
929 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
931 buf
= xrealloc (buf
, bsize
+= length_byte
);
933 memcpy (bufp
, start
, length_byte
);
936 /* Check STRING again in case gc relocated it. */
937 strp
= SDATA (string
) + idx
;
940 else if (! multibyte
) /* just copy other chars */
941 *bufp
++ = *strp
++, nchars
++;
946 STRING_CHAR_AND_LENGTH (strp
, len
);
950 memcpy (bufp
, strp
, len
);
957 if (changed
) /* don't bother if nothing substituted */
958 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
962 RETURN_UNGCPRO (tem
);
968 DEFSYM (Qfunction_documentation
, "function-documentation");
970 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
971 doc
: /* Name of file containing documentation strings of built-in symbols. */);
972 Vdoc_file_name
= Qnil
;
974 DEFVAR_LISP ("build-files", Vbuild_files
,
975 doc
: /* A list of files used to build this Emacs binary. */);
978 defsubr (&Sdocumentation
);
979 defsubr (&Sdocumentation_property
);
980 defsubr (&Ssnarf_documentation
);
981 defsubr (&Ssubstitute_command_keys
);