1 /* Lisp object printing and output streams.
2 Copyright (C) 1985, 1986, 1988, 1993, 1994, 1995, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007 Free Software Foundation, Inc.
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 2, or (at your option)
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; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
28 #include "character.h"
34 #include "dispextern.h"
36 #include "intervals.h"
38 Lisp_Object Vstandard_output
, Qstandard_output
;
40 Lisp_Object Qtemp_buffer_setup_hook
;
42 /* These are used to print like we read. */
43 extern Lisp_Object Qbackquote
, Qcomma
, Qcomma_at
, Qcomma_dot
, Qfunction
;
45 Lisp_Object Vfloat_output_format
, Qfloat_output_format
;
47 /* Work around a problem that happens because math.h on hpux 7
48 defines two static variables--which, in Emacs, are not really static,
49 because `static' is defined as nothing. The problem is that they are
50 defined both here and in lread.c.
51 These macros prevent the name conflict. */
52 #if defined (HPUX) && !defined (HPUX8)
53 #define _MAXLDBL print_maxldbl
54 #define _NMAXLDBL print_nmaxldbl
63 /* Default to values appropriate for IEEE floating point. */
68 #define DBL_MANT_DIG 53
74 #define DBL_MIN 2.2250738585072014e-308
77 #ifdef DBL_MIN_REPLACEMENT
79 #define DBL_MIN DBL_MIN_REPLACEMENT
82 /* Define DOUBLE_DIGITS_BOUND, an upper bound on the number of decimal digits
83 needed to express a float without losing information.
84 The general-case formula is valid for the usual case, IEEE floating point,
85 but many compilers can't optimize the formula to an integer constant,
86 so make a special case for it. */
87 #if FLT_RADIX == 2 && DBL_MANT_DIG == 53
88 #define DOUBLE_DIGITS_BOUND 17 /* IEEE floating point */
90 #define DOUBLE_DIGITS_BOUND ((int) ceil (log10 (pow (FLT_RADIX, DBL_MANT_DIG))))
93 /* Avoid actual stack overflow in print. */
96 /* Nonzero if inside outputting backquote in old style. */
97 int old_backquote_output
;
99 /* Detect most circularities to print finite output. */
100 #define PRINT_CIRCLE 200
101 Lisp_Object being_printed
[PRINT_CIRCLE
];
103 /* When printing into a buffer, first we put the text in this
104 block, then insert it all at once. */
107 /* Size allocated in print_buffer. */
108 int print_buffer_size
;
109 /* Chars stored in print_buffer. */
110 int print_buffer_pos
;
111 /* Bytes stored in print_buffer. */
112 int print_buffer_pos_byte
;
114 /* Maximum length of list to print in full; noninteger means
115 effectively infinity */
117 Lisp_Object Vprint_length
;
119 /* Maximum depth of list to print in full; noninteger means
120 effectively infinity. */
122 Lisp_Object Vprint_level
;
124 /* Nonzero means print newlines in strings as \n. */
126 int print_escape_newlines
;
128 /* Nonzero means to print single-byte non-ascii characters in strings as
131 int print_escape_nonascii
;
133 /* Nonzero means to print multibyte characters in strings as hex escapes. */
135 int print_escape_multibyte
;
137 Lisp_Object Qprint_escape_newlines
;
138 Lisp_Object Qprint_escape_multibyte
, Qprint_escape_nonascii
;
140 /* Nonzero means print (quote foo) forms as 'foo, etc. */
144 /* Non-nil means print #: before uninterned symbols. */
146 Lisp_Object Vprint_gensym
;
148 /* Non-nil means print recursive structures using #n= and #n# syntax. */
150 Lisp_Object Vprint_circle
;
152 /* Non-nil means keep continuous number for #n= and #n# syntax
153 between several print functions. */
155 Lisp_Object Vprint_continuous_numbering
;
157 /* Vprint_number_table is a vector like [OBJ1 STAT1 OBJ2 STAT2 ...],
158 where OBJn are objects going to be printed, and STATn are their status,
159 which may be different meanings during process. See the comments of
160 the functions print and print_preprocess for details.
161 print_number_index keeps the last position the next object should be added,
162 twice of which is the actual vector position in Vprint_number_table. */
163 int print_number_index
;
164 Lisp_Object Vprint_number_table
;
166 /* PRINT_NUMBER_OBJECT returns the I'th object in Vprint_number_table TABLE.
167 PRINT_NUMBER_STATUS returns the status of the I'th object in TABLE.
168 See the comment of the variable Vprint_number_table. */
169 #define PRINT_NUMBER_OBJECT(table,i) XVECTOR ((table))->contents[(i) * 2]
170 #define PRINT_NUMBER_STATUS(table,i) XVECTOR ((table))->contents[(i) * 2 + 1]
172 /* Nonzero means print newline to stdout before next minibuffer message.
173 Defined in xdisp.c */
175 extern int noninteractive_need_newline
;
177 extern int minibuffer_auto_raise
;
179 #ifdef MAX_PRINT_CHARS
180 static int print_chars
;
181 static int max_print
;
182 #endif /* MAX_PRINT_CHARS */
184 void print_interval ();
186 /* GDB resets this to zero on W32 to disable OutputDebugString calls. */
187 int print_output_debug_flag
= 1;
190 /* Low level output routines for characters and strings */
192 /* Lisp functions to do output using a stream
193 must have the stream in a variable called printcharfun
194 and must start with PRINTPREPARE, end with PRINTFINISH,
195 and use PRINTDECLARE to declare common variables.
196 Use PRINTCHAR to output one character,
197 or call strout to output a block of characters. */
199 #define PRINTDECLARE \
200 struct buffer *old = current_buffer; \
201 int old_point = -1, start_point = -1; \
202 int old_point_byte = -1, start_point_byte = -1; \
203 int specpdl_count = SPECPDL_INDEX (); \
204 int free_print_buffer = 0; \
205 int multibyte = !NILP (current_buffer->enable_multibyte_characters); \
208 #define PRINTPREPARE \
209 original = printcharfun; \
210 if (NILP (printcharfun)) printcharfun = Qt; \
211 if (BUFFERP (printcharfun)) \
213 if (XBUFFER (printcharfun) != current_buffer) \
214 Fset_buffer (printcharfun); \
215 printcharfun = Qnil; \
217 if (MARKERP (printcharfun)) \
219 EMACS_INT marker_pos; \
220 if (! XMARKER (printcharfun)->buffer) \
221 error ("Marker does not point anywhere"); \
222 if (XMARKER (printcharfun)->buffer != current_buffer) \
223 set_buffer_internal (XMARKER (printcharfun)->buffer); \
224 marker_pos = marker_position (printcharfun); \
225 if (marker_pos < BEGV || marker_pos > ZV) \
226 error ("Marker is outside the accessible part of the buffer"); \
228 old_point_byte = PT_BYTE; \
229 SET_PT_BOTH (marker_pos, \
230 marker_byte_position (printcharfun)); \
232 start_point_byte = PT_BYTE; \
233 printcharfun = Qnil; \
235 if (NILP (printcharfun)) \
237 Lisp_Object string; \
238 if (NILP (current_buffer->enable_multibyte_characters) \
239 && ! print_escape_multibyte) \
240 specbind (Qprint_escape_multibyte, Qt); \
241 if (! NILP (current_buffer->enable_multibyte_characters) \
242 && ! print_escape_nonascii) \
243 specbind (Qprint_escape_nonascii, Qt); \
244 if (print_buffer != 0) \
246 string = make_string_from_bytes (print_buffer, \
248 print_buffer_pos_byte); \
249 record_unwind_protect (print_unwind, string); \
253 print_buffer_size = 1000; \
254 print_buffer = (char *) xmalloc (print_buffer_size); \
255 free_print_buffer = 1; \
257 print_buffer_pos = 0; \
258 print_buffer_pos_byte = 0; \
260 if (EQ (printcharfun, Qt) && ! noninteractive) \
261 setup_echo_area_for_printing (multibyte);
263 #define PRINTFINISH \
264 if (NILP (printcharfun)) \
266 if (print_buffer_pos != print_buffer_pos_byte \
267 && NILP (current_buffer->enable_multibyte_characters)) \
269 unsigned char *temp \
270 = (unsigned char *) alloca (print_buffer_pos + 1); \
271 copy_text (print_buffer, temp, print_buffer_pos_byte, \
273 insert_1_both (temp, print_buffer_pos, \
274 print_buffer_pos, 0, 1, 0); \
277 insert_1_both (print_buffer, print_buffer_pos, \
278 print_buffer_pos_byte, 0, 1, 0); \
279 signal_after_change (PT - print_buffer_pos, 0, print_buffer_pos);\
281 if (free_print_buffer) \
283 xfree (print_buffer); \
286 unbind_to (specpdl_count, Qnil); \
287 if (MARKERP (original)) \
288 set_marker_both (original, Qnil, PT, PT_BYTE); \
289 if (old_point >= 0) \
290 SET_PT_BOTH (old_point + (old_point >= start_point \
291 ? PT - start_point : 0), \
292 old_point_byte + (old_point_byte >= start_point_byte \
293 ? PT_BYTE - start_point_byte : 0)); \
294 if (old != current_buffer) \
295 set_buffer_internal (old);
297 #define PRINTCHAR(ch) printchar (ch, printcharfun)
299 /* This is used to restore the saved contents of print_buffer
300 when there is a recursive call to print. */
303 print_unwind (saved_text
)
304 Lisp_Object saved_text
;
306 bcopy (SDATA (saved_text
), print_buffer
, SCHARS (saved_text
));
311 /* Print character CH using method FUN. FUN nil means print to
312 print_buffer. FUN t means print to echo area or stdout if
313 non-interactive. If FUN is neither nil nor t, call FUN with CH as
321 #ifdef MAX_PRINT_CHARS
324 #endif /* MAX_PRINT_CHARS */
326 if (!NILP (fun
) && !EQ (fun
, Qt
))
327 call1 (fun
, make_number (ch
));
330 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
331 int len
= CHAR_STRING (ch
, str
);
337 if (print_buffer_pos_byte
+ len
>= print_buffer_size
)
338 print_buffer
= (char *) xrealloc (print_buffer
,
339 print_buffer_size
*= 2);
340 bcopy (str
, print_buffer
+ print_buffer_pos_byte
, len
);
341 print_buffer_pos
+= 1;
342 print_buffer_pos_byte
+= len
;
344 else if (noninteractive
)
346 fwrite (str
, 1, len
, stdout
);
347 noninteractive_need_newline
= 1;
352 = !NILP (current_buffer
->enable_multibyte_characters
);
354 setup_echo_area_for_printing (multibyte_p
);
356 message_dolog (str
, len
, 0, multibyte_p
);
362 /* Output SIZE characters, SIZE_BYTE bytes from string PTR using
363 method PRINTCHARFUN. If SIZE < 0, use the string length of PTR for
364 both SIZE and SIZE_BYTE. PRINTCHARFUN nil means output to
365 print_buffer. PRINTCHARFUN t means output to the echo area or to
366 stdout if non-interactive. If neither nil nor t, call Lisp
367 function PRINTCHARFUN for each character printed. MULTIBYTE
368 non-zero means PTR contains multibyte characters.
370 In the case where PRINTCHARFUN is nil, it is safe for PTR to point
371 to data in a Lisp string. Otherwise that is not safe. */
374 strout (ptr
, size
, size_byte
, printcharfun
, multibyte
)
377 Lisp_Object printcharfun
;
381 size_byte
= size
= strlen (ptr
);
383 if (NILP (printcharfun
))
385 if (print_buffer_pos_byte
+ size_byte
> print_buffer_size
)
387 print_buffer_size
= print_buffer_size
* 2 + size_byte
;
388 print_buffer
= (char *) xrealloc (print_buffer
,
391 bcopy (ptr
, print_buffer
+ print_buffer_pos_byte
, size_byte
);
392 print_buffer_pos
+= size
;
393 print_buffer_pos_byte
+= size_byte
;
395 #ifdef MAX_PRINT_CHARS
398 #endif /* MAX_PRINT_CHARS */
400 else if (noninteractive
&& EQ (printcharfun
, Qt
))
402 fwrite (ptr
, 1, size_byte
, stdout
);
403 noninteractive_need_newline
= 1;
405 else if (EQ (printcharfun
, Qt
))
407 /* Output to echo area. We're trying to avoid a little overhead
408 here, that's the reason we don't call printchar to do the
412 = !NILP (current_buffer
->enable_multibyte_characters
);
414 setup_echo_area_for_printing (multibyte_p
);
415 message_dolog (ptr
, size_byte
, 0, multibyte_p
);
417 if (size
== size_byte
)
419 for (i
= 0; i
< size
; ++i
)
420 insert_char ((unsigned char) *ptr
++);
425 for (i
= 0; i
< size_byte
; i
+= len
)
427 int ch
= STRING_CHAR_AND_LENGTH (ptr
+ i
, size_byte
- i
, len
);
432 #ifdef MAX_PRINT_CHARS
435 #endif /* MAX_PRINT_CHARS */
439 /* PRINTCHARFUN is a Lisp function. */
442 if (size
== size_byte
)
444 while (i
< size_byte
)
452 while (i
< size_byte
)
454 /* Here, we must convert each multi-byte form to the
455 corresponding character code before handing it to
458 int ch
= STRING_CHAR_AND_LENGTH (ptr
+ i
, size_byte
- i
, len
);
466 /* Print the contents of a string STRING using PRINTCHARFUN.
467 It isn't safe to use strout in many cases,
468 because printing one char can relocate. */
471 print_string (string
, printcharfun
)
473 Lisp_Object printcharfun
;
475 if (EQ (printcharfun
, Qt
) || NILP (printcharfun
))
479 if (print_escape_nonascii
)
480 string
= string_escape_byte8 (string
);
482 if (STRING_MULTIBYTE (string
))
483 chars
= SCHARS (string
);
484 else if (! print_escape_nonascii
485 && (EQ (printcharfun
, Qt
)
486 ? ! NILP (buffer_defaults
.enable_multibyte_characters
)
487 : ! NILP (current_buffer
->enable_multibyte_characters
)))
489 /* If unibyte string STRING contains 8-bit codes, we must
490 convert STRING to a multibyte string containing the same
495 chars
= SBYTES (string
);
496 bytes
= parse_str_to_multibyte (SDATA (string
), chars
);
499 newstr
= make_uninit_multibyte_string (chars
, bytes
);
500 bcopy (SDATA (string
), SDATA (newstr
), chars
);
501 str_to_multibyte (SDATA (newstr
), bytes
, chars
);
506 chars
= SBYTES (string
);
508 if (EQ (printcharfun
, Qt
))
510 /* Output to echo area. */
511 int nbytes
= SBYTES (string
);
514 /* Copy the string contents so that relocation of STRING by
515 GC does not cause trouble. */
518 SAFE_ALLOCA (buffer
, char *, nbytes
);
519 bcopy (SDATA (string
), buffer
, nbytes
);
521 strout (buffer
, chars
, SBYTES (string
),
522 printcharfun
, STRING_MULTIBYTE (string
));
527 /* No need to copy, since output to print_buffer can't GC. */
528 strout (SDATA (string
),
529 chars
, SBYTES (string
),
530 printcharfun
, STRING_MULTIBYTE (string
));
534 /* Otherwise, string may be relocated by printing one char.
535 So re-fetch the string address for each character. */
537 int size
= SCHARS (string
);
538 int size_byte
= SBYTES (string
);
541 if (size
== size_byte
)
542 for (i
= 0; i
< size
; i
++)
543 PRINTCHAR (SREF (string
, i
));
545 for (i
= 0; i
< size_byte
; )
547 /* Here, we must convert each multi-byte form to the
548 corresponding character code before handing it to PRINTCHAR. */
550 int ch
= STRING_CHAR_AND_LENGTH (SDATA (string
) + i
,
559 DEFUN ("write-char", Fwrite_char
, Swrite_char
, 1, 2, 0,
560 doc
: /* Output character CHARACTER to stream PRINTCHARFUN.
561 PRINTCHARFUN defaults to the value of `standard-output' (which see). */)
562 (character
, printcharfun
)
563 Lisp_Object character
, printcharfun
;
567 if (NILP (printcharfun
))
568 printcharfun
= Vstandard_output
;
569 CHECK_NUMBER (character
);
571 PRINTCHAR (XINT (character
));
576 /* Used from outside of print.c to print a block of SIZE
577 single-byte chars at DATA on the default output stream.
578 Do not use this on the contents of a Lisp string. */
581 write_string (data
, size
)
586 Lisp_Object printcharfun
;
588 printcharfun
= Vstandard_output
;
591 strout (data
, size
, size
, printcharfun
, 0);
595 /* Used from outside of print.c to print a block of SIZE
596 single-byte chars at DATA on a specified stream PRINTCHARFUN.
597 Do not use this on the contents of a Lisp string. */
600 write_string_1 (data
, size
, printcharfun
)
603 Lisp_Object printcharfun
;
608 strout (data
, size
, size
, printcharfun
, 0);
614 temp_output_buffer_setup (bufname
)
617 int count
= SPECPDL_INDEX ();
618 register struct buffer
*old
= current_buffer
;
619 register Lisp_Object buf
;
621 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
623 Fset_buffer (Fget_buffer_create (build_string (bufname
)));
625 Fkill_all_local_variables ();
626 delete_all_overlays (current_buffer
);
627 current_buffer
->directory
= old
->directory
;
628 current_buffer
->read_only
= Qnil
;
629 current_buffer
->filename
= Qnil
;
630 current_buffer
->undo_list
= Qt
;
631 eassert (current_buffer
->overlays_before
== NULL
);
632 eassert (current_buffer
->overlays_after
== NULL
);
633 current_buffer
->enable_multibyte_characters
634 = buffer_defaults
.enable_multibyte_characters
;
635 specbind (Qinhibit_read_only
, Qt
);
636 specbind (Qinhibit_modification_hooks
, Qt
);
638 XSETBUFFER (buf
, current_buffer
);
640 Frun_hooks (1, &Qtemp_buffer_setup_hook
);
642 unbind_to (count
, Qnil
);
644 specbind (Qstandard_output
, buf
);
648 internal_with_output_to_temp_buffer (bufname
, function
, args
)
650 Lisp_Object (*function
) P_ ((Lisp_Object
));
653 int count
= SPECPDL_INDEX ();
654 Lisp_Object buf
, val
;
658 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
659 temp_output_buffer_setup (bufname
);
660 buf
= Vstandard_output
;
663 val
= (*function
) (args
);
666 temp_output_buffer_show (buf
);
669 return unbind_to (count
, val
);
672 DEFUN ("with-output-to-temp-buffer",
673 Fwith_output_to_temp_buffer
, Swith_output_to_temp_buffer
,
675 doc
: /* Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
676 The buffer is cleared out initially, and marked as unmodified when done.
677 All output done by BODY is inserted in that buffer by default.
678 The buffer is displayed in another window, but not selected.
679 The value of the last form in BODY is returned.
680 If BODY does not finish normally, the buffer BUFNAME is not displayed.
682 The hook `temp-buffer-setup-hook' is run before BODY,
683 with the buffer BUFNAME temporarily current.
684 The hook `temp-buffer-show-hook' is run after the buffer is displayed,
685 with the buffer temporarily current, and the window that was used
686 to display it temporarily selected.
688 If variable `temp-buffer-show-function' is non-nil, call it at the end
689 to get the buffer displayed instead of just displaying the non-selected
690 buffer and calling the hook. It gets one argument, the buffer to display.
692 usage: (with-output-to-temp-buffer BUFNAME BODY ...) */)
698 int count
= SPECPDL_INDEX ();
699 Lisp_Object buf
, val
;
702 name
= Feval (Fcar (args
));
704 temp_output_buffer_setup (SDATA (name
));
705 buf
= Vstandard_output
;
708 val
= Fprogn (XCDR (args
));
711 temp_output_buffer_show (buf
);
714 return unbind_to (count
, val
);
718 static void print ();
719 static void print_preprocess ();
720 static void print_preprocess_string ();
721 static void print_object ();
723 DEFUN ("terpri", Fterpri
, Sterpri
, 0, 1, 0,
724 doc
: /* Output a newline to stream PRINTCHARFUN.
725 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used. */)
727 Lisp_Object printcharfun
;
731 if (NILP (printcharfun
))
732 printcharfun
= Vstandard_output
;
739 DEFUN ("prin1", Fprin1
, Sprin1
, 1, 2, 0,
740 doc
: /* Output the printed representation of OBJECT, any Lisp object.
741 Quoting characters are printed when needed to make output that `read'
742 can handle, whenever this is possible. For complex objects, the behavior
743 is controlled by `print-level' and `print-length', which see.
745 OBJECT is any of the Lisp data types: a number, a string, a symbol,
746 a list, a buffer, a window, a frame, etc.
748 A printed representation of an object is text which describes that object.
750 Optional argument PRINTCHARFUN is the output stream, which can be one
753 - a buffer, in which case output is inserted into that buffer at point;
754 - a marker, in which case output is inserted at marker's position;
755 - a function, in which case that function is called once for each
756 character of OBJECT's printed representation;
757 - a symbol, in which case that symbol's function definition is called; or
758 - t, in which case the output is displayed in the echo area.
760 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
762 (object
, printcharfun
)
763 Lisp_Object object
, printcharfun
;
767 #ifdef MAX_PRINT_CHARS
769 #endif /* MAX_PRINT_CHARS */
770 if (NILP (printcharfun
))
771 printcharfun
= Vstandard_output
;
773 print (object
, printcharfun
, 1);
778 /* a buffer which is used to hold output being built by prin1-to-string */
779 Lisp_Object Vprin1_to_string_buffer
;
781 DEFUN ("prin1-to-string", Fprin1_to_string
, Sprin1_to_string
, 1, 2, 0,
782 doc
: /* Return a string containing the printed representation of OBJECT.
783 OBJECT can be any Lisp object. This function outputs quoting characters
784 when necessary to make output that `read' can handle, whenever possible,
785 unless the optional second argument NOESCAPE is non-nil. For complex objects,
786 the behavior is controlled by `print-level' and `print-length', which see.
788 OBJECT is any of the Lisp data types: a number, a string, a symbol,
789 a list, a buffer, a window, a frame, etc.
791 A printed representation of an object is text which describes that object. */)
793 Lisp_Object object
, noescape
;
795 Lisp_Object printcharfun
;
796 /* struct gcpro gcpro1, gcpro2; */
797 Lisp_Object save_deactivate_mark
;
798 int count
= specpdl_ptr
- specpdl
;
799 struct buffer
*previous
;
801 specbind (Qinhibit_modification_hooks
, Qt
);
806 /* Save and restore this--we are altering a buffer
807 but we don't want to deactivate the mark just for that.
808 No need for specbind, since errors deactivate the mark. */
809 save_deactivate_mark
= Vdeactivate_mark
;
810 /* GCPRO2 (object, save_deactivate_mark); */
813 printcharfun
= Vprin1_to_string_buffer
;
815 print (object
, printcharfun
, NILP (noescape
));
816 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
820 previous
= current_buffer
;
821 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
822 object
= Fbuffer_string ();
823 if (SBYTES (object
) == SCHARS (object
))
824 STRING_SET_UNIBYTE (object
);
826 /* Note that this won't make prepare_to_modify_buffer call
827 ask-user-about-supersession-threat because this buffer
828 does not visit a file. */
830 set_buffer_internal (previous
);
832 Vdeactivate_mark
= save_deactivate_mark
;
836 return unbind_to (count
, object
);
839 DEFUN ("princ", Fprinc
, Sprinc
, 1, 2, 0,
840 doc
: /* Output the printed representation of OBJECT, any Lisp object.
841 No quoting characters are used; no delimiters are printed around
842 the contents of strings.
844 OBJECT is any of the Lisp data types: a number, a string, a symbol,
845 a list, a buffer, a window, a frame, etc.
847 A printed representation of an object is text which describes that object.
849 Optional argument PRINTCHARFUN is the output stream, which can be one
852 - a buffer, in which case output is inserted into that buffer at point;
853 - a marker, in which case output is inserted at marker's position;
854 - a function, in which case that function is called once for each
855 character of OBJECT's printed representation;
856 - a symbol, in which case that symbol's function definition is called; or
857 - t, in which case the output is displayed in the echo area.
859 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
861 (object
, printcharfun
)
862 Lisp_Object object
, printcharfun
;
866 if (NILP (printcharfun
))
867 printcharfun
= Vstandard_output
;
869 print (object
, printcharfun
, 0);
874 DEFUN ("print", Fprint
, Sprint
, 1, 2, 0,
875 doc
: /* Output the printed representation of OBJECT, with newlines around it.
876 Quoting characters are printed when needed to make output that `read'
877 can handle, whenever this is possible. For complex objects, the behavior
878 is controlled by `print-level' and `print-length', which see.
880 OBJECT is any of the Lisp data types: a number, a string, a symbol,
881 a list, a buffer, a window, a frame, etc.
883 A printed representation of an object is text which describes that object.
885 Optional argument PRINTCHARFUN is the output stream, which can be one
888 - a buffer, in which case output is inserted into that buffer at point;
889 - a marker, in which case output is inserted at marker's position;
890 - a function, in which case that function is called once for each
891 character of OBJECT's printed representation;
892 - a symbol, in which case that symbol's function definition is called; or
893 - t, in which case the output is displayed in the echo area.
895 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
897 (object
, printcharfun
)
898 Lisp_Object object
, printcharfun
;
903 #ifdef MAX_PRINT_CHARS
905 max_print
= MAX_PRINT_CHARS
;
906 #endif /* MAX_PRINT_CHARS */
907 if (NILP (printcharfun
))
908 printcharfun
= Vstandard_output
;
912 print (object
, printcharfun
, 1);
915 #ifdef MAX_PRINT_CHARS
918 #endif /* MAX_PRINT_CHARS */
923 /* The subroutine object for external-debugging-output is kept here
924 for the convenience of the debugger. */
925 Lisp_Object Qexternal_debugging_output
;
927 DEFUN ("external-debugging-output", Fexternal_debugging_output
, Sexternal_debugging_output
, 1, 1, 0,
928 doc
: /* Write CHARACTER to stderr.
929 You can call print while debugging emacs, and pass it this function
930 to make it write to the debugging output. */)
932 Lisp_Object character
;
934 CHECK_NUMBER (character
);
935 putc (XINT (character
), stderr
);
938 /* Send the output to a debugger (nothing happens if there isn't one). */
939 if (print_output_debug_flag
)
941 char buf
[2] = {(char) XINT (character
), '\0'};
942 OutputDebugString (buf
);
949 /* This function is never called. Its purpose is to prevent
950 print_output_debug_flag from being optimized away. */
953 debug_output_compilation_hack (x
)
956 print_output_debug_flag
= x
;
959 #if defined (GNU_LINUX)
961 /* This functionality is not vitally important in general, so we rely on
962 non-portable ability to use stderr as lvalue. */
964 #define WITH_REDIRECT_DEBUGGING_OUTPUT 1
966 FILE *initial_stderr_stream
= NULL
;
968 DEFUN ("redirect-debugging-output", Fredirect_debugging_output
, Sredirect_debugging_output
,
970 "FDebug output file: \nP",
971 doc
: /* Redirect debugging output (stderr stream) to file FILE.
972 If FILE is nil, reset target to the initial stderr stream.
973 Optional arg APPEND non-nil (interactively, with prefix arg) means
974 append to existing target file. */)
976 Lisp_Object file
, append
;
978 if (initial_stderr_stream
!= NULL
)
980 stderr
= initial_stderr_stream
;
981 initial_stderr_stream
= NULL
;
985 file
= Fexpand_file_name (file
, Qnil
);
986 initial_stderr_stream
= stderr
;
987 stderr
= fopen (SDATA (file
), NILP (append
) ? "w" : "a");
990 stderr
= initial_stderr_stream
;
991 initial_stderr_stream
= NULL
;
992 report_file_error ("Cannot open debugging output stream",
998 #endif /* GNU_LINUX */
1001 /* This is the interface for debugging printing. */
1007 Fprin1 (arg
, Qexternal_debugging_output
);
1008 fprintf (stderr
, "\r\n");
1012 safe_debug_print (arg
)
1015 int valid
= valid_lisp_object_p (arg
);
1020 fprintf (stderr
, "#<%s_LISP_OBJECT 0x%08lx>\r\n",
1021 !valid
? "INVALID" : "SOME",
1022 #ifdef NO_UNION_TYPE
1025 (unsigned long) arg
.i
1031 DEFUN ("error-message-string", Ferror_message_string
, Serror_message_string
,
1033 doc
: /* Convert an error value (ERROR-SYMBOL . DATA) to an error message.
1034 See Info anchor `(elisp)Definition of signal' for some details on how this
1035 error message is constructed. */)
1039 struct buffer
*old
= current_buffer
;
1041 struct gcpro gcpro1
;
1043 /* If OBJ is (error STRING), just return STRING.
1044 That is not only faster, it also avoids the need to allocate
1045 space here when the error is due to memory full. */
1046 if (CONSP (obj
) && EQ (XCAR (obj
), Qerror
)
1047 && CONSP (XCDR (obj
))
1048 && STRINGP (XCAR (XCDR (obj
)))
1049 && NILP (XCDR (XCDR (obj
))))
1050 return XCAR (XCDR (obj
));
1052 print_error_message (obj
, Vprin1_to_string_buffer
, 0, Qnil
);
1054 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
1055 value
= Fbuffer_string ();
1059 set_buffer_internal (old
);
1065 /* Print an error message for the error DATA onto Lisp output stream
1066 STREAM (suitable for the print functions).
1067 CONTEXT is a C string describing the context of the error.
1068 CALLER is the Lisp function inside which the error was signaled. */
1071 print_error_message (data
, stream
, context
, caller
)
1072 Lisp_Object data
, stream
;
1076 Lisp_Object errname
, errmsg
, file_error
, tail
;
1077 struct gcpro gcpro1
;
1081 write_string_1 (context
, -1, stream
);
1083 /* If we know from where the error was signaled, show it in
1085 if (!NILP (caller
) && SYMBOLP (caller
))
1087 Lisp_Object cname
= SYMBOL_NAME (caller
);
1088 char *name
= alloca (SBYTES (cname
));
1089 bcopy (SDATA (cname
), name
, SBYTES (cname
));
1090 message_dolog (name
, SBYTES (cname
), 0, 0);
1091 message_dolog (": ", 2, 0, 0);
1094 errname
= Fcar (data
);
1096 if (EQ (errname
, Qerror
))
1101 errmsg
= Fcar (data
);
1106 Lisp_Object error_conditions
;
1107 errmsg
= Fget (errname
, Qerror_message
);
1108 error_conditions
= Fget (errname
, Qerror_conditions
);
1109 file_error
= Fmemq (Qfile_error
, error_conditions
);
1112 /* Print an error message including the data items. */
1114 tail
= Fcdr_safe (data
);
1117 /* For file-error, make error message by concatenating
1118 all the data items. They are all strings. */
1119 if (!NILP (file_error
) && CONSP (tail
))
1120 errmsg
= XCAR (tail
), tail
= XCDR (tail
);
1122 if (STRINGP (errmsg
))
1123 Fprinc (errmsg
, stream
);
1125 write_string_1 ("peculiar error", -1, stream
);
1127 for (i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
1131 write_string_1 (i
? ", " : ": ", 2, stream
);
1133 if (!NILP (file_error
) || EQ (errname
, Qend_of_file
))
1134 Fprinc (obj
, stream
);
1136 Fprin1 (obj
, stream
);
1145 * The buffer should be at least as large as the max string size of the
1146 * largest float, printed in the biggest notation. This is undoubtedly
1147 * 20d float_output_format, with the negative of the C-constant "HUGE"
1150 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
1152 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
1153 * case of -1e307 in 20d float_output_format. What is one to do (short of
1154 * re-writing _doprnt to be more sane)?
1159 float_to_string (buf
, data
)
1166 /* Check for plus infinity in a way that won't lose
1167 if there is no plus infinity. */
1168 if (data
== data
/ 2 && data
> 1.0)
1170 strcpy (buf
, "1.0e+INF");
1173 /* Likewise for minus infinity. */
1174 if (data
== data
/ 2 && data
< -1.0)
1176 strcpy (buf
, "-1.0e+INF");
1179 /* Check for NaN in a way that won't fail if there are no NaNs. */
1180 if (! (data
* 0.0 >= 0.0))
1182 /* Prepend "-" if the NaN's sign bit is negative.
1183 The sign bit of a double is the bit that is 1 in -0.0. */
1185 union { double d
; char c
[sizeof (double)]; } u_data
, u_minus_zero
;
1187 u_minus_zero
.d
= - 0.0;
1188 for (i
= 0; i
< sizeof (double); i
++)
1189 if (u_data
.c
[i
] & u_minus_zero
.c
[i
])
1195 strcpy (buf
, "0.0e+NaN");
1199 if (NILP (Vfloat_output_format
)
1200 || !STRINGP (Vfloat_output_format
))
1203 /* Generate the fewest number of digits that represent the
1204 floating point value without losing information.
1205 The following method is simple but a bit slow.
1206 For ideas about speeding things up, please see:
1208 Guy L Steele Jr & Jon L White, How to print floating-point numbers
1209 accurately. SIGPLAN notices 25, 6 (June 1990), 112-126.
1211 Robert G Burger & R Kent Dybvig, Printing floating point numbers
1212 quickly and accurately, SIGPLAN notices 31, 5 (May 1996), 108-116. */
1214 width
= fabs (data
) < DBL_MIN
? 1 : DBL_DIG
;
1216 sprintf (buf
, "%.*g", width
, data
);
1217 while (width
++ < DOUBLE_DIGITS_BOUND
&& atof (buf
) != data
);
1219 else /* oink oink */
1221 /* Check that the spec we have is fully valid.
1222 This means not only valid for printf,
1223 but meant for floats, and reasonable. */
1224 cp
= SDATA (Vfloat_output_format
);
1233 /* Check the width specification. */
1235 if ('0' <= *cp
&& *cp
<= '9')
1239 width
= (width
* 10) + (*cp
++ - '0');
1240 while (*cp
>= '0' && *cp
<= '9');
1242 /* A precision of zero is valid only for %f. */
1244 || (width
== 0 && *cp
!= 'f'))
1248 if (*cp
!= 'e' && *cp
!= 'f' && *cp
!= 'g')
1254 sprintf (buf
, SDATA (Vfloat_output_format
), data
);
1257 /* Make sure there is a decimal point with digit after, or an
1258 exponent, so that the value is readable as a float. But don't do
1259 this with "%.0f"; it's valid for that not to produce a decimal
1260 point. Note that width can be 0 only for %.0f. */
1263 for (cp
= buf
; *cp
; cp
++)
1264 if ((*cp
< '0' || *cp
> '9') && *cp
!= '-')
1267 if (*cp
== '.' && cp
[1] == 0)
1284 print (obj
, printcharfun
, escapeflag
)
1286 register Lisp_Object printcharfun
;
1289 old_backquote_output
= 0;
1291 /* Reset print_number_index and Vprint_number_table only when
1292 the variable Vprint_continuous_numbering is nil. Otherwise,
1293 the values of these variables will be kept between several
1295 if (NILP (Vprint_continuous_numbering
)
1296 || NILP (Vprint_number_table
))
1298 print_number_index
= 0;
1299 Vprint_number_table
= Qnil
;
1302 /* Construct Vprint_number_table for print-gensym and print-circle. */
1303 if (!NILP (Vprint_gensym
) || !NILP (Vprint_circle
))
1305 int i
, start
, index
;
1306 start
= index
= print_number_index
;
1307 /* Construct Vprint_number_table.
1308 This increments print_number_index for the objects added. */
1310 print_preprocess (obj
);
1312 /* Remove unnecessary objects, which appear only once in OBJ;
1313 that is, whose status is Qnil. Compactify the necessary objects. */
1314 for (i
= start
; i
< print_number_index
; i
++)
1315 if (!NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1317 PRINT_NUMBER_OBJECT (Vprint_number_table
, index
)
1318 = PRINT_NUMBER_OBJECT (Vprint_number_table
, i
);
1322 /* Clear out objects outside the active part of the table. */
1323 for (i
= index
; i
< print_number_index
; i
++)
1324 PRINT_NUMBER_OBJECT (Vprint_number_table
, i
) = Qnil
;
1326 /* Reset the status field for the next print step. Now this
1327 field means whether the object has already been printed. */
1328 for (i
= start
; i
< print_number_index
; i
++)
1329 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qnil
;
1331 print_number_index
= index
;
1335 print_object (obj
, printcharfun
, escapeflag
);
1338 /* Construct Vprint_number_table according to the structure of OBJ.
1339 OBJ itself and all its elements will be added to Vprint_number_table
1340 recursively if it is a list, vector, compiled function, char-table,
1341 string (its text properties will be traced), or a symbol that has
1342 no obarray (this is for the print-gensym feature).
1343 The status fields of Vprint_number_table mean whether each object appears
1344 more than once in OBJ: Qnil at the first time, and Qt after that . */
1346 print_preprocess (obj
)
1352 Lisp_Object halftail
;
1354 /* Give up if we go so deep that print_object will get an error. */
1355 /* See similar code in print_object. */
1356 if (print_depth
>= PRINT_CIRCLE
)
1357 error ("Apparently circular structure being printed");
1359 /* Avoid infinite recursion for circular nested structure
1360 in the case where Vprint_circle is nil. */
1361 if (NILP (Vprint_circle
))
1363 for (i
= 0; i
< print_depth
; i
++)
1364 if (EQ (obj
, being_printed
[i
]))
1366 being_printed
[print_depth
] = obj
;
1373 if (STRINGP (obj
) || CONSP (obj
) || VECTORP (obj
)
1374 || COMPILEDP (obj
) || CHAR_TABLE_P (obj
)
1375 || (! NILP (Vprint_gensym
)
1377 && !SYMBOL_INTERNED_P (obj
)))
1379 /* In case print-circle is nil and print-gensym is t,
1380 add OBJ to Vprint_number_table only when OBJ is a symbol. */
1381 if (! NILP (Vprint_circle
) || SYMBOLP (obj
))
1383 for (i
= 0; i
< print_number_index
; i
++)
1384 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
), obj
))
1386 /* OBJ appears more than once. Let's remember that. */
1387 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qt
;
1392 /* OBJ is not yet recorded. Let's add to the table. */
1393 if (print_number_index
== 0)
1395 /* Initialize the table. */
1396 Vprint_number_table
= Fmake_vector (make_number (40), Qnil
);
1398 else if (XVECTOR (Vprint_number_table
)->size
== print_number_index
* 2)
1400 /* Reallocate the table. */
1401 int i
= print_number_index
* 4;
1402 Lisp_Object old_table
= Vprint_number_table
;
1403 Vprint_number_table
= Fmake_vector (make_number (i
), Qnil
);
1404 for (i
= 0; i
< print_number_index
; i
++)
1406 PRINT_NUMBER_OBJECT (Vprint_number_table
, i
)
1407 = PRINT_NUMBER_OBJECT (old_table
, i
);
1408 PRINT_NUMBER_STATUS (Vprint_number_table
, i
)
1409 = PRINT_NUMBER_STATUS (old_table
, i
);
1412 PRINT_NUMBER_OBJECT (Vprint_number_table
, print_number_index
) = obj
;
1413 /* If Vprint_continuous_numbering is non-nil and OBJ is a gensym,
1414 always print the gensym with a number. This is a special for
1415 the lisp function byte-compile-output-docform. */
1416 if (!NILP (Vprint_continuous_numbering
)
1418 && !SYMBOL_INTERNED_P (obj
))
1419 PRINT_NUMBER_STATUS (Vprint_number_table
, print_number_index
) = Qt
;
1420 print_number_index
++;
1423 switch (XGCTYPE (obj
))
1426 /* A string may have text properties, which can be circular. */
1427 traverse_intervals_noorder (STRING_INTERVALS (obj
),
1428 print_preprocess_string
, Qnil
);
1432 /* Use HALFTAIL and LOOP_COUNT to detect circular lists,
1433 just as in print_object. */
1434 if (loop_count
&& EQ (obj
, halftail
))
1436 print_preprocess (XCAR (obj
));
1439 if (!(loop_count
& 1))
1440 halftail
= XCDR (halftail
);
1443 case Lisp_Vectorlike
:
1444 size
= XVECTOR (obj
)->size
;
1445 if (size
& PSEUDOVECTOR_FLAG
)
1446 size
&= PSEUDOVECTOR_SIZE_MASK
;
1447 for (i
= 0; i
< size
; i
++)
1448 print_preprocess (XVECTOR (obj
)->contents
[i
]);
1459 print_preprocess_string (interval
, arg
)
1463 print_preprocess (interval
->plist
);
1466 /* A flag to control printing of `charset' text property.
1467 The default value is Qdefault. */
1468 Lisp_Object Vprint_charset_text_property
;
1469 extern Lisp_Object Qdefault
;
1471 static void print_check_string_charset_prop ();
1473 #define PRINT_STRING_NON_CHARSET_FOUND 1
1474 #define PRINT_STRING_UNSAFE_CHARSET_FOUND 2
1476 /* Bitwize or of the abobe macros. */
1477 static int print_check_string_result
;
1480 print_check_string_charset_prop (interval
, string
)
1486 if (NILP (interval
->plist
)
1487 || (print_check_string_result
== (PRINT_STRING_NON_CHARSET_FOUND
1488 | PRINT_STRING_UNSAFE_CHARSET_FOUND
)))
1490 for (val
= interval
->plist
; CONSP (val
) && ! EQ (XCAR (val
), Qcharset
);
1491 val
= XCDR (XCDR (val
)));
1494 print_check_string_result
|= PRINT_STRING_NON_CHARSET_FOUND
;
1497 if (! (print_check_string_result
& PRINT_STRING_NON_CHARSET_FOUND
))
1499 if (! EQ (val
, interval
->plist
)
1500 || CONSP (XCDR (XCDR (val
))))
1501 print_check_string_result
|= PRINT_STRING_NON_CHARSET_FOUND
;
1503 if (NILP (Vprint_charset_text_property
)
1504 || ! (print_check_string_result
& PRINT_STRING_UNSAFE_CHARSET_FOUND
))
1507 int charpos
= interval
->position
;
1508 int bytepos
= string_char_to_byte (string
, charpos
);
1509 Lisp_Object charset
;
1511 charset
= XCAR (XCDR (val
));
1512 for (i
= 0; i
< LENGTH (interval
); i
++)
1514 FETCH_STRING_CHAR_ADVANCE (c
, string
, charpos
, bytepos
);
1515 if (! ASCII_CHAR_P (c
)
1516 && ! EQ (CHARSET_NAME (CHAR_CHARSET (c
)), charset
))
1518 print_check_string_result
|= PRINT_STRING_UNSAFE_CHARSET_FOUND
;
1525 /* The value is (charset . nil). */
1526 static Lisp_Object print_prune_charset_plist
;
1529 print_prune_string_charset (string
)
1532 print_check_string_result
= 0;
1533 traverse_intervals (STRING_INTERVALS (string
), 0,
1534 print_check_string_charset_prop
, string
);
1535 if (! (print_check_string_result
& PRINT_STRING_UNSAFE_CHARSET_FOUND
))
1537 string
= Fcopy_sequence (string
);
1538 if (print_check_string_result
& PRINT_STRING_NON_CHARSET_FOUND
)
1540 if (NILP (print_prune_charset_plist
))
1541 print_prune_charset_plist
= Fcons (Qcharset
, Qnil
);
1542 Fremove_text_properties (make_number (0),
1543 make_number (SCHARS (string
)),
1544 print_prune_charset_plist
, string
);
1547 Fset_text_properties (make_number (0), make_number (SCHARS (string
)),
1554 print_object (obj
, printcharfun
, escapeflag
)
1556 register Lisp_Object printcharfun
;
1563 /* Detect circularities and truncate them. */
1564 if (STRINGP (obj
) || CONSP (obj
) || VECTORP (obj
)
1565 || COMPILEDP (obj
) || CHAR_TABLE_P (obj
) || SUB_CHAR_TABLE_P (obj
)
1566 || (! NILP (Vprint_gensym
)
1568 && !SYMBOL_INTERNED_P (obj
)))
1570 if (NILP (Vprint_circle
) && NILP (Vprint_gensym
))
1572 /* Simple but incomplete way. */
1574 for (i
= 0; i
< print_depth
; i
++)
1575 if (EQ (obj
, being_printed
[i
]))
1577 sprintf (buf
, "#%d", i
);
1578 strout (buf
, -1, -1, printcharfun
, 0);
1581 being_printed
[print_depth
] = obj
;
1585 /* With the print-circle feature. */
1587 for (i
= 0; i
< print_number_index
; i
++)
1588 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
), obj
))
1590 if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1592 /* Add a prefix #n= if OBJ has not yet been printed;
1593 that is, its status field is nil. */
1594 sprintf (buf
, "#%d=", i
+ 1);
1595 strout (buf
, -1, -1, printcharfun
, 0);
1596 /* OBJ is going to be printed. Set the status to t. */
1597 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qt
;
1602 /* Just print #n# if OBJ has already been printed. */
1603 sprintf (buf
, "#%d#", i
+ 1);
1604 strout (buf
, -1, -1, printcharfun
, 0);
1613 /* See similar code in print_preprocess. */
1614 if (print_depth
> PRINT_CIRCLE
)
1615 error ("Apparently circular structure being printed");
1616 #ifdef MAX_PRINT_CHARS
1617 if (max_print
&& print_chars
> max_print
)
1622 #endif /* MAX_PRINT_CHARS */
1624 switch (XGCTYPE (obj
))
1627 if (sizeof (int) == sizeof (EMACS_INT
))
1628 sprintf (buf
, "%d", XINT (obj
));
1629 else if (sizeof (long) == sizeof (EMACS_INT
))
1630 sprintf (buf
, "%ld", (long) XINT (obj
));
1633 strout (buf
, -1, -1, printcharfun
, 0);
1638 char pigbuf
[350]; /* see comments in float_to_string */
1640 float_to_string (pigbuf
, XFLOAT_DATA (obj
));
1641 strout (pigbuf
, -1, -1, printcharfun
, 0);
1647 print_string (obj
, printcharfun
);
1650 register int i
, i_byte
;
1651 struct gcpro gcpro1
;
1654 /* 1 means we must ensure that the next character we output
1655 cannot be taken as part of a hex character escape. */
1656 int need_nonhex
= 0;
1657 int multibyte
= STRING_MULTIBYTE (obj
);
1661 if (! EQ (Vprint_charset_text_property
, Qt
))
1662 obj
= print_prune_string_charset (obj
);
1664 if (!NULL_INTERVAL_P (STRING_INTERVALS (obj
)))
1672 size_byte
= SBYTES (obj
);
1674 for (i
= 0, i_byte
= 0; i_byte
< size_byte
;)
1676 /* Here, we must convert each multi-byte form to the
1677 corresponding character code before handing it to PRINTCHAR. */
1683 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1684 size_byte
- i_byte
, len
);
1692 if (c
== '\n' && print_escape_newlines
)
1697 else if (c
== '\f' && print_escape_newlines
)
1703 && (CHAR_BYTE8_P (c
)
1704 || (! ASCII_CHAR_P (c
) && print_escape_multibyte
)))
1706 /* When multibyte is disabled,
1707 print multibyte string chars using hex escapes.
1708 For a char code that could be in a unibyte string,
1709 when found in a multibyte string, always use a hex escape
1710 so it reads back as multibyte. */
1711 unsigned char outbuf
[50];
1713 if (CHAR_BYTE8_P (c
))
1714 sprintf (outbuf
, "\\%03o", CHAR_TO_BYTE8 (c
));
1717 sprintf (outbuf
, "\\x%04x", c
);
1720 strout (outbuf
, -1, -1, printcharfun
, 0);
1722 else if (! multibyte
1723 && SINGLE_BYTE_CHAR_P (c
) && ! ASCII_BYTE_P (c
)
1724 && print_escape_nonascii
)
1726 /* When printing in a multibyte buffer
1727 or when explicitly requested,
1728 print single-byte non-ASCII string chars
1729 using octal escapes. */
1730 unsigned char outbuf
[5];
1731 sprintf (outbuf
, "\\%03o", c
);
1732 strout (outbuf
, -1, -1, printcharfun
, 0);
1736 /* If we just had a hex escape, and this character
1737 could be taken as part of it,
1738 output `\ ' to prevent that. */
1742 if ((c
>= 'a' && c
<= 'f')
1743 || (c
>= 'A' && c
<= 'F')
1744 || (c
>= '0' && c
<= '9'))
1745 strout ("\\ ", -1, -1, printcharfun
, 0);
1748 if (c
== '\"' || c
== '\\')
1755 if (!NULL_INTERVAL_P (STRING_INTERVALS (obj
)))
1757 traverse_intervals (STRING_INTERVALS (obj
),
1758 0, print_interval
, printcharfun
);
1768 register int confusing
;
1769 register unsigned char *p
= SDATA (SYMBOL_NAME (obj
));
1770 register unsigned char *end
= p
+ SBYTES (SYMBOL_NAME (obj
));
1772 int i
, i_byte
, size_byte
;
1775 name
= SYMBOL_NAME (obj
);
1777 if (p
!= end
&& (*p
== '-' || *p
== '+')) p
++;
1780 /* If symbol name begins with a digit, and ends with a digit,
1781 and contains nothing but digits and `e', it could be treated
1782 as a number. So set CONFUSING.
1784 Symbols that contain periods could also be taken as numbers,
1785 but periods are always escaped, so we don't have to worry
1787 else if (*p
>= '0' && *p
<= '9'
1788 && end
[-1] >= '0' && end
[-1] <= '9')
1790 while (p
!= end
&& ((*p
>= '0' && *p
<= '9')
1791 /* Needed for \2e10. */
1794 confusing
= (end
== p
);
1799 if (! NILP (Vprint_gensym
) && !SYMBOL_INTERNED_P (obj
))
1805 size_byte
= SBYTES (name
);
1807 for (i
= 0, i_byte
= 0; i_byte
< size_byte
;)
1809 /* Here, we must convert each multi-byte form to the
1810 corresponding character code before handing it to PRINTCHAR. */
1811 FETCH_STRING_CHAR_ADVANCE (c
, name
, i
, i_byte
);
1816 if (c
== '\"' || c
== '\\' || c
== '\''
1817 || c
== ';' || c
== '#' || c
== '(' || c
== ')'
1818 || c
== ',' || c
=='.' || c
== '`'
1819 || c
== '[' || c
== ']' || c
== '?' || c
<= 040
1821 PRINTCHAR ('\\'), confusing
= 0;
1829 /* If deeper than spec'd depth, print placeholder. */
1830 if (INTEGERP (Vprint_level
)
1831 && print_depth
> XINT (Vprint_level
))
1832 strout ("...", -1, -1, printcharfun
, 0);
1833 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1834 && (EQ (XCAR (obj
), Qquote
)))
1837 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1839 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1840 && (EQ (XCAR (obj
), Qfunction
)))
1844 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1846 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1847 && ! old_backquote_output
1848 && ((EQ (XCAR (obj
), Qbackquote
)
1849 || EQ (XCAR (obj
), Qcomma
)
1850 || EQ (XCAR (obj
), Qcomma_at
)
1851 || EQ (XCAR (obj
), Qcomma_dot
))))
1853 print_object (XCAR (obj
), printcharfun
, 0);
1854 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1860 /* If the first element is a backquote form,
1861 print it old-style so it won't be misunderstood. */
1862 if (print_quoted
&& CONSP (XCAR (obj
))
1863 && CONSP (XCDR (XCAR (obj
)))
1864 && NILP (XCDR (XCDR (XCAR (obj
))))
1865 && EQ (XCAR (XCAR (obj
)), Qbackquote
))
1871 print_object (Qbackquote
, printcharfun
, 0);
1874 ++old_backquote_output
;
1875 print_object (XCAR (XCDR (tem
)), printcharfun
, 0);
1876 --old_backquote_output
;
1883 int print_length
, i
;
1884 Lisp_Object halftail
= obj
;
1886 /* Negative values of print-length are invalid in CL.
1887 Treat them like nil, as CMUCL does. */
1888 if (NATNUMP (Vprint_length
))
1889 print_length
= XFASTINT (Vprint_length
);
1896 /* Detect circular list. */
1897 if (NILP (Vprint_circle
))
1899 /* Simple but imcomplete way. */
1900 if (i
!= 0 && EQ (obj
, halftail
))
1902 sprintf (buf
, " . #%d", i
/ 2);
1903 strout (buf
, -1, -1, printcharfun
, 0);
1909 /* With the print-circle feature. */
1913 for (i
= 0; i
< print_number_index
; i
++)
1914 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
),
1917 if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1919 strout (" . ", 3, 3, printcharfun
, 0);
1920 print_object (obj
, printcharfun
, escapeflag
);
1924 sprintf (buf
, " . #%d#", i
+ 1);
1925 strout (buf
, -1, -1, printcharfun
, 0);
1935 if (print_length
&& i
> print_length
)
1937 strout ("...", 3, 3, printcharfun
, 0);
1941 print_object (XCAR (obj
), printcharfun
, escapeflag
);
1945 halftail
= XCDR (halftail
);
1949 /* OBJ non-nil here means it's the end of a dotted list. */
1952 strout (" . ", 3, 3, printcharfun
, 0);
1953 print_object (obj
, printcharfun
, escapeflag
);
1961 case Lisp_Vectorlike
:
1966 strout ("#<process ", -1, -1, printcharfun
, 0);
1967 print_string (XPROCESS (obj
)->name
, printcharfun
);
1971 print_string (XPROCESS (obj
)->name
, printcharfun
);
1973 else if (BOOL_VECTOR_P (obj
))
1976 register unsigned char c
;
1977 struct gcpro gcpro1
;
1979 = ((XBOOL_VECTOR (obj
)->size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1)
1980 / BOOL_VECTOR_BITS_PER_CHAR
);
1986 sprintf (buf
, "%ld", (long) XBOOL_VECTOR (obj
)->size
);
1987 strout (buf
, -1, -1, printcharfun
, 0);
1990 /* Don't print more characters than the specified maximum.
1991 Negative values of print-length are invalid. Treat them
1992 like a print-length of nil. */
1993 if (NATNUMP (Vprint_length
)
1994 && XFASTINT (Vprint_length
) < size_in_chars
)
1995 size_in_chars
= XFASTINT (Vprint_length
);
1997 for (i
= 0; i
< size_in_chars
; i
++)
2000 c
= XBOOL_VECTOR (obj
)->data
[i
];
2001 if (! ASCII_BYTE_P (c
))
2003 sprintf (buf
, "\\%03o", c
);
2004 strout (buf
, -1, -1, printcharfun
, 0);
2006 else if (c
== '\n' && print_escape_newlines
)
2011 else if (c
== '\f' && print_escape_newlines
)
2016 else if (c
> '\177')
2018 /* Use octal escapes to avoid encoding issues. */
2020 PRINTCHAR ('0' + ((c
>> 6) & 3));
2021 PRINTCHAR ('0' + ((c
>> 3) & 7));
2022 PRINTCHAR ('0' + (c
& 7));
2026 if (c
== '\"' || c
== '\\')
2035 else if (SUBRP (obj
))
2037 strout ("#<subr ", -1, -1, printcharfun
, 0);
2038 strout (XSUBR (obj
)->symbol_name
, -1, -1, printcharfun
, 0);
2041 else if (WINDOWP (obj
))
2043 strout ("#<window ", -1, -1, printcharfun
, 0);
2044 sprintf (buf
, "%ld", (long) XFASTINT (XWINDOW (obj
)->sequence_number
));
2045 strout (buf
, -1, -1, printcharfun
, 0);
2046 if (!NILP (XWINDOW (obj
)->buffer
))
2048 strout (" on ", -1, -1, printcharfun
, 0);
2049 print_string (XBUFFER (XWINDOW (obj
)->buffer
)->name
, printcharfun
);
2053 else if (HASH_TABLE_P (obj
))
2055 struct Lisp_Hash_Table
*h
= XHASH_TABLE (obj
);
2056 strout ("#<hash-table", -1, -1, printcharfun
, 0);
2057 if (SYMBOLP (h
->test
))
2061 strout (SDATA (SYMBOL_NAME (h
->test
)), -1, -1, printcharfun
, 0);
2063 strout (SDATA (SYMBOL_NAME (h
->weak
)), -1, -1, printcharfun
, 0);
2065 sprintf (buf
, "%ld/%ld", (long) XFASTINT (h
->count
),
2066 (long) XVECTOR (h
->next
)->size
);
2067 strout (buf
, -1, -1, printcharfun
, 0);
2069 sprintf (buf
, " 0x%lx", (unsigned long) h
);
2070 strout (buf
, -1, -1, printcharfun
, 0);
2073 else if (BUFFERP (obj
))
2075 if (NILP (XBUFFER (obj
)->name
))
2076 strout ("#<killed buffer>", -1, -1, printcharfun
, 0);
2077 else if (escapeflag
)
2079 strout ("#<buffer ", -1, -1, printcharfun
, 0);
2080 print_string (XBUFFER (obj
)->name
, printcharfun
);
2084 print_string (XBUFFER (obj
)->name
, printcharfun
);
2086 else if (WINDOW_CONFIGURATIONP (obj
))
2088 strout ("#<window-configuration>", -1, -1, printcharfun
, 0);
2090 else if (FRAMEP (obj
))
2092 strout ((FRAME_LIVE_P (XFRAME (obj
))
2093 ? "#<frame " : "#<dead frame "),
2094 -1, -1, printcharfun
, 0);
2095 print_string (XFRAME (obj
)->name
, printcharfun
);
2096 sprintf (buf
, " 0x%lx", (unsigned long) (XFRAME (obj
)));
2097 strout (buf
, -1, -1, printcharfun
, 0);
2102 EMACS_INT size
= XVECTOR (obj
)->size
;
2103 if (COMPILEDP (obj
))
2106 size
&= PSEUDOVECTOR_SIZE_MASK
;
2108 if (CHAR_TABLE_P (obj
) || SUB_CHAR_TABLE_P (obj
))
2110 /* We print a char-table as if it were a vector,
2111 lumping the parent and default slots in with the
2112 character slots. But we add #^ as a prefix. */
2115 if (SUB_CHAR_TABLE_P (obj
))
2117 size
&= PSEUDOVECTOR_SIZE_MASK
;
2119 if (size
& PSEUDOVECTOR_FLAG
)
2125 register Lisp_Object tem
;
2126 int real_size
= size
;
2128 /* Don't print more elements than the specified maximum. */
2129 if (NATNUMP (Vprint_length
)
2130 && XFASTINT (Vprint_length
) < size
)
2131 size
= XFASTINT (Vprint_length
);
2133 for (i
= 0; i
< size
; i
++)
2135 if (i
) PRINTCHAR (' ');
2136 tem
= XVECTOR (obj
)->contents
[i
];
2137 print_object (tem
, printcharfun
, escapeflag
);
2139 if (size
< real_size
)
2140 strout (" ...", 4, 4, printcharfun
, 0);
2147 switch (XMISCTYPE (obj
))
2149 case Lisp_Misc_Marker
:
2150 strout ("#<marker ", -1, -1, printcharfun
, 0);
2151 /* Do you think this is necessary? */
2152 if (XMARKER (obj
)->insertion_type
!= 0)
2153 strout ("(moves after insertion) ", -1, -1, printcharfun
, 0);
2154 if (! XMARKER (obj
)->buffer
)
2155 strout ("in no buffer", -1, -1, printcharfun
, 0);
2158 sprintf (buf
, "at %d", marker_position (obj
));
2159 strout (buf
, -1, -1, printcharfun
, 0);
2160 strout (" in ", -1, -1, printcharfun
, 0);
2161 print_string (XMARKER (obj
)->buffer
->name
, printcharfun
);
2166 case Lisp_Misc_Overlay
:
2167 strout ("#<overlay ", -1, -1, printcharfun
, 0);
2168 if (! XMARKER (OVERLAY_START (obj
))->buffer
)
2169 strout ("in no buffer", -1, -1, printcharfun
, 0);
2172 sprintf (buf
, "from %d to %d in ",
2173 marker_position (OVERLAY_START (obj
)),
2174 marker_position (OVERLAY_END (obj
)));
2175 strout (buf
, -1, -1, printcharfun
, 0);
2176 print_string (XMARKER (OVERLAY_START (obj
))->buffer
->name
,
2182 /* Remaining cases shouldn't happen in normal usage, but let's print
2183 them anyway for the benefit of the debugger. */
2184 case Lisp_Misc_Free
:
2185 strout ("#<misc free cell>", -1, -1, printcharfun
, 0);
2188 case Lisp_Misc_Intfwd
:
2189 sprintf (buf
, "#<intfwd to %ld>", (long) *XINTFWD (obj
)->intvar
);
2190 strout (buf
, -1, -1, printcharfun
, 0);
2193 case Lisp_Misc_Boolfwd
:
2194 sprintf (buf
, "#<boolfwd to %s>",
2195 (*XBOOLFWD (obj
)->boolvar
? "t" : "nil"));
2196 strout (buf
, -1, -1, printcharfun
, 0);
2199 case Lisp_Misc_Objfwd
:
2200 strout ("#<objfwd to ", -1, -1, printcharfun
, 0);
2201 print_object (*XOBJFWD (obj
)->objvar
, printcharfun
, escapeflag
);
2205 case Lisp_Misc_Buffer_Objfwd
:
2206 strout ("#<buffer_objfwd to ", -1, -1, printcharfun
, 0);
2207 print_object (PER_BUFFER_VALUE (current_buffer
,
2208 XBUFFER_OBJFWD (obj
)->offset
),
2209 printcharfun
, escapeflag
);
2213 case Lisp_Misc_Kboard_Objfwd
:
2214 strout ("#<kboard_objfwd to ", -1, -1, printcharfun
, 0);
2215 print_object (*(Lisp_Object
*) ((char *) current_kboard
2216 + XKBOARD_OBJFWD (obj
)->offset
),
2217 printcharfun
, escapeflag
);
2221 case Lisp_Misc_Buffer_Local_Value
:
2222 strout ("#<buffer_local_value ", -1, -1, printcharfun
, 0);
2223 goto do_buffer_local
;
2224 case Lisp_Misc_Some_Buffer_Local_Value
:
2225 strout ("#<some_buffer_local_value ", -1, -1, printcharfun
, 0);
2227 strout ("[realvalue] ", -1, -1, printcharfun
, 0);
2228 print_object (XBUFFER_LOCAL_VALUE (obj
)->realvalue
,
2229 printcharfun
, escapeflag
);
2230 if (XBUFFER_LOCAL_VALUE (obj
)->found_for_buffer
)
2231 strout ("[local in buffer] ", -1, -1, printcharfun
, 0);
2233 strout ("[buffer] ", -1, -1, printcharfun
, 0);
2234 print_object (XBUFFER_LOCAL_VALUE (obj
)->buffer
,
2235 printcharfun
, escapeflag
);
2236 if (XBUFFER_LOCAL_VALUE (obj
)->check_frame
)
2238 if (XBUFFER_LOCAL_VALUE (obj
)->found_for_frame
)
2239 strout ("[local in frame] ", -1, -1, printcharfun
, 0);
2241 strout ("[frame] ", -1, -1, printcharfun
, 0);
2242 print_object (XBUFFER_LOCAL_VALUE (obj
)->frame
,
2243 printcharfun
, escapeflag
);
2245 strout ("[alist-elt] ", -1, -1, printcharfun
, 0);
2246 print_object (XCAR (XBUFFER_LOCAL_VALUE (obj
)->cdr
),
2247 printcharfun
, escapeflag
);
2248 strout ("[default-value] ", -1, -1, printcharfun
, 0);
2249 print_object (XCDR (XBUFFER_LOCAL_VALUE (obj
)->cdr
),
2250 printcharfun
, escapeflag
);
2254 case Lisp_Misc_Save_Value
:
2255 strout ("#<save_value ", -1, -1, printcharfun
, 0);
2256 sprintf(buf
, "ptr=0x%08lx int=%d",
2257 (unsigned long) XSAVE_VALUE (obj
)->pointer
,
2258 XSAVE_VALUE (obj
)->integer
);
2259 strout (buf
, -1, -1, printcharfun
, 0);
2271 /* We're in trouble if this happens!
2272 Probably should just abort () */
2273 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun
, 0);
2275 sprintf (buf
, "(MISC 0x%04x)", (int) XMISCTYPE (obj
));
2276 else if (VECTORLIKEP (obj
))
2277 sprintf (buf
, "(PVEC 0x%08x)", (int) XVECTOR (obj
)->size
);
2279 sprintf (buf
, "(0x%02x)", (int) XTYPE (obj
));
2280 strout (buf
, -1, -1, printcharfun
, 0);
2281 strout (" Save your buffers immediately and please report this bug>",
2282 -1, -1, printcharfun
, 0);
2290 /* Print a description of INTERVAL using PRINTCHARFUN.
2291 This is part of printing a string that has text properties. */
2294 print_interval (interval
, printcharfun
)
2296 Lisp_Object printcharfun
;
2298 if (NILP (interval
->plist
))
2301 print_object (make_number (interval
->position
), printcharfun
, 1);
2303 print_object (make_number (interval
->position
+ LENGTH (interval
)),
2306 print_object (interval
->plist
, printcharfun
, 1);
2313 Qtemp_buffer_setup_hook
= intern ("temp-buffer-setup-hook");
2314 staticpro (&Qtemp_buffer_setup_hook
);
2316 DEFVAR_LISP ("standard-output", &Vstandard_output
,
2317 doc
: /* Output stream `print' uses by default for outputting a character.
2318 This may be any function of one argument.
2319 It may also be a buffer (output is inserted before point)
2320 or a marker (output is inserted and the marker is advanced)
2321 or the symbol t (output appears in the echo area). */);
2322 Vstandard_output
= Qt
;
2323 Qstandard_output
= intern ("standard-output");
2324 staticpro (&Qstandard_output
);
2326 DEFVAR_LISP ("float-output-format", &Vfloat_output_format
,
2327 doc
: /* The format descriptor string used to print floats.
2328 This is a %-spec like those accepted by `printf' in C,
2329 but with some restrictions. It must start with the two characters `%.'.
2330 After that comes an integer precision specification,
2331 and then a letter which controls the format.
2332 The letters allowed are `e', `f' and `g'.
2333 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"
2334 Use `f' for decimal point notation \"DIGITS.DIGITS\".
2335 Use `g' to choose the shorter of those two formats for the number at hand.
2336 The precision in any of these cases is the number of digits following
2337 the decimal point. With `f', a precision of 0 means to omit the
2338 decimal point. 0 is not allowed with `e' or `g'.
2340 A value of nil means to use the shortest notation
2341 that represents the number without losing information. */);
2342 Vfloat_output_format
= Qnil
;
2343 Qfloat_output_format
= intern ("float-output-format");
2344 staticpro (&Qfloat_output_format
);
2346 DEFVAR_LISP ("print-length", &Vprint_length
,
2347 doc
: /* Maximum length of list to print before abbreviating.
2348 A value of nil means no limit. See also `eval-expression-print-length'. */);
2349 Vprint_length
= Qnil
;
2351 DEFVAR_LISP ("print-level", &Vprint_level
,
2352 doc
: /* Maximum depth of list nesting to print before abbreviating.
2353 A value of nil means no limit. See also `eval-expression-print-level'. */);
2354 Vprint_level
= Qnil
;
2356 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines
,
2357 doc
: /* Non-nil means print newlines in strings as `\\n'.
2358 Also print formfeeds as `\\f'. */);
2359 print_escape_newlines
= 0;
2361 DEFVAR_BOOL ("print-escape-nonascii", &print_escape_nonascii
,
2362 doc
: /* Non-nil means print unibyte non-ASCII chars in strings as \\OOO.
2363 \(OOO is the octal representation of the character code.)
2364 Only single-byte characters are affected, and only in `prin1'.
2365 When the output goes in a multibyte buffer, this feature is
2366 enabled regardless of the value of the variable. */);
2367 print_escape_nonascii
= 0;
2369 DEFVAR_BOOL ("print-escape-multibyte", &print_escape_multibyte
,
2370 doc
: /* Non-nil means print multibyte characters in strings as \\xXXXX.
2371 \(XXXX is the hex representation of the character code.)
2372 This affects only `prin1'. */);
2373 print_escape_multibyte
= 0;
2375 DEFVAR_BOOL ("print-quoted", &print_quoted
,
2376 doc
: /* Non-nil means print quoted forms with reader syntax.
2377 I.e., (quote foo) prints as 'foo, (function foo) as #'foo, and backquoted
2378 forms print as in the new syntax. */);
2381 DEFVAR_LISP ("print-gensym", &Vprint_gensym
,
2382 doc
: /* Non-nil means print uninterned symbols so they will read as uninterned.
2383 I.e., the value of (make-symbol \"foobar\") prints as #:foobar.
2384 When the uninterned symbol appears within a recursive data structure,
2385 and the symbol appears more than once, in addition use the #N# and #N=
2386 constructs as needed, so that multiple references to the same symbol are
2387 shared once again when the text is read back. */);
2388 Vprint_gensym
= Qnil
;
2390 DEFVAR_LISP ("print-circle", &Vprint_circle
,
2391 doc
: /* *Non-nil means print recursive structures using #N= and #N# syntax.
2392 If nil, printing proceeds recursively and may lead to
2393 `max-lisp-eval-depth' being exceeded or an error may occur:
2394 \"Apparently circular structure being printed.\" Also see
2395 `print-length' and `print-level'.
2396 If non-nil, shared substructures anywhere in the structure are printed
2397 with `#N=' before the first occurrence (in the order of the print
2398 representation) and `#N#' in place of each subsequent occurrence,
2399 where N is a positive decimal integer. */);
2400 Vprint_circle
= Qnil
;
2402 DEFVAR_LISP ("print-continuous-numbering", &Vprint_continuous_numbering
,
2403 doc
: /* *Non-nil means number continuously across print calls.
2404 This affects the numbers printed for #N= labels and #M# references.
2405 See also `print-circle', `print-gensym', and `print-number-table'.
2406 This variable should not be set with `setq'; bind it with a `let' instead. */);
2407 Vprint_continuous_numbering
= Qnil
;
2409 DEFVAR_LISP ("print-number-table", &Vprint_number_table
,
2410 doc
: /* A vector used internally to produce `#N=' labels and `#N#' references.
2411 The Lisp printer uses this vector to detect Lisp objects referenced more
2414 When you bind `print-continuous-numbering' to t, you should probably
2415 also bind `print-number-table' to nil. This ensures that the value of
2416 `print-number-table' can be garbage-collected once the printing is
2417 done. If all elements of `print-number-table' are nil, it means that
2418 the printing done so far has not found any shared structure or objects
2419 that need to be recorded in the table. */);
2420 Vprint_number_table
= Qnil
;
2422 DEFVAR_LISP ("print-charset-text-property", &Vprint_charset_text_property
,
2423 doc
: /* A flag to control printing of `charset' text property on printing a string.
2424 The value must be nil, t, or `default'.
2426 If the value is nil, don't print the text property `charset'.
2428 If the value is t, always print the text property `charset'.
2430 If the value is `default', print the text property `charset' only when
2431 the value is different from what is guessed in the current charset
2433 Vprint_charset_text_property
= Qdefault
;
2435 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
2436 staticpro (&Vprin1_to_string_buffer
);
2439 defsubr (&Sprin1_to_string
);
2440 defsubr (&Serror_message_string
);
2444 defsubr (&Swrite_char
);
2445 defsubr (&Sexternal_debugging_output
);
2446 #ifdef WITH_REDIRECT_DEBUGGING_OUTPUT
2447 defsubr (&Sredirect_debugging_output
);
2450 Qexternal_debugging_output
= intern ("external-debugging-output");
2451 staticpro (&Qexternal_debugging_output
);
2453 Qprint_escape_newlines
= intern ("print-escape-newlines");
2454 staticpro (&Qprint_escape_newlines
);
2456 Qprint_escape_multibyte
= intern ("print-escape-multibyte");
2457 staticpro (&Qprint_escape_multibyte
);
2459 Qprint_escape_nonascii
= intern ("print-escape-nonascii");
2460 staticpro (&Qprint_escape_nonascii
);
2462 print_prune_charset_plist
= Qnil
;
2463 staticpro (&print_prune_charset_plist
);
2465 defsubr (&Swith_output_to_temp_buffer
);
2468 /* arch-tag: bc797170-94ae-41de-86e3-75e20f8f7a39
2469 (do not change this comment) */