1 /* Record indices of function doc strings stored in a file.
2 Copyright (C) 1985-1986, 1993-1995, 1997-2011
3 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/>. */
23 #include <sys/types.h>
24 #include <sys/file.h> /* Must be after sys/types.h for USG*/
33 #include "character.h"
37 Lisp_Object Qfunction_documentation
;
39 extern Lisp_Object Qclosure
;
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
;
45 static Lisp_Object
Fdocumentation_property (Lisp_Object
, Lisp_Object
,
47 static Lisp_Object
Fsnarf_documentation (Lisp_Object
);
49 /* readchar in lread.c calls back here to fetch the next byte.
50 If UNREADFLAG is 1, we unread a byte. */
53 read_bytecode_char (int unreadflag
)
57 read_bytecode_pointer
--;
60 return *read_bytecode_pointer
++;
63 /* Extract a doc string from a file. FILEPOS says where to get it.
64 If it is an integer, use that position in the standard DOC-... file.
65 If it is (FILE . INTEGER), use FILE as the file name
66 and INTEGER as the position in that file.
67 But if INTEGER is negative, make it positive.
68 (A negative integer is used for user variables, so we can distinguish
69 them without actually fetching the doc string.)
71 If the location does not point to the beginning of a docstring
72 (e.g. because the file has been modified and the location is stale),
75 If UNIBYTE is nonzero, always make a unibyte string.
77 If DEFINITION is nonzero, assume this is for reading
78 a dynamic function definition; convert the bytestring
79 and the constants vector with appropriate byte handling,
80 and return a cons cell. */
83 get_doc_string (Lisp_Object filepos
, int unibyte
, int definition
)
88 register char *p
, *p1
;
92 Lisp_Object file
, tem
;
95 if (INTEGERP (filepos
))
97 file
= Vdoc_file_name
;
98 position
= XINT (filepos
);
100 else if (CONSP (filepos
))
102 file
= XCAR (filepos
);
103 position
= XINT (XCDR (filepos
));
109 position
= - position
;
111 if (!STRINGP (Vdoc_directory
))
117 /* Put the file name in NAME as a C string.
118 If it is relative, combine it with Vdoc_directory. */
120 tem
= Ffile_name_absolute_p (file
);
121 file
= ENCODE_FILE (file
);
124 Lisp_Object docdir
= ENCODE_FILE (Vdoc_directory
);
125 minsize
= SCHARS (docdir
);
126 /* sizeof ("../etc/") == 8 */
129 SAFE_ALLOCA (name
, char *, minsize
+ SCHARS (file
) + 8);
130 strcpy (name
, SSDATA (docdir
));
131 strcat (name
, SSDATA (file
));
135 name
= SSDATA (file
);
138 fd
= emacs_open (name
, O_RDONLY
, 0);
142 if (!NILP (Vpurify_flag
))
144 /* Preparing to dump; DOC file is probably not installed.
145 So check in ../etc. */
146 strcpy (name
, "../etc/");
147 strcat (name
, SSDATA (file
));
149 fd
= emacs_open (name
, O_RDONLY
, 0);
153 error ("Cannot open doc string file \"%s\"", name
);
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)
164 error ("Position %"pI
"d out of range in doc string file \"%s\"",
170 /* Read the doc string into get_doc_string_buffer.
171 P points beyond the data just read. */
173 p
= get_doc_string_buffer
;
176 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
177 - (p
- get_doc_string_buffer
));
180 /* Allocate or grow the buffer if we need to. */
183 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
184 get_doc_string_buffer
=
185 xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
187 p
= get_doc_string_buffer
+ in_buffer
;
188 space_left
= (get_doc_string_buffer_size
- 1
189 - (p
- get_doc_string_buffer
));
192 /* Read a disk block at a time.
193 If we read the same block last time, maybe skip this? */
194 if (space_left
> 1024 * 8)
195 space_left
= 1024 * 8;
196 nread
= emacs_read (fd
, p
, space_left
);
200 error ("Read error on documentation file");
205 if (p
== get_doc_string_buffer
)
206 p1
= strchr (p
+ offset
, '\037');
208 p1
= strchr (p
, '\037');
219 /* Sanity checking. */
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
] != '#')
235 if (get_doc_string_buffer
[offset
- test
++] != '\n')
237 while (get_doc_string_buffer
[offset
- test
] > ' ')
239 if (get_doc_string_buffer
[offset
- test
] != '\037')
243 /* Scan the text and perform quoting with ^A (char code 1).
244 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
245 from
= get_doc_string_buffer
+ offset
;
246 to
= get_doc_string_buffer
+ offset
;
263 unsigned char uc
= c
;
265 Invalid data in documentation file -- %c followed by code %03o",
273 /* If DEFINITION, read from this buffer
274 the same way we would read bytes from a file. */
277 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
278 return Fread (Qlambda
);
282 return make_unibyte_string (get_doc_string_buffer
+ offset
,
283 to
- (get_doc_string_buffer
+ offset
));
286 /* The data determines whether the string is multibyte. */
288 multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
290 to
- (get_doc_string_buffer
+ offset
));
291 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
293 to
- (get_doc_string_buffer
+ offset
));
297 /* Get a string from position FILEPOS and pass it through the Lisp reader.
298 We use this for fetching the bytecode string and constants vector
299 of a compiled function from the .elc file. */
302 read_doc_string (Lisp_Object filepos
)
304 return get_doc_string (filepos
, 0, 1);
308 reread_doc_file (Lisp_Object file
)
311 Lisp_Object reply
, prompt
[3];
314 prompt
[0] = build_string ("File ");
315 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
316 prompt
[2] = build_string (" is out of sync. Reload? ");
317 reply
= Fy_or_n_p (Fconcat (3, prompt
));
324 Fsnarf_documentation (Vdoc_file_name
);
326 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
331 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
332 doc
: /* Return the documentation string of FUNCTION.
333 Unless a non-nil second argument RAW is given, the
334 string is passed through `substitute-command-keys'. */)
335 (Lisp_Object function
, Lisp_Object raw
)
346 if (SYMBOLP (function
))
348 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
350 return Fdocumentation_property (function
, Qfunction_documentation
,
354 fun
= Findirect_function (function
, Qnil
);
357 if (XSUBR (fun
)->doc
== 0)
359 /* FIXME: This is not portable, as it assumes that string
360 pointers have the top bit clear. */
361 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
362 doc
= build_string (XSUBR (fun
)->doc
);
364 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
366 else if (COMPILEDP (fun
))
368 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
372 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
375 else if (NATNUMP (tem
) || CONSP (tem
))
381 else if (STRINGP (fun
) || VECTORP (fun
))
383 return build_string ("Keyboard macro.");
385 else if (CONSP (fun
))
388 if (!SYMBOLP (funcar
))
389 xsignal1 (Qinvalid_function
, fun
);
390 else if (EQ (funcar
, Qkeymap
))
391 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
392 else if (EQ (funcar
, Qlambda
)
393 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
394 || EQ (funcar
, Qautoload
))
396 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
397 Lisp_Object tem
= Fcar (tem1
);
400 /* Handle a doc reference--but these never come last
401 in the function body, so reject them if they are last. */
402 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
403 && !NILP (XCDR (tem1
)))
408 else if (EQ (funcar
, Qmacro
))
409 return Fdocumentation (Fcdr (fun
), raw
);
416 xsignal1 (Qinvalid_function
, fun
);
419 /* Check for an advised function. Its doc string
420 has an `ad-advice-info' text property. */
423 Lisp_Object innerfunc
;
424 innerfunc
= Fget_text_property (make_number (0),
425 intern ("ad-advice-info"),
427 if (! NILP (innerfunc
))
428 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
431 /* If DOC is 0, it's typically because of a dumped file missing
432 from the DOC file (bug in src/Makefile.in). */
433 if (EQ (doc
, make_number (0)))
435 if (INTEGERP (doc
) || CONSP (doc
))
438 tem
= get_doc_string (doc
, 0, 0);
439 if (NILP (tem
) && try_reload
)
441 /* The file is newer, we need to reset the pointers. */
442 struct gcpro gcpro1
, gcpro2
;
443 GCPRO2 (function
, raw
);
444 try_reload
= reread_doc_file (Fcar_safe (doc
));
457 doc
= Fsubstitute_command_keys (doc
);
461 DEFUN ("documentation-property", Fdocumentation_property
,
462 Sdocumentation_property
, 2, 3, 0,
463 doc
: /* Return the documentation string that is SYMBOL's PROP property.
464 Third argument RAW omitted or nil means pass the result through
465 `substitute-command-keys' if it is a string.
467 This differs from `get' in that it can refer to strings stored in the
468 `etc/DOC' file; and that it evaluates documentation properties that
470 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
475 documentation_property
:
477 tem
= Fget (symbol
, prop
);
478 if (EQ (tem
, make_number (0)))
480 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
482 Lisp_Object doc
= tem
;
483 tem
= get_doc_string (tem
, 0, 0);
484 if (NILP (tem
) && try_reload
)
486 /* The file is newer, we need to reset the pointers. */
487 struct gcpro gcpro1
, gcpro2
, gcpro3
;
488 GCPRO3 (symbol
, prop
, raw
);
489 try_reload
= reread_doc_file (Fcar_safe (doc
));
494 goto documentation_property
;
498 else if (!STRINGP (tem
))
499 /* Feval protects its argument. */
500 tem
= Feval (tem
, Qnil
);
502 if (NILP (raw
) && STRINGP (tem
))
503 tem
= Fsubstitute_command_keys (tem
);
507 /* Scanning the DOC files and placing docstring offsets into functions. */
510 store_function_docstring (Lisp_Object fun
, ptrdiff_t offset
)
512 fun
= indirect_function (fun
);
514 /* The type determines where the docstring is stored. */
516 /* Lisp_Subrs have a slot for it. */
519 intptr_t negative_offset
= - offset
;
520 XSUBR (fun
)->doc
= (char *) negative_offset
;
523 /* If it's a lisp form, stick it in the form. */
524 else if (CONSP (fun
))
529 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
530 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
532 tem
= Fcdr (Fcdr (fun
));
533 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
534 XSETCAR (tem
, make_number (offset
));
536 else if (EQ (tem
, Qmacro
))
537 store_function_docstring (XCDR (fun
), offset
);
540 /* Bytecode objects sometimes have slots for it. */
541 else if (COMPILEDP (fun
))
543 /* This bytecode object must have a slot for the
544 docstring, since we've found a docstring for it. */
545 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
546 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
550 static const char buildobj
[] = BUILDOBJ
;
552 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
554 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
555 This searches the `etc/DOC...' file for doc strings and
556 records them in function and variable definitions.
557 The function takes one argument, FILENAME, a string;
558 it specifies the file name (without a directory) of the DOC file.
559 That file is found in `../etc' now; later, when the dumped Emacs is run,
560 the same file name is found in the `doc-directory'. */)
561 (Lisp_Object filename
)
566 register EMACS_INT pos
;
572 CHECK_STRING (filename
);
576 (!NILP (Vpurify_flag
))
577 #else /* CANNOT_DUMP */
579 #endif /* CANNOT_DUMP */
581 name
= (char *) alloca (SCHARS (filename
) + 14);
582 strcpy (name
, "../etc/");
586 CHECK_STRING (Vdoc_directory
);
587 name
= (char *) alloca (SCHARS (filename
)
588 + SCHARS (Vdoc_directory
) + 1);
589 strcpy (name
, SSDATA (Vdoc_directory
));
591 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
593 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
594 if (NILP (Vbuild_files
))
596 const char *beg
, *end
;
598 for (beg
= buildobj
; *beg
; beg
= end
)
602 while (*beg
&& isspace (*beg
)) ++beg
;
604 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
605 if (*end
== '/') beg
= end
+1; /* skip directory part */
608 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
609 len
-= 2; /* Just take .o if it ends in .obj */
612 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
614 Vbuild_files
= Fpurecopy (Vbuild_files
);
617 fd
= emacs_open (name
, O_RDONLY
, 0);
619 report_file_error ("Opening doc string file",
620 Fcons (build_string (name
), Qnil
));
621 Vdoc_file_name
= filename
;
628 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
634 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
635 while (p
!= end
&& *p
!= '\037') p
++;
636 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
639 end
= strchr (p
, '\n');
641 /* See if this is a file name, and if it is a file in build-files. */
645 if (end
- p
> 4 && end
[-2] == '.'
646 && (end
[-1] == 'o' || end
[-1] == 'c'))
648 ptrdiff_t len
= end
- p
- 2;
649 char *fromfile
= alloca (len
+ 1);
650 strncpy (fromfile
, &p
[2], len
);
652 if (fromfile
[len
-1] == 'c')
653 fromfile
[len
-1] = 'o';
655 skip_file
= NILP (Fmember (build_string (fromfile
),
660 sym
= oblookup (Vobarray
, p
+ 2,
661 multibyte_chars_in_text ((unsigned char *) p
+ 2,
664 /* Check skip_file so that when a function is defined several
665 times in different files (typically, once in xterm, once in
666 w32term, ...), we only pay attention to the one that
668 if (! skip_file
&& SYMBOLP (sym
))
670 /* Attach a docstring to a variable? */
673 /* Install file-position as variable-documentation property
674 and make it negative for a user-variable
675 (doc starts with a `*'). */
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')
683 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
685 else if (p
[1] == 'S')
686 ; /* Just a source file name boundary marker. Ignore it. */
689 error ("DOC file invalid at position %"pI
"d", pos
);
694 memmove (buf
, end
, filled
);
700 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
701 Ssubstitute_command_keys
, 1, 1, 0,
702 doc
: /* Substitute key descriptions for command names in STRING.
703 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
704 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
706 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
707 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
708 Substrings of the form \\=\\<MAPVAR> specify to use the value 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 Returns original STRING if no substitutions were made. Otherwise,
714 a new string, without any text properties, is returned. */)
719 register unsigned char *strp
;
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
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
750 keymap
= Voverriding_local_map
;
752 bsize
= SBYTES (string
);
753 bufp
= buf
= (char *) xmalloc (bsize
);
755 strp
= SDATA (string
);
756 while (strp
< SDATA (string
) + SBYTES (string
))
758 if (strp
[0] == '\\' && strp
[1] == '=')
760 /* \= quotes the next character;
761 thus, to put in \[ without its special meaning, use \=\[. */
768 STRING_CHAR_AND_LENGTH (strp
, len
);
772 memcpy (bufp
, strp
, len
);
778 *bufp
++ = *strp
++, nchars
++;
780 else if (strp
[0] == '\\' && strp
[1] == '[')
783 int 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
= (char *) 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
;
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
));
889 name
= Fsymbol_name (name
);
890 insert_string ("\nUses keymap \"");
891 insert_from_string (name
, 0, 0,
894 insert_string ("\", which is not currently defined.\n");
895 if (start
[-1] == '<') keymap
= Qnil
;
897 else if (start
[-1] == '<')
901 /* Get the list of active keymaps that precede this one.
902 If this one's not active, get nil. */
903 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
904 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
905 Qnil
, (char *)0, 1, 0, 0, 1);
907 tem
= Fbuffer_string ();
909 set_buffer_internal (oldbuf
);
913 length
= SCHARS (tem
);
914 length_byte
= SBYTES (tem
);
917 ptrdiff_t offset
= bufp
- buf
;
918 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
920 buf
= (char *) xrealloc (buf
, bsize
+= length_byte
);
922 memcpy (bufp
, start
, length_byte
);
925 /* Check STRING again in case gc relocated it. */
926 strp
= SDATA (string
) + idx
;
929 else if (! multibyte
) /* just copy other chars */
930 *bufp
++ = *strp
++, nchars
++;
935 STRING_CHAR_AND_LENGTH (strp
, len
);
939 memcpy (bufp
, strp
, len
);
946 if (changed
) /* don't bother if nothing substituted */
947 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
951 RETURN_UNGCPRO (tem
);
957 DEFSYM (Qfunction_documentation
, "function-documentation");
959 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
960 doc
: /* Name of file containing documentation strings of built-in symbols. */);
961 Vdoc_file_name
= Qnil
;
963 DEFVAR_LISP ("build-files", Vbuild_files
,
964 doc
: /* A list of files used to build this Emacs binary. */);
967 defsubr (&Sdocumentation
);
968 defsubr (&Sdocumentation_property
);
969 defsubr (&Ssnarf_documentation
);
970 defsubr (&Ssubstitute_command_keys
);