1 /* Record indices of function doc strings stored in a file.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2014 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/>. */
24 #include <sys/types.h>
25 #include <sys/file.h> /* Must be after sys/types.h for USG. */
32 #include "character.h"
37 Lisp_Object Qfunction_documentation
;
39 /* Buffer used for reading from documentation file. */
40 static char *get_doc_string_buffer
;
41 static ptrdiff_t get_doc_string_buffer_size
;
43 static unsigned char *read_bytecode_pointer
;
45 /* `readchar' in lread.c calls back here to fetch the next byte.
46 If UNREADFLAG is 1, we unread a byte. */
49 read_bytecode_char (bool unreadflag
)
53 read_bytecode_pointer
--;
56 return *read_bytecode_pointer
++;
59 /* Extract a doc string from a file. FILEPOS says where to get it.
60 If it is an integer, use that position in the standard DOC file.
61 If it is (FILE . INTEGER), use FILE as the file name
62 and INTEGER as the position in that file.
63 But if INTEGER is negative, make it positive.
64 (A negative integer is used for user variables, so we can distinguish
65 them without actually fetching the doc string.)
67 If the location does not point to the beginning of a docstring
68 (e.g. because the file has been modified and the location is stale),
71 If UNIBYTE, always make a unibyte string.
73 If DEFINITION, assume this is for reading
74 a dynamic function definition; convert the bytestring
75 and the constants vector with appropriate byte handling,
76 and return a cons cell. */
79 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
81 char *from
, *to
, *name
, *p
, *p1
;
86 Lisp_Object file
, tem
, pos
;
89 if (INTEGERP (filepos
))
91 file
= Vdoc_file_name
;
94 else if (CONSP (filepos
))
96 file
= XCAR (filepos
);
102 position
= eabs (XINT (pos
));
104 if (!STRINGP (Vdoc_directory
))
110 /* Put the file name in NAME as a C string.
111 If it is relative, combine it with Vdoc_directory. */
113 tem
= Ffile_name_absolute_p (file
);
114 file
= ENCODE_FILE (file
);
117 Lisp_Object docdir
= ENCODE_FILE (Vdoc_directory
);
118 minsize
= SCHARS (docdir
);
119 /* sizeof ("../etc/") == 8 */
122 name
= SAFE_ALLOCA (minsize
+ SCHARS (file
) + 8);
123 strcpy (name
, SSDATA (docdir
));
124 strcat (name
, SSDATA (file
));
128 name
= SSDATA (file
);
131 fd
= emacs_open (name
, O_RDONLY
, 0);
135 if (!NILP (Vpurify_flag
))
137 /* Preparing to dump; DOC file is probably not installed.
138 So check in ../etc. */
139 strcpy (name
, "../etc/");
140 strcat (name
, SSDATA (file
));
142 fd
= emacs_open (name
, O_RDONLY
, 0);
148 return concat3 (build_string ("Cannot open doc string file \""),
149 file
, build_string ("\"\n"));
153 record_unwind_protect_int (close_file_unwind
, fd
);
155 /* Seek only to beginning of disk block. */
156 /* Make sure we read at least 1024 bytes before `position'
157 so we can check the leading text for consistency. */
158 offset
= min (position
, max (1024, position
% (8 * 1024)));
159 if (TYPE_MAXIMUM (off_t
) < position
160 || lseek (fd
, position
- offset
, 0) < 0)
161 error ("Position %"pI
"d out of range in doc string file \"%s\"",
164 /* Read the doc string into get_doc_string_buffer.
165 P points beyond the data just read. */
167 p
= get_doc_string_buffer
;
170 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
171 - (p
- get_doc_string_buffer
));
174 /* Allocate or grow the buffer if we need to. */
177 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
178 get_doc_string_buffer
179 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
181 p
= get_doc_string_buffer
+ in_buffer
;
182 space_left
= (get_doc_string_buffer_size
- 1
183 - (p
- get_doc_string_buffer
));
186 /* Read a disk block at a time.
187 If we read the same block last time, maybe skip this? */
188 if (space_left
> 1024 * 8)
189 space_left
= 1024 * 8;
190 nread
= emacs_read (fd
, p
, space_left
);
192 report_file_error ("Read error on documentation file", file
);
196 if (p
== get_doc_string_buffer
)
197 p1
= strchr (p
+ offset
, '\037');
199 p1
= strchr (p
, '\037');
211 /* Sanity checking. */
215 /* A dynamic docstring should be either at the very beginning of a "#@
216 comment" or right after a dynamic docstring delimiter (in case we
217 pack several such docstrings within the same comment). */
218 if (get_doc_string_buffer
[offset
- test
] != '\037')
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
] != '#')
233 if (get_doc_string_buffer
[offset
- test
++] != '\n')
235 while (get_doc_string_buffer
[offset
- test
] > ' ')
237 if (get_doc_string_buffer
[offset
- test
] != '\037')
241 /* Scan the text and perform quoting with ^A (char code 1).
242 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
243 from
= get_doc_string_buffer
+ offset
;
244 to
= get_doc_string_buffer
+ offset
;
261 unsigned char uc
= c
;
263 Invalid data in documentation file -- %c followed by code %03o",
271 /* If DEFINITION, read from this buffer
272 the same way we would read bytes from a file. */
275 read_bytecode_pointer
= (unsigned char *) get_doc_string_buffer
+ offset
;
276 return Fread (Qlambda
);
280 return make_unibyte_string (get_doc_string_buffer
+ offset
,
281 to
- (get_doc_string_buffer
+ offset
));
284 /* The data determines whether the string is multibyte. */
286 = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
288 to
- (get_doc_string_buffer
+ offset
));
289 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
291 to
- (get_doc_string_buffer
+ offset
));
295 /* Get a string from position FILEPOS and pass it through the Lisp reader.
296 We use this for fetching the bytecode string and constants vector
297 of a compiled function from the .elc file. */
300 read_doc_string (Lisp_Object filepos
)
302 return get_doc_string (filepos
, 0, 1);
306 reread_doc_file (Lisp_Object file
)
309 Lisp_Object reply
, prompt
[3];
312 prompt
[0] = build_string ("File ");
313 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
314 prompt
[2] = build_string (" is out of sync. Reload? ");
315 reply
= Fy_or_n_p (Fconcat (3, prompt
));
322 Fsnarf_documentation (Vdoc_file_name
);
324 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
329 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
330 doc
: /* Return the documentation string of FUNCTION.
331 Unless a non-nil second argument RAW is given, the
332 string is passed through `substitute-command-keys'. */)
333 (Lisp_Object function
, Lisp_Object raw
)
344 if (SYMBOLP (function
))
346 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
348 return Fdocumentation_property (function
, Qfunction_documentation
,
352 fun
= Findirect_function (function
, Qnil
);
353 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
357 if (XSUBR (fun
)->doc
== 0)
359 /* FIXME: This is not portable, as it assumes that string
360 pointers have the top bit clear. */
361 else if ((intptr_t) XSUBR (fun
)->doc
>= 0)
362 doc
= build_string (XSUBR (fun
)->doc
);
364 doc
= make_number ((intptr_t) XSUBR (fun
)->doc
);
366 else if (COMPILEDP (fun
))
368 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
372 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
375 else if (NATNUMP (tem
) || CONSP (tem
))
381 else if (STRINGP (fun
) || VECTORP (fun
))
383 return build_string ("Keyboard macro.");
385 else if (CONSP (fun
))
388 if (!SYMBOLP (funcar
))
389 xsignal1 (Qinvalid_function
, fun
);
390 else if (EQ (funcar
, Qkeymap
))
391 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
392 else if (EQ (funcar
, Qlambda
)
393 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
394 || EQ (funcar
, Qautoload
))
396 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
397 Lisp_Object tem
= Fcar (tem1
);
400 /* Handle a doc reference--but these never come last
401 in the function body, so reject them if they are last. */
402 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
403 && !NILP (XCDR (tem1
)))
414 xsignal1 (Qinvalid_function
, fun
);
417 /* If DOC is 0, it's typically because of a dumped file missing
418 from the DOC file (bug in src/Makefile.in). */
419 if (EQ (doc
, make_number (0)))
421 if (INTEGERP (doc
) || CONSP (doc
))
424 tem
= get_doc_string (doc
, 0, 0);
425 if (NILP (tem
) && try_reload
)
427 /* The file is newer, we need to reset the pointers. */
428 struct gcpro gcpro1
, gcpro2
;
429 GCPRO2 (function
, raw
);
430 try_reload
= reread_doc_file (Fcar_safe (doc
));
443 doc
= Fsubstitute_command_keys (doc
);
447 DEFUN ("documentation-property", Fdocumentation_property
,
448 Sdocumentation_property
, 2, 3, 0,
449 doc
: /* Return the documentation string that is SYMBOL's PROP property.
450 Third argument RAW omitted or nil means pass the result through
451 `substitute-command-keys' if it is a string.
453 This differs from `get' in that it can refer to strings stored in the
454 `etc/DOC' file; and that it evaluates documentation properties that
456 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
461 documentation_property
:
463 tem
= Fget (symbol
, prop
);
464 if (EQ (tem
, make_number (0)))
466 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
468 Lisp_Object doc
= tem
;
469 tem
= get_doc_string (tem
, 0, 0);
470 if (NILP (tem
) && try_reload
)
472 /* The file is newer, we need to reset the pointers. */
473 struct gcpro gcpro1
, gcpro2
, gcpro3
;
474 GCPRO3 (symbol
, prop
, raw
);
475 try_reload
= reread_doc_file (Fcar_safe (doc
));
480 goto documentation_property
;
484 else if (!STRINGP (tem
))
485 /* Feval protects its argument. */
486 tem
= Feval (tem
, Qnil
);
488 if (NILP (raw
) && STRINGP (tem
))
489 tem
= Fsubstitute_command_keys (tem
);
493 /* Scanning the DOC files and placing docstring offsets into functions. */
496 store_function_docstring (Lisp_Object obj
, ptrdiff_t offset
)
498 /* Don't use indirect_function here, or defaliases will apply their
499 docstrings to the base functions (Bug#2603). */
500 Lisp_Object fun
= SYMBOLP (obj
) ? SYMBOL_FUNCTION (obj
) : obj
;
502 /* The type determines where the docstring is stored. */
504 /* Lisp_Subrs have a slot for it. */
507 intptr_t negative_offset
= - offset
;
508 XSUBR (fun
)->doc
= (char *) negative_offset
;
511 /* If it's a lisp form, stick it in the form. */
512 else if (CONSP (fun
))
517 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
518 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
520 tem
= Fcdr (Fcdr (fun
));
521 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
522 /* FIXME: This modifies typically pure hash-cons'd data, so its
523 correctness is quite delicate. */
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
));
538 message ("No docstring slot for %s",
539 SYMBOLP (obj
) ? SSDATA (SYMBOL_NAME (obj
)) : "<anonymous>");
544 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
546 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
547 This searches the `etc/DOC...' file for doc strings and
548 records them in function and variable definitions.
549 The function takes one argument, FILENAME, a string;
550 it specifies the file name (without a directory) of the DOC file.
551 That file is found in `../etc' now; later, when the dumped Emacs is run,
552 the same file name is found in the `doc-directory'. */)
553 (Lisp_Object filename
)
563 /* Preloaded defcustoms using custom-initialize-delay are added to
564 this list, but kept unbound. See http://debbugs.gnu.org/11565 */
565 Lisp_Object delayed_init
=
566 find_symbol_value (intern ("custom-delayed-init-variables"));
568 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
570 CHECK_STRING (filename
);
574 (!NILP (Vpurify_flag
))
575 #else /* CANNOT_DUMP */
577 #endif /* CANNOT_DUMP */
579 name
= alloca (SCHARS (filename
) + 14);
580 strcpy (name
, "../etc/");
584 CHECK_STRING (Vdoc_directory
);
585 name
= alloca (SCHARS (filename
) + SCHARS (Vdoc_directory
) + 1);
586 strcpy (name
, SSDATA (Vdoc_directory
));
588 strcat (name
, SSDATA (filename
)); /*** Add this line ***/
590 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
591 if (NILP (Vbuild_files
))
593 static char const *const buildobj
[] =
595 #include "buildobj.h"
597 int i
= ARRAYELTS (buildobj
);
599 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
600 Vbuild_files
= Fpurecopy (Vbuild_files
);
603 fd
= emacs_open (name
, O_RDONLY
, 0);
606 int open_errno
= errno
;
607 report_file_errno ("Opening doc string file", build_string (name
),
611 record_unwind_protect_int (close_file_unwind
, fd
);
612 Vdoc_file_name
= filename
;
619 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
624 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
625 p
= memchr (buf
, '\037', end
- buf
);
626 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
629 end
= strchr (p
, '\n');
631 /* See if this is a file name, and if it is a file in build-files. */
635 if (end
- p
> 4 && end
[-2] == '.'
636 && (end
[-1] == 'o' || end
[-1] == 'c'))
638 ptrdiff_t len
= end
- p
- 2;
639 char *fromfile
= alloca (len
+ 1);
640 memcpy (fromfile
, &p
[2], len
);
642 if (fromfile
[len
-1] == 'c')
643 fromfile
[len
-1] = 'o';
645 skip_file
= NILP (Fmember (build_string (fromfile
),
650 sym
= oblookup (Vobarray
, p
+ 2,
651 multibyte_chars_in_text ((unsigned char *) p
+ 2,
654 /* Check skip_file so that when a function is defined several
655 times in different files (typically, once in xterm, once in
656 w32term, ...), we only pay attention to the one that
658 if (! skip_file
&& SYMBOLP (sym
))
660 /* Attach a docstring to a variable? */
663 /* Install file-position as variable-documentation property
664 and make it negative for a user-variable
665 (doc starts with a `*'). */
666 if (!NILP (Fboundp (sym
))
667 || !NILP (Fmemq (sym
, delayed_init
)))
668 Fput (sym
, Qvariable_documentation
,
669 make_number ((pos
+ end
+ 1 - buf
)
670 * (end
[1] == '*' ? -1 : 1)));
673 /* Attach a docstring to a function? */
674 else if (p
[1] == 'F')
676 if (!NILP (Ffboundp (sym
)))
677 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
679 else if (p
[1] == 'S')
680 ; /* Just a source file name boundary marker. Ignore it. */
683 error ("DOC file invalid at position %"pI
"d", pos
);
688 memmove (buf
, end
, filled
);
694 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
695 Ssubstitute_command_keys
, 1, 1, 0,
696 doc
: /* Substitute key descriptions for command names in STRING.
697 Each substring of the form \\=\\[COMMAND] is replaced by either a
698 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
701 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
702 the value of MAPVAR as a keymap. This summary is similar to the one
703 produced by `describe-bindings'. The summary ends in two newlines
704 \(used by the helper function `help-make-xrefs' to find the end of the
707 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
708 as the keymap for future \\=\\[COMMAND] substrings.
709 \\=\\= quotes the following character and is discarded;
710 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
712 Return the original STRING if no substitutions are made.
713 Otherwise, return a new string. */)
724 unsigned char *start
;
725 ptrdiff_t length
, length_byte
;
727 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
734 CHECK_STRING (string
);
738 GCPRO4 (string
, tem
, keymap
, name
);
740 multibyte
= STRING_MULTIBYTE (string
);
743 /* KEYMAP is either nil (which means search all the active keymaps)
744 or a specified local map (which means search just that and the
745 global map). If non-nil, it might come from Voverriding_local_map,
746 or from a \\<mapname> construct in STRING itself.. */
747 keymap
= Voverriding_local_map
;
749 bsize
= SBYTES (string
);
750 bufp
= buf
= xmalloc_atomic (bsize
);
752 strp
= SDATA (string
);
753 while (strp
< SDATA (string
) + SBYTES (string
))
755 if (strp
[0] == '\\' && strp
[1] == '=')
757 /* \= quotes the next character;
758 thus, to put in \[ without its special meaning, use \=\[. */
765 STRING_CHAR_AND_LENGTH (strp
, len
);
769 memcpy (bufp
, strp
, len
);
775 *bufp
++ = *strp
++, nchars
++;
777 else if (strp
[0] == '\\' && strp
[1] == '[')
780 bool follow_remap
= 1;
783 strp
+= 2; /* skip \[ */
785 start_idx
= start
- SDATA (string
);
787 while ((strp
- SDATA (string
)
791 length_byte
= strp
- start
;
795 /* Save STRP in IDX. */
796 idx
= strp
- SDATA (string
);
797 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
800 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
802 if (VECTORP (tem
) && ASIZE (tem
) > 1
803 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
806 name
= AREF (tem
, 1);
811 /* Note the Fwhere_is_internal can GC, so we have to take
812 relocation of string contents into account. */
813 strp
= SDATA (string
) + idx
;
814 start
= SDATA (string
) + start_idx
;
816 if (NILP (tem
)) /* but not on any keys */
818 ptrdiff_t offset
= bufp
- buf
;
819 if (STRING_BYTES_BOUND
- 4 < bsize
)
821 buf
= xrealloc (buf
, bsize
+= 4);
823 memcpy (bufp
, "M-x ", 4);
827 length
= multibyte_chars_in_text (start
, length_byte
);
829 length
= length_byte
;
833 { /* function is on a key */
834 tem
= Fkey_description (tem
, Qnil
);
838 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
839 \<foo> just sets the keymap used for \[cmd]. */
840 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
842 struct buffer
*oldbuf
;
844 /* This is for computing the SHADOWS arg for describe_map_tree. */
845 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
846 Lisp_Object earlier_maps
;
850 strp
+= 2; /* skip \{ or \< */
852 start_idx
= start
- SDATA (string
);
854 while ((strp
- SDATA (string
) < SBYTES (string
))
855 && *strp
!= '}' && *strp
!= '>')
858 length_byte
= strp
- start
;
859 strp
++; /* skip } or > */
861 /* Save STRP in IDX. */
862 idx
= strp
- SDATA (string
);
864 /* Get the value of the keymap in TEM, or nil if undefined.
865 Do this while still in the user's current buffer
866 in case it is a local variable. */
867 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
868 tem
= Fboundp (name
);
871 tem
= Fsymbol_value (name
);
874 tem
= get_keymap (tem
, 0, 1);
875 /* Note that get_keymap can GC. */
876 strp
= SDATA (string
) + idx
;
877 start
= SDATA (string
) + start_idx
;
881 /* Now switch to a temp buffer. */
882 oldbuf
= current_buffer
;
883 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
884 /* This is for an unusual case where some after-change
885 function uses 'format' or 'prin1' or something else that
886 will thrash Vprin1_to_string_buffer we are using. */
887 specbind (Qinhibit_modification_hooks
, Qt
);
891 name
= Fsymbol_name (name
);
892 insert_string ("\nUses keymap `");
893 insert_from_string (name
, 0, 0,
896 insert_string ("', which is not currently defined.\n");
897 if (start
[-1] == '<') keymap
= Qnil
;
899 else if (start
[-1] == '<')
903 /* Get the list of active keymaps that precede this one.
904 If this one's not active, get nil. */
905 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
906 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
907 Qnil
, 0, 1, 0, 0, 1);
909 tem
= Fbuffer_string ();
911 set_buffer_internal (oldbuf
);
916 length
= SCHARS (tem
);
917 length_byte
= SBYTES (tem
);
920 ptrdiff_t offset
= bufp
- buf
;
921 if (STRING_BYTES_BOUND
- length_byte
< bsize
)
923 buf
= xrealloc (buf
, bsize
+= length_byte
);
925 memcpy (bufp
, start
, length_byte
);
928 /* Check STRING again in case gc relocated it. */
929 strp
= SDATA (string
) + idx
;
932 else if (! multibyte
) /* just copy other chars */
933 *bufp
++ = *strp
++, nchars
++;
938 STRING_CHAR_AND_LENGTH (strp
, len
);
942 memcpy (bufp
, strp
, len
);
949 if (changed
) /* don't bother if nothing substituted */
950 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
962 DEFSYM (Qfunction_documentation
, "function-documentation");
964 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
965 doc
: /* Name of file containing documentation strings of built-in symbols. */);
966 Vdoc_file_name
= Qnil
;
968 DEFVAR_LISP ("build-files", Vbuild_files
,
969 doc
: /* A list of files used to build this Emacs binary. */);