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 %"pEd
" 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
;
256 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
262 /* If DEFINITION, read from this buffer
263 the same way we would read bytes from a file. */
266 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
267 return Fread (Qlambda
);
271 return make_unibyte_string (get_doc_string_buffer
+ offset
,
272 to
- (get_doc_string_buffer
+ offset
));
275 /* The data determines whether the string is multibyte. */
277 multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
279 to
- (get_doc_string_buffer
+ offset
));
280 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
282 to
- (get_doc_string_buffer
+ offset
));
286 /* Get a string from position FILEPOS and pass it through the Lisp reader.
287 We use this for fetching the bytecode string and constants vector
288 of a compiled function from the .elc file. */
291 read_doc_string (Lisp_Object filepos
)
293 return get_doc_string (filepos
, 0, 1);
297 reread_doc_file (Lisp_Object file
)
300 Lisp_Object reply
, prompt
[3];
303 prompt
[0] = build_string ("File ");
304 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
305 prompt
[2] = build_string (" is out of sync. Reload? ");
306 reply
= Fy_or_n_p (Fconcat (3, prompt
));
313 Fsnarf_documentation (Vdoc_file_name
);
315 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
320 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
321 doc
: /* Return the documentation string of FUNCTION.
322 Unless a non-nil second argument RAW is given, the
323 string is passed through `substitute-command-keys'. */)
324 (Lisp_Object function
, Lisp_Object raw
)
335 if (SYMBOLP (function
))
337 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
339 return Fdocumentation_property (function
, Qfunction_documentation
,
343 fun
= Findirect_function (function
, Qnil
);
346 if (XSUBR (fun
)->doc
== 0)
348 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
349 doc
= build_string (XSUBR (fun
)->doc
);
351 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
353 else if (COMPILEDP (fun
))
355 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
359 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
362 else if (NATNUMP (tem
) || CONSP (tem
))
368 else if (STRINGP (fun
) || VECTORP (fun
))
370 return build_string ("Keyboard macro.");
372 else if (CONSP (fun
))
375 if (!SYMBOLP (funcar
))
376 xsignal1 (Qinvalid_function
, fun
);
377 else if (EQ (funcar
, Qkeymap
))
378 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
379 else if (EQ (funcar
, Qlambda
)
380 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
381 || EQ (funcar
, Qautoload
))
383 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
384 Lisp_Object tem
= Fcar (tem1
);
387 /* Handle a doc reference--but these never come last
388 in the function body, so reject them if they are last. */
389 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
390 && !NILP (XCDR (tem1
)))
395 else if (EQ (funcar
, Qmacro
))
396 return Fdocumentation (Fcdr (fun
), raw
);
403 xsignal1 (Qinvalid_function
, fun
);
406 /* Check for an advised function. Its doc string
407 has an `ad-advice-info' text property. */
410 Lisp_Object innerfunc
;
411 innerfunc
= Fget_text_property (make_number (0),
412 intern ("ad-advice-info"),
414 if (! NILP (innerfunc
))
415 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
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 fun
, EMACS_INT offset
)
498 /* Use EMACS_INT because we get offset from pointer subtraction. */
500 fun
= indirect_function (fun
);
502 /* The type determines where the docstring is stored. */
504 /* Lisp_Subrs have a slot for it. */
506 XSUBR (fun
)->doc
= (char *) - offset
;
508 /* If it's a lisp form, stick it in the form. */
509 else if (CONSP (fun
))
514 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
515 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
517 tem
= Fcdr (Fcdr (fun
));
518 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
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
));
535 static const char buildobj
[] = BUILDOBJ
;
537 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
539 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
540 This searches the `etc/DOC...' file for doc strings and
541 records them in function and variable definitions.
542 The function takes one argument, FILENAME, a string;
543 it specifies the file name (without a directory) of the DOC file.
544 That file is found in `../etc' now; later, when the dumped Emacs is run,
545 the same file name is found in the `doc-directory'. */)
546 (Lisp_Object filename
)
550 register EMACS_INT filled
;
551 register EMACS_INT pos
;
557 CHECK_STRING (filename
);
561 (!NILP (Vpurify_flag
))
562 #else /* CANNOT_DUMP */
564 #endif /* CANNOT_DUMP */
566 name
= (char *) alloca (SCHARS (filename
) + 14);
567 strcpy (name
, "../etc/");
571 CHECK_STRING (Vdoc_directory
);
572 name
= (char *) alloca (SCHARS (filename
)
573 + SCHARS (Vdoc_directory
) + 1);
574 strcpy (name
, SSDATA (Vdoc_directory
));
576 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
578 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
579 if (NILP (Vbuild_files
))
581 const char *beg
, *end
;
583 for (beg
= buildobj
; *beg
; beg
= end
)
587 while (*beg
&& isspace (*beg
)) ++beg
;
589 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
590 if (*end
== '/') beg
= end
+1; /* skip directory part */
593 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
594 len
-= 2; /* Just take .o if it ends in .obj */
597 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
599 Vbuild_files
= Fpurecopy (Vbuild_files
);
602 fd
= emacs_open (name
, O_RDONLY
, 0);
604 report_file_error ("Opening doc string file",
605 Fcons (build_string (name
), Qnil
));
606 Vdoc_file_name
= filename
;
613 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
619 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
620 while (p
!= end
&& *p
!= '\037') p
++;
621 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
624 end
= strchr (p
, '\n');
626 /* See if this is a file name, and if it is a file in build-files. */
630 if (end
- p
> 4 && end
[-2] == '.'
631 && (end
[-1] == 'o' || end
[-1] == 'c'))
633 EMACS_INT len
= end
- p
- 2;
634 char *fromfile
= alloca (len
+ 1);
635 strncpy (fromfile
, &p
[2], len
);
637 if (fromfile
[len
-1] == 'c')
638 fromfile
[len
-1] = 'o';
640 skip_file
= NILP (Fmember (build_string (fromfile
),
645 sym
= oblookup (Vobarray
, p
+ 2,
646 multibyte_chars_in_text ((unsigned char *) p
+ 2,
649 /* Check skip_file so that when a function is defined several
650 times in different files (typically, once in xterm, once in
651 w32term, ...), we only pay attention to the one that
653 if (! skip_file
&& SYMBOLP (sym
))
655 /* Attach a docstring to a variable? */
658 /* Install file-position as variable-documentation property
659 and make it negative for a user-variable
660 (doc starts with a `*'). */
661 Fput (sym
, Qvariable_documentation
,
662 make_number ((pos
+ end
+ 1 - buf
)
663 * (end
[1] == '*' ? -1 : 1)));
666 /* Attach a docstring to a function? */
667 else if (p
[1] == 'F')
668 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
670 else if (p
[1] == 'S')
671 ; /* Just a source file name boundary marker. Ignore it. */
674 error ("DOC file invalid at position %"pEd
, pos
);
679 memmove (buf
, end
, filled
);
685 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
686 Ssubstitute_command_keys
, 1, 1, 0,
687 doc
: /* Substitute key descriptions for command names in STRING.
688 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
689 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
691 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
692 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
693 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
694 as the keymap for future \\=\\[COMMAND] substrings.
695 \\=\\= quotes the following character and is discarded;
696 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
698 Returns original STRING if no substitutions were made. Otherwise,
699 a new string, without any text properties, is returned. */)
704 register unsigned char *strp
;
710 unsigned char *start
;
711 EMACS_INT length
, length_byte
;
713 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
720 CHECK_STRING (string
);
724 GCPRO4 (string
, tem
, keymap
, name
);
726 multibyte
= STRING_MULTIBYTE (string
);
729 /* KEYMAP is either nil (which means search all the active keymaps)
730 or a specified local map (which means search just that and the
731 global map). If non-nil, it might come from Voverriding_local_map,
732 or from a \\<mapname> construct in STRING itself.. */
733 keymap
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
735 keymap
= Voverriding_local_map
;
737 bsize
= SBYTES (string
);
738 bufp
= buf
= (char *) xmalloc (bsize
);
740 strp
= SDATA (string
);
741 while (strp
< SDATA (string
) + SBYTES (string
))
743 if (strp
[0] == '\\' && strp
[1] == '=')
745 /* \= quotes the next character;
746 thus, to put in \[ without its special meaning, use \=\[. */
753 STRING_CHAR_AND_LENGTH (strp
, len
);
757 memcpy (bufp
, strp
, len
);
763 *bufp
++ = *strp
++, nchars
++;
765 else if (strp
[0] == '\\' && strp
[1] == '[')
768 int follow_remap
= 1;
771 strp
+= 2; /* skip \[ */
773 start_idx
= start
- SDATA (string
);
775 while ((strp
- SDATA (string
)
779 length_byte
= strp
- start
;
783 /* Save STRP in IDX. */
784 idx
= strp
- SDATA (string
);
785 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
788 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
790 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
791 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
794 name
= AREF (tem
, 1);
799 /* Note the Fwhere_is_internal can GC, so we have to take
800 relocation of string contents into account. */
801 strp
= SDATA (string
) + idx
;
802 start
= SDATA (string
) + start_idx
;
804 if (NILP (tem
)) /* but not on any keys */
806 EMACS_INT offset
= bufp
- buf
;
807 buf
= (char *) xrealloc (buf
, bsize
+= 4);
809 memcpy (bufp
, "M-x ", 4);
813 length
= multibyte_chars_in_text (start
, length_byte
);
815 length
= length_byte
;
819 { /* function is on a key */
820 tem
= Fkey_description (tem
, Qnil
);
824 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
825 \<foo> just sets the keymap used for \[cmd]. */
826 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
828 struct buffer
*oldbuf
;
830 /* This is for computing the SHADOWS arg for describe_map_tree. */
831 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
832 Lisp_Object earlier_maps
;
835 strp
+= 2; /* skip \{ or \< */
837 start_idx
= start
- SDATA (string
);
839 while ((strp
- SDATA (string
) < SBYTES (string
))
840 && *strp
!= '}' && *strp
!= '>')
843 length_byte
= strp
- start
;
844 strp
++; /* skip } or > */
846 /* Save STRP in IDX. */
847 idx
= strp
- SDATA (string
);
849 /* Get the value of the keymap in TEM, or nil if undefined.
850 Do this while still in the user's current buffer
851 in case it is a local variable. */
852 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
853 tem
= Fboundp (name
);
856 tem
= Fsymbol_value (name
);
859 tem
= get_keymap (tem
, 0, 1);
860 /* Note that get_keymap can GC. */
861 strp
= SDATA (string
) + idx
;
862 start
= SDATA (string
) + start_idx
;
866 /* Now switch to a temp buffer. */
867 oldbuf
= current_buffer
;
868 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
872 name
= Fsymbol_name (name
);
873 insert_string ("\nUses keymap \"");
874 insert_from_string (name
, 0, 0,
877 insert_string ("\", which is not currently defined.\n");
878 if (start
[-1] == '<') keymap
= Qnil
;
880 else if (start
[-1] == '<')
884 /* Get the list of active keymaps that precede this one.
885 If this one's not active, get nil. */
886 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
887 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
888 Qnil
, (char *)0, 1, 0, 0, 1);
890 tem
= Fbuffer_string ();
892 set_buffer_internal (oldbuf
);
896 length
= SCHARS (tem
);
897 length_byte
= SBYTES (tem
);
900 EMACS_INT offset
= bufp
- buf
;
901 buf
= (char *) xrealloc (buf
, bsize
+= length_byte
);
903 memcpy (bufp
, start
, length_byte
);
906 /* Check STRING again in case gc relocated it. */
907 strp
= SDATA (string
) + idx
;
910 else if (! multibyte
) /* just copy other chars */
911 *bufp
++ = *strp
++, nchars
++;
916 STRING_CHAR_AND_LENGTH (strp
, len
);
920 memcpy (bufp
, strp
, len
);
927 if (changed
) /* don't bother if nothing substituted */
928 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
932 RETURN_UNGCPRO (tem
);
938 Qfunction_documentation
= intern_c_string ("function-documentation");
939 staticpro (&Qfunction_documentation
);
941 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
942 doc
: /* Name of file containing documentation strings of built-in symbols. */);
943 Vdoc_file_name
= Qnil
;
945 DEFVAR_LISP ("build-files", Vbuild_files
,
946 doc
: /* A list of files used to build this Emacs binary. */);
949 defsubr (&Sdocumentation
);
950 defsubr (&Sdocumentation_property
);
951 defsubr (&Ssnarf_documentation
);
952 defsubr (&Ssubstitute_command_keys
);