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
);
123 minsize
= SCHARS (Vdoc_directory
);
124 /* sizeof ("../etc/") == 8 */
127 SAFE_ALLOCA (name
, char *, minsize
+ SCHARS (file
) + 8);
128 strcpy (name
, SSDATA (Vdoc_directory
));
129 strcat (name
, SSDATA (file
));
133 name
= SSDATA (file
);
136 fd
= emacs_open (name
, O_RDONLY
, 0);
140 if (!NILP (Vpurify_flag
))
142 /* Preparing to dump; DOC file is probably not installed.
143 So check in ../etc. */
144 strcpy (name
, "../etc/");
145 strcat (name
, SSDATA (file
));
147 fd
= emacs_open (name
, O_RDONLY
, 0);
151 error ("Cannot open doc string file \"%s\"", name
);
154 /* Seek only to beginning of disk block. */
155 /* Make sure we read at least 1024 bytes before `position'
156 so we can check the leading text for consistency. */
157 offset
= min (position
, max (1024, position
% (8 * 1024)));
158 if (TYPE_MAXIMUM (off_t
) < position
159 || lseek (fd
, position
- offset
, 0) < 0)
162 error ("Position %"pI
"d out of range in doc string file \"%s\"",
168 /* Read the doc string into get_doc_string_buffer.
169 P points beyond the data just read. */
171 p
= get_doc_string_buffer
;
174 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
175 - (p
- get_doc_string_buffer
));
178 /* Allocate or grow the buffer if we need to. */
181 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
182 get_doc_string_buffer
=
183 xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
185 p
= get_doc_string_buffer
+ in_buffer
;
186 space_left
= (get_doc_string_buffer_size
- 1
187 - (p
- get_doc_string_buffer
));
190 /* Read a disk block at a time.
191 If we read the same block last time, maybe skip this? */
192 if (space_left
> 1024 * 8)
193 space_left
= 1024 * 8;
194 nread
= emacs_read (fd
, p
, space_left
);
198 error ("Read error on documentation file");
203 if (p
== get_doc_string_buffer
)
204 p1
= strchr (p
+ offset
, '\037');
206 p1
= strchr (p
, '\037');
217 /* Sanity checking. */
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
] != '#')
233 if (get_doc_string_buffer
[offset
- test
++] != '\n')
235 while (get_doc_string_buffer
[offset
- test
] > ' ')
237 if (get_doc_string_buffer
[offset
- test
] != '\037')
241 /* Scan the text and perform quoting with ^A (char code 1).
242 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
243 from
= get_doc_string_buffer
+ offset
;
244 to
= get_doc_string_buffer
+ offset
;
261 unsigned char uc
= c
;
263 Invalid data in documentation file -- %c followed by code %03o",
271 /* If DEFINITION, read from this buffer
272 the same way we would read bytes from a file. */
275 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
276 return Fread (Qlambda
);
280 return make_unibyte_string (get_doc_string_buffer
+ offset
,
281 to
- (get_doc_string_buffer
+ offset
));
284 /* The data determines whether the string is multibyte. */
286 multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
288 to
- (get_doc_string_buffer
+ offset
));
289 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
291 to
- (get_doc_string_buffer
+ offset
));
295 /* Get a string from position FILEPOS and pass it through the Lisp reader.
296 We use this for fetching the bytecode string and constants vector
297 of a compiled function from the .elc file. */
300 read_doc_string (Lisp_Object filepos
)
302 return get_doc_string (filepos
, 0, 1);
306 reread_doc_file (Lisp_Object file
)
309 Lisp_Object reply
, prompt
[3];
312 prompt
[0] = build_string ("File ");
313 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
314 prompt
[2] = build_string (" is out of sync. Reload? ");
315 reply
= Fy_or_n_p (Fconcat (3, prompt
));
322 Fsnarf_documentation (Vdoc_file_name
);
324 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
329 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
330 doc
: /* Return the documentation string of FUNCTION.
331 Unless a non-nil second argument RAW is given, the
332 string is passed through `substitute-command-keys'. */)
333 (Lisp_Object function
, Lisp_Object raw
)
344 if (SYMBOLP (function
))
346 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
348 return Fdocumentation_property (function
, Qfunction_documentation
,
352 fun
= Findirect_function (function
, Qnil
);
355 if (XSUBR (fun
)->doc
== 0)
357 /* FIXME: This is not portable, as it assumes that string
358 pointers have the top bit clear. */
359 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
360 doc
= build_string (XSUBR (fun
)->doc
);
362 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
364 else if (COMPILEDP (fun
))
366 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
370 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
373 else if (NATNUMP (tem
) || CONSP (tem
))
379 else if (STRINGP (fun
) || VECTORP (fun
))
381 return build_string ("Keyboard macro.");
383 else if (CONSP (fun
))
386 if (!SYMBOLP (funcar
))
387 xsignal1 (Qinvalid_function
, fun
);
388 else if (EQ (funcar
, Qkeymap
))
389 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
390 else if (EQ (funcar
, Qlambda
)
391 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
392 || EQ (funcar
, Qautoload
))
394 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
395 Lisp_Object tem
= Fcar (tem1
);
398 /* Handle a doc reference--but these never come last
399 in the function body, so reject them if they are last. */
400 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
401 && !NILP (XCDR (tem1
)))
406 else if (EQ (funcar
, Qmacro
))
407 return Fdocumentation (Fcdr (fun
), raw
);
414 xsignal1 (Qinvalid_function
, fun
);
417 /* Check for an advised function. Its doc string
418 has an `ad-advice-info' text property. */
421 Lisp_Object innerfunc
;
422 innerfunc
= Fget_text_property (make_number (0),
423 intern ("ad-advice-info"),
425 if (! NILP (innerfunc
))
426 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
429 /* If DOC is 0, it's typically because of a dumped file missing
430 from the DOC file (bug in src/Makefile.in). */
431 if (EQ (doc
, make_number (0)))
433 if (INTEGERP (doc
) || CONSP (doc
))
436 tem
= get_doc_string (doc
, 0, 0);
437 if (NILP (tem
) && try_reload
)
439 /* The file is newer, we need to reset the pointers. */
440 struct gcpro gcpro1
, gcpro2
;
441 GCPRO2 (function
, raw
);
442 try_reload
= reread_doc_file (Fcar_safe (doc
));
455 doc
= Fsubstitute_command_keys (doc
);
459 DEFUN ("documentation-property", Fdocumentation_property
,
460 Sdocumentation_property
, 2, 3, 0,
461 doc
: /* Return the documentation string that is SYMBOL's PROP property.
462 Third argument RAW omitted or nil means pass the result through
463 `substitute-command-keys' if it is a string.
465 This differs from `get' in that it can refer to strings stored in the
466 `etc/DOC' file; and that it evaluates documentation properties that
468 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
473 documentation_property
:
475 tem
= Fget (symbol
, prop
);
476 if (EQ (tem
, make_number (0)))
478 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
480 Lisp_Object doc
= tem
;
481 tem
= get_doc_string (tem
, 0, 0);
482 if (NILP (tem
) && try_reload
)
484 /* The file is newer, we need to reset the pointers. */
485 struct gcpro gcpro1
, gcpro2
, gcpro3
;
486 GCPRO3 (symbol
, prop
, raw
);
487 try_reload
= reread_doc_file (Fcar_safe (doc
));
492 goto documentation_property
;
496 else if (!STRINGP (tem
))
497 /* Feval protects its argument. */
498 tem
= Feval (tem
, Qnil
);
500 if (NILP (raw
) && STRINGP (tem
))
501 tem
= Fsubstitute_command_keys (tem
);
505 /* Scanning the DOC files and placing docstring offsets into functions. */
508 store_function_docstring (Lisp_Object fun
, ptrdiff_t offset
)
510 fun
= indirect_function (fun
);
512 /* The type determines where the docstring is stored. */
514 /* Lisp_Subrs have a slot for it. */
517 intptr_t negative_offset
= - offset
;
518 XSUBR (fun
)->doc
= (char *) negative_offset
;
521 /* If it's a lisp form, stick it in the form. */
522 else if (CONSP (fun
))
527 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
528 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
530 tem
= Fcdr (Fcdr (fun
));
531 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
532 XSETCAR (tem
, make_number (offset
));
534 else if (EQ (tem
, Qmacro
))
535 store_function_docstring (XCDR (fun
), offset
);
538 /* Bytecode objects sometimes have slots for it. */
539 else if (COMPILEDP (fun
))
541 /* This bytecode object must have a slot for the
542 docstring, since we've found a docstring for it. */
543 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
544 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
548 static const char buildobj
[] = BUILDOBJ
;
550 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
552 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
553 This searches the `etc/DOC...' file for doc strings and
554 records them in function and variable definitions.
555 The function takes one argument, FILENAME, a string;
556 it specifies the file name (without a directory) of the DOC file.
557 That file is found in `../etc' now; later, when the dumped Emacs is run,
558 the same file name is found in the `doc-directory'. */)
559 (Lisp_Object filename
)
564 register EMACS_INT pos
;
570 CHECK_STRING (filename
);
574 (!NILP (Vpurify_flag
))
575 #else /* CANNOT_DUMP */
577 #endif /* CANNOT_DUMP */
579 name
= (char *) alloca (SCHARS (filename
) + 14);
580 strcpy (name
, "../etc/");
584 CHECK_STRING (Vdoc_directory
);
585 name
= (char *) alloca (SCHARS (filename
)
586 + SCHARS (Vdoc_directory
) + 1);
587 strcpy (name
, SSDATA (Vdoc_directory
));
589 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
591 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
592 if (NILP (Vbuild_files
))
594 const char *beg
, *end
;
596 for (beg
= buildobj
; *beg
; beg
= end
)
600 while (*beg
&& isspace (*beg
)) ++beg
;
602 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
603 if (*end
== '/') beg
= end
+1; /* skip directory part */
606 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
607 len
-= 2; /* Just take .o if it ends in .obj */
610 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
612 Vbuild_files
= Fpurecopy (Vbuild_files
);
615 fd
= emacs_open (name
, O_RDONLY
, 0);
617 report_file_error ("Opening doc string file",
618 Fcons (build_string (name
), Qnil
));
619 Vdoc_file_name
= filename
;
626 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
632 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
633 while (p
!= end
&& *p
!= '\037') p
++;
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
= alloca (len
+ 1);
648 strncpy (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 Fput (sym
, Qvariable_documentation
,
675 make_number ((pos
+ end
+ 1 - buf
)
676 * (end
[1] == '*' ? -1 : 1)));
679 /* Attach a docstring to a function? */
680 else if (p
[1] == 'F')
681 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
683 else if (p
[1] == 'S')
684 ; /* Just a source file name boundary marker. Ignore it. */
687 error ("DOC file invalid at position %"pI
"d", pos
);
692 memmove (buf
, end
, filled
);
698 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
699 Ssubstitute_command_keys
, 1, 1, 0,
700 doc
: /* Substitute key descriptions for command names in STRING.
701 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
702 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
704 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
705 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
706 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
707 as the keymap for future \\=\\[COMMAND] substrings.
708 \\=\\= quotes the following character and is discarded;
709 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
711 Returns original STRING if no substitutions were made. Otherwise,
712 a new string, without any text properties, is returned. */)
717 register unsigned char *strp
;
723 unsigned char *start
;
724 ptrdiff_t length
, length_byte
;
726 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
733 CHECK_STRING (string
);
737 GCPRO4 (string
, tem
, keymap
, name
);
739 multibyte
= STRING_MULTIBYTE (string
);
742 /* KEYMAP is either nil (which means search all the active keymaps)
743 or a specified local map (which means search just that and the
744 global map). If non-nil, it might come from Voverriding_local_map,
745 or from a \\<mapname> construct in STRING itself.. */
746 keymap
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
748 keymap
= Voverriding_local_map
;
750 bsize
= SBYTES (string
);
751 bufp
= buf
= (char *) xmalloc (bsize
);
753 strp
= SDATA (string
);
754 while (strp
< SDATA (string
) + SBYTES (string
))
756 if (strp
[0] == '\\' && strp
[1] == '=')
758 /* \= quotes the next character;
759 thus, to put in \[ without its special meaning, use \=\[. */
766 STRING_CHAR_AND_LENGTH (strp
, len
);
770 memcpy (bufp
, strp
, len
);
776 *bufp
++ = *strp
++, nchars
++;
778 else if (strp
[0] == '\\' && strp
[1] == '[')
781 int follow_remap
= 1;
784 strp
+= 2; /* skip \[ */
786 start_idx
= start
- SDATA (string
);
788 while ((strp
- SDATA (string
)
792 length_byte
= strp
- start
;
796 /* Save STRP in IDX. */
797 idx
= strp
- SDATA (string
);
798 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
801 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
803 if (VECTORP (tem
) && ASIZE (tem
) > 1
804 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
807 name
= AREF (tem
, 1);
812 /* Note the Fwhere_is_internal can GC, so we have to take
813 relocation of string contents into account. */
814 strp
= SDATA (string
) + idx
;
815 start
= SDATA (string
) + start_idx
;
817 if (NILP (tem
)) /* but not on any keys */
819 ptrdiff_t offset
= bufp
- buf
;
820 if (STRING_BYTES_BOUND
- 4 < bsize
)
822 buf
= (char *) xrealloc (buf
, bsize
+= 4);
824 memcpy (bufp
, "M-x ", 4);
828 length
= multibyte_chars_in_text (start
, length_byte
);
830 length
= length_byte
;
834 { /* function is on a key */
835 tem
= Fkey_description (tem
, Qnil
);
839 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
840 \<foo> just sets the keymap used for \[cmd]. */
841 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
843 struct buffer
*oldbuf
;
845 /* This is for computing the SHADOWS arg for describe_map_tree. */
846 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
847 Lisp_Object earlier_maps
;
850 strp
+= 2; /* skip \{ or \< */
852 start_idx
= start
- SDATA (string
);
854 while ((strp
- SDATA (string
) < SBYTES (string
))
855 && *strp
!= '}' && *strp
!= '>')
858 length_byte
= strp
- start
;
859 strp
++; /* skip } or > */
861 /* Save STRP in IDX. */
862 idx
= strp
- SDATA (string
);
864 /* Get the value of the keymap in TEM, or nil if undefined.
865 Do this while still in the user's current buffer
866 in case it is a local variable. */
867 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
868 tem
= Fboundp (name
);
871 tem
= Fsymbol_value (name
);
874 tem
= get_keymap (tem
, 0, 1);
875 /* Note that get_keymap can GC. */
876 strp
= SDATA (string
) + idx
;
877 start
= SDATA (string
) + start_idx
;
881 /* Now switch to a temp buffer. */
882 oldbuf
= current_buffer
;
883 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
887 name
= Fsymbol_name (name
);
888 insert_string ("\nUses keymap \"");
889 insert_from_string (name
, 0, 0,
892 insert_string ("\", which is not currently defined.\n");
893 if (start
[-1] == '<') keymap
= Qnil
;
895 else if (start
[-1] == '<')
899 /* Get the list of active keymaps that precede this one.
900 If this one's not active, get nil. */
901 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
902 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
903 Qnil
, (char *)0, 1, 0, 0, 1);
905 tem
= Fbuffer_string ();
907 set_buffer_internal (oldbuf
);
911 length
= SCHARS (tem
);
912 length_byte
= SBYTES (tem
);
915 ptrdiff_t offset
= bufp
- buf
;
916 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
918 buf
= (char *) xrealloc (buf
, bsize
+= length_byte
);
920 memcpy (bufp
, start
, length_byte
);
923 /* Check STRING again in case gc relocated it. */
924 strp
= SDATA (string
) + idx
;
927 else if (! multibyte
) /* just copy other chars */
928 *bufp
++ = *strp
++, nchars
++;
933 STRING_CHAR_AND_LENGTH (strp
, len
);
937 memcpy (bufp
, strp
, len
);
944 if (changed
) /* don't bother if nothing substituted */
945 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
949 RETURN_UNGCPRO (tem
);
955 DEFSYM (Qfunction_documentation
, "function-documentation");
957 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
958 doc
: /* Name of file containing documentation strings of built-in symbols. */);
959 Vdoc_file_name
= Qnil
;
961 DEFVAR_LISP ("build-files", Vbuild_files
,
962 doc
: /* A list of files used to build this Emacs binary. */);
965 defsubr (&Sdocumentation
);
966 defsubr (&Sdocumentation_property
);
967 defsubr (&Ssnarf_documentation
);
968 defsubr (&Ssubstitute_command_keys
);