1 /* Record indices of function doc strings stored in a file.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
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*/
44 #include "character.h"
49 extern char *index
P_ ((const char *, int));
52 Lisp_Object Vdoc_file_name
;
54 Lisp_Object Qfunction_documentation
;
56 /* A list of files used to build this Emacs binary. */
57 static Lisp_Object Vbuild_files
;
59 extern Lisp_Object Voverriding_local_map
, Qclosure
;
61 extern Lisp_Object Qremap
;
63 /* Buffer used for reading from documentation file. */
64 static char *get_doc_string_buffer
;
65 static int get_doc_string_buffer_size
;
67 static unsigned char *read_bytecode_pointer
;
68 Lisp_Object Fsnarf_documentation
P_ ((Lisp_Object
));
70 /* readchar in lread.c calls back here to fetch the next byte.
71 If UNREADFLAG is 1, we unread a byte. */
74 read_bytecode_char (unreadflag
)
79 read_bytecode_pointer
--;
82 return *read_bytecode_pointer
++;
85 /* Extract a doc string from a file. FILEPOS says where to get it.
86 If it is an integer, use that position in the standard DOC-... file.
87 If it is (FILE . INTEGER), use FILE as the file name
88 and INTEGER as the position in that file.
89 But if INTEGER is negative, make it positive.
90 (A negative integer is used for user variables, so we can distinguish
91 them without actually fetching the doc string.)
93 If the location does not point to the beginning of a docstring
94 (e.g. because the file has been modified and the location is stale),
97 If UNIBYTE is nonzero, always make a unibyte string.
99 If DEFINITION is nonzero, assume this is for reading
100 a dynamic function definition; convert the bytestring
101 and the constants vector with appropriate byte handling,
102 and return a cons cell. */
105 get_doc_string (filepos
, unibyte
, definition
)
107 int unibyte
, definition
;
112 register char *p
, *p1
;
114 int offset
, position
;
115 Lisp_Object file
, tem
;
117 if (INTEGERP (filepos
))
119 file
= Vdoc_file_name
;
120 position
= XINT (filepos
);
122 else if (CONSP (filepos
))
124 file
= XCAR (filepos
);
125 position
= XINT (XCDR (filepos
));
131 position
= - position
;
133 if (!STRINGP (Vdoc_directory
))
139 /* Put the file name in NAME as a C string.
140 If it is relative, combine it with Vdoc_directory. */
142 tem
= Ffile_name_absolute_p (file
);
145 minsize
= SCHARS (Vdoc_directory
);
146 /* sizeof ("../etc/") == 8 */
149 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
150 strcpy (name
, SDATA (Vdoc_directory
));
151 strcat (name
, SDATA (file
));
155 name
= (char *) SDATA (file
);
158 fd
= emacs_open (name
, O_RDONLY
, 0);
162 if (!NILP (Vpurify_flag
))
164 /* Preparing to dump; DOC file is probably not installed.
165 So check in ../etc. */
166 strcpy (name
, "../etc/");
167 strcat (name
, SDATA (file
));
169 fd
= emacs_open (name
, O_RDONLY
, 0);
173 error ("Cannot open doc string file \"%s\"", name
);
176 /* Seek only to beginning of disk block. */
177 /* Make sure we read at least 1024 bytes before `position'
178 so we can check the leading text for consistency. */
179 offset
= min (position
, max (1024, position
% (8 * 1024)));
180 if (0 > lseek (fd
, position
- offset
, 0))
183 error ("Position %ld out of range in doc string file \"%s\"",
187 /* Read the doc string into get_doc_string_buffer.
188 P points beyond the data just read. */
190 p
= get_doc_string_buffer
;
193 int space_left
= (get_doc_string_buffer_size
194 - (p
- get_doc_string_buffer
));
197 /* Allocate or grow the buffer if we need to. */
200 int in_buffer
= p
- get_doc_string_buffer
;
201 get_doc_string_buffer_size
+= 16 * 1024;
202 get_doc_string_buffer
203 = (char *) xrealloc (get_doc_string_buffer
,
204 get_doc_string_buffer_size
+ 1);
205 p
= get_doc_string_buffer
+ in_buffer
;
206 space_left
= (get_doc_string_buffer_size
207 - (p
- get_doc_string_buffer
));
210 /* Read a disk block at a time.
211 If we read the same block last time, maybe skip this? */
212 if (space_left
> 1024 * 8)
213 space_left
= 1024 * 8;
214 nread
= emacs_read (fd
, p
, space_left
);
218 error ("Read error on documentation file");
223 if (p
== get_doc_string_buffer
)
224 p1
= (char *) index (p
+ offset
, '\037');
226 p1
= (char *) index (p
, '\037');
237 /* Sanity checking. */
241 if (get_doc_string_buffer
[offset
- test
++] != ' ')
243 while (get_doc_string_buffer
[offset
- test
] >= '0'
244 && get_doc_string_buffer
[offset
- test
] <= '9')
246 if (get_doc_string_buffer
[offset
- test
++] != '@'
247 || get_doc_string_buffer
[offset
- test
] != '#')
253 if (get_doc_string_buffer
[offset
- test
++] != '\n')
255 while (get_doc_string_buffer
[offset
- test
] > ' ')
257 if (get_doc_string_buffer
[offset
- test
] != '\037')
261 /* Scan the text and perform quoting with ^A (char code 1).
262 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
263 from
= get_doc_string_buffer
+ offset
;
264 to
= get_doc_string_buffer
+ offset
;
280 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
286 /* If DEFINITION, read from this buffer
287 the same way we would read bytes from a file. */
290 read_bytecode_pointer
= get_doc_string_buffer
+ offset
;
291 return Fread (Qlambda
);
295 return make_unibyte_string (get_doc_string_buffer
+ offset
,
296 to
- (get_doc_string_buffer
+ offset
));
299 /* Let the data determine whether the string is multibyte,
300 even if Emacs is running in --unibyte mode. */
301 int nchars
= multibyte_chars_in_text (get_doc_string_buffer
+ offset
,
302 to
- (get_doc_string_buffer
+ offset
));
303 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
305 to
- (get_doc_string_buffer
+ offset
));
309 /* Get a string from position FILEPOS and pass it through the Lisp reader.
310 We use this for fetching the bytecode string and constants vector
311 of a compiled function from the .elc file. */
314 read_doc_string (filepos
)
317 return get_doc_string (filepos
, 0, 1);
321 reread_doc_file (file
)
325 Lisp_Object reply
, prompt
[3];
328 prompt
[0] = build_string ("File ");
329 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
330 prompt
[2] = build_string (" is out of sync. Reload? ");
331 reply
= Fy_or_n_p (Fconcat (3, prompt
));
338 Fsnarf_documentation (Vdoc_file_name
);
340 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
345 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
346 doc
: /* Return the documentation string of FUNCTION.
347 Unless a non-nil second argument RAW is given, the
348 string is passed through `substitute-command-keys'. */)
350 Lisp_Object function
, raw
;
354 Lisp_Object tem
, doc
;
361 if (SYMBOLP (function
)
362 && (tem
= Fget (function
, Qfunction_documentation
),
364 return Fdocumentation_property (function
, Qfunction_documentation
, raw
);
366 fun
= Findirect_function (function
, Qnil
);
369 if (XSUBR (fun
)->doc
== 0)
371 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
372 doc
= build_string (XSUBR (fun
)->doc
);
374 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
376 else if (COMPILEDP (fun
))
378 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
380 tem
= AREF (fun
, COMPILED_DOC_STRING
);
383 else if (NATNUMP (tem
) || CONSP (tem
))
388 else if (FUNVECP (fun
))
390 /* Unless otherwise handled, funvecs have no documentation. */
393 else if (STRINGP (fun
) || VECTORP (fun
))
395 return build_string ("Keyboard macro.");
397 else if (CONSP (fun
))
400 if (!SYMBOLP (funcar
))
401 xsignal1 (Qinvalid_function
, fun
);
402 else if (EQ (funcar
, Qkeymap
))
403 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
404 else if (EQ (funcar
, Qlambda
)
405 || EQ (funcar
, Qautoload
))
408 tem1
= Fcdr (Fcdr (fun
));
412 /* Handle a doc reference--but these never come last
413 in the function body, so reject them if they are last. */
414 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
415 && !NILP (XCDR (tem1
)))
420 else if (EQ (funcar
, Qclosure
))
421 return Fdocumentation (Fcdr (XCDR (fun
)), raw
);
422 else if (EQ (funcar
, Qmacro
))
423 return Fdocumentation (Fcdr (fun
), raw
);
430 xsignal1 (Qinvalid_function
, fun
);
433 /* Check for an advised function. Its doc string
434 has an `ad-advice-info' text property. */
437 Lisp_Object innerfunc
;
438 innerfunc
= Fget_text_property (make_number (0),
439 intern ("ad-advice-info"),
441 if (! NILP (innerfunc
))
442 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
445 /* If DOC is 0, it's typically because of a dumped file missing
446 from the DOC file (bug in src/Makefile.in). */
447 if (EQ (doc
, make_number (0)))
449 if (INTEGERP (doc
) || CONSP (doc
))
452 tem
= get_doc_string (doc
, 0, 0);
453 if (NILP (tem
) && try_reload
)
455 /* The file is newer, we need to reset the pointers. */
456 struct gcpro gcpro1
, gcpro2
;
457 GCPRO2 (function
, raw
);
458 try_reload
= reread_doc_file (Fcar_safe (doc
));
471 doc
= Fsubstitute_command_keys (doc
);
475 DEFUN ("documentation-property", Fdocumentation_property
,
476 Sdocumentation_property
, 2, 3, 0,
477 doc
: /* Return the documentation string that is SYMBOL's PROP property.
478 Third argument RAW omitted or nil means pass the result through
479 `substitute-command-keys' if it is a string.
481 This differs from `get' in that it can refer to strings stored in the
482 `etc/DOC' file; and that it evaluates documentation properties that
485 Lisp_Object symbol
, prop
, raw
;
490 documentation_property
:
492 tem
= Fget (symbol
, prop
);
493 if (EQ (tem
, make_number (0)))
495 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
497 Lisp_Object doc
= tem
;
498 tem
= get_doc_string (tem
, 0, 0);
499 if (NILP (tem
) && try_reload
)
501 /* The file is newer, we need to reset the pointers. */
502 struct gcpro gcpro1
, gcpro2
, gcpro3
;
503 GCPRO3 (symbol
, prop
, raw
);
504 try_reload
= reread_doc_file (Fcar_safe (doc
));
509 goto documentation_property
;
513 else if (!STRINGP (tem
))
514 /* Feval protects its argument. */
517 if (NILP (raw
) && STRINGP (tem
))
518 tem
= Fsubstitute_command_keys (tem
);
522 /* Scanning the DOC files and placing docstring offsets into functions. */
525 store_function_docstring (fun
, offset
)
527 /* Use EMACS_INT because we get this from pointer subtraction. */
530 fun
= indirect_function (fun
);
532 /* The type determines where the docstring is stored. */
534 /* Lisp_Subrs have a slot for it. */
536 XSUBR (fun
)->doc
= (char *) - offset
;
538 /* If it's a lisp form, stick it in the form. */
539 else if (CONSP (fun
))
544 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
546 tem
= Fcdr (Fcdr (fun
));
547 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
548 XSETCAR (tem
, make_number (offset
));
550 else if (EQ (tem
, Qmacro
))
551 store_function_docstring (XCDR (fun
), offset
);
552 else if (EQ (tem
, Qclosure
))
553 store_function_docstring (Fcdr (XCDR (fun
)), offset
);
556 /* Bytecode objects sometimes have slots for it. */
557 else if (COMPILEDP (fun
))
559 /* This bytecode object must have a slot for the
560 docstring, since we've found a docstring for it. */
561 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
562 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
566 static const char buildobj
[] = BUILDOBJ
;
568 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
570 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
571 This searches the `etc/DOC...' file for doc strings and
572 records them in function and variable definitions.
573 The function takes one argument, FILENAME, a string;
574 it specifies the file name (without a directory) of the DOC file.
575 That file is found in `../etc' now; later, when the dumped Emacs is run,
576 the same file name is found in the `doc-directory'. */)
578 Lisp_Object filename
;
584 register char *p
, *end
;
589 CHECK_STRING (filename
);
593 (!NILP (Vpurify_flag
))
594 #else /* CANNOT_DUMP */
596 #endif /* CANNOT_DUMP */
598 name
= (char *) alloca (SCHARS (filename
) + 14);
599 strcpy (name
, "../etc/");
603 CHECK_STRING (Vdoc_directory
);
604 name
= (char *) alloca (SCHARS (filename
)
605 + SCHARS (Vdoc_directory
) + 1);
606 strcpy (name
, SDATA (Vdoc_directory
));
608 strcat (name
, SDATA (filename
)); /*** Add this line ***/
610 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
611 if (NILP (Vbuild_files
))
613 const char *beg
, *end
;
615 for (beg
= buildobj
; *beg
; beg
= end
)
619 while (*beg
&& isspace (*beg
)) ++beg
;
621 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
622 if (*end
== '/') beg
= end
+1; /* skip directory part */
625 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
626 len
-= 2; /* Just take .o if it ends in .obj */
629 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
631 Vbuild_files
= Fpurecopy (Vbuild_files
);
634 fd
= emacs_open (name
, O_RDONLY
, 0);
636 report_file_error ("Opening doc string file",
637 Fcons (build_string (name
), Qnil
));
638 Vdoc_file_name
= filename
;
644 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
650 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
651 while (p
!= end
&& *p
!= '\037') p
++;
652 /* p points to ^_Ffunctionname\n or ^_Vvarname\n. */
655 end
= (char *) index (p
, '\n');
657 /* See if this is a file name, and if it is a file in build-files. */
658 if (p
[1] == 'S' && end
- p
> 4 && end
[-2] == '.'
659 && (end
[-1] == 'o' || end
[-1] == 'c'))
661 int len
= end
- p
- 2;
662 char *fromfile
= alloca (len
+ 1);
663 strncpy (fromfile
, &p
[2], len
);
665 if (fromfile
[len
-1] == 'c')
666 fromfile
[len
-1] = 'o';
668 skip_file
= NILP (Fmember (build_string (fromfile
),
672 sym
= oblookup (Vobarray
, p
+ 2,
673 multibyte_chars_in_text (p
+ 2, end
- p
- 2),
675 /* Check skip_file so that when a function is defined several
676 times in different files (typically, once in xterm, once in
677 w32term, ...), we only pay attention to the one that
679 if (! skip_file
&& SYMBOLP (sym
))
681 /* Attach a docstring to a variable? */
684 /* Install file-position as variable-documentation property
685 and make it negative for a user-variable
686 (doc starts with a `*'). */
687 Fput (sym
, Qvariable_documentation
,
688 make_number ((pos
+ end
+ 1 - buf
)
689 * (end
[1] == '*' ? -1 : 1)));
692 /* Attach a docstring to a function? */
693 else if (p
[1] == 'F')
694 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
696 else if (p
[1] == 'S')
697 ; /* Just a source file name boundary marker. Ignore it. */
700 error ("DOC file invalid at position %d", pos
);
705 bcopy (end
, buf
, filled
);
711 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
712 Ssubstitute_command_keys
, 1, 1, 0,
713 doc
: /* Substitute key descriptions for command names in STRING.
714 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
715 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
717 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
718 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
719 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
720 as the keymap for future \\=\\[COMMAND] substrings.
721 \\=\\= quotes the following character and is discarded;
722 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
724 Returns original STRING if no substitutions were made. Otherwise,
725 a new string, without any text properties, is returned. */)
731 register unsigned char *strp
;
732 register unsigned char *bufp
;
737 unsigned char *start
;
738 int length
, length_byte
;
740 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
747 CHECK_STRING (string
);
751 GCPRO4 (string
, tem
, keymap
, name
);
753 multibyte
= STRING_MULTIBYTE (string
);
756 /* KEYMAP is either nil (which means search all the active keymaps)
757 or a specified local map (which means search just that and the
758 global map). If non-nil, it might come from Voverriding_local_map,
759 or from a \\<mapname> construct in STRING itself.. */
760 keymap
= current_kboard
->Voverriding_terminal_local_map
;
762 keymap
= Voverriding_local_map
;
764 bsize
= SBYTES (string
);
765 bufp
= buf
= (unsigned char *) xmalloc (bsize
);
767 strp
= SDATA (string
);
768 while (strp
< SDATA (string
) + SBYTES (string
))
770 if (strp
[0] == '\\' && strp
[1] == '=')
772 /* \= quotes the next character;
773 thus, to put in \[ without its special meaning, use \=\[. */
780 STRING_CHAR_AND_LENGTH (strp
, len
);
784 bcopy (strp
, bufp
, len
);
790 *bufp
++ = *strp
++, nchars
++;
792 else if (strp
[0] == '\\' && strp
[1] == '[')
795 int follow_remap
= 1;
798 strp
+= 2; /* skip \[ */
800 start_idx
= start
- SDATA (string
);
802 while ((strp
- SDATA (string
)
806 length_byte
= strp
- start
;
810 /* Save STRP in IDX. */
811 idx
= strp
- SDATA (string
);
812 name
= Fintern (make_string (start
, length_byte
), Qnil
);
815 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
817 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
818 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
821 name
= AREF (tem
, 1);
826 /* Note the Fwhere_is_internal can GC, so we have to take
827 relocation of string contents into account. */
828 strp
= SDATA (string
) + idx
;
829 start
= SDATA (string
) + start_idx
;
831 if (NILP (tem
)) /* but not on any keys */
833 int offset
= bufp
- buf
;
834 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
836 bcopy ("M-x ", bufp
, 4);
840 length
= multibyte_chars_in_text (start
, length_byte
);
842 length
= length_byte
;
846 { /* function is on a key */
847 tem
= Fkey_description (tem
, Qnil
);
851 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
852 \<foo> just sets the keymap used for \[cmd]. */
853 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
855 struct buffer
*oldbuf
;
857 /* This is for computing the SHADOWS arg for describe_map_tree. */
858 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
859 Lisp_Object earlier_maps
;
862 strp
+= 2; /* skip \{ or \< */
864 start_idx
= start
- SDATA (string
);
866 while ((strp
- SDATA (string
) < SBYTES (string
))
867 && *strp
!= '}' && *strp
!= '>')
870 length_byte
= strp
- start
;
871 strp
++; /* skip } or > */
873 /* Save STRP in IDX. */
874 idx
= strp
- SDATA (string
);
876 /* Get the value of the keymap in TEM, or nil if undefined.
877 Do this while still in the user's current buffer
878 in case it is a local variable. */
879 name
= Fintern (make_string (start
, length_byte
), Qnil
);
880 tem
= Fboundp (name
);
883 tem
= Fsymbol_value (name
);
886 tem
= get_keymap (tem
, 0, 1);
887 /* Note that get_keymap can GC. */
888 strp
= SDATA (string
) + idx
;
889 start
= SDATA (string
) + start_idx
;
893 /* Now switch to a temp buffer. */
894 oldbuf
= current_buffer
;
895 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
899 name
= Fsymbol_name (name
);
900 insert_string ("\nUses keymap \"");
901 insert_from_string (name
, 0, 0,
904 insert_string ("\", which is not currently defined.\n");
905 if (start
[-1] == '<') keymap
= Qnil
;
907 else if (start
[-1] == '<')
911 /* Get the list of active keymaps that precede this one.
912 If this one's not active, get nil. */
913 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
914 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
915 Qnil
, (char *)0, 1, 0, 0, 1);
917 tem
= Fbuffer_string ();
919 set_buffer_internal (oldbuf
);
923 length
= SCHARS (tem
);
924 length_byte
= SBYTES (tem
);
927 int offset
= bufp
- buf
;
928 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
930 bcopy (start
, bufp
, length_byte
);
933 /* Check STRING again in case gc relocated it. */
934 strp
= (unsigned char *) SDATA (string
) + idx
;
937 else if (! multibyte
) /* just copy other chars */
938 *bufp
++ = *strp
++, nchars
++;
943 STRING_CHAR_AND_LENGTH (strp
, len
);
947 bcopy (strp
, bufp
, len
);
954 if (changed
) /* don't bother if nothing substituted */
955 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
959 RETURN_UNGCPRO (tem
);
965 Qfunction_documentation
= intern_c_string ("function-documentation");
966 staticpro (&Qfunction_documentation
);
968 DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name
,
969 doc
: /* Name of file containing documentation strings of built-in symbols. */);
970 Vdoc_file_name
= Qnil
;
972 DEFVAR_LISP ("build-files", &Vbuild_files
,
973 doc
: /* A list of files used to build this Emacs binary. */);
976 defsubr (&Sdocumentation
);
977 defsubr (&Sdocumentation_property
);
978 defsubr (&Ssnarf_documentation
);
979 defsubr (&Ssubstitute_command_keys
);
982 /* arch-tag: 56281d4d-6949-43e2-be2e-f6517de744ba
983 (do not change this comment) */