1 /* Record indices of function doc strings stored in a file. -*- coding: utf-8 -*-
3 Copyright (C) 1985-1986, 1993-1995, 1997-2017 Free Software Foundation,
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 (at
11 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 <https://www.gnu.org/licenses/>. */
25 #include <sys/types.h>
26 #include <sys/file.h> /* Must be after sys/types.h for USG. */
33 #include "character.h"
37 #include "intervals.h"
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 static char const sibling_etc
[] = "../etc/";
48 /* `readchar' in lread.c calls back here to fetch the next byte.
49 If UNREADFLAG is 1, we unread a byte. */
52 read_bytecode_char (bool unreadflag
)
56 read_bytecode_pointer
--;
59 return *read_bytecode_pointer
++;
62 /* Extract a doc string from a file. FILEPOS says where to get it.
63 If it is an integer, use that position in the standard DOC file.
64 If it is (FILE . INTEGER), use FILE as the file name
65 and INTEGER as the position in that file.
66 But if INTEGER is negative, make it positive.
67 (A negative integer is used for user variables, so we can distinguish
68 them without actually fetching the doc string.)
70 If the location does not point to the beginning of a docstring
71 (e.g. because the file has been modified and the location is stale),
74 If UNIBYTE, always make a unibyte string.
76 If DEFINITION, assume this is for reading
77 a dynamic function definition; convert the bytestring
78 and the constants vector with appropriate byte handling,
79 and return a cons cell. */
82 get_doc_string (Lisp_Object filepos
, bool unibyte
, bool definition
)
84 char *from
, *to
, *name
, *p
, *p1
;
88 Lisp_Object file
, tem
, pos
;
92 if (INTEGERP (filepos
))
94 file
= Vdoc_file_name
;
97 else if (CONSP (filepos
))
99 file
= XCAR (filepos
);
100 pos
= XCDR (filepos
);
105 position
= eabs (XINT (pos
));
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
);
117 file
= ENCODE_FILE (file
);
119 = NILP (tem
) ? ENCODE_FILE (Vdoc_directory
) : empty_unibyte_string
;
120 ptrdiff_t docdir_sizemax
= SBYTES (docdir
) + 1;
122 docdir_sizemax
= max (docdir_sizemax
, sizeof sibling_etc
);
124 name
= SAFE_ALLOCA (docdir_sizemax
+ SBYTES (file
));
125 lispstpcpy (lispstpcpy (name
, docdir
), file
);
127 fd
= emacs_open (name
, O_RDONLY
, 0);
131 if (!NILP (Vpurify_flag
))
133 /* Preparing to dump; DOC file is probably not installed.
134 So check in ../etc. */
135 lispstpcpy (stpcpy (name
, sibling_etc
), file
);
137 fd
= emacs_open (name
, O_RDONLY
, 0);
142 if (errno
== EMFILE
|| errno
== ENFILE
)
143 report_file_error ("Read error on documentation file", file
);
146 AUTO_STRING (cannot_open
, "Cannot open doc string file \"");
147 AUTO_STRING (quote_nl
, "\"\n");
148 return concat3 (cannot_open
, file
, quote_nl
);
151 count
= SPECPDL_INDEX ();
152 record_unwind_protect_int (close_file_unwind
, fd
);
154 /* Seek only to beginning of disk block. */
155 /* Make sure we read at least 1024 bytes before `position'
156 so we can check the leading text for consistency. */
157 offset
= min (position
, max (1024, position
% (8 * 1024)));
158 if (TYPE_MAXIMUM (off_t
) < position
159 || lseek (fd
, position
- offset
, 0) < 0)
160 error ("Position %"pI
"d out of range in doc string file \"%s\"",
163 /* Read the doc string into get_doc_string_buffer.
164 P points beyond the data just read. */
166 p
= get_doc_string_buffer
;
169 ptrdiff_t space_left
= (get_doc_string_buffer_size
- 1
170 - (p
- get_doc_string_buffer
));
173 /* Allocate or grow the buffer if we need to. */
176 ptrdiff_t in_buffer
= p
- get_doc_string_buffer
;
177 get_doc_string_buffer
178 = xpalloc (get_doc_string_buffer
, &get_doc_string_buffer_size
,
180 p
= get_doc_string_buffer
+ in_buffer
;
181 space_left
= (get_doc_string_buffer_size
- 1
182 - (p
- get_doc_string_buffer
));
185 /* Read a disk block at a time.
186 If we read the same block last time, maybe skip this? */
187 if (space_left
> 1024 * 8)
188 space_left
= 1024 * 8;
189 nread
= emacs_read_quit (fd
, p
, space_left
);
191 report_file_error ("Read error on documentation file", file
);
195 if (p
== get_doc_string_buffer
)
196 p1
= strchr (p
+ offset
, '\037');
198 p1
= strchr (p
, '\037');
207 unbind_to (count
, Qnil
);
210 /* Sanity checking. */
214 /* A dynamic docstring should be either at the very beginning of a "#@
215 comment" or right after a dynamic docstring delimiter (in case we
216 pack several such docstrings within the same comment). */
217 if (get_doc_string_buffer
[offset
- test
] != '\037')
219 if (get_doc_string_buffer
[offset
- test
++] != ' ')
221 while (get_doc_string_buffer
[offset
- test
] >= '0'
222 && get_doc_string_buffer
[offset
- test
] <= '9')
224 if (get_doc_string_buffer
[offset
- test
++] != '@'
225 || 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 Fsnarf_documentation (Vdoc_file_name
);
310 Fload (file
, Qt
, Qt
, Qt
, Qnil
);
315 DEFUN ("documentation", Fdocumentation
, Sdocumentation
, 1, 2, 0,
316 doc
: /* Return the documentation string of FUNCTION.
317 Unless a non-nil second argument RAW is given, the
318 string is passed through `substitute-command-keys'. */)
319 (Lisp_Object function
, Lisp_Object raw
)
330 if (SYMBOLP (function
))
332 Lisp_Object tem
= Fget (function
, Qfunction_documentation
);
334 return Fdocumentation_property (function
, Qfunction_documentation
,
338 fun
= Findirect_function (function
, Qnil
);
340 xsignal1 (Qvoid_function
, function
);
341 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
344 doc
= make_number (XSUBR (fun
)->doc
);
345 else if (MODULE_FUNCTIONP (fun
))
346 doc
= XMODULE_FUNCTION (fun
)->documentation
;
347 else if (COMPILEDP (fun
))
349 if (PVSIZE (fun
) <= COMPILED_DOC_STRING
)
353 Lisp_Object tem
= AREF (fun
, COMPILED_DOC_STRING
);
356 else if (NATNUMP (tem
) || CONSP (tem
))
362 else if (STRINGP (fun
) || VECTORP (fun
))
364 return build_string ("Keyboard macro.");
366 else if (CONSP (fun
))
369 if (!SYMBOLP (funcar
))
370 xsignal1 (Qinvalid_function
, fun
);
371 else if (EQ (funcar
, Qkeymap
))
372 return build_string ("Prefix command (definition is a keymap associating keystrokes with commands).");
373 else if (EQ (funcar
, Qlambda
)
374 || (EQ (funcar
, Qclosure
) && (fun
= XCDR (fun
), 1))
375 || EQ (funcar
, Qautoload
))
377 Lisp_Object tem1
= Fcdr (Fcdr (fun
));
378 Lisp_Object tem
= Fcar (tem1
);
381 /* Handle a doc reference--but these never come last
382 in the function body, so reject them if they are last. */
383 else if ((NATNUMP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
384 && !NILP (XCDR (tem1
)))
395 xsignal1 (Qinvalid_function
, fun
);
398 /* If DOC is 0, it's typically because of a dumped file missing
399 from the DOC file (bug in src/Makefile.in). */
400 if (EQ (doc
, make_number (0)))
402 if (INTEGERP (doc
) || CONSP (doc
))
405 tem
= get_doc_string (doc
, 0, 0);
406 if (NILP (tem
) && try_reload
)
408 /* The file is newer, we need to reset the pointers. */
409 try_reload
= reread_doc_file (Fcar_safe (doc
));
421 doc
= Fsubstitute_command_keys (doc
);
425 DEFUN ("documentation-property", Fdocumentation_property
,
426 Sdocumentation_property
, 2, 3, 0,
427 doc
: /* Return the documentation string that is SYMBOL's PROP property.
428 Third argument RAW omitted or nil means pass the result through
429 `substitute-command-keys' if it is a string.
431 This differs from `get' in that it can refer to strings stored in the
432 `etc/DOC' file; and that it evaluates documentation properties that
434 (Lisp_Object symbol
, Lisp_Object prop
, Lisp_Object raw
)
439 documentation_property
:
441 tem
= Fget (symbol
, prop
);
442 if (EQ (tem
, make_number (0)))
444 if (INTEGERP (tem
) || (CONSP (tem
) && INTEGERP (XCDR (tem
))))
446 Lisp_Object doc
= tem
;
447 tem
= get_doc_string (tem
, 0, 0);
448 if (NILP (tem
) && try_reload
)
450 /* The file is newer, we need to reset the pointers. */
451 try_reload
= reread_doc_file (Fcar_safe (doc
));
455 goto documentation_property
;
459 else if (!STRINGP (tem
))
460 /* Feval protects its argument. */
461 tem
= Feval (tem
, Qnil
);
463 if (NILP (raw
) && STRINGP (tem
))
464 tem
= Fsubstitute_command_keys (tem
);
468 /* Scanning the DOC files and placing docstring offsets into functions. */
471 store_function_docstring (Lisp_Object obj
, EMACS_INT offset
)
473 /* Don't use indirect_function here, or defaliases will apply their
474 docstrings to the base functions (Bug#2603). */
475 Lisp_Object fun
= SYMBOLP (obj
) ? XSYMBOL (obj
)->function
: obj
;
477 /* The type determines where the docstring is stored. */
479 /* If it's a lisp form, stick it in the form. */
480 if (CONSP (fun
) && EQ (XCAR (fun
), Qmacro
))
487 if (EQ (tem
, Qlambda
) || EQ (tem
, Qautoload
)
488 || (EQ (tem
, Qclosure
) && (fun
= XCDR (fun
), 1)))
490 tem
= Fcdr (Fcdr (fun
));
491 if (CONSP (tem
) && INTEGERP (XCAR (tem
)))
492 /* FIXME: This modifies typically pure hash-cons'd data, so its
493 correctness is quite delicate. */
494 XSETCAR (tem
, make_number (offset
));
498 /* Lisp_Subrs have a slot for it. */
499 else if (SUBRP (fun
))
500 XSUBR (fun
)->doc
= offset
;
502 /* Bytecode objects sometimes have slots for it. */
503 else if (COMPILEDP (fun
))
505 /* This bytecode object must have a slot for the
506 docstring, since we've found a docstring for it. */
507 if (PVSIZE (fun
) > COMPILED_DOC_STRING
)
508 ASET (fun
, COMPILED_DOC_STRING
, make_number (offset
));
511 AUTO_STRING (format
, "No docstring slot for %s");
512 CALLN (Fmessage
, format
,
515 : build_string ("<anonymous>")));
521 DEFUN ("Snarf-documentation", Fsnarf_documentation
, Ssnarf_documentation
,
523 doc
: /* Used during Emacs initialization to scan the `etc/DOC...' file.
524 This searches the `etc/DOC...' file for doc strings and
525 records them in function and variable definitions.
526 The function takes one argument, FILENAME, a string;
527 it specifies the file name (without a directory) of the DOC file.
528 That file is found in `../etc' now; later, when the dumped Emacs is run,
529 the same file name is found in the `doc-directory'. */)
530 (Lisp_Object filename
)
542 /* Preloaded defcustoms using custom-initialize-delay are added to
543 this list, but kept unbound. See https://debbugs.gnu.org/11565 */
544 Lisp_Object delayed_init
=
545 find_symbol_value (intern ("custom-delayed-init-variables"));
547 if (EQ (delayed_init
, Qunbound
)) delayed_init
= Qnil
;
549 CHECK_STRING (filename
);
553 (!NILP (Vpurify_flag
))
554 #else /* CANNOT_DUMP */
556 #endif /* CANNOT_DUMP */
558 dirname
= sibling_etc
;
559 dirlen
= sizeof sibling_etc
- 1;
563 CHECK_STRING (Vdoc_directory
);
564 dirname
= SSDATA (Vdoc_directory
);
565 dirlen
= SBYTES (Vdoc_directory
);
568 count
= SPECPDL_INDEX ();
570 name
= SAFE_ALLOCA (dirlen
+ SBYTES (filename
) + 1);
571 lispstpcpy (stpcpy (name
, dirname
), filename
); /*** Add this line ***/
573 /* Vbuild_files is nil when temacs is run, and non-nil after that. */
574 if (NILP (Vbuild_files
))
576 static char const *const buildobj
[] =
578 #include "buildobj.h"
580 int i
= ARRAYELTS (buildobj
);
582 Vbuild_files
= Fcons (build_string (buildobj
[i
]), Vbuild_files
);
583 Vbuild_files
= Fpurecopy (Vbuild_files
);
586 fd
= emacs_open (name
, O_RDONLY
, 0);
589 int open_errno
= errno
;
590 report_file_errno ("Opening doc string file", build_string (name
),
593 record_unwind_protect_int (close_file_unwind
, fd
);
594 Vdoc_file_name
= filename
;
600 filled
+= emacs_read_quit (fd
, &buf
[filled
], sizeof buf
- 1 - filled
);
605 char *end
= buf
+ (filled
< 512 ? filled
: filled
- 128);
606 p
= memchr (buf
, '\037', end
- buf
);
607 /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n. */
610 end
= strchr (p
, '\n');
612 /* See if this is a file name, and if it is a file in build-files. */
616 if (end
- p
> 4 && end
[-2] == '.'
617 && (end
[-1] == 'o' || end
[-1] == 'c'))
619 ptrdiff_t len
= end
- p
- 2;
620 char *fromfile
= SAFE_ALLOCA (len
+ 1);
621 memcpy (fromfile
, &p
[2], len
);
623 if (fromfile
[len
-1] == 'c')
624 fromfile
[len
-1] = 'o';
626 skip_file
= NILP (Fmember (build_string (fromfile
),
631 sym
= oblookup (Vobarray
, p
+ 2,
632 multibyte_chars_in_text ((unsigned char *) p
+ 2,
635 /* Check skip_file so that when a function is defined several
636 times in different files (typically, once in xterm, once in
637 w32term, ...), we only pay attention to the one that
639 if (! skip_file
&& SYMBOLP (sym
))
641 /* Attach a docstring to a variable? */
644 /* Install file-position as variable-documentation property
645 and make it negative for a user-variable
646 (doc starts with a `*'). */
647 if (!NILP (Fboundp (sym
))
648 || !NILP (Fmemq (sym
, delayed_init
)))
649 Fput (sym
, Qvariable_documentation
,
650 make_number ((pos
+ end
+ 1 - buf
)
651 * (end
[1] == '*' ? -1 : 1)));
654 /* Attach a docstring to a function? */
655 else if (p
[1] == 'F')
657 if (!NILP (Ffboundp (sym
)))
658 store_function_docstring (sym
, pos
+ end
+ 1 - buf
);
660 else if (p
[1] == 'S')
661 ; /* Just a source file name boundary marker. Ignore it. */
664 error ("DOC file invalid at position %"pI
"d", pos
);
669 memmove (buf
, end
, filled
);
673 return unbind_to (count
, Qnil
);
676 /* Return true if text quoting style should default to quote `like this'. */
678 default_to_grave_quoting_style (void)
680 if (!text_quoting_flag
)
682 if (! DISP_TABLE_P (Vstandard_display_table
))
684 Lisp_Object dv
= DISP_CHAR_VECTOR (XCHAR_TABLE (Vstandard_display_table
),
685 LEFT_SINGLE_QUOTATION_MARK
);
686 return (VECTORP (dv
) && ASIZE (dv
) == 1
687 && EQ (AREF (dv
, 0), make_number ('`')));
690 /* Return the current effective text quoting style. */
691 enum text_quoting_style
692 text_quoting_style (void)
694 if (NILP (Vtext_quoting_style
)
695 ? default_to_grave_quoting_style ()
696 : EQ (Vtext_quoting_style
, Qgrave
))
697 return GRAVE_QUOTING_STYLE
;
698 else if (EQ (Vtext_quoting_style
, Qstraight
))
699 return STRAIGHT_QUOTING_STYLE
;
701 return CURVE_QUOTING_STYLE
;
704 DEFUN ("substitute-command-keys", Fsubstitute_command_keys
,
705 Ssubstitute_command_keys
, 1, 1, 0,
706 doc
: /* Substitute key descriptions for command names in STRING.
707 Each substring of the form \\=\\[COMMAND] is replaced by either a
708 keystroke sequence that invokes COMMAND, or "M-x COMMAND" if COMMAND
711 Each substring of the form \\=\\{MAPVAR} is replaced by a summary of
712 the value of MAPVAR as a keymap. This summary is similar to the one
713 produced by `describe-bindings'. The summary ends in two newlines
714 \(used by the helper function `help-make-xrefs' to find the end of the
717 Each substring of the form \\=\\<MAPVAR> specifies the use of MAPVAR
718 as the keymap for future \\=\\[COMMAND] substrings.
720 Each grave accent \\=` is replaced by left quote, and each apostrophe \\='
721 is replaced by right quote. Left and right quote characters are
722 specified by `text-quoting-style'.
724 \\=\\= quotes the following character and is discarded; thus, \\=\\=\\=\\= puts \\=\\=
725 into the output, \\=\\=\\=\\[ puts \\=\\[ into the output, and \\=\\=\\=` puts \\=` into the
728 Return the original STRING if no substitutions are made.
729 Otherwise, return a new string. */)
733 bool changed
= false;
734 bool nonquotes_changed
= false;
741 unsigned char const *start
;
742 ptrdiff_t length
, length_byte
;
749 /* If STRING contains non-ASCII unibyte data, process its
750 properly-encoded multibyte equivalent instead. This simplifies
751 the implementation and is OK since substitute-command-keys is
752 intended for use only on text strings. Keep STRING around, since
753 it will be returned if no changes occur. */
754 Lisp_Object str
= Fstring_make_multibyte (string
);
756 enum text_quoting_style quoting_style
= text_quoting_style ();
760 /* KEYMAP is either nil (which means search all the active keymaps)
761 or a specified local map (which means search just that and the
762 global map). If non-nil, it might come from Voverriding_local_map,
763 or from a \\<mapname> construct in STRING itself.. */
764 keymap
= Voverriding_local_map
;
766 ptrdiff_t strbytes
= SBYTES (str
);
769 /* Fixed-size stack buffer. */
770 char sbuf
[MAX_ALLOCA
];
772 /* Heap-allocated buffer, if any. */
775 /* Extra room for expansion due to replacing ‘\[]’ with ‘M-x ’. */
776 enum { EXTRA_ROOM
= sizeof "M-x " - sizeof "\\[]" };
778 ptrdiff_t count
= SPECPDL_INDEX ();
780 if (bsize
<= sizeof sbuf
- EXTRA_ROOM
)
788 buf
= abuf
= xpalloc (NULL
, &bsize
, EXTRA_ROOM
, STRING_BYTES_BOUND
, 1);
789 record_unwind_protect_ptr (xfree
, abuf
);
794 while (strp
< SDATA (str
) + strbytes
)
796 unsigned char *close_bracket
;
798 if (strp
[0] == '\\' && strp
[1] == '='
799 && strp
+ 2 < SDATA (str
) + strbytes
)
801 /* \= quotes the next character;
802 thus, to put in \[ without its special meaning, use \=\[. */
803 changed
= nonquotes_changed
= true;
805 /* Fall through to copy one char. */
807 else if (strp
[0] == '\\' && strp
[1] == '['
809 = memchr (strp
+ 2, ']',
810 SDATA (str
) + strbytes
- (strp
+ 2))))
812 bool follow_remap
= 1;
815 length_byte
= close_bracket
- start
;
816 idx
= close_bracket
+ 1 - SDATA (str
);
818 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
821 tem
= Fwhere_is_internal (name
, keymap
, Qt
, Qnil
, Qnil
);
823 if (VECTORP (tem
) && ASIZE (tem
) > 1
824 && EQ (AREF (tem
, 0), Qremap
) && SYMBOLP (AREF (tem
, 1))
827 name
= AREF (tem
, 1);
832 /* Fwhere_is_internal can GC, so take relocation of string
833 contents into account. */
834 strp
= SDATA (str
) + idx
;
835 start
= strp
- length_byte
- 1;
837 if (NILP (tem
)) /* but not on any keys */
839 memcpy (bufp
, "M-x ", 4);
842 length
= multibyte_chars_in_text (start
, length_byte
);
846 { /* function is on a key */
847 tem
= Fkey_description (tem
, Qnil
);
851 /* \{foo} is replaced with a summary of the keymap (symbol-value foo).
852 \<foo> just sets the keymap used for \[cmd]. */
853 else if (strp
[0] == '\\' && (strp
[1] == '{' || strp
[1] == '<')
855 = memchr (strp
+ 2, strp
[1] == '{' ? '}' : '>',
856 SDATA (str
) + strbytes
- (strp
+ 2))))
859 bool generate_summary
= strp
[1] == '{';
860 /* This is for computing the SHADOWS arg for describe_map_tree. */
861 Lisp_Object active_maps
= Fcurrent_active_maps (Qnil
, Qnil
);
862 ptrdiff_t count
= SPECPDL_INDEX ();
865 length_byte
= close_bracket
- start
;
866 idx
= close_bracket
+ 1 - SDATA (str
);
868 /* Get the value of the keymap in TEM, or nil if undefined.
869 Do this while still in the user's current buffer
870 in case it is a local variable. */
871 name
= Fintern (make_string ((char *) start
, length_byte
), Qnil
);
872 tem
= Fboundp (name
);
875 tem
= Fsymbol_value (name
);
877 tem
= get_keymap (tem
, 0, 1);
880 /* Now switch to a temp buffer. */
881 struct buffer
*oldbuf
= current_buffer
;
882 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
883 /* This is for an unusual case where some after-change
884 function uses 'format' or 'prin1' or something else that
885 will thrash Vprin1_to_string_buffer we are using. */
886 specbind (Qinhibit_modification_hooks
, Qt
);
890 name
= Fsymbol_name (name
);
891 AUTO_STRING (msg_prefix
, "\nUses keymap `");
892 insert1 (Fsubstitute_command_keys (msg_prefix
));
893 insert_from_string (name
, 0, 0,
896 AUTO_STRING (msg_suffix
, "', which is not currently defined.\n");
897 insert1 (Fsubstitute_command_keys (msg_suffix
));
898 if (!generate_summary
)
901 else if (!generate_summary
)
905 /* Get the list of active keymaps that precede this one.
906 If this one's not active, get nil. */
907 Lisp_Object earlier_maps
908 = Fcdr (Fmemq (tem
, Freverse (active_maps
)));
909 describe_map_tree (tem
, 1, Fnreverse (earlier_maps
),
910 Qnil
, 0, 1, 0, 0, 1);
912 tem
= Fbuffer_string ();
914 set_buffer_internal (oldbuf
);
915 unbind_to (count
, Qnil
);
919 /* Convert non-ASCII unibyte data to properly-encoded multibyte,
920 for the same reason STRING was converted to STR. */
921 tem
= Fstring_make_multibyte (tem
);
923 length
= SCHARS (tem
);
924 length_byte
= SBYTES (tem
);
926 nonquotes_changed
= true;
930 ptrdiff_t offset
= bufp
- buf
;
931 ptrdiff_t avail
= bsize
- offset
;
932 ptrdiff_t need
= strbytes
- idx
;
933 if (INT_ADD_WRAPV (need
, length_byte
+ EXTRA_ROOM
, &need
))
937 abuf
= xpalloc (abuf
, &bsize
, need
- avail
,
938 STRING_BYTES_BOUND
, 1);
941 record_unwind_protect_ptr (xfree
, abuf
);
942 memcpy (abuf
, sbuf
, offset
);
945 set_unwind_protect_ptr (count
, xfree
, abuf
);
949 memcpy (bufp
, start
, length_byte
);
953 /* Some of the previous code can GC, so take relocation of
954 string contents into account. */
955 strp
= SDATA (str
) + idx
;
960 else if ((strp
[0] == '`' || strp
[0] == '\'')
961 && quoting_style
== CURVE_QUOTING_STYLE
)
963 start
= (unsigned char const *) (strp
[0] == '`' ? uLSQM
: uRSQM
);
965 length_byte
= sizeof uLSQM
- 1;
966 idx
= strp
- SDATA (str
) + 1;
969 else if (strp
[0] == '`' && quoting_style
== STRAIGHT_QUOTING_STYLE
)
981 while (! CHAR_HEAD_P (*strp
));
985 if (changed
) /* don't bother if nothing substituted */
987 tem
= make_string_from_bytes (buf
, nchars
, bufp
- buf
);
988 if (!nonquotes_changed
)
990 /* Nothing has changed other than quoting, so copy the string’s
991 text properties. FIXME: Text properties should survive other
993 INTERVAL interval_copy
= copy_intervals (string_intervals (string
),
997 set_interval_object (interval_copy
, tem
);
998 set_string_intervals (tem
, interval_copy
);
1004 return unbind_to (count
, tem
);
1010 DEFSYM (Qfunction_documentation
, "function-documentation");
1011 DEFSYM (Qgrave
, "grave");
1012 DEFSYM (Qstraight
, "straight");
1014 DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name
,
1015 doc
: /* Name of file containing documentation strings of built-in symbols. */);
1016 Vdoc_file_name
= Qnil
;
1018 DEFVAR_LISP ("build-files", Vbuild_files
,
1019 doc
: /* A list of files used to build this Emacs binary. */);
1020 Vbuild_files
= Qnil
;
1022 DEFVAR_LISP ("text-quoting-style", Vtext_quoting_style
,
1023 doc
: /* Style to use for single quotes in help and messages.
1024 Its value should be a symbol. It works by substituting certain single
1025 quotes for grave accent and apostrophe. This is done in help output
1026 and in functions like `message' and `format-message'. It is not done
1029 `curve' means quote with curved single quotes ‘like this’.
1030 `straight' means quote with straight apostrophes \\='like this\\='.
1031 `grave' means quote with grave accent and apostrophe \\=`like this\\=';
1032 i.e., do not alter quote marks. The default value nil acts like
1033 `curve' if curved single quotes are displayable, and like `grave'
1035 Vtext_quoting_style
= Qnil
;
1037 DEFVAR_BOOL ("internal--text-quoting-flag", text_quoting_flag
,
1038 doc
: /* If nil, a nil `text-quoting-style' is treated as `grave'. */);
1039 /* Initialized by ‘main’. */
1041 defsubr (&Sdocumentation
);
1042 defsubr (&Sdocumentation_property
);
1043 defsubr (&Ssnarf_documentation
);
1044 defsubr (&Ssubstitute_command_keys
);