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, 2011
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*/
34 #include "character.h"
38 Lisp_Object Qfunction_documentation
;
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 Lisp_Object
Fsnarf_documentation (Lisp_Object
);
47 /* readchar in lread.c calls back here to fetch the next byte.
48 If UNREADFLAG is 1, we unread a byte. */
51 read_bytecode_char (int unreadflag
)
55 read_bytecode_pointer
--;
58 return *read_bytecode_pointer
++;
61 /* Extract a doc string from a file. FILEPOS says where to get it.
62 If it is an integer, use that position in the standard DOC-... file.
63 If it is (FILE . INTEGER), use FILE as the file name
64 and INTEGER as the position in that file.
65 But if INTEGER is negative, make it positive.
66 (A negative integer is used for user variables, so we can distinguish
67 them without actually fetching the doc string.)
69 If the location does not point to the beginning of a docstring
70 (e.g. because the file has been modified and the location is stale),
73 If UNIBYTE is nonzero, always make a unibyte string.
75 If DEFINITION is nonzero, assume this is for reading
76 a dynamic function definition; convert the bytestring
77 and the constants vector with appropriate byte handling,
78 and return a cons cell. */
81 get_doc_string (Lisp_Object filepos
, int unibyte
, int definition
)
86 register char *p
, *p1
;
88 EMACS_INT offset
, position
;
89 Lisp_Object file
, tem
;
91 if (INTEGERP (filepos
))
93 file
= Vdoc_file_name
;
94 position
= XINT (filepos
);
96 else if (CONSP (filepos
))
98 file
= XCAR (filepos
);
99 position
= XINT (XCDR (filepos
));
105 position
= - position
;
107 if (!STRINGP (Vdoc_directory
))
113 /* Put the file name in NAME as a C string.
114 If it is relative, combine it with Vdoc_directory. */
116 tem
= Ffile_name_absolute_p (file
);
119 minsize
= SCHARS (Vdoc_directory
);
120 /* sizeof ("../etc/") == 8 */
123 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
124 strcpy (name
, SDATA (Vdoc_directory
));
125 strcat (name
, SDATA (file
));
129 name
= (char *) SDATA (file
);
132 fd
= emacs_open (name
, O_RDONLY
, 0);
136 if (!NILP (Vpurify_flag
))
138 /* Preparing to dump; DOC file is probably not installed.
139 So check in ../etc. */
140 strcpy (name
, "../etc/");
141 strcat (name
, SDATA (file
));
143 fd
= emacs_open (name
, O_RDONLY
, 0);
147 error ("Cannot open doc string file \"%s\"", name
);
150 /* Seek only to beginning of disk block. */
151 /* Make sure we read at least 1024 bytes before `position'
152 so we can check the leading text for consistency. */
153 offset
= min (position
, max (1024, position
% (8 * 1024)));
154 if (0 > lseek (fd
, position
- offset
, 0))
157 error ("Position %ld out of range in doc string file \"%s\"",
161 /* Read the doc string into get_doc_string_buffer.
162 P points beyond the data just read. */
164 p
= get_doc_string_buffer
;
167 EMACS_INT space_left
= (get_doc_string_buffer_size
168 - (p
- get_doc_string_buffer
));
171 /* Allocate or grow the buffer if we need to. */
174 EMACS_INT in_buffer
= p
- get_doc_string_buffer
;
175 get_doc_string_buffer_size
+= 16 * 1024;
176 get_doc_string_buffer
177 = (char *) xrealloc (get_doc_string_buffer
,
178 get_doc_string_buffer_size
+ 1);
179 p
= get_doc_string_buffer
+ in_buffer
;
180 space_left
= (get_doc_string_buffer_size
181 - (p
- get_doc_string_buffer
));
184 /* Read a disk block at a time.
185 If we read the same block last time, maybe skip this? */
186 if (space_left
> 1024 * 8)
187 space_left
= 1024 * 8;
188 nread
= emacs_read (fd
, p
, space_left
);
192 error ("Read error on documentation file");
197 if (p
== get_doc_string_buffer
)
198 p1
= strchr (p
+ offset
, '\037');
200 p1
= strchr (p
, '\037');
211 /* Sanity checking. */
215 if (get_doc_string_buffer
[offset
- test
++] != ' ')
217 while (get_doc_string_buffer
[offset
- test
] >= '0'
218 && get_doc_string_buffer
[offset
- test
] <= '9')
220 if (get_doc_string_buffer
[offset
- test
++] != '@'
221 || get_doc_string_buffer
[offset
- test
] != '#')
227 if (get_doc_string_buffer
[offset
- test
++] != '\n')
229 while (get_doc_string_buffer
[offset
- test
] > ' ')
231 if (get_doc_string_buffer
[offset
- test
] != '\037')
235 /* Scan the text and perform quoting with ^A (char code 1).
236 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
237 from
= get_doc_string_buffer
+ offset
;
238 to
= get_doc_string_buffer
+ offset
;
254 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
260 /* If DEFINITION, read from this buffer
261 the same way we would read bytes from a file. */
264 read_bytecode_pointer
= get_doc_string_buffer
+ offset
;
265 return Fread (Qlambda
);
269 return make_unibyte_string (get_doc_string_buffer
+ offset
,
270 to
- (get_doc_string_buffer
+ offset
));
273 /* The data determines whether the string is multibyte. */
274 EMACS_INT nchars
= multibyte_chars_in_text (get_doc_string_buffer
+ offset
,
275 to
- (get_doc_string_buffer
+ offset
));
276 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
278 to
- (get_doc_string_buffer
+ offset
));
282 /* Get a string from position FILEPOS and pass it through the Lisp reader.
283 We use this for fetching the bytecode string and constants vector
284 of a compiled function from the .elc file. */
287 read_doc_string (Lisp_Object filepos
)
289 return get_doc_string (filepos
, 0, 1);
293 reread_doc_file (Lisp_Object file
)
296 Lisp_Object reply
, prompt
[3];
299 prompt
[0] = build_string ("File ");
300 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
301 prompt
[2] = build_string (" is out of sync. Reload? ");
302 reply
= Fy_or_n_p (Fconcat (3, prompt
));
309 Fsnarf_documentation (Vdoc_file_name
);
311 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
316 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
317 doc
: /* Return the documentation string of FUNCTION.
318 Unless a non-nil second argument RAW is given, the
319 string is passed through `substitute-command-keys'. */)
320 (Lisp_Object function
, Lisp_Object raw
)
324 Lisp_Object tem
, doc
;
331 if (SYMBOLP (function
)
332 && (tem
= Fget (function
, Qfunction_documentation
),
334 return Fdocumentation_property (function
, Qfunction_documentation
, raw
);
336 fun
= Findirect_function (function
, Qnil
);
339 if (XSUBR (fun
)->doc
== 0)
341 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
342 doc
= build_string (XSUBR (fun
)->doc
);
344 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
346 else if (COMPILEDP (fun
))
348 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
350 tem
= AREF (fun
, COMPILED_DOC_STRING
);
353 else if (NATNUMP (tem
) || CONSP (tem
))
358 else if (STRINGP (fun
) || VECTORP (fun
))
360 return build_string ("Keyboard macro.");
362 else if (CONSP (fun
))
365 if (!SYMBOLP (funcar
))
366 xsignal1 (Qinvalid_function
, fun
);
367 else if (EQ (funcar
, Qkeymap
))
368 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
369 else if (EQ (funcar
, Qlambda
)
370 || EQ (funcar
, Qautoload
))
373 tem1
= Fcdr (Fcdr (fun
));
377 /* Handle a doc reference--but these never come last
378 in the function body, so reject them if they are last. */
379 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
380 && !NILP (XCDR (tem1
)))
385 else if (EQ (funcar
, Qmacro
))
386 return Fdocumentation (Fcdr (fun
), raw
);
393 xsignal1 (Qinvalid_function
, fun
);
396 /* Check for an advised function. Its doc string
397 has an `ad-advice-info' text property. */
400 Lisp_Object innerfunc
;
401 innerfunc
= Fget_text_property (make_number (0),
402 intern ("ad-advice-info"),
404 if (! NILP (innerfunc
))
405 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
408 /* If DOC is 0, it's typically because of a dumped file missing
409 from the DOC file (bug in src/Makefile.in). */
410 if (EQ (doc
, make_number (0)))
412 if (INTEGERP (doc
) || CONSP (doc
))
415 tem
= get_doc_string (doc
, 0, 0);
416 if (NILP (tem
) && try_reload
)
418 /* The file is newer, we need to reset the pointers. */
419 struct gcpro gcpro1
, gcpro2
;
420 GCPRO2 (function
, raw
);
421 try_reload
= reread_doc_file (Fcar_safe (doc
));
434 doc
= Fsubstitute_command_keys (doc
);
438 DEFUN ("documentation-property", Fdocumentation_property
,
439 Sdocumentation_property
, 2, 3, 0,
440 doc
: /* Return the documentation string that is SYMBOL's PROP property.
441 Third argument RAW omitted or nil means pass the result through
442 `substitute-command-keys' if it is a string.
444 This differs from `get' in that it can refer to strings stored in the
445 `etc/DOC' file; and that it evaluates documentation properties that
447 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
452 documentation_property
:
454 tem
= Fget (symbol
, prop
);
455 if (EQ (tem
, make_number (0)))
457 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
459 Lisp_Object doc
= tem
;
460 tem
= get_doc_string (tem
, 0, 0);
461 if (NILP (tem
) && try_reload
)
463 /* The file is newer, we need to reset the pointers. */
464 struct gcpro gcpro1
, gcpro2
, gcpro3
;
465 GCPRO3 (symbol
, prop
, raw
);
466 try_reload
= reread_doc_file (Fcar_safe (doc
));
471 goto documentation_property
;
475 else if (!STRINGP (tem
))
476 /* Feval protects its argument. */
479 if (NILP (raw
) && STRINGP (tem
))
480 tem
= Fsubstitute_command_keys (tem
);
484 /* Scanning the DOC files and placing docstring offsets into functions. */
487 store_function_docstring (Lisp_Object fun
, EMACS_INT offset
)
488 /* Use EMACS_INT because we get offset from pointer subtraction. */
490 fun
= indirect_function (fun
);
492 /* The type determines where the docstring is stored. */
494 /* Lisp_Subrs have a slot for it. */
496 XSUBR (fun
)->doc
= (char *) - offset
;
498 /* If it's a lisp form, stick it in the form. */
499 else if (CONSP (fun
))
504 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
506 tem
= Fcdr (Fcdr (fun
));
507 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
508 XSETCAR (tem
, make_number (offset
));
510 else if (EQ (tem
, Qmacro
))
511 store_function_docstring (XCDR (fun
), offset
);
514 /* Bytecode objects sometimes have slots for it. */
515 else if (COMPILEDP (fun
))
517 /* This bytecode object must have a slot for the
518 docstring, since we've found a docstring for it. */
519 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
520 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
524 static const char buildobj
[] = BUILDOBJ
;
526 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
528 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
529 This searches the `etc/DOC...' file for doc strings and
530 records them in function and variable definitions.
531 The function takes one argument, FILENAME, a string;
532 it specifies the file name (without a directory) of the DOC file.
533 That file is found in `../etc' now; later, when the dumped Emacs is run,
534 the same file name is found in the `doc-directory'. */)
535 (Lisp_Object filename
)
539 register EMACS_INT filled
;
540 register EMACS_INT pos
;
541 register char *p
, *end
;
546 CHECK_STRING (filename
);
550 (!NILP (Vpurify_flag
))
551 #else /* CANNOT_DUMP */
553 #endif /* CANNOT_DUMP */
555 name
= (char *) alloca (SCHARS (filename
) + 14);
556 strcpy (name
, "../etc/");
560 CHECK_STRING (Vdoc_directory
);
561 name
= (char *) alloca (SCHARS (filename
)
562 + SCHARS (Vdoc_directory
) + 1);
563 strcpy (name
, SDATA (Vdoc_directory
));
565 strcat (name
, SDATA (filename
)); /*** Add this line ***/
567 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
568 if (NILP (Vbuild_files
))
570 const char *beg
, *end
;
572 for (beg
= buildobj
; *beg
; beg
= end
)
576 while (*beg
&& isspace (*beg
)) ++beg
;
578 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
579 if (*end
== '/') beg
= end
+1; /* skip directory part */
582 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
583 len
-= 2; /* Just take .o if it ends in .obj */
586 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
588 Vbuild_files
= Fpurecopy (Vbuild_files
);
591 fd
= emacs_open (name
, O_RDONLY
, 0);
593 report_file_error ("Opening doc string file",
594 Fcons (build_string (name
), Qnil
));
595 Vdoc_file_name
= filename
;
601 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
607 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
608 while (p
!= end
&& *p
!= '\037') p
++;
609 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
612 end
= strchr (p
, '\n');
614 /* See if this is a file name, and if it is a file in build-files. */
618 if (end
- p
> 4 && end
[-2] == '.'
619 && (end
[-1] == 'o' || end
[-1] == 'c'))
621 EMACS_INT len
= end
- p
- 2;
622 char *fromfile
= alloca (len
+ 1);
623 strncpy (fromfile
, &p
[2], len
);
625 if (fromfile
[len
-1] == 'c')
626 fromfile
[len
-1] = 'o';
628 skip_file
= NILP (Fmember (build_string (fromfile
),
633 sym
= oblookup (Vobarray
, p
+ 2,
634 multibyte_chars_in_text (p
+ 2, end
- p
- 2),
636 /* Check skip_file so that when a function is defined several
637 times in different files (typically, once in xterm, once in
638 w32term, ...), we only pay attention to the one that
640 if (! skip_file
&& SYMBOLP (sym
))
642 /* Attach a docstring to a variable? */
645 /* Install file-position as variable-documentation property
646 and make it negative for a user-variable
647 (doc starts with a `*'). */
648 Fput (sym
, Qvariable_documentation
,
649 make_number ((pos
+ end
+ 1 - buf
)
650 * (end
[1] == '*' ? -1 : 1)));
653 /* Attach a docstring to a function? */
654 else if (p
[1] == 'F')
655 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
657 else if (p
[1] == 'S')
658 ; /* Just a source file name boundary marker. Ignore it. */
661 error ("DOC file invalid at position %d", pos
);
666 memmove (buf
, end
, filled
);
672 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
673 Ssubstitute_command_keys
, 1, 1, 0,
674 doc
: /* Substitute key descriptions for command names in STRING.
675 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
676 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
678 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
679 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
680 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
681 as the keymap for future \\=\\[COMMAND] substrings.
682 \\=\\= quotes the following character and is discarded;
683 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
685 Returns original STRING if no substitutions were made. Otherwise,
686 a new string, without any text properties, is returned. */)
691 register unsigned char *strp
;
692 register unsigned char *bufp
;
697 unsigned char *start
;
698 EMACS_INT length
, length_byte
;
700 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
707 CHECK_STRING (string
);
711 GCPRO4 (string
, tem
, keymap
, name
);
713 multibyte
= STRING_MULTIBYTE (string
);
716 /* KEYMAP is either nil (which means search all the active keymaps)
717 or a specified local map (which means search just that and the
718 global map). If non-nil, it might come from Voverriding_local_map,
719 or from a \\<mapname> construct in STRING itself.. */
720 keymap
= current_kboard
->Voverriding_terminal_local_map
;
722 keymap
= Voverriding_local_map
;
724 bsize
= SBYTES (string
);
725 bufp
= buf
= (unsigned char *) xmalloc (bsize
);
727 strp
= SDATA (string
);
728 while (strp
< SDATA (string
) + SBYTES (string
))
730 if (strp
[0] == '\\' && strp
[1] == '=')
732 /* \= quotes the next character;
733 thus, to put in \[ without its special meaning, use \=\[. */
740 STRING_CHAR_AND_LENGTH (strp
, len
);
744 memcpy (bufp
, strp
, len
);
750 *bufp
++ = *strp
++, nchars
++;
752 else if (strp
[0] == '\\' && strp
[1] == '[')
755 int follow_remap
= 1;
758 strp
+= 2; /* skip \[ */
760 start_idx
= start
- SDATA (string
);
762 while ((strp
- SDATA (string
)
766 length_byte
= strp
- start
;
770 /* Save STRP in IDX. */
771 idx
= strp
- SDATA (string
);
772 name
= Fintern (make_string (start
, length_byte
), Qnil
);
775 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
777 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
778 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
781 name
= AREF (tem
, 1);
786 /* Note the Fwhere_is_internal can GC, so we have to take
787 relocation of string contents into account. */
788 strp
= SDATA (string
) + idx
;
789 start
= SDATA (string
) + start_idx
;
791 if (NILP (tem
)) /* but not on any keys */
793 EMACS_INT offset
= bufp
- buf
;
794 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
796 memcpy (bufp
, "M-x ", 4);
800 length
= multibyte_chars_in_text (start
, length_byte
);
802 length
= length_byte
;
806 { /* function is on a key */
807 tem
= Fkey_description (tem
, Qnil
);
811 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
812 \<foo> just sets the keymap used for \[cmd]. */
813 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
815 struct buffer
*oldbuf
;
817 /* This is for computing the SHADOWS arg for describe_map_tree. */
818 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
819 Lisp_Object earlier_maps
;
822 strp
+= 2; /* skip \{ or \< */
824 start_idx
= start
- SDATA (string
);
826 while ((strp
- SDATA (string
) < SBYTES (string
))
827 && *strp
!= '}' && *strp
!= '>')
830 length_byte
= strp
- start
;
831 strp
++; /* skip } or > */
833 /* Save STRP in IDX. */
834 idx
= strp
- SDATA (string
);
836 /* Get the value of the keymap in TEM, or nil if undefined.
837 Do this while still in the user's current buffer
838 in case it is a local variable. */
839 name
= Fintern (make_string (start
, length_byte
), Qnil
);
840 tem
= Fboundp (name
);
843 tem
= Fsymbol_value (name
);
846 tem
= get_keymap (tem
, 0, 1);
847 /* Note that get_keymap can GC. */
848 strp
= SDATA (string
) + idx
;
849 start
= SDATA (string
) + start_idx
;
853 /* Now switch to a temp buffer. */
854 oldbuf
= current_buffer
;
855 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
859 name
= Fsymbol_name (name
);
860 insert_string ("\nUses keymap \"");
861 insert_from_string (name
, 0, 0,
864 insert_string ("\", which is not currently defined.\n");
865 if (start
[-1] == '<') keymap
= Qnil
;
867 else if (start
[-1] == '<')
871 /* Get the list of active keymaps that precede this one.
872 If this one's not active, get nil. */
873 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
874 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
875 Qnil
, (char *)0, 1, 0, 0, 1);
877 tem
= Fbuffer_string ();
879 set_buffer_internal (oldbuf
);
883 length
= SCHARS (tem
);
884 length_byte
= SBYTES (tem
);
887 EMACS_INT offset
= bufp
- buf
;
888 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
890 memcpy (bufp
, start
, length_byte
);
893 /* Check STRING again in case gc relocated it. */
894 strp
= (unsigned char *) SDATA (string
) + idx
;
897 else if (! multibyte
) /* just copy other chars */
898 *bufp
++ = *strp
++, nchars
++;
903 STRING_CHAR_AND_LENGTH (strp
, len
);
907 memcpy (bufp
, strp
, len
);
914 if (changed
) /* don't bother if nothing substituted */
915 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
919 RETURN_UNGCPRO (tem
);
925 Qfunction_documentation
= intern_c_string ("function-documentation");
926 staticpro (&Qfunction_documentation
);
928 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
929 doc
: /* Name of file containing documentation strings of built-in symbols. */);
930 Vdoc_file_name
= Qnil
;
932 DEFVAR_LISP ("build-files", Vbuild_files
,
933 doc
: /* A list of files used to build this Emacs binary. */);
936 defsubr (&Sdocumentation
);
937 defsubr (&Sdocumentation_property
);
938 defsubr (&Ssnarf_documentation
);
939 defsubr (&Ssubstitute_command_keys
);