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 (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
;
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 (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 (int unreadflag
)
78 read_bytecode_pointer
--;
81 return *read_bytecode_pointer
++;
84 /* Extract a doc string from a file. FILEPOS says where to get it.
85 If it is an integer, use that position in the standard DOC-... file.
86 If it is (FILE . INTEGER), use FILE as the file name
87 and INTEGER as the position in that file.
88 But if INTEGER is negative, make it positive.
89 (A negative integer is used for user variables, so we can distinguish
90 them without actually fetching the doc string.)
92 If the location does not point to the beginning of a docstring
93 (e.g. because the file has been modified and the location is stale),
96 If UNIBYTE is nonzero, always make a unibyte string.
98 If DEFINITION is nonzero, assume this is for reading
99 a dynamic function definition; convert the bytestring
100 and the constants vector with appropriate byte handling,
101 and return a cons cell. */
104 get_doc_string (Lisp_Object filepos
, int unibyte
, int definition
)
109 register char *p
, *p1
;
111 int offset
, position
;
112 Lisp_Object file
, tem
;
114 if (INTEGERP (filepos
))
116 file
= Vdoc_file_name
;
117 position
= XINT (filepos
);
119 else if (CONSP (filepos
))
121 file
= XCAR (filepos
);
122 position
= XINT (XCDR (filepos
));
128 position
= - position
;
130 if (!STRINGP (Vdoc_directory
))
136 /* Put the file name in NAME as a C string.
137 If it is relative, combine it with Vdoc_directory. */
139 tem
= Ffile_name_absolute_p (file
);
142 minsize
= SCHARS (Vdoc_directory
);
143 /* sizeof ("../etc/") == 8 */
146 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
147 strcpy (name
, SDATA (Vdoc_directory
));
148 strcat (name
, SDATA (file
));
152 name
= (char *) SDATA (file
);
155 fd
= emacs_open (name
, O_RDONLY
, 0);
159 if (!NILP (Vpurify_flag
))
161 /* Preparing to dump; DOC file is probably not installed.
162 So check in ../etc. */
163 strcpy (name
, "../etc/");
164 strcat (name
, SDATA (file
));
166 fd
= emacs_open (name
, O_RDONLY
, 0);
170 error ("Cannot open doc string file \"%s\"", name
);
173 /* Seek only to beginning of disk block. */
174 /* Make sure we read at least 1024 bytes before `position'
175 so we can check the leading text for consistency. */
176 offset
= min (position
, max (1024, position
% (8 * 1024)));
177 if (0 > lseek (fd
, position
- offset
, 0))
180 error ("Position %ld out of range in doc string file \"%s\"",
184 /* Read the doc string into get_doc_string_buffer.
185 P points beyond the data just read. */
187 p
= get_doc_string_buffer
;
190 int space_left
= (get_doc_string_buffer_size
191 - (p
- get_doc_string_buffer
));
194 /* Allocate or grow the buffer if we need to. */
197 int in_buffer
= p
- get_doc_string_buffer
;
198 get_doc_string_buffer_size
+= 16 * 1024;
199 get_doc_string_buffer
200 = (char *) xrealloc (get_doc_string_buffer
,
201 get_doc_string_buffer_size
+ 1);
202 p
= get_doc_string_buffer
+ in_buffer
;
203 space_left
= (get_doc_string_buffer_size
204 - (p
- get_doc_string_buffer
));
207 /* Read a disk block at a time.
208 If we read the same block last time, maybe skip this? */
209 if (space_left
> 1024 * 8)
210 space_left
= 1024 * 8;
211 nread
= emacs_read (fd
, p
, space_left
);
215 error ("Read error on documentation file");
220 if (p
== get_doc_string_buffer
)
221 p1
= (char *) index (p
+ offset
, '\037');
223 p1
= (char *) index (p
, '\037');
234 /* Sanity checking. */
238 if (get_doc_string_buffer
[offset
- test
++] != ' ')
240 while (get_doc_string_buffer
[offset
- test
] >= '0'
241 && get_doc_string_buffer
[offset
- test
] <= '9')
243 if (get_doc_string_buffer
[offset
- test
++] != '@'
244 || get_doc_string_buffer
[offset
- test
] != '#')
250 if (get_doc_string_buffer
[offset
- test
++] != '\n')
252 while (get_doc_string_buffer
[offset
- test
] > ' ')
254 if (get_doc_string_buffer
[offset
- test
] != '\037')
258 /* Scan the text and perform quoting with ^A (char code 1).
259 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
260 from
= get_doc_string_buffer
+ offset
;
261 to
= get_doc_string_buffer
+ offset
;
277 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
283 /* If DEFINITION, read from this buffer
284 the same way we would read bytes from a file. */
287 read_bytecode_pointer
= get_doc_string_buffer
+ offset
;
288 return Fread (Qlambda
);
292 return make_unibyte_string (get_doc_string_buffer
+ offset
,
293 to
- (get_doc_string_buffer
+ offset
));
296 /* Let the data determine whether the string is multibyte,
297 even if Emacs is running in --unibyte mode. */
298 int nchars
= multibyte_chars_in_text (get_doc_string_buffer
+ offset
,
299 to
- (get_doc_string_buffer
+ offset
));
300 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
302 to
- (get_doc_string_buffer
+ offset
));
306 /* Get a string from position FILEPOS and pass it through the Lisp reader.
307 We use this for fetching the bytecode string and constants vector
308 of a compiled function from the .elc file. */
311 read_doc_string (Lisp_Object filepos
)
313 return get_doc_string (filepos
, 0, 1);
317 reread_doc_file (Lisp_Object file
)
320 Lisp_Object reply
, prompt
[3];
323 prompt
[0] = build_string ("File ");
324 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
325 prompt
[2] = build_string (" is out of sync. Reload? ");
326 reply
= Fy_or_n_p (Fconcat (3, prompt
));
333 Fsnarf_documentation (Vdoc_file_name
);
335 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
340 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
341 doc
: /* Return the documentation string of FUNCTION.
342 Unless a non-nil second argument RAW is given, the
343 string is passed through `substitute-command-keys'. */)
345 Lisp_Object function
, raw
;
349 Lisp_Object tem
, doc
;
356 if (SYMBOLP (function
)
357 && (tem
= Fget (function
, Qfunction_documentation
),
359 return Fdocumentation_property (function
, Qfunction_documentation
, raw
);
361 fun
= Findirect_function (function
, Qnil
);
364 if (XSUBR (fun
)->doc
== 0)
366 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
367 doc
= build_string (XSUBR (fun
)->doc
);
369 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
371 else if (COMPILEDP (fun
))
373 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
375 tem
= AREF (fun
, COMPILED_DOC_STRING
);
378 else if (NATNUMP (tem
) || CONSP (tem
))
383 else if (STRINGP (fun
) || VECTORP (fun
))
385 return build_string ("Keyboard macro.");
387 else if (CONSP (fun
))
390 if (!SYMBOLP (funcar
))
391 xsignal1 (Qinvalid_function
, fun
);
392 else if (EQ (funcar
, Qkeymap
))
393 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
394 else if (EQ (funcar
, Qlambda
)
395 || EQ (funcar
, Qautoload
))
398 tem1
= Fcdr (Fcdr (fun
));
402 /* Handle a doc reference--but these never come last
403 in the function body, so reject them if they are last. */
404 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
405 && !NILP (XCDR (tem1
)))
410 else if (EQ (funcar
, Qmacro
))
411 return Fdocumentation (Fcdr (fun
), raw
);
418 xsignal1 (Qinvalid_function
, fun
);
421 /* Check for an advised function. Its doc string
422 has an `ad-advice-info' text property. */
425 Lisp_Object innerfunc
;
426 innerfunc
= Fget_text_property (make_number (0),
427 intern ("ad-advice-info"),
429 if (! NILP (innerfunc
))
430 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
433 /* If DOC is 0, it's typically because of a dumped file missing
434 from the DOC file (bug in src/Makefile.in). */
435 if (EQ (doc
, make_number (0)))
437 if (INTEGERP (doc
) || CONSP (doc
))
440 tem
= get_doc_string (doc
, 0, 0);
441 if (NILP (tem
) && try_reload
)
443 /* The file is newer, we need to reset the pointers. */
444 struct gcpro gcpro1
, gcpro2
;
445 GCPRO2 (function
, raw
);
446 try_reload
= reread_doc_file (Fcar_safe (doc
));
459 doc
= Fsubstitute_command_keys (doc
);
463 DEFUN ("documentation-property", Fdocumentation_property
,
464 Sdocumentation_property
, 2, 3, 0,
465 doc
: /* Return the documentation string that is SYMBOL's PROP property.
466 Third argument RAW omitted or nil means pass the result through
467 `substitute-command-keys' if it is a string.
469 This differs from `get' in that it can refer to strings stored in the
470 `etc/DOC' file; and that it evaluates documentation properties that
473 Lisp_Object symbol
, prop
, raw
;
478 documentation_property
:
480 tem
= Fget (symbol
, prop
);
481 if (EQ (tem
, make_number (0)))
483 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
485 Lisp_Object doc
= tem
;
486 tem
= get_doc_string (tem
, 0, 0);
487 if (NILP (tem
) && try_reload
)
489 /* The file is newer, we need to reset the pointers. */
490 struct gcpro gcpro1
, gcpro2
, gcpro3
;
491 GCPRO3 (symbol
, prop
, raw
);
492 try_reload
= reread_doc_file (Fcar_safe (doc
));
497 goto documentation_property
;
501 else if (!STRINGP (tem
))
502 /* Feval protects its argument. */
505 if (NILP (raw
) && STRINGP (tem
))
506 tem
= Fsubstitute_command_keys (tem
);
510 /* Scanning the DOC files and placing docstring offsets into functions. */
513 store_function_docstring (Lisp_Object fun
, EMACS_INT offset
)
515 /* Use EMACS_INT because we get this from pointer subtraction. */
518 fun
= indirect_function (fun
);
520 /* The type determines where the docstring is stored. */
522 /* Lisp_Subrs have a slot for it. */
524 XSUBR (fun
)->doc
= (char *) - offset
;
526 /* If it's a lisp form, stick it in the form. */
527 else if (CONSP (fun
))
532 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
534 tem
= Fcdr (Fcdr (fun
));
535 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
536 XSETCAR (tem
, make_number (offset
));
538 else if (EQ (tem
, Qmacro
))
539 store_function_docstring (XCDR (fun
), offset
);
542 /* Bytecode objects sometimes have slots for it. */
543 else if (COMPILEDP (fun
))
545 /* This bytecode object must have a slot for the
546 docstring, since we've found a docstring for it. */
547 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
548 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
552 static const char buildobj
[] = BUILDOBJ
;
554 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
556 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
557 This searches the `etc/DOC...' file for doc strings and
558 records them in function and variable definitions.
559 The function takes one argument, FILENAME, a string;
560 it specifies the file name (without a directory) of the DOC file.
561 That file is found in `../etc' now; later, when the dumped Emacs is run,
562 the same file name is found in the `doc-directory'. */)
564 Lisp_Object filename
;
570 register char *p
, *end
;
575 CHECK_STRING (filename
);
579 (!NILP (Vpurify_flag
))
580 #else /* CANNOT_DUMP */
582 #endif /* CANNOT_DUMP */
584 name
= (char *) alloca (SCHARS (filename
) + 14);
585 strcpy (name
, "../etc/");
589 CHECK_STRING (Vdoc_directory
);
590 name
= (char *) alloca (SCHARS (filename
)
591 + SCHARS (Vdoc_directory
) + 1);
592 strcpy (name
, SDATA (Vdoc_directory
));
594 strcat (name
, SDATA (filename
)); /*** Add this line ***/
596 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
597 if (NILP (Vbuild_files
))
599 const char *beg
, *end
;
601 for (beg
= buildobj
; *beg
; beg
= end
)
605 while (*beg
&& isspace (*beg
)) ++beg
;
607 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
608 if (*end
== '/') beg
= end
+1; /* skip directory part */
611 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
612 len
-= 2; /* Just take .o if it ends in .obj */
615 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
617 Vbuild_files
= Fpurecopy (Vbuild_files
);
620 fd
= emacs_open (name
, O_RDONLY
, 0);
622 report_file_error ("Opening doc string file",
623 Fcons (build_string (name
), Qnil
));
624 Vdoc_file_name
= filename
;
630 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
636 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
637 while (p
!= end
&& *p
!= '\037') p
++;
638 /* p points to ^_Ffunctionname\n or ^_Vvarname\n. */
641 end
= (char *) index (p
, '\n');
643 /* See if this is a file name, and if it is a file in build-files. */
644 if (p
[1] == 'S' && end
- p
> 4 && end
[-2] == '.'
645 && (end
[-1] == 'o' || end
[-1] == 'c'))
647 int len
= end
- p
- 2;
648 char *fromfile
= alloca (len
+ 1);
649 strncpy (fromfile
, &p
[2], len
);
651 if (fromfile
[len
-1] == 'c')
652 fromfile
[len
-1] = 'o';
654 skip_file
= NILP (Fmember (build_string (fromfile
),
658 sym
= oblookup (Vobarray
, p
+ 2,
659 multibyte_chars_in_text (p
+ 2, end
- p
- 2),
661 /* Check skip_file so that when a function is defined several
662 times in different files (typically, once in xterm, once in
663 w32term, ...), we only pay attention to the one that
665 if (! skip_file
&& SYMBOLP (sym
))
667 /* Attach a docstring to a variable? */
670 /* Install file-position as variable-documentation property
671 and make it negative for a user-variable
672 (doc starts with a `*'). */
673 Fput (sym
, Qvariable_documentation
,
674 make_number ((pos
+ end
+ 1 - buf
)
675 * (end
[1] == '*' ? -1 : 1)));
678 /* Attach a docstring to a function? */
679 else if (p
[1] == 'F')
680 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
682 else if (p
[1] == 'S')
683 ; /* Just a source file name boundary marker. Ignore it. */
686 error ("DOC file invalid at position %d", pos
);
691 bcopy (end
, buf
, filled
);
697 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
698 Ssubstitute_command_keys
, 1, 1, 0,
699 doc
: /* Substitute key descriptions for command names in STRING.
700 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
701 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
703 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
704 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
705 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
706 as the keymap for future \\=\\[COMMAND] substrings.
707 \\=\\= quotes the following character and is discarded;
708 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
710 Returns original STRING if no substitutions were made. Otherwise,
711 a new string, without any text properties, is returned. */)
717 register unsigned char *strp
;
718 register unsigned char *bufp
;
723 unsigned char *start
;
724 int 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
= current_kboard
->Voverriding_terminal_local_map
;
748 keymap
= Voverriding_local_map
;
750 bsize
= SBYTES (string
);
751 bufp
= buf
= (unsigned 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 bcopy (strp
, bufp
, 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 (start
, length_byte
), Qnil
);
801 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
803 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 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 int offset
= bufp
- buf
;
820 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
822 bcopy ("M-x ", bufp
, 4);
826 length
= multibyte_chars_in_text (start
, length_byte
);
828 length
= length_byte
;
832 { /* function is on a key */
833 tem
= Fkey_description (tem
, Qnil
);
837 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
838 \<foo> just sets the keymap used for \[cmd]. */
839 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
841 struct buffer
*oldbuf
;
843 /* This is for computing the SHADOWS arg for describe_map_tree. */
844 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
845 Lisp_Object earlier_maps
;
848 strp
+= 2; /* skip \{ or \< */
850 start_idx
= start
- SDATA (string
);
852 while ((strp
- SDATA (string
) < SBYTES (string
))
853 && *strp
!= '}' && *strp
!= '>')
856 length_byte
= strp
- start
;
857 strp
++; /* skip } or > */
859 /* Save STRP in IDX. */
860 idx
= strp
- SDATA (string
);
862 /* Get the value of the keymap in TEM, or nil if undefined.
863 Do this while still in the user's current buffer
864 in case it is a local variable. */
865 name
= Fintern (make_string (start
, length_byte
), Qnil
);
866 tem
= Fboundp (name
);
869 tem
= Fsymbol_value (name
);
872 tem
= get_keymap (tem
, 0, 1);
873 /* Note that get_keymap can GC. */
874 strp
= SDATA (string
) + idx
;
875 start
= SDATA (string
) + start_idx
;
879 /* Now switch to a temp buffer. */
880 oldbuf
= current_buffer
;
881 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
885 name
= Fsymbol_name (name
);
886 insert_string ("\nUses keymap \"");
887 insert_from_string (name
, 0, 0,
890 insert_string ("\", which is not currently defined.\n");
891 if (start
[-1] == '<') keymap
= Qnil
;
893 else if (start
[-1] == '<')
897 /* Get the list of active keymaps that precede this one.
898 If this one's not active, get nil. */
899 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
900 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
901 Qnil
, (char *)0, 1, 0, 0, 1);
903 tem
= Fbuffer_string ();
905 set_buffer_internal (oldbuf
);
909 length
= SCHARS (tem
);
910 length_byte
= SBYTES (tem
);
913 int offset
= bufp
- buf
;
914 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
916 bcopy (start
, bufp
, length_byte
);
919 /* Check STRING again in case gc relocated it. */
920 strp
= (unsigned char *) SDATA (string
) + idx
;
923 else if (! multibyte
) /* just copy other chars */
924 *bufp
++ = *strp
++, nchars
++;
929 STRING_CHAR_AND_LENGTH (strp
, len
);
933 bcopy (strp
, bufp
, len
);
940 if (changed
) /* don't bother if nothing substituted */
941 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
945 RETURN_UNGCPRO (tem
);
951 Qfunction_documentation
= intern_c_string ("function-documentation");
952 staticpro (&Qfunction_documentation
);
954 DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name
,
955 doc
: /* Name of file containing documentation strings of built-in symbols. */);
956 Vdoc_file_name
= Qnil
;
958 DEFVAR_LISP ("build-files", &Vbuild_files
,
959 doc
: /* A list of files used to build this Emacs binary. */);
962 defsubr (&Sdocumentation
);
963 defsubr (&Sdocumentation_property
);
964 defsubr (&Ssnarf_documentation
);
965 defsubr (&Ssubstitute_command_keys
);
968 /* arch-tag: 56281d4d-6949-43e2-be2e-f6517de744ba
969 (do not change this comment) */