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"
48 Lisp_Object Vdoc_file_name
;
50 Lisp_Object Qfunction_documentation
;
52 /* A list of files used to build this Emacs binary. */
53 static Lisp_Object Vbuild_files
;
55 /* Buffer used for reading from documentation file. */
56 static char *get_doc_string_buffer
;
57 static int get_doc_string_buffer_size
;
59 static unsigned char *read_bytecode_pointer
;
60 Lisp_Object
Fsnarf_documentation (Lisp_Object
);
62 /* readchar in lread.c calls back here to fetch the next byte.
63 If UNREADFLAG is 1, we unread a byte. */
66 read_bytecode_char (int unreadflag
)
70 read_bytecode_pointer
--;
73 return *read_bytecode_pointer
++;
76 /* Extract a doc string from a file. FILEPOS says where to get it.
77 If it is an integer, use that position in the standard DOC-... file.
78 If it is (FILE . INTEGER), use FILE as the file name
79 and INTEGER as the position in that file.
80 But if INTEGER is negative, make it positive.
81 (A negative integer is used for user variables, so we can distinguish
82 them without actually fetching the doc string.)
84 If the location does not point to the beginning of a docstring
85 (e.g. because the file has been modified and the location is stale),
88 If UNIBYTE is nonzero, always make a unibyte string.
90 If DEFINITION is nonzero, assume this is for reading
91 a dynamic function definition; convert the bytestring
92 and the constants vector with appropriate byte handling,
93 and return a cons cell. */
96 get_doc_string (Lisp_Object filepos
, int unibyte
, int definition
)
101 register char *p
, *p1
;
103 int offset
, position
;
104 Lisp_Object file
, tem
;
106 if (INTEGERP (filepos
))
108 file
= Vdoc_file_name
;
109 position
= XINT (filepos
);
111 else if (CONSP (filepos
))
113 file
= XCAR (filepos
);
114 position
= XINT (XCDR (filepos
));
120 position
= - position
;
122 if (!STRINGP (Vdoc_directory
))
128 /* Put the file name in NAME as a C string.
129 If it is relative, combine it with Vdoc_directory. */
131 tem
= Ffile_name_absolute_p (file
);
134 minsize
= SCHARS (Vdoc_directory
);
135 /* sizeof ("../etc/") == 8 */
138 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
139 strcpy (name
, SDATA (Vdoc_directory
));
140 strcat (name
, SDATA (file
));
144 name
= (char *) SDATA (file
);
147 fd
= emacs_open (name
, O_RDONLY
, 0);
151 if (!NILP (Vpurify_flag
))
153 /* Preparing to dump; DOC file is probably not installed.
154 So check in ../etc. */
155 strcpy (name
, "../etc/");
156 strcat (name
, SDATA (file
));
158 fd
= emacs_open (name
, O_RDONLY
, 0);
162 error ("Cannot open doc string file \"%s\"", name
);
165 /* Seek only to beginning of disk block. */
166 /* Make sure we read at least 1024 bytes before `position'
167 so we can check the leading text for consistency. */
168 offset
= min (position
, max (1024, position
% (8 * 1024)));
169 if (0 > lseek (fd
, position
- offset
, 0))
172 error ("Position %ld out of range in doc string file \"%s\"",
176 /* Read the doc string into get_doc_string_buffer.
177 P points beyond the data just read. */
179 p
= get_doc_string_buffer
;
182 int space_left
= (get_doc_string_buffer_size
183 - (p
- get_doc_string_buffer
));
186 /* Allocate or grow the buffer if we need to. */
189 int in_buffer
= p
- get_doc_string_buffer
;
190 get_doc_string_buffer_size
+= 16 * 1024;
191 get_doc_string_buffer
192 = (char *) xrealloc (get_doc_string_buffer
,
193 get_doc_string_buffer_size
+ 1);
194 p
= get_doc_string_buffer
+ in_buffer
;
195 space_left
= (get_doc_string_buffer_size
196 - (p
- get_doc_string_buffer
));
199 /* Read a disk block at a time.
200 If we read the same block last time, maybe skip this? */
201 if (space_left
> 1024 * 8)
202 space_left
= 1024 * 8;
203 nread
= emacs_read (fd
, p
, space_left
);
207 error ("Read error on documentation file");
212 if (p
== get_doc_string_buffer
)
213 p1
= strchr (p
+ offset
, '\037');
215 p1
= strchr (p
, '\037');
226 /* Sanity checking. */
230 if (get_doc_string_buffer
[offset
- test
++] != ' ')
232 while (get_doc_string_buffer
[offset
- test
] >= '0'
233 && get_doc_string_buffer
[offset
- test
] <= '9')
235 if (get_doc_string_buffer
[offset
- test
++] != '@'
236 || get_doc_string_buffer
[offset
- test
] != '#')
242 if (get_doc_string_buffer
[offset
- test
++] != '\n')
244 while (get_doc_string_buffer
[offset
- test
] > ' ')
246 if (get_doc_string_buffer
[offset
- test
] != '\037')
250 /* Scan the text and perform quoting with ^A (char code 1).
251 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
252 from
= get_doc_string_buffer
+ offset
;
253 to
= get_doc_string_buffer
+ offset
;
269 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
275 /* If DEFINITION, read from this buffer
276 the same way we would read bytes from a file. */
279 read_bytecode_pointer
= get_doc_string_buffer
+ offset
;
280 return Fread (Qlambda
);
284 return make_unibyte_string (get_doc_string_buffer
+ offset
,
285 to
- (get_doc_string_buffer
+ offset
));
288 /* Let the data determine whether the string is multibyte,
289 even if Emacs is running in --unibyte mode. */
290 int nchars
= multibyte_chars_in_text (get_doc_string_buffer
+ offset
,
291 to
- (get_doc_string_buffer
+ offset
));
292 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
294 to
- (get_doc_string_buffer
+ offset
));
298 /* Get a string from position FILEPOS and pass it through the Lisp reader.
299 We use this for fetching the bytecode string and constants vector
300 of a compiled function from the .elc file. */
303 read_doc_string (Lisp_Object filepos
)
305 return get_doc_string (filepos
, 0, 1);
309 reread_doc_file (Lisp_Object file
)
312 Lisp_Object reply
, prompt
[3];
315 prompt
[0] = build_string ("File ");
316 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
317 prompt
[2] = build_string (" is out of sync. Reload? ");
318 reply
= Fy_or_n_p (Fconcat (3, prompt
));
325 Fsnarf_documentation (Vdoc_file_name
);
327 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
332 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
333 doc
: /* Return the documentation string of FUNCTION.
334 Unless a non-nil second argument RAW is given, the
335 string is passed through `substitute-command-keys'. */)
336 (Lisp_Object function
, Lisp_Object raw
)
340 Lisp_Object tem
, doc
;
347 if (SYMBOLP (function
)
348 && (tem
= Fget (function
, Qfunction_documentation
),
350 return Fdocumentation_property (function
, Qfunction_documentation
, raw
);
352 fun
= Findirect_function (function
, Qnil
);
355 if (XSUBR (fun
)->doc
== 0)
357 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
358 doc
= build_string (XSUBR (fun
)->doc
);
360 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
362 else if (COMPILEDP (fun
))
364 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
366 tem
= AREF (fun
, COMPILED_DOC_STRING
);
369 else if (NATNUMP (tem
) || CONSP (tem
))
374 else if (STRINGP (fun
) || VECTORP (fun
))
376 return build_string ("Keyboard macro.");
378 else if (CONSP (fun
))
381 if (!SYMBOLP (funcar
))
382 xsignal1 (Qinvalid_function
, fun
);
383 else if (EQ (funcar
, Qkeymap
))
384 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
385 else if (EQ (funcar
, Qlambda
)
386 || EQ (funcar
, Qautoload
))
389 tem1
= Fcdr (Fcdr (fun
));
393 /* Handle a doc reference--but these never come last
394 in the function body, so reject them if they are last. */
395 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
396 && !NILP (XCDR (tem1
)))
401 else if (EQ (funcar
, Qmacro
))
402 return Fdocumentation (Fcdr (fun
), raw
);
409 xsignal1 (Qinvalid_function
, fun
);
412 /* Check for an advised function. Its doc string
413 has an `ad-advice-info' text property. */
416 Lisp_Object innerfunc
;
417 innerfunc
= Fget_text_property (make_number (0),
418 intern ("ad-advice-info"),
420 if (! NILP (innerfunc
))
421 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
424 /* If DOC is 0, it's typically because of a dumped file missing
425 from the DOC file (bug in src/Makefile.in). */
426 if (EQ (doc
, make_number (0)))
428 if (INTEGERP (doc
) || CONSP (doc
))
431 tem
= get_doc_string (doc
, 0, 0);
432 if (NILP (tem
) && try_reload
)
434 /* The file is newer, we need to reset the pointers. */
435 struct gcpro gcpro1
, gcpro2
;
436 GCPRO2 (function
, raw
);
437 try_reload
= reread_doc_file (Fcar_safe (doc
));
450 doc
= Fsubstitute_command_keys (doc
);
454 DEFUN ("documentation-property", Fdocumentation_property
,
455 Sdocumentation_property
, 2, 3, 0,
456 doc
: /* Return the documentation string that is SYMBOL's PROP property.
457 Third argument RAW omitted or nil means pass the result through
458 `substitute-command-keys' if it is a string.
460 This differs from `get' in that it can refer to strings stored in the
461 `etc/DOC' file; and that it evaluates documentation properties that
463 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
468 documentation_property
:
470 tem
= Fget (symbol
, prop
);
471 if (EQ (tem
, make_number (0)))
473 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
475 Lisp_Object doc
= tem
;
476 tem
= get_doc_string (tem
, 0, 0);
477 if (NILP (tem
) && try_reload
)
479 /* The file is newer, we need to reset the pointers. */
480 struct gcpro gcpro1
, gcpro2
, gcpro3
;
481 GCPRO3 (symbol
, prop
, raw
);
482 try_reload
= reread_doc_file (Fcar_safe (doc
));
487 goto documentation_property
;
491 else if (!STRINGP (tem
))
492 /* Feval protects its argument. */
495 if (NILP (raw
) && STRINGP (tem
))
496 tem
= Fsubstitute_command_keys (tem
);
500 /* Scanning the DOC files and placing docstring offsets into functions. */
503 store_function_docstring (Lisp_Object fun
, EMACS_INT offset
)
504 /* Use EMACS_INT because we get offset from pointer subtraction. */
506 fun
= indirect_function (fun
);
508 /* The type determines where the docstring is stored. */
510 /* Lisp_Subrs have a slot for it. */
512 XSUBR (fun
)->doc
= (char *) - offset
;
514 /* If it's a lisp form, stick it in the form. */
515 else if (CONSP (fun
))
520 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
522 tem
= Fcdr (Fcdr (fun
));
523 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
524 XSETCAR (tem
, make_number (offset
));
526 else if (EQ (tem
, Qmacro
))
527 store_function_docstring (XCDR (fun
), offset
);
530 /* Bytecode objects sometimes have slots for it. */
531 else if (COMPILEDP (fun
))
533 /* This bytecode object must have a slot for the
534 docstring, since we've found a docstring for it. */
535 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
536 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
540 static const char buildobj
[] = BUILDOBJ
;
542 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
544 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
545 This searches the `etc/DOC...' file for doc strings and
546 records them in function and variable definitions.
547 The function takes one argument, FILENAME, a string;
548 it specifies the file name (without a directory) of the DOC file.
549 That file is found in `../etc' now; later, when the dumped Emacs is run,
550 the same file name is found in the `doc-directory'. */)
551 (Lisp_Object filename
)
557 register char *p
, *end
;
562 CHECK_STRING (filename
);
566 (!NILP (Vpurify_flag
))
567 #else /* CANNOT_DUMP */
569 #endif /* CANNOT_DUMP */
571 name
= (char *) alloca (SCHARS (filename
) + 14);
572 strcpy (name
, "../etc/");
576 CHECK_STRING (Vdoc_directory
);
577 name
= (char *) alloca (SCHARS (filename
)
578 + SCHARS (Vdoc_directory
) + 1);
579 strcpy (name
, SDATA (Vdoc_directory
));
581 strcat (name
, SDATA (filename
)); /*** Add this line ***/
583 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
584 if (NILP (Vbuild_files
))
586 const char *beg
, *end
;
588 for (beg
= buildobj
; *beg
; beg
= end
)
592 while (*beg
&& isspace (*beg
)) ++beg
;
594 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
595 if (*end
== '/') beg
= end
+1; /* skip directory part */
598 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
599 len
-= 2; /* Just take .o if it ends in .obj */
602 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
604 Vbuild_files
= Fpurecopy (Vbuild_files
);
607 fd
= emacs_open (name
, O_RDONLY
, 0);
609 report_file_error ("Opening doc string file",
610 Fcons (build_string (name
), Qnil
));
611 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 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 (p
+ 2, end
- p
- 2),
652 /* Check skip_file so that when a function is defined several
653 times in different files (typically, once in xterm, once in
654 w32term, ...), we only pay attention to the one that
656 if (! skip_file
&& SYMBOLP (sym
))
658 /* Attach a docstring to a variable? */
661 /* Install file-position as variable-documentation property
662 and make it negative for a user-variable
663 (doc starts with a `*'). */
664 Fput (sym
, Qvariable_documentation
,
665 make_number ((pos
+ end
+ 1 - buf
)
666 * (end
[1] == '*' ? -1 : 1)));
669 /* Attach a docstring to a function? */
670 else if (p
[1] == 'F')
671 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
673 else if (p
[1] == 'S')
674 ; /* Just a source file name boundary marker. Ignore it. */
677 error ("DOC file invalid at position %d", pos
);
682 memcpy (buf
, end
, filled
);
688 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
689 Ssubstitute_command_keys
, 1, 1, 0,
690 doc
: /* Substitute key descriptions for command names in STRING.
691 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
692 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
694 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
695 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
696 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
697 as the keymap for future \\=\\[COMMAND] substrings.
698 \\=\\= quotes the following character and is discarded;
699 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
701 Returns original STRING if no substitutions were made. Otherwise,
702 a new string, without any text properties, is returned. */)
707 register unsigned char *strp
;
708 register unsigned char *bufp
;
713 unsigned char *start
;
714 int length
, length_byte
;
716 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
723 CHECK_STRING (string
);
727 GCPRO4 (string
, tem
, keymap
, name
);
729 multibyte
= STRING_MULTIBYTE (string
);
732 /* KEYMAP is either nil (which means search all the active keymaps)
733 or a specified local map (which means search just that and the
734 global map). If non-nil, it might come from Voverriding_local_map,
735 or from a \\<mapname> construct in STRING itself.. */
736 keymap
= current_kboard
->Voverriding_terminal_local_map
;
738 keymap
= Voverriding_local_map
;
740 bsize
= SBYTES (string
);
741 bufp
= buf
= (unsigned char *) xmalloc (bsize
);
743 strp
= SDATA (string
);
744 while (strp
< SDATA (string
) + SBYTES (string
))
746 if (strp
[0] == '\\' && strp
[1] == '=')
748 /* \= quotes the next character;
749 thus, to put in \[ without its special meaning, use \=\[. */
756 STRING_CHAR_AND_LENGTH (strp
, len
);
760 memcpy (bufp
, strp
, len
);
766 *bufp
++ = *strp
++, nchars
++;
768 else if (strp
[0] == '\\' && strp
[1] == '[')
771 int follow_remap
= 1;
774 strp
+= 2; /* skip \[ */
776 start_idx
= start
- SDATA (string
);
778 while ((strp
- SDATA (string
)
782 length_byte
= strp
- start
;
786 /* Save STRP in IDX. */
787 idx
= strp
- SDATA (string
);
788 name
= Fintern (make_string (start
, length_byte
), Qnil
);
791 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
793 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
794 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
797 name
= AREF (tem
, 1);
802 /* Note the Fwhere_is_internal can GC, so we have to take
803 relocation of string contents into account. */
804 strp
= SDATA (string
) + idx
;
805 start
= SDATA (string
) + start_idx
;
807 if (NILP (tem
)) /* but not on any keys */
809 int offset
= bufp
- buf
;
810 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
812 memcpy (bufp
, "M-x ", 4);
816 length
= multibyte_chars_in_text (start
, length_byte
);
818 length
= length_byte
;
822 { /* function is on a key */
823 tem
= Fkey_description (tem
, Qnil
);
827 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
828 \<foo> just sets the keymap used for \[cmd]. */
829 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
831 struct buffer
*oldbuf
;
833 /* This is for computing the SHADOWS arg for describe_map_tree. */
834 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
835 Lisp_Object earlier_maps
;
838 strp
+= 2; /* skip \{ or \< */
840 start_idx
= start
- SDATA (string
);
842 while ((strp
- SDATA (string
) < SBYTES (string
))
843 && *strp
!= '}' && *strp
!= '>')
846 length_byte
= strp
- start
;
847 strp
++; /* skip } or > */
849 /* Save STRP in IDX. */
850 idx
= strp
- SDATA (string
);
852 /* Get the value of the keymap in TEM, or nil if undefined.
853 Do this while still in the user's current buffer
854 in case it is a local variable. */
855 name
= Fintern (make_string (start
, length_byte
), Qnil
);
856 tem
= Fboundp (name
);
859 tem
= Fsymbol_value (name
);
862 tem
= get_keymap (tem
, 0, 1);
863 /* Note that get_keymap can GC. */
864 strp
= SDATA (string
) + idx
;
865 start
= SDATA (string
) + start_idx
;
869 /* Now switch to a temp buffer. */
870 oldbuf
= current_buffer
;
871 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
875 name
= Fsymbol_name (name
);
876 insert_string ("\nUses keymap \"");
877 insert_from_string (name
, 0, 0,
880 insert_string ("\", which is not currently defined.\n");
881 if (start
[-1] == '<') keymap
= Qnil
;
883 else if (start
[-1] == '<')
887 /* Get the list of active keymaps that precede this one.
888 If this one's not active, get nil. */
889 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
890 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
891 Qnil
, (char *)0, 1, 0, 0, 1);
893 tem
= Fbuffer_string ();
895 set_buffer_internal (oldbuf
);
899 length
= SCHARS (tem
);
900 length_byte
= SBYTES (tem
);
903 int offset
= bufp
- buf
;
904 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
906 memcpy (bufp
, start
, length_byte
);
909 /* Check STRING again in case gc relocated it. */
910 strp
= (unsigned char *) SDATA (string
) + idx
;
913 else if (! multibyte
) /* just copy other chars */
914 *bufp
++ = *strp
++, nchars
++;
919 STRING_CHAR_AND_LENGTH (strp
, len
);
923 memcpy (bufp
, strp
, len
);
930 if (changed
) /* don't bother if nothing substituted */
931 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
935 RETURN_UNGCPRO (tem
);
941 Qfunction_documentation
= intern_c_string ("function-documentation");
942 staticpro (&Qfunction_documentation
);
944 DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name
,
945 doc
: /* Name of file containing documentation strings of built-in symbols. */);
946 Vdoc_file_name
= Qnil
;
948 DEFVAR_LISP ("build-files", &Vbuild_files
,
949 doc
: /* A list of files used to build this Emacs binary. */);
952 defsubr (&Sdocumentation
);
953 defsubr (&Sdocumentation_property
);
954 defsubr (&Ssnarf_documentation
);
955 defsubr (&Ssubstitute_command_keys
);
958 /* arch-tag: 56281d4d-6949-43e2-be2e-f6517de744ba
959 (do not change this comment) */