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 int 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
;
90 EMACS_INT offset
, position
;
91 Lisp_Object file
, tem
;
93 if (INTEGERP (filepos
))
95 file
= Vdoc_file_name
;
96 position
= XINT (filepos
);
98 else if (CONSP (filepos
))
100 file
= XCAR (filepos
);
101 position
= XINT (XCDR (filepos
));
107 position
= - position
;
109 if (!STRINGP (Vdoc_directory
))
115 /* Put the file name in NAME as a C string.
116 If it is relative, combine it with Vdoc_directory. */
118 tem
= Ffile_name_absolute_p (file
);
121 minsize
= SCHARS (Vdoc_directory
);
122 /* sizeof ("../etc/") == 8 */
125 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
126 strcpy (name
, SSDATA (Vdoc_directory
));
127 strcat (name
, SSDATA (file
));
131 name
= SSDATA (file
);
134 fd
= emacs_open (name
, O_RDONLY
, 0);
138 if (!NILP (Vpurify_flag
))
140 /* Preparing to dump; DOC file is probably not installed.
141 So check in ../etc. */
142 strcpy (name
, "../etc/");
143 strcat (name
, SSDATA (file
));
145 fd
= emacs_open (name
, O_RDONLY
, 0);
149 error ("Cannot open doc string file \"%s\"", name
);
152 /* Seek only to beginning of disk block. */
153 /* Make sure we read at least 1024 bytes before `position'
154 so we can check the leading text for consistency. */
155 offset
= min (position
, max (1024, position
% (8 * 1024)));
156 if (0 > lseek (fd
, position
- offset
, 0))
159 error ("Position %"pI
"d out of range in doc string file \"%s\"",
163 /* Read the doc string into get_doc_string_buffer.
164 P points beyond the data just read. */
166 p
= get_doc_string_buffer
;
169 EMACS_INT space_left
= (get_doc_string_buffer_size
170 - (p
- get_doc_string_buffer
));
173 /* Allocate or grow the buffer if we need to. */
176 EMACS_INT in_buffer
= p
- get_doc_string_buffer
;
177 get_doc_string_buffer_size
+= 16 * 1024;
178 get_doc_string_buffer
179 = (char *) xrealloc (get_doc_string_buffer
,
180 get_doc_string_buffer_size
+ 1);
181 p
= get_doc_string_buffer
+ in_buffer
;
182 space_left
= (get_doc_string_buffer_size
183 - (p
- get_doc_string_buffer
));
186 /* Read a disk block at a time.
187 If we read the same block last time, maybe skip this? */
188 if (space_left
> 1024 * 8)
189 space_left
= 1024 * 8;
190 nread
= emacs_read (fd
, p
, space_left
);
194 error ("Read error on documentation file");
199 if (p
== get_doc_string_buffer
)
200 p1
= strchr (p
+ offset
, '\037');
202 p1
= strchr (p
, '\037');
213 /* Sanity checking. */
217 if (get_doc_string_buffer
[offset
- test
++] != ' ')
219 while (get_doc_string_buffer
[offset
- test
] >= '0'
220 && get_doc_string_buffer
[offset
- test
] <= '9')
222 if (get_doc_string_buffer
[offset
- test
++] != '@'
223 || 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 Invalid data in documentation file -- %c followed by code %03o",
264 /* If DEFINITION, read from this buffer
265 the same way we would read bytes from a file. */
268 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
269 return Fread (Qlambda
);
273 return make_unibyte_string (get_doc_string_buffer
+ offset
,
274 to
- (get_doc_string_buffer
+ offset
));
277 /* The data determines whether the string is multibyte. */
279 multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
281 to
- (get_doc_string_buffer
+ offset
));
282 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
284 to
- (get_doc_string_buffer
+ offset
));
288 /* Get a string from position FILEPOS and pass it through the Lisp reader.
289 We use this for fetching the bytecode string and constants vector
290 of a compiled function from the .elc file. */
293 read_doc_string (Lisp_Object filepos
)
295 return get_doc_string (filepos
, 0, 1);
299 reread_doc_file (Lisp_Object file
)
302 Lisp_Object reply
, prompt
[3];
305 prompt
[0] = build_string ("File ");
306 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
307 prompt
[2] = build_string (" is out of sync. Reload? ");
308 reply
= Fy_or_n_p (Fconcat (3, prompt
));
315 Fsnarf_documentation (Vdoc_file_name
);
317 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
322 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
323 doc
: /* Return the documentation string of FUNCTION.
324 Unless a non-nil second argument RAW is given, the
325 string is passed through `substitute-command-keys'. */)
326 (Lisp_Object function
, Lisp_Object raw
)
337 if (SYMBOLP (function
))
339 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
341 return Fdocumentation_property (function
, Qfunction_documentation
,
345 fun
= Findirect_function (function
, Qnil
);
348 if (XSUBR (fun
)->doc
== 0)
350 /* FIXME: This is not portable, as it assumes that string
351 pointers have the top bit clear. */
352 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
353 doc
= build_string (XSUBR (fun
)->doc
);
355 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
357 else if (COMPILEDP (fun
))
359 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
363 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
366 else if (NATNUMP (tem
) || CONSP (tem
))
372 else if (STRINGP (fun
) || VECTORP (fun
))
374 return build_string ("Keyboard macro.");
376 else if (CONSP (fun
))
379 if (!SYMBOLP (funcar
))
380 xsignal1 (Qinvalid_function
, fun
);
381 else if (EQ (funcar
, Qkeymap
))
382 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
383 else if (EQ (funcar
, Qlambda
)
384 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
385 || EQ (funcar
, Qautoload
))
387 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
388 Lisp_Object tem
= Fcar (tem1
);
391 /* Handle a doc reference--but these never come last
392 in the function body, so reject them if they are last. */
393 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
394 && !NILP (XCDR (tem1
)))
399 else if (EQ (funcar
, Qmacro
))
400 return Fdocumentation (Fcdr (fun
), raw
);
407 xsignal1 (Qinvalid_function
, fun
);
410 /* Check for an advised function. Its doc string
411 has an `ad-advice-info' text property. */
414 Lisp_Object innerfunc
;
415 innerfunc
= Fget_text_property (make_number (0),
416 intern ("ad-advice-info"),
418 if (! NILP (innerfunc
))
419 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
422 /* If DOC is 0, it's typically because of a dumped file missing
423 from the DOC file (bug in src/Makefile.in). */
424 if (EQ (doc
, make_number (0)))
426 if (INTEGERP (doc
) || CONSP (doc
))
429 tem
= get_doc_string (doc
, 0, 0);
430 if (NILP (tem
) && try_reload
)
432 /* The file is newer, we need to reset the pointers. */
433 struct gcpro gcpro1
, gcpro2
;
434 GCPRO2 (function
, raw
);
435 try_reload
= reread_doc_file (Fcar_safe (doc
));
448 doc
= Fsubstitute_command_keys (doc
);
452 DEFUN ("documentation-property", Fdocumentation_property
,
453 Sdocumentation_property
, 2, 3, 0,
454 doc
: /* Return the documentation string that is SYMBOL's PROP property.
455 Third argument RAW omitted or nil means pass the result through
456 `substitute-command-keys' if it is a string.
458 This differs from `get' in that it can refer to strings stored in the
459 `etc/DOC' file; and that it evaluates documentation properties that
461 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
466 documentation_property
:
468 tem
= Fget (symbol
, prop
);
469 if (EQ (tem
, make_number (0)))
471 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
473 Lisp_Object doc
= tem
;
474 tem
= get_doc_string (tem
, 0, 0);
475 if (NILP (tem
) && try_reload
)
477 /* The file is newer, we need to reset the pointers. */
478 struct gcpro gcpro1
, gcpro2
, gcpro3
;
479 GCPRO3 (symbol
, prop
, raw
);
480 try_reload
= reread_doc_file (Fcar_safe (doc
));
485 goto documentation_property
;
489 else if (!STRINGP (tem
))
490 /* Feval protects its argument. */
491 tem
= Feval (tem
, Qnil
);
493 if (NILP (raw
) && STRINGP (tem
))
494 tem
= Fsubstitute_command_keys (tem
);
498 /* Scanning the DOC files and placing docstring offsets into functions. */
501 store_function_docstring (Lisp_Object fun
, EMACS_INT offset
)
502 /* Use EMACS_INT because we get offset from pointer subtraction. */
504 fun
= indirect_function (fun
);
506 /* The type determines where the docstring is stored. */
508 /* Lisp_Subrs have a slot for it. */
510 XSUBR (fun
)->doc
= (char *) - 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 XSETCAR (tem
, make_number (offset
));
525 else if (EQ (tem
, Qmacro
))
526 store_function_docstring (XCDR (fun
), offset
);
529 /* Bytecode objects sometimes have slots for it. */
530 else if (COMPILEDP (fun
))
532 /* This bytecode object must have a slot for the
533 docstring, since we've found a docstring for it. */
534 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
535 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
539 static const char buildobj
[] = BUILDOBJ
;
541 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
543 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
544 This searches the `etc/DOC...' file for doc strings and
545 records them in function and variable definitions.
546 The function takes one argument, FILENAME, a string;
547 it specifies the file name (without a directory) of the DOC file.
548 That file is found in `../etc' now; later, when the dumped Emacs is run,
549 the same file name is found in the `doc-directory'. */)
550 (Lisp_Object filename
)
554 register EMACS_INT filled
;
555 register EMACS_INT pos
;
561 CHECK_STRING (filename
);
565 (!NILP (Vpurify_flag
))
566 #else /* CANNOT_DUMP */
568 #endif /* CANNOT_DUMP */
570 name
= (char *) alloca (SCHARS (filename
) + 14);
571 strcpy (name
, "../etc/");
575 CHECK_STRING (Vdoc_directory
);
576 name
= (char *) alloca (SCHARS (filename
)
577 + SCHARS (Vdoc_directory
) + 1);
578 strcpy (name
, SSDATA (Vdoc_directory
));
580 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
582 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
583 if (NILP (Vbuild_files
))
585 const char *beg
, *end
;
587 for (beg
= buildobj
; *beg
; beg
= end
)
591 while (*beg
&& isspace (*beg
)) ++beg
;
593 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
594 if (*end
== '/') beg
= end
+1; /* skip directory part */
597 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
598 len
-= 2; /* Just take .o if it ends in .obj */
601 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
603 Vbuild_files
= Fpurecopy (Vbuild_files
);
606 fd
= emacs_open (name
, O_RDONLY
, 0);
608 report_file_error ("Opening doc string file",
609 Fcons (build_string (name
), Qnil
));
610 Vdoc_file_name
= filename
;
617 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
623 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
624 while (p
!= end
&& *p
!= '\037') p
++;
625 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
628 end
= strchr (p
, '\n');
630 /* See if this is a file name, and if it is a file in build-files. */
634 if (end
- p
> 4 && end
[-2] == '.'
635 && (end
[-1] == 'o' || end
[-1] == 'c'))
637 EMACS_INT len
= end
- p
- 2;
638 char *fromfile
= alloca (len
+ 1);
639 strncpy (fromfile
, &p
[2], len
);
641 if (fromfile
[len
-1] == 'c')
642 fromfile
[len
-1] = 'o';
644 skip_file
= NILP (Fmember (build_string (fromfile
),
649 sym
= oblookup (Vobarray
, p
+ 2,
650 multibyte_chars_in_text ((unsigned char *) p
+ 2,
653 /* Check skip_file so that when a function is defined several
654 times in different files (typically, once in xterm, once in
655 w32term, ...), we only pay attention to the one that
657 if (! skip_file
&& SYMBOLP (sym
))
659 /* Attach a docstring to a variable? */
662 /* Install file-position as variable-documentation property
663 and make it negative for a user-variable
664 (doc starts with a `*'). */
665 Fput (sym
, Qvariable_documentation
,
666 make_number ((pos
+ end
+ 1 - buf
)
667 * (end
[1] == '*' ? -1 : 1)));
670 /* Attach a docstring to a function? */
671 else if (p
[1] == 'F')
672 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
674 else if (p
[1] == 'S')
675 ; /* Just a source file name boundary marker. Ignore it. */
678 error ("DOC file invalid at position %"pI
"d", pos
);
683 memmove (buf
, end
, filled
);
689 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
690 Ssubstitute_command_keys
, 1, 1, 0,
691 doc
: /* Substitute key descriptions for command names in STRING.
692 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
693 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
695 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
696 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
697 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
698 as the keymap for future \\=\\[COMMAND] substrings.
699 \\=\\= quotes the following character and is discarded;
700 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
702 Returns original STRING if no substitutions were made. Otherwise,
703 a new string, without any text properties, is returned. */)
708 register unsigned char *strp
;
714 unsigned char *start
;
715 EMACS_INT length
, length_byte
;
717 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
724 CHECK_STRING (string
);
728 GCPRO4 (string
, tem
, keymap
, name
);
730 multibyte
= STRING_MULTIBYTE (string
);
733 /* KEYMAP is either nil (which means search all the active keymaps)
734 or a specified local map (which means search just that and the
735 global map). If non-nil, it might come from Voverriding_local_map,
736 or from a \\<mapname> construct in STRING itself.. */
737 keymap
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
739 keymap
= Voverriding_local_map
;
741 bsize
= SBYTES (string
);
742 bufp
= buf
= (char *) xmalloc (bsize
);
744 strp
= SDATA (string
);
745 while (strp
< SDATA (string
) + SBYTES (string
))
747 if (strp
[0] == '\\' && strp
[1] == '=')
749 /* \= quotes the next character;
750 thus, to put in \[ without its special meaning, use \=\[. */
757 STRING_CHAR_AND_LENGTH (strp
, len
);
761 memcpy (bufp
, strp
, len
);
767 *bufp
++ = *strp
++, nchars
++;
769 else if (strp
[0] == '\\' && strp
[1] == '[')
772 int follow_remap
= 1;
775 strp
+= 2; /* skip \[ */
777 start_idx
= start
- SDATA (string
);
779 while ((strp
- SDATA (string
)
783 length_byte
= strp
- start
;
787 /* Save STRP in IDX. */
788 idx
= strp
- SDATA (string
);
789 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
792 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
794 if (VECTORP (tem
) && ASIZE (tem
) > 1
795 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
798 name
= AREF (tem
, 1);
803 /* Note the Fwhere_is_internal can GC, so we have to take
804 relocation of string contents into account. */
805 strp
= SDATA (string
) + idx
;
806 start
= SDATA (string
) + start_idx
;
808 if (NILP (tem
)) /* but not on any keys */
810 EMACS_INT offset
= bufp
- buf
;
811 buf
= (char *) xrealloc (buf
, bsize
+= 4);
813 memcpy (bufp
, "M-x ", 4);
817 length
= multibyte_chars_in_text (start
, length_byte
);
819 length
= length_byte
;
823 { /* function is on a key */
824 tem
= Fkey_description (tem
, Qnil
);
828 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
829 \<foo> just sets the keymap used for \[cmd]. */
830 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
832 struct buffer
*oldbuf
;
834 /* This is for computing the SHADOWS arg for describe_map_tree. */
835 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
836 Lisp_Object earlier_maps
;
839 strp
+= 2; /* skip \{ or \< */
841 start_idx
= start
- SDATA (string
);
843 while ((strp
- SDATA (string
) < SBYTES (string
))
844 && *strp
!= '}' && *strp
!= '>')
847 length_byte
= strp
- start
;
848 strp
++; /* skip } or > */
850 /* Save STRP in IDX. */
851 idx
= strp
- SDATA (string
);
853 /* Get the value of the keymap in TEM, or nil if undefined.
854 Do this while still in the user's current buffer
855 in case it is a local variable. */
856 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
857 tem
= Fboundp (name
);
860 tem
= Fsymbol_value (name
);
863 tem
= get_keymap (tem
, 0, 1);
864 /* Note that get_keymap can GC. */
865 strp
= SDATA (string
) + idx
;
866 start
= SDATA (string
) + start_idx
;
870 /* Now switch to a temp buffer. */
871 oldbuf
= current_buffer
;
872 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
876 name
= Fsymbol_name (name
);
877 insert_string ("\nUses keymap \"");
878 insert_from_string (name
, 0, 0,
881 insert_string ("\", which is not currently defined.\n");
882 if (start
[-1] == '<') keymap
= Qnil
;
884 else if (start
[-1] == '<')
888 /* Get the list of active keymaps that precede this one.
889 If this one's not active, get nil. */
890 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
891 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
892 Qnil
, (char *)0, 1, 0, 0, 1);
894 tem
= Fbuffer_string ();
896 set_buffer_internal (oldbuf
);
900 length
= SCHARS (tem
);
901 length_byte
= SBYTES (tem
);
904 EMACS_INT offset
= bufp
- buf
;
905 buf
= (char *) xrealloc (buf
, bsize
+= length_byte
);
907 memcpy (bufp
, start
, length_byte
);
910 /* Check STRING again in case gc relocated it. */
911 strp
= SDATA (string
) + idx
;
914 else if (! multibyte
) /* just copy other chars */
915 *bufp
++ = *strp
++, nchars
++;
920 STRING_CHAR_AND_LENGTH (strp
, len
);
924 memcpy (bufp
, strp
, len
);
931 if (changed
) /* don't bother if nothing substituted */
932 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
936 RETURN_UNGCPRO (tem
);
942 Qfunction_documentation
= intern_c_string ("function-documentation");
943 staticpro (&Qfunction_documentation
);
945 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
946 doc
: /* Name of file containing documentation strings of built-in symbols. */);
947 Vdoc_file_name
= Qnil
;
949 DEFVAR_LISP ("build-files", Vbuild_files
,
950 doc
: /* A list of files used to build this Emacs binary. */);
953 defsubr (&Sdocumentation
);
954 defsubr (&Sdocumentation_property
);
955 defsubr (&Ssnarf_documentation
);
956 defsubr (&Ssubstitute_command_keys
);