1 /* Record indices of function doc strings stored in a file.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2012 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*/
31 #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
;
46 /* readchar in lread.c calls back here to fetch the next byte.
47 If UNREADFLAG is 1, we unread a byte. */
50 read_bytecode_char (int unreadflag
)
54 read_bytecode_pointer
--;
57 return *read_bytecode_pointer
++;
60 /* Extract a doc string from a file. FILEPOS says where to get it.
61 If it is an integer, use that position in the standard DOC-... file.
62 If it is (FILE . INTEGER), use FILE as the file name
63 and INTEGER as the position in that file.
64 But if INTEGER is negative, make it positive.
65 (A negative integer is used for user variables, so we can distinguish
66 them without actually fetching the doc string.)
68 If the location does not point to the beginning of a docstring
69 (e.g. because the file has been modified and the location is stale),
72 If UNIBYTE is nonzero, always make a unibyte string.
74 If DEFINITION is nonzero, assume this is for reading
75 a dynamic function definition; convert the bytestring
76 and the constants vector with appropriate byte handling,
77 and return a cons cell. */
80 get_doc_string (Lisp_Object filepos
, int unibyte
, int definition
)
85 register char *p
, *p1
;
89 Lisp_Object file
, tem
;
92 if (INTEGERP (filepos
))
94 file
= Vdoc_file_name
;
95 position
= XINT (filepos
);
97 else if (CONSP (filepos
))
99 file
= XCAR (filepos
);
100 position
= XINT (XCDR (filepos
));
106 position
= - position
;
108 if (!STRINGP (Vdoc_directory
))
114 /* Put the file name in NAME as a C string.
115 If it is relative, combine it with Vdoc_directory. */
117 tem
= Ffile_name_absolute_p (file
);
118 file
= ENCODE_FILE (file
);
121 Lisp_Object docdir
= ENCODE_FILE (Vdoc_directory
);
122 minsize
= SCHARS (docdir
);
123 /* sizeof ("../etc/") == 8 */
126 SAFE_ALLOCA (name
, char *, minsize
+ SCHARS (file
) + 8);
127 strcpy (name
, SSDATA (docdir
));
128 strcat (name
, SSDATA (file
));
132 name
= SSDATA (file
);
135 fd
= emacs_open (name
, O_RDONLY
, 0);
139 if (!NILP (Vpurify_flag
))
141 /* Preparing to dump; DOC file is probably not installed.
142 So check in ../etc. */
143 strcpy (name
, "../etc/");
144 strcat (name
, SSDATA (file
));
146 fd
= emacs_open (name
, O_RDONLY
, 0);
150 error ("Cannot open doc string file \"%s\"", name
);
153 /* Seek only to beginning of disk block. */
154 /* Make sure we read at least 1024 bytes before `position'
155 so we can check the leading text for consistency. */
156 offset
= min (position
, max (1024, position
% (8 * 1024)));
157 if (TYPE_MAXIMUM (off_t
) < position
158 || lseek (fd
, position
- offset
, 0) < 0)
161 error ("Position %"pI
"d out of range in doc string file \"%s\"",
167 /* Read the doc string into get_doc_string_buffer.
168 P points beyond the data just read. */
170 p
= get_doc_string_buffer
;
173 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
174 - (p
- get_doc_string_buffer
));
177 /* Allocate or grow the buffer if we need to. */
180 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
181 get_doc_string_buffer
=
182 xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
184 p
= get_doc_string_buffer
+ in_buffer
;
185 space_left
= (get_doc_string_buffer_size
- 1
186 - (p
- get_doc_string_buffer
));
189 /* Read a disk block at a time.
190 If we read the same block last time, maybe skip this? */
191 if (space_left
> 1024 * 8)
192 space_left
= 1024 * 8;
193 nread
= emacs_read (fd
, p
, space_left
);
197 error ("Read error on documentation file");
202 if (p
== get_doc_string_buffer
)
203 p1
= strchr (p
+ offset
, '\037');
205 p1
= strchr (p
, '\037');
216 /* Sanity checking. */
220 if (get_doc_string_buffer
[offset
- test
++] != ' ')
222 while (get_doc_string_buffer
[offset
- test
] >= '0'
223 && get_doc_string_buffer
[offset
- test
] <= '9')
225 if (get_doc_string_buffer
[offset
- test
++] != '@'
226 || get_doc_string_buffer
[offset
- test
] != '#')
232 if (get_doc_string_buffer
[offset
- test
++] != '\n')
234 while (get_doc_string_buffer
[offset
- test
] > ' ')
236 if (get_doc_string_buffer
[offset
- test
] != '\037')
240 /* Scan the text and perform quoting with ^A (char code 1).
241 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
242 from
= get_doc_string_buffer
+ offset
;
243 to
= get_doc_string_buffer
+ offset
;
260 unsigned char uc
= c
;
262 Invalid data in documentation file -- %c followed by code %03o",
270 /* If DEFINITION, read from this buffer
271 the same way we would read bytes from a file. */
274 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
275 return Fread (Qlambda
);
279 return make_unibyte_string (get_doc_string_buffer
+ offset
,
280 to
- (get_doc_string_buffer
+ offset
));
283 /* The data determines whether the string is multibyte. */
285 multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
287 to
- (get_doc_string_buffer
+ offset
));
288 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
290 to
- (get_doc_string_buffer
+ offset
));
294 /* Get a string from position FILEPOS and pass it through the Lisp reader.
295 We use this for fetching the bytecode string and constants vector
296 of a compiled function from the .elc file. */
299 read_doc_string (Lisp_Object filepos
)
301 return get_doc_string (filepos
, 0, 1);
305 reread_doc_file (Lisp_Object file
)
308 Lisp_Object reply
, prompt
[3];
311 prompt
[0] = build_string ("File ");
312 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
313 prompt
[2] = build_string (" is out of sync. Reload? ");
314 reply
= Fy_or_n_p (Fconcat (3, prompt
));
321 Fsnarf_documentation (Vdoc_file_name
);
323 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
328 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
329 doc
: /* Return the documentation string of FUNCTION.
330 Unless a non-nil second argument RAW is given, the
331 string is passed through `substitute-command-keys'. */)
332 (Lisp_Object function
, Lisp_Object raw
)
343 if (SYMBOLP (function
))
345 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
347 return Fdocumentation_property (function
, Qfunction_documentation
,
351 fun
= Findirect_function (function
, Qnil
);
354 if (XSUBR (fun
)->doc
== 0)
356 /* FIXME: This is not portable, as it assumes that string
357 pointers have the top bit clear. */
358 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
359 doc
= build_string (XSUBR (fun
)->doc
);
361 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
363 else if (COMPILEDP (fun
))
365 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
369 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
372 else if (NATNUMP (tem
) || CONSP (tem
))
378 else if (STRINGP (fun
) || VECTORP (fun
))
380 return build_string ("Keyboard macro.");
382 else if (CONSP (fun
))
385 if (!SYMBOLP (funcar
))
386 xsignal1 (Qinvalid_function
, fun
);
387 else if (EQ (funcar
, Qkeymap
))
388 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
389 else if (EQ (funcar
, Qlambda
)
390 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
391 || EQ (funcar
, Qautoload
))
393 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
394 Lisp_Object tem
= Fcar (tem1
);
397 /* Handle a doc reference--but these never come last
398 in the function body, so reject them if they are last. */
399 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
400 && !NILP (XCDR (tem1
)))
405 else if (EQ (funcar
, Qmacro
))
406 return Fdocumentation (Fcdr (fun
), raw
);
413 xsignal1 (Qinvalid_function
, fun
);
416 /* Check for an advised function. Its doc string
417 has an `ad-advice-info' text property. */
420 Lisp_Object innerfunc
;
421 innerfunc
= Fget_text_property (make_number (0),
422 intern ("ad-advice-info"),
424 if (! NILP (innerfunc
))
425 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
428 /* If DOC is 0, it's typically because of a dumped file missing
429 from the DOC file (bug in src/Makefile.in). */
430 if (EQ (doc
, make_number (0)))
432 if (INTEGERP (doc
) || CONSP (doc
))
435 tem
= get_doc_string (doc
, 0, 0);
436 if (NILP (tem
) && try_reload
)
438 /* The file is newer, we need to reset the pointers. */
439 struct gcpro gcpro1
, gcpro2
;
440 GCPRO2 (function
, raw
);
441 try_reload
= reread_doc_file (Fcar_safe (doc
));
454 doc
= Fsubstitute_command_keys (doc
);
458 DEFUN ("documentation-property", Fdocumentation_property
,
459 Sdocumentation_property
, 2, 3, 0,
460 doc
: /* Return the documentation string that is SYMBOL's PROP property.
461 Third argument RAW omitted or nil means pass the result through
462 `substitute-command-keys' if it is a string.
464 This differs from `get' in that it can refer to strings stored in the
465 `etc/DOC' file; and that it evaluates documentation properties that
467 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
472 documentation_property
:
474 tem
= Fget (symbol
, prop
);
475 if (EQ (tem
, make_number (0)))
477 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
479 Lisp_Object doc
= tem
;
480 tem
= get_doc_string (tem
, 0, 0);
481 if (NILP (tem
) && try_reload
)
483 /* The file is newer, we need to reset the pointers. */
484 struct gcpro gcpro1
, gcpro2
, gcpro3
;
485 GCPRO3 (symbol
, prop
, raw
);
486 try_reload
= reread_doc_file (Fcar_safe (doc
));
491 goto documentation_property
;
495 else if (!STRINGP (tem
))
496 /* Feval protects its argument. */
497 tem
= Feval (tem
, Qnil
);
499 if (NILP (raw
) && STRINGP (tem
))
500 tem
= Fsubstitute_command_keys (tem
);
504 /* Scanning the DOC files and placing docstring offsets into functions. */
507 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
509 /* Don't use indirect_function here, or defaliases will apply their
510 docstrings to the base functions (Bug#2603). */
511 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
513 /* The type determines where the docstring is stored. */
515 /* Lisp_Subrs have a slot for it. */
518 intptr_t negative_offset
= - offset
;
519 XSUBR (fun
)->doc
= (char *) negative_offset
;
522 /* If it's a lisp form, stick it in the form. */
523 else if (CONSP (fun
))
528 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
529 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
531 tem
= Fcdr (Fcdr (fun
));
532 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
533 XSETCAR (tem
, make_number (offset
));
535 else if (EQ (tem
, Qmacro
))
536 store_function_docstring (XCDR (fun
), offset
);
539 /* Bytecode objects sometimes have slots for it. */
540 else if (COMPILEDP (fun
))
542 /* This bytecode object must have a slot for the
543 docstring, since we've found a docstring for it. */
544 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
545 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
549 static const char buildobj
[] = BUILDOBJ
;
551 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
553 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
554 This searches the `etc/DOC...' file for doc strings and
555 records them in function and variable definitions.
556 The function takes one argument, FILENAME, a string;
557 it specifies the file name (without a directory) of the DOC file.
558 That file is found in `../etc' now; later, when the dumped Emacs is run,
559 the same file name is found in the `doc-directory'. */)
560 (Lisp_Object filename
)
565 register EMACS_INT pos
;
571 CHECK_STRING (filename
);
575 (!NILP (Vpurify_flag
))
576 #else /* CANNOT_DUMP */
578 #endif /* CANNOT_DUMP */
580 name
= (char *) alloca (SCHARS (filename
) + 14);
581 strcpy (name
, "../etc/");
585 CHECK_STRING (Vdoc_directory
);
586 name
= (char *) alloca (SCHARS (filename
)
587 + SCHARS (Vdoc_directory
) + 1);
588 strcpy (name
, SSDATA (Vdoc_directory
));
590 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
592 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
593 if (NILP (Vbuild_files
))
595 const char *beg
, *end
;
597 for (beg
= buildobj
; *beg
; beg
= end
)
601 while (*beg
&& isspace (*beg
)) ++beg
;
603 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
604 if (*end
== '/') beg
= end
+1; /* skip directory part */
607 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
608 len
-= 2; /* Just take .o if it ends in .obj */
611 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
613 Vbuild_files
= Fpurecopy (Vbuild_files
);
616 fd
= emacs_open (name
, O_RDONLY
, 0);
618 report_file_error ("Opening doc string file",
619 Fcons (build_string (name
), Qnil
));
620 Vdoc_file_name
= filename
;
627 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
633 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
634 while (p
!= end
&& *p
!= '\037') p
++;
635 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
638 end
= strchr (p
, '\n');
640 /* See if this is a file name, and if it is a file in build-files. */
644 if (end
- p
> 4 && end
[-2] == '.'
645 && (end
[-1] == 'o' || end
[-1] == 'c'))
647 ptrdiff_t 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
),
659 sym
= oblookup (Vobarray
, p
+ 2,
660 multibyte_chars_in_text ((unsigned char *) p
+ 2,
663 /* Check skip_file so that when a function is defined several
664 times in different files (typically, once in xterm, once in
665 w32term, ...), we only pay attention to the one that
667 if (! skip_file
&& SYMBOLP (sym
))
669 /* Attach a docstring to a variable? */
672 /* Install file-position as variable-documentation property
673 and make it negative for a user-variable
674 (doc starts with a `*'). */
675 if (!NILP (Fboundp (sym
)))
676 Fput (sym
, Qvariable_documentation
,
677 make_number ((pos
+ end
+ 1 - buf
)
678 * (end
[1] == '*' ? -1 : 1)));
681 /* Attach a docstring to a function? */
682 else if (p
[1] == 'F')
684 if (!NILP (Ffboundp (sym
)))
685 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
687 else if (p
[1] == 'S')
688 ; /* Just a source file name boundary marker. Ignore it. */
691 error ("DOC file invalid at position %"pI
"d", pos
);
696 memmove (buf
, end
, filled
);
702 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
703 Ssubstitute_command_keys
, 1, 1, 0,
704 doc
: /* Substitute key descriptions for command names in STRING.
705 Each substring of the form \\=\\[COMMAND] is replaced by either a
706 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
709 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
710 the value of MAPVAR as a keymap. This summary is similar to the one
711 produced by `describe-bindings'. The summary ends in two newlines
712 \(used by the helper function `help-make-xrefs' to find the end of the
715 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
716 as the keymap for future \\=\\[COMMAND] substrings.
717 \\=\\= quotes the following character and is discarded;
718 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
720 Return the original STRING if no substitutions are made.
721 Otherwise, return a new string, without any text properties. */)
726 register unsigned char *strp
;
732 unsigned char *start
;
733 ptrdiff_t length
, length_byte
;
735 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
742 CHECK_STRING (string
);
746 GCPRO4 (string
, tem
, keymap
, name
);
748 multibyte
= STRING_MULTIBYTE (string
);
751 /* KEYMAP is either nil (which means search all the active keymaps)
752 or a specified local map (which means search just that and the
753 global map). If non-nil, it might come from Voverriding_local_map,
754 or from a \\<mapname> construct in STRING itself.. */
755 keymap
= KVAR (current_kboard
, Voverriding_terminal_local_map
);
757 keymap
= Voverriding_local_map
;
759 bsize
= SBYTES (string
);
760 bufp
= buf
= xmalloc (bsize
);
762 strp
= SDATA (string
);
763 while (strp
< SDATA (string
) + SBYTES (string
))
765 if (strp
[0] == '\\' && strp
[1] == '=')
767 /* \= quotes the next character;
768 thus, to put in \[ without its special meaning, use \=\[. */
775 STRING_CHAR_AND_LENGTH (strp
, len
);
779 memcpy (bufp
, strp
, len
);
785 *bufp
++ = *strp
++, nchars
++;
787 else if (strp
[0] == '\\' && strp
[1] == '[')
790 int follow_remap
= 1;
793 strp
+= 2; /* skip \[ */
795 start_idx
= start
- SDATA (string
);
797 while ((strp
- SDATA (string
)
801 length_byte
= strp
- start
;
805 /* Save STRP in IDX. */
806 idx
= strp
- SDATA (string
);
807 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
810 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
812 if (VECTORP (tem
) && ASIZE (tem
) > 1
813 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
816 name
= AREF (tem
, 1);
821 /* Note the Fwhere_is_internal can GC, so we have to take
822 relocation of string contents into account. */
823 strp
= SDATA (string
) + idx
;
824 start
= SDATA (string
) + start_idx
;
826 if (NILP (tem
)) /* but not on any keys */
828 ptrdiff_t offset
= bufp
- buf
;
829 if (STRING_BYTES_BOUND
- 4 < bsize
)
831 buf
= (char *) xrealloc (buf
, bsize
+= 4);
833 memcpy (bufp
, "M-x ", 4);
837 length
= multibyte_chars_in_text (start
, length_byte
);
839 length
= length_byte
;
843 { /* function is on a key */
844 tem
= Fkey_description (tem
, Qnil
);
848 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
849 \<foo> just sets the keymap used for \[cmd]. */
850 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
852 struct buffer
*oldbuf
;
854 /* This is for computing the SHADOWS arg for describe_map_tree. */
855 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
856 Lisp_Object earlier_maps
;
859 strp
+= 2; /* skip \{ or \< */
861 start_idx
= start
- SDATA (string
);
863 while ((strp
- SDATA (string
) < SBYTES (string
))
864 && *strp
!= '}' && *strp
!= '>')
867 length_byte
= strp
- start
;
868 strp
++; /* skip } or > */
870 /* Save STRP in IDX. */
871 idx
= strp
- SDATA (string
);
873 /* Get the value of the keymap in TEM, or nil if undefined.
874 Do this while still in the user's current buffer
875 in case it is a local variable. */
876 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
877 tem
= Fboundp (name
);
880 tem
= Fsymbol_value (name
);
883 tem
= get_keymap (tem
, 0, 1);
884 /* Note that get_keymap can GC. */
885 strp
= SDATA (string
) + idx
;
886 start
= SDATA (string
) + start_idx
;
890 /* Now switch to a temp buffer. */
891 oldbuf
= current_buffer
;
892 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
896 name
= Fsymbol_name (name
);
897 insert_string ("\nUses keymap `");
898 insert_from_string (name
, 0, 0,
901 insert_string ("', which is not currently defined.\n");
902 if (start
[-1] == '<') keymap
= Qnil
;
904 else if (start
[-1] == '<')
908 /* Get the list of active keymaps that precede this one.
909 If this one's not active, get nil. */
910 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
911 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
912 Qnil
, (char *)0, 1, 0, 0, 1);
914 tem
= Fbuffer_string ();
916 set_buffer_internal (oldbuf
);
920 length
= SCHARS (tem
);
921 length_byte
= SBYTES (tem
);
924 ptrdiff_t offset
= bufp
- buf
;
925 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
927 buf
= (char *) xrealloc (buf
, bsize
+= length_byte
);
929 memcpy (bufp
, start
, length_byte
);
932 /* Check STRING again in case gc relocated it. */
933 strp
= SDATA (string
) + idx
;
936 else if (! multibyte
) /* just copy other chars */
937 *bufp
++ = *strp
++, nchars
++;
942 STRING_CHAR_AND_LENGTH (strp
, len
);
946 memcpy (bufp
, strp
, len
);
953 if (changed
) /* don't bother if nothing substituted */
954 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
958 RETURN_UNGCPRO (tem
);
964 DEFSYM (Qfunction_documentation
, "function-documentation");
966 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
967 doc
: /* Name of file containing documentation strings of built-in symbols. */);
968 Vdoc_file_name
= Qnil
;
970 DEFVAR_LISP ("build-files", Vbuild_files
,
971 doc
: /* A list of files used to build this Emacs binary. */);
974 defsubr (&Sdocumentation
);
975 defsubr (&Sdocumentation_property
);
976 defsubr (&Ssnarf_documentation
);
977 defsubr (&Ssubstitute_command_keys
);