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 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, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
25 #include <sys/types.h>
26 #include <sys/file.h> /* Must be after sys/types.h for USG and BSD4_1*/
44 #include "character.h"
48 extern char *index
P_ ((const char *, int));
51 Lisp_Object Vdoc_file_name
;
53 Lisp_Object Qfunction_documentation
;
55 /* A list of files used to build this Emacs binary. */
56 static Lisp_Object Vbuild_files
;
58 extern Lisp_Object Voverriding_local_map
;
60 extern Lisp_Object Qremap
;
62 /* For VMS versions with limited file name syntax,
63 convert the name to something VMS will allow. */
65 munge_doc_file_name (name
)
69 #ifndef NO_HYPHENS_IN_FILENAMES
70 extern char * sys_translate_unix (char *ufile
);
71 strcpy (name
, sys_translate_unix (name
));
72 #else /* NO_HYPHENS_IN_FILENAMES */
80 #endif /* NO_HYPHENS_IN_FILENAMES */
84 /* Buffer used for reading from documentation file. */
85 static char *get_doc_string_buffer
;
86 static int get_doc_string_buffer_size
;
88 static unsigned char *read_bytecode_pointer
;
89 Lisp_Object Fsnarf_documentation
P_ ((Lisp_Object
));
91 /* readchar in lread.c calls back here to fetch the next byte.
92 If UNREADFLAG is 1, we unread a byte. */
95 read_bytecode_char (unreadflag
)
100 read_bytecode_pointer
--;
103 return *read_bytecode_pointer
++;
106 /* Extract a doc string from a file. FILEPOS says where to get it.
107 If it is an integer, use that position in the standard DOC-... file.
108 If it is (FILE . INTEGER), use FILE as the file name
109 and INTEGER as the position in that file.
110 But if INTEGER is negative, make it positive.
111 (A negative integer is used for user variables, so we can distinguish
112 them without actually fetching the doc string.)
114 If the location does not point to the beginning of a docstring
115 (e.g. because the file has been modified and the location is stale),
118 If UNIBYTE is nonzero, always make a unibyte string.
120 If DEFINITION is nonzero, assume this is for reading
121 a dynamic function definition; convert the bytestring
122 and the constants vector with appropriate byte handling,
123 and return a cons cell. */
126 get_doc_string (filepos
, unibyte
, definition
)
128 int unibyte
, definition
;
133 register char *p
, *p1
;
135 int offset
, position
;
136 Lisp_Object file
, tem
;
138 if (INTEGERP (filepos
))
140 file
= Vdoc_file_name
;
141 position
= XINT (filepos
);
143 else if (CONSP (filepos
))
145 file
= XCAR (filepos
);
146 position
= XINT (XCDR (filepos
));
152 position
= - position
;
154 if (!STRINGP (Vdoc_directory
))
160 /* Put the file name in NAME as a C string.
161 If it is relative, combine it with Vdoc_directory. */
163 tem
= Ffile_name_absolute_p (file
);
166 minsize
= SCHARS (Vdoc_directory
);
167 /* sizeof ("../etc/") == 8 */
170 name
= (char *) alloca (minsize
+ SCHARS (file
) + 8);
171 strcpy (name
, SDATA (Vdoc_directory
));
172 strcat (name
, SDATA (file
));
173 munge_doc_file_name (name
);
177 name
= (char *) SDATA (file
);
180 fd
= emacs_open (name
, O_RDONLY
, 0);
184 if (!NILP (Vpurify_flag
))
186 /* Preparing to dump; DOC file is probably not installed.
187 So check in ../etc. */
188 strcpy (name
, "../etc/");
189 strcat (name
, SDATA (file
));
190 munge_doc_file_name (name
);
192 fd
= emacs_open (name
, O_RDONLY
, 0);
196 error ("Cannot open doc string file \"%s\"", name
);
199 /* Seek only to beginning of disk block. */
200 /* Make sure we read at least 1024 bytes before `position'
201 so we can check the leading text for consistency. */
202 offset
= min (position
, max (1024, position
% (8 * 1024)));
203 if (0 > lseek (fd
, position
- offset
, 0))
206 error ("Position %ld out of range in doc string file \"%s\"",
210 /* Read the doc string into get_doc_string_buffer.
211 P points beyond the data just read. */
213 p
= get_doc_string_buffer
;
216 int space_left
= (get_doc_string_buffer_size
217 - (p
- get_doc_string_buffer
));
220 /* Allocate or grow the buffer if we need to. */
223 int in_buffer
= p
- get_doc_string_buffer
;
224 get_doc_string_buffer_size
+= 16 * 1024;
225 get_doc_string_buffer
226 = (char *) xrealloc (get_doc_string_buffer
,
227 get_doc_string_buffer_size
+ 1);
228 p
= get_doc_string_buffer
+ in_buffer
;
229 space_left
= (get_doc_string_buffer_size
230 - (p
- get_doc_string_buffer
));
233 /* Read a disk block at a time.
234 If we read the same block last time, maybe skip this? */
235 if (space_left
> 1024 * 8)
236 space_left
= 1024 * 8;
237 nread
= emacs_read (fd
, p
, space_left
);
241 error ("Read error on documentation file");
246 if (p
== get_doc_string_buffer
)
247 p1
= (char *) index (p
+ offset
, '\037');
249 p1
= (char *) index (p
, '\037');
260 /* Sanity checking. */
264 if (get_doc_string_buffer
[offset
- test
++] != ' ')
266 while (get_doc_string_buffer
[offset
- test
] >= '0'
267 && get_doc_string_buffer
[offset
- test
] <= '9')
269 if (get_doc_string_buffer
[offset
- test
++] != '@'
270 || get_doc_string_buffer
[offset
- test
] != '#')
276 if (get_doc_string_buffer
[offset
- test
++] != '\n')
278 while (get_doc_string_buffer
[offset
- test
] > ' ')
280 if (get_doc_string_buffer
[offset
- test
] != '\037')
284 /* Scan the text and perform quoting with ^A (char code 1).
285 ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */
286 from
= get_doc_string_buffer
+ offset
;
287 to
= get_doc_string_buffer
+ offset
;
303 error ("Invalid data in documentation file -- ^A followed by code 0%o", c
);
309 /* If DEFINITION, read from this buffer
310 the same way we would read bytes from a file. */
313 read_bytecode_pointer
= get_doc_string_buffer
+ offset
;
314 return Fread (Qlambda
);
318 return make_unibyte_string (get_doc_string_buffer
+ offset
,
319 to
- (get_doc_string_buffer
+ offset
));
322 /* Let the data determine whether the string is multibyte,
323 even if Emacs is running in --unibyte mode. */
324 int nchars
= multibyte_chars_in_text (get_doc_string_buffer
+ offset
,
325 to
- (get_doc_string_buffer
+ offset
));
326 return make_string_from_bytes (get_doc_string_buffer
+ offset
,
328 to
- (get_doc_string_buffer
+ offset
));
332 /* Get a string from position FILEPOS and pass it through the Lisp reader.
333 We use this for fetching the bytecode string and constants vector
334 of a compiled function from the .elc file. */
337 read_doc_string (filepos
)
340 return get_doc_string (filepos
, 0, 1);
344 reread_doc_file (file
)
348 Lisp_Object reply
, prompt
[3];
351 prompt
[0] = build_string ("File ");
352 prompt
[1] = NILP (file
) ? Vdoc_file_name
: file
;
353 prompt
[2] = build_string (" is out of sync. Reload? ");
354 reply
= Fy_or_n_p (Fconcat (3, prompt
));
361 Fsnarf_documentation (Vdoc_file_name
);
363 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
368 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
369 doc
: /* Return the documentation string of FUNCTION.
370 Unless a non-nil second argument RAW is given, the
371 string is passed through `substitute-command-keys'. */)
373 Lisp_Object function
, raw
;
377 Lisp_Object tem
, doc
;
384 if (SYMBOLP (function
)
385 && (tem
= Fget (function
, Qfunction_documentation
),
387 return Fdocumentation_property (function
, Qfunction_documentation
, raw
);
389 fun
= Findirect_function (function
, Qnil
);
392 if (XSUBR (fun
)->doc
== 0)
394 else if ((EMACS_INT
) XSUBR (fun
)->doc
>= 0)
395 doc
= build_string (XSUBR (fun
)->doc
);
397 doc
= make_number ((EMACS_INT
) XSUBR (fun
)->doc
);
399 else if (COMPILEDP (fun
))
401 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) <= COMPILED_DOC_STRING
)
403 tem
= AREF (fun
, COMPILED_DOC_STRING
);
406 else if (NATNUMP (tem
) || CONSP (tem
))
411 else if (STRINGP (fun
) || VECTORP (fun
))
413 return build_string ("Keyboard macro.");
415 else if (CONSP (fun
))
418 if (!SYMBOLP (funcar
))
419 xsignal1 (Qinvalid_function
, fun
);
420 else if (EQ (funcar
, Qkeymap
))
421 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
422 else if (EQ (funcar
, Qlambda
)
423 || EQ (funcar
, Qautoload
))
426 tem1
= Fcdr (Fcdr (fun
));
430 /* Handle a doc reference--but these never come last
431 in the function body, so reject them if they are last. */
432 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
433 && !NILP (XCDR (tem1
)))
438 /* Check for an advised function. Its doc string
439 has an `ad-advice-info' text property. */
442 Lisp_Object innerfunc
;
443 innerfunc
= Fget_text_property (make_number (0),
444 intern ("ad-advice-info"),
446 if (! NILP (innerfunc
))
447 doc
= call1 (intern ("ad-make-advised-docstring"), innerfunc
);
450 else if (EQ (funcar
, Qmacro
))
451 return Fdocumentation (Fcdr (fun
), raw
);
458 xsignal1 (Qinvalid_function
, fun
);
461 /* If DOC is 0, it's typically because of a dumped file missing
462 from the DOC file (bug in src/Makefile.in). */
463 if (EQ (doc
, make_number (0)))
465 if (INTEGERP (doc
) || CONSP (doc
))
468 tem
= get_doc_string (doc
, 0, 0);
469 if (NILP (tem
) && try_reload
)
471 /* The file is newer, we need to reset the pointers. */
472 struct gcpro gcpro1
, gcpro2
;
473 GCPRO2 (function
, raw
);
474 try_reload
= reread_doc_file (Fcar_safe (doc
));
487 doc
= Fsubstitute_command_keys (doc
);
491 DEFUN ("documentation-property", Fdocumentation_property
,
492 Sdocumentation_property
, 2, 3, 0,
493 doc
: /* Return the documentation string that is SYMBOL's PROP property.
494 Third argument RAW omitted or nil means pass the result through
495 `substitute-command-keys' if it is a string.
497 This differs from `get' in that it can refer to strings stored in the
498 `etc/DOC' file; and that it evaluates documentation properties that
501 Lisp_Object symbol
, prop
, raw
;
506 documentation_property
:
508 tem
= Fget (symbol
, prop
);
509 if (EQ (tem
, make_number (0)))
511 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
513 Lisp_Object doc
= tem
;
514 tem
= get_doc_string (tem
, 0, 0);
515 if (NILP (tem
) && try_reload
)
517 /* The file is newer, we need to reset the pointers. */
518 struct gcpro gcpro1
, gcpro2
, gcpro3
;
519 GCPRO3 (symbol
, prop
, raw
);
520 try_reload
= reread_doc_file (Fcar_safe (doc
));
525 goto documentation_property
;
529 else if (!STRINGP (tem
))
530 /* Feval protects its argument. */
533 if (NILP (raw
) && STRINGP (tem
))
534 tem
= Fsubstitute_command_keys (tem
);
538 /* Scanning the DOC files and placing docstring offsets into functions. */
541 store_function_docstring (fun
, offset
)
543 /* Use EMACS_INT because we get this from pointer subtraction. */
546 fun
= indirect_function (fun
);
548 /* The type determines where the docstring is stored. */
550 /* Lisp_Subrs have a slot for it. */
552 XSUBR (fun
)->doc
= (char *) - offset
;
554 /* If it's a lisp form, stick it in the form. */
555 else if (CONSP (fun
))
560 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
562 tem
= Fcdr (Fcdr (fun
));
563 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
564 XSETCARFASTINT (tem
, offset
);
566 else if (EQ (tem
, Qmacro
))
567 store_function_docstring (XCDR (fun
), offset
);
570 /* Bytecode objects sometimes have slots for it. */
571 else if (COMPILEDP (fun
))
573 /* This bytecode object must have a slot for the
574 docstring, since we've found a docstring for it. */
575 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
576 XSETFASTINT (AREF (fun
, COMPILED_DOC_STRING
), offset
);
581 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
583 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
584 This searches the `etc/DOC...' file for doc strings and
585 records them in function and variable definitions.
586 The function takes one argument, FILENAME, a string;
587 it specifies the file name (without a directory) of the DOC file.
588 That file is found in `../etc' now; later, when the dumped Emacs is run,
589 the same file name is found in the `doc-directory'. */)
591 Lisp_Object filename
;
597 register char *p
, *end
;
602 CHECK_STRING (filename
);
606 (!NILP (Vpurify_flag
))
607 #else /* CANNOT_DUMP */
609 #endif /* CANNOT_DUMP */
611 name
= (char *) alloca (SCHARS (filename
) + 14);
612 strcpy (name
, "../etc/");
616 CHECK_STRING (Vdoc_directory
);
617 name
= (char *) alloca (SCHARS (filename
)
618 + SCHARS (Vdoc_directory
) + 1);
619 strcpy (name
, SDATA (Vdoc_directory
));
621 strcat (name
, SDATA (filename
)); /*** Add this line ***/
622 munge_doc_file_name (name
);
624 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
625 if (NILP (Vbuild_files
))
632 Lisp_Object buildobj
= Fexpand_file_name (build_string ("buildobj.lst"),
635 fd
= emacs_open (SDATA (buildobj
), O_RDONLY
, 0);
637 report_file_error ("Opening file buildobj.lst", Qnil
);
643 to_read
= cp_size
- 1 - filled
;
644 cp
= xrealloc (cp
, cp_size
);
645 nr_read
= emacs_read (fd
, &cp
[filled
], to_read
);
647 if (nr_read
< to_read
)
654 for (beg
= cp
; *beg
; beg
= end
)
658 while (*beg
&& isspace (*beg
)) ++beg
;
660 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
661 if (*end
== '/') beg
= end
+1; /* skip directory part */
664 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
665 len
-= 2; /* Just take .o if it ends in .obj */
668 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
674 fd
= emacs_open (name
, O_RDONLY
, 0);
676 report_file_error ("Opening doc string file",
677 Fcons (build_string (name
), Qnil
));
678 Vdoc_file_name
= filename
;
684 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
690 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
691 while (p
!= end
&& *p
!= '\037') p
++;
692 /* p points to ^_Ffunctionname\n or ^_Vvarname\n. */
695 end
= (char *) index (p
, '\n');
697 /* See if this is a file name, and if it is a file in build-files. */
698 if (p
[1] == 'S' && end
- p
> 4 && end
[-2] == '.'
699 && (end
[-1] == 'o' || end
[-1] == 'c'))
701 int len
= end
- p
- 2;
702 char *fromfile
= alloca (len
+ 1);
703 strncpy (fromfile
, &p
[2], len
);
705 if (fromfile
[len
-1] == 'c')
706 fromfile
[len
-1] = 'o';
708 skip_file
= NILP (Fmember (build_string (fromfile
),
712 sym
= oblookup (Vobarray
, p
+ 2,
713 multibyte_chars_in_text (p
+ 2, end
- p
- 2),
715 /* Check skip_file so that when a function is defined several
716 times in different files (typically, once in xterm, once in
717 w32term, ...), we only pay attention to the one that
719 if (! skip_file
&& SYMBOLP (sym
))
721 /* Attach a docstring to a variable? */
724 /* Install file-position as variable-documentation property
725 and make it negative for a user-variable
726 (doc starts with a `*'). */
727 Fput (sym
, Qvariable_documentation
,
728 make_number ((pos
+ end
+ 1 - buf
)
729 * (end
[1] == '*' ? -1 : 1)));
732 /* Attach a docstring to a function? */
733 else if (p
[1] == 'F')
734 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
736 else if (p
[1] == 'S')
737 ; /* Just a source file name boundary marker. Ignore it. */
740 error ("DOC file invalid at position %d", pos
);
745 bcopy (end
, buf
, filled
);
751 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
752 Ssubstitute_command_keys
, 1, 1, 0,
753 doc
: /* Substitute key descriptions for command names in STRING.
754 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
755 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
757 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
758 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
759 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
760 as the keymap for future \\=\\[COMMAND] substrings.
761 \\=\\= quotes the following character and is discarded;
762 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
764 Returns original STRING if no substitutions were made. Otherwise,
765 a new string, without any text properties, is returned. */)
771 register unsigned char *strp
;
772 register unsigned char *bufp
;
777 unsigned char *start
;
778 int length
, length_byte
;
780 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
787 CHECK_STRING (string
);
791 GCPRO4 (string
, tem
, keymap
, name
);
793 multibyte
= STRING_MULTIBYTE (string
);
796 /* KEYMAP is either nil (which means search all the active keymaps)
797 or a specified local map (which means search just that and the
798 global map). If non-nil, it might come from Voverriding_local_map,
799 or from a \\<mapname> construct in STRING itself.. */
800 keymap
= current_kboard
->Voverriding_terminal_local_map
;
802 keymap
= Voverriding_local_map
;
804 bsize
= SBYTES (string
);
805 bufp
= buf
= (unsigned char *) xmalloc (bsize
);
807 strp
= SDATA (string
);
808 while (strp
< SDATA (string
) + SBYTES (string
))
810 if (strp
[0] == '\\' && strp
[1] == '=')
812 /* \= quotes the next character;
813 thus, to put in \[ without its special meaning, use \=\[. */
819 int maxlen
= SDATA (string
) + SBYTES (string
) - strp
;
821 STRING_CHAR_AND_LENGTH (strp
, maxlen
, len
);
825 bcopy (strp
, bufp
, len
);
831 *bufp
++ = *strp
++, nchars
++;
833 else if (strp
[0] == '\\' && strp
[1] == '[')
836 int follow_remap
= 1;
839 strp
+= 2; /* skip \[ */
841 start_idx
= start
- SDATA (string
);
843 while ((strp
- SDATA (string
)
847 length_byte
= strp
- start
;
851 /* Save STRP in IDX. */
852 idx
= strp
- SDATA (string
);
853 name
= Fintern (make_string (start
, length_byte
), Qnil
);
856 /* Ignore remappings unless there are no ordinary bindings. */
857 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qt
);
859 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
861 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
862 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
865 name
= AREF (tem
, 1);
870 /* Note the Fwhere_is_internal can GC, so we have to take
871 relocation of string contents into account. */
872 strp
= SDATA (string
) + idx
;
873 start
= SDATA (string
) + start_idx
;
875 if (NILP (tem
)) /* but not on any keys */
877 int offset
= bufp
- buf
;
878 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
880 bcopy ("M-x ", bufp
, 4);
884 length
= multibyte_chars_in_text (start
, length_byte
);
886 length
= length_byte
;
890 { /* function is on a key */
891 tem
= Fkey_description (tem
, Qnil
);
895 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
896 \<foo> just sets the keymap used for \[cmd]. */
897 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
899 struct buffer
*oldbuf
;
901 /* This is for computing the SHADOWS arg for describe_map_tree. */
902 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
903 Lisp_Object earlier_maps
;
906 strp
+= 2; /* skip \{ or \< */
908 start_idx
= start
- SDATA (string
);
910 while ((strp
- SDATA (string
) < SBYTES (string
))
911 && *strp
!= '}' && *strp
!= '>')
914 length_byte
= strp
- start
;
915 strp
++; /* skip } or > */
917 /* Save STRP in IDX. */
918 idx
= strp
- SDATA (string
);
920 /* Get the value of the keymap in TEM, or nil if undefined.
921 Do this while still in the user's current buffer
922 in case it is a local variable. */
923 name
= Fintern (make_string (start
, length_byte
), Qnil
);
924 tem
= Fboundp (name
);
927 tem
= Fsymbol_value (name
);
930 tem
= get_keymap (tem
, 0, 1);
931 /* Note that get_keymap can GC. */
932 strp
= SDATA (string
) + idx
;
933 start
= SDATA (string
) + start_idx
;
937 /* Now switch to a temp buffer. */
938 oldbuf
= current_buffer
;
939 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
943 name
= Fsymbol_name (name
);
944 insert_string ("\nUses keymap \"");
945 insert_from_string (name
, 0, 0,
948 insert_string ("\", which is not currently defined.\n");
949 if (start
[-1] == '<') keymap
= Qnil
;
951 else if (start
[-1] == '<')
955 /* Get the list of active keymaps that precede this one.
956 If this one's not active, get nil. */
957 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
958 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
959 Qnil
, (char *)0, 1, 0, 0, 1);
961 tem
= Fbuffer_string ();
963 set_buffer_internal (oldbuf
);
967 length
= SCHARS (tem
);
968 length_byte
= SBYTES (tem
);
971 int offset
= bufp
- buf
;
972 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
974 bcopy (start
, bufp
, length_byte
);
977 /* Check STRING again in case gc relocated it. */
978 strp
= (unsigned char *) SDATA (string
) + idx
;
981 else if (! multibyte
) /* just copy other chars */
982 *bufp
++ = *strp
++, nchars
++;
986 int maxlen
= SDATA (string
) + SBYTES (string
) - strp
;
988 STRING_CHAR_AND_LENGTH (strp
, maxlen
, len
);
992 bcopy (strp
, bufp
, len
);
999 if (changed
) /* don't bother if nothing substituted */
1000 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
1004 RETURN_UNGCPRO (tem
);
1010 Qfunction_documentation
= intern ("function-documentation");
1011 staticpro (&Qfunction_documentation
);
1013 DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name
,
1014 doc
: /* Name of file containing documentation strings of built-in symbols. */);
1015 Vdoc_file_name
= Qnil
;
1017 DEFVAR_LISP ("build-files", &Vbuild_files
,
1018 doc
: /* A list of files used to build this Emacs binary. */);
1019 Vbuild_files
= Qnil
;
1021 defsubr (&Sdocumentation
);
1022 defsubr (&Sdocumentation_property
);
1023 defsubr (&Ssnarf_documentation
);
1024 defsubr (&Ssubstitute_command_keys
);
1027 /* arch-tag: 56281d4d-6949-43e2-be2e-f6517de744ba
1028 (do not change this comment) */