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 else if (EQ (funcar
, Qmacro
))
439 return Fdocumentation (Fcdr (fun
), raw
);
446 xsignal1 (Qinvalid_function
, fun
);
449 /* If DOC is 0, it's typically because of a dumped file missing
450 from the DOC file (bug in src/Makefile.in). */
451 if (EQ (doc
, make_number (0)))
453 if (INTEGERP (doc
) || CONSP (doc
))
456 tem
= get_doc_string (doc
, 0, 0);
457 if (NILP (tem
) && try_reload
)
459 /* The file is newer, we need to reset the pointers. */
460 struct gcpro gcpro1
, gcpro2
;
461 GCPRO2 (function
, raw
);
462 try_reload
= reread_doc_file (Fcar_safe (doc
));
475 doc
= Fsubstitute_command_keys (doc
);
479 DEFUN ("documentation-property", Fdocumentation_property
,
480 Sdocumentation_property
, 2, 3, 0,
481 doc
: /* Return the documentation string that is SYMBOL's PROP property.
482 Third argument RAW omitted or nil means pass the result through
483 `substitute-command-keys' if it is a string.
485 This differs from `get' in that it can refer to strings stored in the
486 `etc/DOC' file; and that it evaluates documentation properties that
489 Lisp_Object symbol
, prop
, raw
;
494 documentation_property
:
496 tem
= Fget (symbol
, prop
);
497 if (EQ (tem
, make_number (0)))
499 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
501 Lisp_Object doc
= tem
;
502 tem
= get_doc_string (tem
, 0, 0);
503 if (NILP (tem
) && try_reload
)
505 /* The file is newer, we need to reset the pointers. */
506 struct gcpro gcpro1
, gcpro2
, gcpro3
;
507 GCPRO3 (symbol
, prop
, raw
);
508 try_reload
= reread_doc_file (Fcar_safe (doc
));
513 goto documentation_property
;
517 else if (!STRINGP (tem
))
518 /* Feval protects its argument. */
521 if (NILP (raw
) && STRINGP (tem
))
522 tem
= Fsubstitute_command_keys (tem
);
526 /* Scanning the DOC files and placing docstring offsets into functions. */
529 store_function_docstring (fun
, offset
)
531 /* Use EMACS_INT because we get this from pointer subtraction. */
534 fun
= indirect_function (fun
);
536 /* The type determines where the docstring is stored. */
538 /* Lisp_Subrs have a slot for it. */
540 XSUBR (fun
)->doc
= (char *) - offset
;
542 /* If it's a lisp form, stick it in the form. */
543 else if (CONSP (fun
))
548 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
))
550 tem
= Fcdr (Fcdr (fun
));
551 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
552 XSETCARFASTINT (tem
, offset
);
554 else if (EQ (tem
, Qmacro
))
555 store_function_docstring (XCDR (fun
), offset
);
558 /* Bytecode objects sometimes have slots for it. */
559 else if (COMPILEDP (fun
))
561 /* This bytecode object must have a slot for the
562 docstring, since we've found a docstring for it. */
563 if ((ASIZE (fun
) & PSEUDOVECTOR_SIZE_MASK
) > COMPILED_DOC_STRING
)
564 XSETFASTINT (AREF (fun
, COMPILED_DOC_STRING
), offset
);
569 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
571 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
572 This searches the `etc/DOC...' file for doc strings and
573 records them in function and variable definitions.
574 The function takes one argument, FILENAME, a string;
575 it specifies the file name (without a directory) of the DOC file.
576 That file is found in `../etc' now; later, when the dumped Emacs is run,
577 the same file name is found in the `doc-directory'. */)
579 Lisp_Object filename
;
585 register char *p
, *end
;
590 CHECK_STRING (filename
);
594 (!NILP (Vpurify_flag
))
595 #else /* CANNOT_DUMP */
597 #endif /* CANNOT_DUMP */
599 name
= (char *) alloca (SCHARS (filename
) + 14);
600 strcpy (name
, "../etc/");
604 CHECK_STRING (Vdoc_directory
);
605 name
= (char *) alloca (SCHARS (filename
)
606 + SCHARS (Vdoc_directory
) + 1);
607 strcpy (name
, SDATA (Vdoc_directory
));
609 strcat (name
, SDATA (filename
)); /*** Add this line ***/
610 munge_doc_file_name (name
);
612 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
613 if (NILP (Vbuild_files
))
620 Lisp_Object buildobj
= Fexpand_file_name (build_string ("buildobj.lst"),
623 fd
= emacs_open (SDATA (buildobj
), O_RDONLY
, 0);
625 report_file_error ("Opening file buildobj.lst", Qnil
);
631 to_read
= cp_size
- 1 - filled
;
632 cp
= xrealloc (cp
, cp_size
);
633 nr_read
= emacs_read (fd
, &cp
[filled
], to_read
);
635 if (nr_read
< to_read
)
642 for (beg
= cp
; *beg
; beg
= end
)
646 while (*beg
&& isspace (*beg
)) ++beg
;
648 for (end
= beg
; *end
&& ! isspace (*end
); ++end
)
649 if (*end
== '/') beg
= end
+1; /* skip directory part */
652 if (len
> 4 && end
[-4] == '.' && end
[-3] == 'o')
653 len
-= 2; /* Just take .o if it ends in .obj */
656 Vbuild_files
= Fcons (make_string (beg
, len
), Vbuild_files
);
662 fd
= emacs_open (name
, O_RDONLY
, 0);
664 report_file_error ("Opening doc string file",
665 Fcons (build_string (name
), Qnil
));
666 Vdoc_file_name
= filename
;
672 filled
+= emacs_read (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
678 end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
679 while (p
!= end
&& *p
!= '\037') p
++;
680 /* p points to ^_Ffunctionname\n or ^_Vvarname\n. */
683 end
= (char *) index (p
, '\n');
685 /* See if this is a file name, and if it is a file in build-files. */
686 if (p
[1] == 'S' && end
- p
> 4 && end
[-2] == '.'
687 && (end
[-1] == 'o' || end
[-1] == 'c'))
689 int len
= end
- p
- 2;
690 char *fromfile
= alloca (len
+ 1);
691 strncpy (fromfile
, &p
[2], len
);
693 if (fromfile
[len
-1] == 'c')
694 fromfile
[len
-1] = 'o';
696 if (EQ (Fmember (build_string (fromfile
), Vbuild_files
), Qnil
))
702 sym
= oblookup (Vobarray
, p
+ 2,
703 multibyte_chars_in_text (p
+ 2, end
- p
- 2),
705 if (! skip_file
&& SYMBOLP (sym
))
707 /* Attach a docstring to a variable? */
710 /* Install file-position as variable-documentation property
711 and make it negative for a user-variable
712 (doc starts with a `*'). */
713 Fput (sym
, Qvariable_documentation
,
714 make_number ((pos
+ end
+ 1 - buf
)
715 * (end
[1] == '*' ? -1 : 1)));
718 /* Attach a docstring to a function? */
719 else if (p
[1] == 'F')
720 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
722 else if (p
[1] == 'S')
723 ; /* Just a source file name boundary marker. Ignore it. */
726 error ("DOC file invalid at position %d", pos
);
731 bcopy (end
, buf
, filled
);
737 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
738 Ssubstitute_command_keys
, 1, 1, 0,
739 doc
: /* Substitute key descriptions for command names in STRING.
740 Substrings of the form \\=\\[COMMAND] replaced by either: a keystroke
741 sequence that will invoke COMMAND, or "M-x COMMAND" if COMMAND is not
743 Substrings of the form \\=\\{MAPVAR} are replaced by summaries
744 \(made by `describe-bindings') of the value of MAPVAR, taken as a keymap.
745 Substrings of the form \\=\\<MAPVAR> specify to use the value of MAPVAR
746 as the keymap for future \\=\\[COMMAND] substrings.
747 \\=\\= quotes the following character and is discarded;
748 thus, \\=\\=\\=\\= puts \\=\\= into the output, and \\=\\=\\=\\[ puts \\=\\[ into the output.
750 Returns original STRING if no substitutions were made. Otherwise,
751 a new string, without any text properties, is returned. */)
757 register unsigned char *strp
;
758 register unsigned char *bufp
;
763 unsigned char *start
;
764 int length
, length_byte
;
766 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
773 CHECK_STRING (string
);
777 GCPRO4 (string
, tem
, keymap
, name
);
779 multibyte
= STRING_MULTIBYTE (string
);
782 /* KEYMAP is either nil (which means search all the active keymaps)
783 or a specified local map (which means search just that and the
784 global map). If non-nil, it might come from Voverriding_local_map,
785 or from a \\<mapname> construct in STRING itself.. */
786 keymap
= current_kboard
->Voverriding_terminal_local_map
;
788 keymap
= Voverriding_local_map
;
790 bsize
= SBYTES (string
);
791 bufp
= buf
= (unsigned char *) xmalloc (bsize
);
793 strp
= SDATA (string
);
794 while (strp
< SDATA (string
) + SBYTES (string
))
796 if (strp
[0] == '\\' && strp
[1] == '=')
798 /* \= quotes the next character;
799 thus, to put in \[ without its special meaning, use \=\[. */
805 int maxlen
= SDATA (string
) + SBYTES (string
) - strp
;
807 STRING_CHAR_AND_LENGTH (strp
, maxlen
, len
);
811 bcopy (strp
, bufp
, len
);
817 *bufp
++ = *strp
++, nchars
++;
819 else if (strp
[0] == '\\' && strp
[1] == '[')
822 int follow_remap
= 1;
825 strp
+= 2; /* skip \[ */
827 start_idx
= start
- SDATA (string
);
829 while ((strp
- SDATA (string
)
833 length_byte
= strp
- start
;
837 /* Save STRP in IDX. */
838 idx
= strp
- SDATA (string
);
839 name
= Fintern (make_string (start
, length_byte
), Qnil
);
842 /* Ignore remappings unless there are no ordinary bindings. */
843 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qt
);
845 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
847 if (VECTORP (tem
) && XVECTOR (tem
)->size
> 1
848 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
851 name
= AREF (tem
, 1);
856 /* Note the Fwhere_is_internal can GC, so we have to take
857 relocation of string contents into account. */
858 strp
= SDATA (string
) + idx
;
859 start
= SDATA (string
) + start_idx
;
861 if (NILP (tem
)) /* but not on any keys */
863 int offset
= bufp
- buf
;
864 buf
= (unsigned char *) xrealloc (buf
, bsize
+= 4);
866 bcopy ("M-x ", bufp
, 4);
870 length
= multibyte_chars_in_text (start
, length_byte
);
872 length
= length_byte
;
876 { /* function is on a key */
877 tem
= Fkey_description (tem
, Qnil
);
881 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
882 \<foo> just sets the keymap used for \[cmd]. */
883 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<'))
885 struct buffer
*oldbuf
;
887 /* This is for computing the SHADOWS arg for describe_map_tree. */
888 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
889 Lisp_Object earlier_maps
;
892 strp
+= 2; /* skip \{ or \< */
894 start_idx
= start
- SDATA (string
);
896 while ((strp
- SDATA (string
) < SBYTES (string
))
897 && *strp
!= '}' && *strp
!= '>')
900 length_byte
= strp
- start
;
901 strp
++; /* skip } or > */
903 /* Save STRP in IDX. */
904 idx
= strp
- SDATA (string
);
906 /* Get the value of the keymap in TEM, or nil if undefined.
907 Do this while still in the user's current buffer
908 in case it is a local variable. */
909 name
= Fintern (make_string (start
, length_byte
), Qnil
);
910 tem
= Fboundp (name
);
913 tem
= Fsymbol_value (name
);
916 tem
= get_keymap (tem
, 0, 1);
917 /* Note that get_keymap can GC. */
918 strp
= SDATA (string
) + idx
;
919 start
= SDATA (string
) + start_idx
;
923 /* Now switch to a temp buffer. */
924 oldbuf
= current_buffer
;
925 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
929 name
= Fsymbol_name (name
);
930 insert_string ("\nUses keymap \"");
931 insert_from_string (name
, 0, 0,
934 insert_string ("\", which is not currently defined.\n");
935 if (start
[-1] == '<') keymap
= Qnil
;
937 else if (start
[-1] == '<')
941 /* Get the list of active keymaps that precede this one.
942 If this one's not active, get nil. */
943 earlier_maps
= Fcdr (Fmemq (tem
, Freverse (active_maps
)));
944 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
945 Qnil
, (char *)0, 1, 0, 0, 1);
947 tem
= Fbuffer_string ();
949 set_buffer_internal (oldbuf
);
953 length
= SCHARS (tem
);
954 length_byte
= SBYTES (tem
);
957 int offset
= bufp
- buf
;
958 buf
= (unsigned char *) xrealloc (buf
, bsize
+= length_byte
);
960 bcopy (start
, bufp
, length_byte
);
963 /* Check STRING again in case gc relocated it. */
964 strp
= (unsigned char *) SDATA (string
) + idx
;
967 else if (! multibyte
) /* just copy other chars */
968 *bufp
++ = *strp
++, nchars
++;
972 int maxlen
= SDATA (string
) + SBYTES (string
) - strp
;
974 STRING_CHAR_AND_LENGTH (strp
, maxlen
, len
);
978 bcopy (strp
, bufp
, len
);
985 if (changed
) /* don't bother if nothing substituted */
986 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
990 RETURN_UNGCPRO (tem
);
996 Qfunction_documentation
= intern ("function-documentation");
997 staticpro (&Qfunction_documentation
);
999 DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name
,
1000 doc
: /* Name of file containing documentation strings of built-in symbols. */);
1001 Vdoc_file_name
= Qnil
;
1003 DEFVAR_LISP ("build-files", &Vbuild_files
,
1004 doc
: /* A list of files used to build this Emacs binary. */);
1005 Vbuild_files
= Qnil
;
1007 defsubr (&Sdocumentation
);
1008 defsubr (&Sdocumentation_property
);
1009 defsubr (&Ssnarf_documentation
);
1010 defsubr (&Ssubstitute_command_keys
);
1013 /* arch-tag: 56281d4d-6949-43e2-be2e-f6517de744ba
1014 (do not change this comment) */