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 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. */
371 strout (ptr
, size
, size_byte
, printcharfun
, multibyte
)
374 Lisp_Object printcharfun
;
378 size_byte
= size
= strlen (ptr
);
380 if (NILP (printcharfun
))
382 if (print_buffer_pos_byte
+ size_byte
> print_buffer_size
)
384 print_buffer_size
= print_buffer_size
* 2 + size_byte
;
385 print_buffer
= (char *) xrealloc (print_buffer
,
388 bcopy (ptr
, print_buffer
+ print_buffer_pos_byte
, size_byte
);
389 print_buffer_pos
+= size
;
390 print_buffer_pos_byte
+= size_byte
;
392 #ifdef MAX_PRINT_CHARS
395 #endif /* MAX_PRINT_CHARS */
397 else if (noninteractive
&& EQ (printcharfun
, Qt
))
399 fwrite (ptr
, 1, size_byte
, stdout
);
400 noninteractive_need_newline
= 1;
402 else if (EQ (printcharfun
, Qt
))
404 /* Output to echo area. We're trying to avoid a little overhead
405 here, that's the reason we don't call printchar to do the
409 = !NILP (current_buffer
->enable_multibyte_characters
);
411 setup_echo_area_for_printing (multibyte_p
);
412 message_dolog (ptr
, size_byte
, 0, multibyte_p
);
414 if (size
== size_byte
)
416 for (i
= 0; i
< size
; ++i
)
417 insert_char ((unsigned char )*ptr
++);
422 for (i
= 0; i
< size_byte
; i
+= len
)
424 int ch
= STRING_CHAR_AND_LENGTH (ptr
+ i
, size_byte
- i
, len
);
429 #ifdef MAX_PRINT_CHARS
432 #endif /* MAX_PRINT_CHARS */
436 /* PRINTCHARFUN is a Lisp function. */
439 if (size
== size_byte
)
441 while (i
< size_byte
)
449 while (i
< size_byte
)
451 /* Here, we must convert each multi-byte form to the
452 corresponding character code before handing it to
455 int ch
= STRING_CHAR_AND_LENGTH (ptr
+ i
, size_byte
- i
, len
);
463 /* Print the contents of a string STRING using PRINTCHARFUN.
464 It isn't safe to use strout in many cases,
465 because printing one char can relocate. */
468 print_string (string
, printcharfun
)
470 Lisp_Object printcharfun
;
472 if (EQ (printcharfun
, Qt
) || NILP (printcharfun
))
476 if (print_escape_nonascii
)
477 string
= string_escape_byte8 (string
);
479 if (STRING_MULTIBYTE (string
))
480 chars
= SCHARS (string
);
481 else if (! print_escape_nonascii
482 && (EQ (printcharfun
, Qt
)
483 ? ! NILP (buffer_defaults
.enable_multibyte_characters
)
484 : ! NILP (current_buffer
->enable_multibyte_characters
)))
486 /* If unibyte string STRING contains 8-bit codes, we must
487 convert STRING to a multibyte string containing the same
492 chars
= SBYTES (string
);
493 bytes
= parse_str_to_multibyte (SDATA (string
), chars
);
496 newstr
= make_uninit_multibyte_string (chars
, bytes
);
497 bcopy (SDATA (string
), SDATA (newstr
), chars
);
498 str_to_multibyte (SDATA (newstr
), bytes
, chars
);
503 chars
= SBYTES (string
);
505 /* strout is safe for output to a frame (echo area) or to print_buffer. */
506 strout (SDATA (string
),
507 chars
, SBYTES (string
),
508 printcharfun
, STRING_MULTIBYTE (string
));
512 /* Otherwise, string may be relocated by printing one char.
513 So re-fetch the string address for each character. */
515 int size
= SCHARS (string
);
516 int size_byte
= SBYTES (string
);
519 if (size
== size_byte
)
520 for (i
= 0; i
< size
; i
++)
521 PRINTCHAR (SREF (string
, i
));
523 for (i
= 0; i
< size_byte
; )
525 /* Here, we must convert each multi-byte form to the
526 corresponding character code before handing it to PRINTCHAR. */
528 int ch
= STRING_CHAR_AND_LENGTH (SDATA (string
) + i
,
537 DEFUN ("write-char", Fwrite_char
, Swrite_char
, 1, 2, 0,
538 doc
: /* Output character CHARACTER to stream PRINTCHARFUN.
539 PRINTCHARFUN defaults to the value of `standard-output' (which see). */)
540 (character
, printcharfun
)
541 Lisp_Object character
, printcharfun
;
545 if (NILP (printcharfun
))
546 printcharfun
= Vstandard_output
;
547 CHECK_NUMBER (character
);
549 PRINTCHAR (XINT (character
));
554 /* Used from outside of print.c to print a block of SIZE
555 single-byte chars at DATA on the default output stream.
556 Do not use this on the contents of a Lisp string. */
559 write_string (data
, size
)
564 Lisp_Object printcharfun
;
566 printcharfun
= Vstandard_output
;
569 strout (data
, size
, size
, printcharfun
, 0);
573 /* Used from outside of print.c to print a block of SIZE
574 single-byte chars at DATA on a specified stream PRINTCHARFUN.
575 Do not use this on the contents of a Lisp string. */
578 write_string_1 (data
, size
, printcharfun
)
581 Lisp_Object printcharfun
;
586 strout (data
, size
, size
, printcharfun
, 0);
592 temp_output_buffer_setup (bufname
)
595 int count
= SPECPDL_INDEX ();
596 register struct buffer
*old
= current_buffer
;
597 register Lisp_Object buf
;
599 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
601 Fset_buffer (Fget_buffer_create (build_string (bufname
)));
603 Fkill_all_local_variables ();
604 delete_all_overlays (current_buffer
);
605 current_buffer
->directory
= old
->directory
;
606 current_buffer
->read_only
= Qnil
;
607 current_buffer
->filename
= Qnil
;
608 current_buffer
->undo_list
= Qt
;
609 eassert (current_buffer
->overlays_before
== NULL
);
610 eassert (current_buffer
->overlays_after
== NULL
);
611 current_buffer
->enable_multibyte_characters
612 = buffer_defaults
.enable_multibyte_characters
;
613 specbind (Qinhibit_read_only
, Qt
);
614 specbind (Qinhibit_modification_hooks
, Qt
);
616 XSETBUFFER (buf
, current_buffer
);
618 Frun_hooks (1, &Qtemp_buffer_setup_hook
);
620 unbind_to (count
, Qnil
);
622 specbind (Qstandard_output
, buf
);
626 internal_with_output_to_temp_buffer (bufname
, function
, args
)
628 Lisp_Object (*function
) P_ ((Lisp_Object
));
631 int count
= SPECPDL_INDEX ();
632 Lisp_Object buf
, val
;
636 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
637 temp_output_buffer_setup (bufname
);
638 buf
= Vstandard_output
;
641 val
= (*function
) (args
);
644 temp_output_buffer_show (buf
);
647 return unbind_to (count
, val
);
650 DEFUN ("with-output-to-temp-buffer",
651 Fwith_output_to_temp_buffer
, Swith_output_to_temp_buffer
,
653 doc
: /* Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
654 The buffer is cleared out initially, and marked as unmodified when done.
655 All output done by BODY is inserted in that buffer by default.
656 The buffer is displayed in another window, but not selected.
657 The value of the last form in BODY is returned.
658 If BODY does not finish normally, the buffer BUFNAME is not displayed.
660 The hook `temp-buffer-setup-hook' is run before BODY,
661 with the buffer BUFNAME temporarily current.
662 The hook `temp-buffer-show-hook' is run after the buffer is displayed,
663 with the buffer temporarily current, and the window that was used
664 to display it temporarily selected.
666 If variable `temp-buffer-show-function' is non-nil, call it at the end
667 to get the buffer displayed instead of just displaying the non-selected
668 buffer and calling the hook. It gets one argument, the buffer to display.
670 usage: (with-output-to-temp-buffer BUFNAME BODY ...) */)
676 int count
= SPECPDL_INDEX ();
677 Lisp_Object buf
, val
;
680 name
= Feval (Fcar (args
));
682 temp_output_buffer_setup (SDATA (name
));
683 buf
= Vstandard_output
;
686 val
= Fprogn (XCDR (args
));
689 temp_output_buffer_show (buf
);
692 return unbind_to (count
, val
);
696 static void print ();
697 static void print_preprocess ();
698 static void print_preprocess_string ();
699 static void print_object ();
701 DEFUN ("terpri", Fterpri
, Sterpri
, 0, 1, 0,
702 doc
: /* Output a newline to stream PRINTCHARFUN.
703 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used. */)
705 Lisp_Object printcharfun
;
709 if (NILP (printcharfun
))
710 printcharfun
= Vstandard_output
;
717 DEFUN ("prin1", Fprin1
, Sprin1
, 1, 2, 0,
718 doc
: /* Output the printed representation of OBJECT, any Lisp object.
719 Quoting characters are printed when needed to make output that `read'
720 can handle, whenever this is possible. For complex objects, the behavior
721 is controlled by `print-level' and `print-length', which see.
723 OBJECT is any of the Lisp data types: a number, a string, a symbol,
724 a list, a buffer, a window, a frame, etc.
726 A printed representation of an object is text which describes that object.
728 Optional argument PRINTCHARFUN is the output stream, which can be one
731 - a buffer, in which case output is inserted into that buffer at point;
732 - a marker, in which case output is inserted at marker's position;
733 - a function, in which case that function is called once for each
734 character of OBJECT's printed representation;
735 - a symbol, in which case that symbol's function definition is called; or
736 - t, in which case the output is displayed in the echo area.
738 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
740 (object
, printcharfun
)
741 Lisp_Object object
, printcharfun
;
745 #ifdef MAX_PRINT_CHARS
747 #endif /* MAX_PRINT_CHARS */
748 if (NILP (printcharfun
))
749 printcharfun
= Vstandard_output
;
751 print (object
, printcharfun
, 1);
756 /* a buffer which is used to hold output being built by prin1-to-string */
757 Lisp_Object Vprin1_to_string_buffer
;
759 DEFUN ("prin1-to-string", Fprin1_to_string
, Sprin1_to_string
, 1, 2, 0,
760 doc
: /* Return a string containing the printed representation of OBJECT.
761 OBJECT can be any Lisp object. This function outputs quoting characters
762 when necessary to make output that `read' can handle, whenever possible,
763 unless the optional second argument NOESCAPE is non-nil. For complex objects,
764 the behavior is controlled by `print-level' and `print-length', which see.
766 OBJECT is any of the Lisp data types: a number, a string, a symbol,
767 a list, a buffer, a window, a frame, etc.
769 A printed representation of an object is text which describes that object. */)
771 Lisp_Object object
, noescape
;
773 Lisp_Object printcharfun
;
774 /* struct gcpro gcpro1, gcpro2; */
775 Lisp_Object save_deactivate_mark
;
776 int count
= specpdl_ptr
- specpdl
;
777 struct buffer
*previous
;
779 specbind (Qinhibit_modification_hooks
, Qt
);
784 /* Save and restore this--we are altering a buffer
785 but we don't want to deactivate the mark just for that.
786 No need for specbind, since errors deactivate the mark. */
787 save_deactivate_mark
= Vdeactivate_mark
;
788 /* GCPRO2 (object, save_deactivate_mark); */
791 printcharfun
= Vprin1_to_string_buffer
;
793 print (object
, printcharfun
, NILP (noescape
));
794 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
798 previous
= current_buffer
;
799 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
800 object
= Fbuffer_string ();
801 if (SBYTES (object
) == SCHARS (object
))
802 STRING_SET_UNIBYTE (object
);
804 /* Note that this won't make prepare_to_modify_buffer call
805 ask-user-about-supersession-threat because this buffer
806 does not visit a file. */
808 set_buffer_internal (previous
);
810 Vdeactivate_mark
= save_deactivate_mark
;
814 return unbind_to (count
, object
);
817 DEFUN ("princ", Fprinc
, Sprinc
, 1, 2, 0,
818 doc
: /* Output the printed representation of OBJECT, any Lisp object.
819 No quoting characters are used; no delimiters are printed around
820 the contents of strings.
822 OBJECT is any of the Lisp data types: a number, a string, a symbol,
823 a list, a buffer, a window, a frame, etc.
825 A printed representation of an object is text which describes that object.
827 Optional argument PRINTCHARFUN is the output stream, which can be one
830 - a buffer, in which case output is inserted into that buffer at point;
831 - a marker, in which case output is inserted at marker's position;
832 - a function, in which case that function is called once for each
833 character of OBJECT's printed representation;
834 - a symbol, in which case that symbol's function definition is called; or
835 - t, in which case the output is displayed in the echo area.
837 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
839 (object
, printcharfun
)
840 Lisp_Object object
, printcharfun
;
844 if (NILP (printcharfun
))
845 printcharfun
= Vstandard_output
;
847 print (object
, printcharfun
, 0);
852 DEFUN ("print", Fprint
, Sprint
, 1, 2, 0,
853 doc
: /* Output the printed representation of OBJECT, with newlines around it.
854 Quoting characters are printed when needed to make output that `read'
855 can handle, whenever this is possible. For complex objects, the behavior
856 is controlled by `print-level' and `print-length', which see.
858 OBJECT is any of the Lisp data types: a number, a string, a symbol,
859 a list, a buffer, a window, a frame, etc.
861 A printed representation of an object is text which describes that object.
863 Optional argument PRINTCHARFUN is the output stream, which can be one
866 - a buffer, in which case output is inserted into that buffer at point;
867 - a marker, in which case output is inserted at marker's position;
868 - a function, in which case that function is called once for each
869 character of OBJECT's printed representation;
870 - a symbol, in which case that symbol's function definition is called; or
871 - t, in which case the output is displayed in the echo area.
873 If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
875 (object
, printcharfun
)
876 Lisp_Object object
, printcharfun
;
881 #ifdef MAX_PRINT_CHARS
883 max_print
= MAX_PRINT_CHARS
;
884 #endif /* MAX_PRINT_CHARS */
885 if (NILP (printcharfun
))
886 printcharfun
= Vstandard_output
;
890 print (object
, printcharfun
, 1);
893 #ifdef MAX_PRINT_CHARS
896 #endif /* MAX_PRINT_CHARS */
901 /* The subroutine object for external-debugging-output is kept here
902 for the convenience of the debugger. */
903 Lisp_Object Qexternal_debugging_output
;
905 DEFUN ("external-debugging-output", Fexternal_debugging_output
, Sexternal_debugging_output
, 1, 1, 0,
906 doc
: /* Write CHARACTER to stderr.
907 You can call print while debugging emacs, and pass it this function
908 to make it write to the debugging output. */)
910 Lisp_Object character
;
912 CHECK_NUMBER (character
);
913 putc (XINT (character
), stderr
);
916 /* Send the output to a debugger (nothing happens if there isn't one). */
917 if (print_output_debug_flag
)
919 char buf
[2] = {(char) XINT (character
), '\0'};
920 OutputDebugString (buf
);
928 #if defined(GNU_LINUX)
930 /* This functionality is not vitally important in general, so we rely on
931 non-portable ability to use stderr as lvalue. */
933 #define WITH_REDIRECT_DEBUGGING_OUTPUT 1
935 FILE *initial_stderr_stream
= NULL
;
937 DEFUN ("redirect-debugging-output", Fredirect_debugging_output
, Sredirect_debugging_output
,
939 "FDebug output file: \nP",
940 doc
: /* Redirect debugging output (stderr stream) to file FILE.
941 If FILE is nil, reset target to the initial stderr stream.
942 Optional arg APPEND non-nil (interactively, with prefix arg) means
943 append to existing target file. */)
945 Lisp_Object file
, append
;
947 if (initial_stderr_stream
!= NULL
)
949 stderr
= initial_stderr_stream
;
950 initial_stderr_stream
= NULL
;
954 file
= Fexpand_file_name (file
, Qnil
);
955 initial_stderr_stream
= stderr
;
956 stderr
= fopen(SDATA (file
), NILP (append
) ? "w" : "a");
959 stderr
= initial_stderr_stream
;
960 initial_stderr_stream
= NULL
;
961 report_file_error ("Cannot open debugging output stream",
967 #endif /* GNU_LINUX */
970 /* This is the interface for debugging printing. */
976 Fprin1 (arg
, Qexternal_debugging_output
);
977 fprintf (stderr
, "\r\n");
981 safe_debug_print (arg
)
984 int valid
= valid_lisp_object_p (arg
);
989 fprintf (stderr
, "#<%s_LISP_OBJECT 0x%08lx>\r\n",
990 !valid
? "INVALID" : "SOME",
994 (unsigned long) arg
.i
1000 DEFUN ("error-message-string", Ferror_message_string
, Serror_message_string
,
1002 doc
: /* Convert an error value (ERROR-SYMBOL . DATA) to an error message.
1003 See Info anchor `(elisp)Definition of signal' for some details on how this
1004 error message is constructed. */)
1008 struct buffer
*old
= current_buffer
;
1010 struct gcpro gcpro1
;
1012 /* If OBJ is (error STRING), just return STRING.
1013 That is not only faster, it also avoids the need to allocate
1014 space here when the error is due to memory full. */
1015 if (CONSP (obj
) && EQ (XCAR (obj
), Qerror
)
1016 && CONSP (XCDR (obj
))
1017 && STRINGP (XCAR (XCDR (obj
)))
1018 && NILP (XCDR (XCDR (obj
))))
1019 return XCAR (XCDR (obj
));
1021 print_error_message (obj
, Vprin1_to_string_buffer
, 0, Qnil
);
1023 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
1024 value
= Fbuffer_string ();
1028 set_buffer_internal (old
);
1034 /* Print an error message for the error DATA onto Lisp output stream
1035 STREAM (suitable for the print functions). */
1038 print_error_message (data
, stream
, context
, caller
)
1039 Lisp_Object data
, stream
;
1043 Lisp_Object errname
, errmsg
, file_error
, tail
;
1044 struct gcpro gcpro1
;
1048 write_string_1 (context
, -1, stream
);
1050 /* If we know from where the error was signaled, show it in
1052 if (!NILP (caller
) && SYMBOLP (caller
))
1054 Lisp_Object cname
= SYMBOL_NAME (caller
);
1055 char *name
= alloca (SBYTES (cname
));
1056 bcopy (SDATA (cname
), name
, SBYTES (cname
));
1057 message_dolog (name
, SBYTES (cname
), 0, 0);
1058 message_dolog (": ", 2, 0, 0);
1061 errname
= Fcar (data
);
1063 if (EQ (errname
, Qerror
))
1068 errmsg
= Fcar (data
);
1073 Lisp_Object error_conditions
;
1074 errmsg
= Fget (errname
, Qerror_message
);
1075 error_conditions
= Fget (errname
, Qerror_conditions
);
1076 file_error
= Fmemq (Qfile_error
, error_conditions
);
1079 /* Print an error message including the data items. */
1081 tail
= Fcdr_safe (data
);
1084 /* For file-error, make error message by concatenating
1085 all the data items. They are all strings. */
1086 if (!NILP (file_error
) && CONSP (tail
))
1087 errmsg
= XCAR (tail
), tail
= XCDR (tail
);
1089 if (STRINGP (errmsg
))
1090 Fprinc (errmsg
, stream
);
1092 write_string_1 ("peculiar error", -1, stream
);
1094 for (i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
1098 write_string_1 (i
? ", " : ": ", 2, stream
);
1100 if (!NILP (file_error
) || EQ (errname
, Qend_of_file
))
1101 Fprinc (obj
, stream
);
1103 Fprin1 (obj
, stream
);
1112 * The buffer should be at least as large as the max string size of the
1113 * largest float, printed in the biggest notation. This is undoubtedly
1114 * 20d float_output_format, with the negative of the C-constant "HUGE"
1117 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
1119 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
1120 * case of -1e307 in 20d float_output_format. What is one to do (short of
1121 * re-writing _doprnt to be more sane)?
1126 float_to_string (buf
, data
)
1133 /* Check for plus infinity in a way that won't lose
1134 if there is no plus infinity. */
1135 if (data
== data
/ 2 && data
> 1.0)
1137 strcpy (buf
, "1.0e+INF");
1140 /* Likewise for minus infinity. */
1141 if (data
== data
/ 2 && data
< -1.0)
1143 strcpy (buf
, "-1.0e+INF");
1146 /* Check for NaN in a way that won't fail if there are no NaNs. */
1147 if (! (data
* 0.0 >= 0.0))
1149 /* Prepend "-" if the NaN's sign bit is negative.
1150 The sign bit of a double is the bit that is 1 in -0.0. */
1152 union { double d
; char c
[sizeof (double)]; } u_data
, u_minus_zero
;
1154 u_minus_zero
.d
= - 0.0;
1155 for (i
= 0; i
< sizeof (double); i
++)
1156 if (u_data
.c
[i
] & u_minus_zero
.c
[i
])
1162 strcpy (buf
, "0.0e+NaN");
1166 if (NILP (Vfloat_output_format
)
1167 || !STRINGP (Vfloat_output_format
))
1170 /* Generate the fewest number of digits that represent the
1171 floating point value without losing information.
1172 The following method is simple but a bit slow.
1173 For ideas about speeding things up, please see:
1175 Guy L Steele Jr & Jon L White, How to print floating-point numbers
1176 accurately. SIGPLAN notices 25, 6 (June 1990), 112-126.
1178 Robert G Burger & R Kent Dybvig, Printing floating point numbers
1179 quickly and accurately, SIGPLAN notices 31, 5 (May 1996), 108-116. */
1181 width
= fabs (data
) < DBL_MIN
? 1 : DBL_DIG
;
1183 sprintf (buf
, "%.*g", width
, data
);
1184 while (width
++ < DOUBLE_DIGITS_BOUND
&& atof (buf
) != data
);
1186 else /* oink oink */
1188 /* Check that the spec we have is fully valid.
1189 This means not only valid for printf,
1190 but meant for floats, and reasonable. */
1191 cp
= SDATA (Vfloat_output_format
);
1200 /* Check the width specification. */
1202 if ('0' <= *cp
&& *cp
<= '9')
1206 width
= (width
* 10) + (*cp
++ - '0');
1207 while (*cp
>= '0' && *cp
<= '9');
1209 /* A precision of zero is valid only for %f. */
1211 || (width
== 0 && *cp
!= 'f'))
1215 if (*cp
!= 'e' && *cp
!= 'f' && *cp
!= 'g')
1221 sprintf (buf
, SDATA (Vfloat_output_format
), data
);
1224 /* Make sure there is a decimal point with digit after, or an
1225 exponent, so that the value is readable as a float. But don't do
1226 this with "%.0f"; it's valid for that not to produce a decimal
1227 point. Note that width can be 0 only for %.0f. */
1230 for (cp
= buf
; *cp
; cp
++)
1231 if ((*cp
< '0' || *cp
> '9') && *cp
!= '-')
1234 if (*cp
== '.' && cp
[1] == 0)
1251 print (obj
, printcharfun
, escapeflag
)
1253 register Lisp_Object printcharfun
;
1256 old_backquote_output
= 0;
1258 /* Reset print_number_index and Vprint_number_table only when
1259 the variable Vprint_continuous_numbering is nil. Otherwise,
1260 the values of these variables will be kept between several
1262 if (NILP (Vprint_continuous_numbering
))
1264 print_number_index
= 0;
1265 Vprint_number_table
= Qnil
;
1268 /* Construct Vprint_number_table for print-gensym and print-circle. */
1269 if (!NILP (Vprint_gensym
) || !NILP (Vprint_circle
))
1271 int i
, start
, index
;
1272 start
= index
= print_number_index
;
1273 /* Construct Vprint_number_table.
1274 This increments print_number_index for the objects added. */
1276 print_preprocess (obj
);
1278 /* Remove unnecessary objects, which appear only once in OBJ;
1279 that is, whose status is Qnil. Compactify the necessary objects. */
1280 for (i
= start
; i
< print_number_index
; i
++)
1281 if (!NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1283 PRINT_NUMBER_OBJECT (Vprint_number_table
, index
)
1284 = PRINT_NUMBER_OBJECT (Vprint_number_table
, i
);
1288 /* Clear out objects outside the active part of the table. */
1289 for (i
= index
; i
< print_number_index
; i
++)
1290 PRINT_NUMBER_OBJECT (Vprint_number_table
, i
) = Qnil
;
1292 /* Reset the status field for the next print step. Now this
1293 field means whether the object has already been printed. */
1294 for (i
= start
; i
< print_number_index
; i
++)
1295 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qnil
;
1297 print_number_index
= index
;
1301 print_object (obj
, printcharfun
, escapeflag
);
1304 /* Construct Vprint_number_table according to the structure of OBJ.
1305 OBJ itself and all its elements will be added to Vprint_number_table
1306 recursively if it is a list, vector, compiled function, char-table,
1307 string (its text properties will be traced), or a symbol that has
1308 no obarray (this is for the print-gensym feature).
1309 The status fields of Vprint_number_table mean whether each object appears
1310 more than once in OBJ: Qnil at the first time, and Qt after that . */
1312 print_preprocess (obj
)
1318 Lisp_Object halftail
;
1320 /* Give up if we go so deep that print_object will get an error. */
1321 /* See similar code in print_object. */
1322 if (print_depth
>= PRINT_CIRCLE
)
1323 error ("Apparently circular structure being printed");
1325 /* Avoid infinite recursion for circular nested structure
1326 in the case where Vprint_circle is nil. */
1327 if (NILP (Vprint_circle
))
1329 for (i
= 0; i
< print_depth
; i
++)
1330 if (EQ (obj
, being_printed
[i
]))
1332 being_printed
[print_depth
] = obj
;
1339 if (STRINGP (obj
) || CONSP (obj
) || VECTORP (obj
)
1340 || COMPILEDP (obj
) || CHAR_TABLE_P (obj
)
1341 || (! NILP (Vprint_gensym
)
1343 && !SYMBOL_INTERNED_P (obj
)))
1345 /* In case print-circle is nil and print-gensym is t,
1346 add OBJ to Vprint_number_table only when OBJ is a symbol. */
1347 if (! NILP (Vprint_circle
) || SYMBOLP (obj
))
1349 for (i
= 0; i
< print_number_index
; i
++)
1350 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
), obj
))
1352 /* OBJ appears more than once. Let's remember that. */
1353 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qt
;
1358 /* OBJ is not yet recorded. Let's add to the table. */
1359 if (print_number_index
== 0)
1361 /* Initialize the table. */
1362 Vprint_number_table
= Fmake_vector (make_number (40), Qnil
);
1364 else if (XVECTOR (Vprint_number_table
)->size
== print_number_index
* 2)
1366 /* Reallocate the table. */
1367 int i
= print_number_index
* 4;
1368 Lisp_Object old_table
= Vprint_number_table
;
1369 Vprint_number_table
= Fmake_vector (make_number (i
), Qnil
);
1370 for (i
= 0; i
< print_number_index
; i
++)
1372 PRINT_NUMBER_OBJECT (Vprint_number_table
, i
)
1373 = PRINT_NUMBER_OBJECT (old_table
, i
);
1374 PRINT_NUMBER_STATUS (Vprint_number_table
, i
)
1375 = PRINT_NUMBER_STATUS (old_table
, i
);
1378 PRINT_NUMBER_OBJECT (Vprint_number_table
, print_number_index
) = obj
;
1379 /* If Vprint_continuous_numbering is non-nil and OBJ is a gensym,
1380 always print the gensym with a number. This is a special for
1381 the lisp function byte-compile-output-docform. */
1382 if (!NILP (Vprint_continuous_numbering
)
1384 && !SYMBOL_INTERNED_P (obj
))
1385 PRINT_NUMBER_STATUS (Vprint_number_table
, print_number_index
) = Qt
;
1386 print_number_index
++;
1389 switch (XGCTYPE (obj
))
1392 /* A string may have text properties, which can be circular. */
1393 traverse_intervals_noorder (STRING_INTERVALS (obj
),
1394 print_preprocess_string
, Qnil
);
1398 /* Use HALFTAIL and LOOP_COUNT to detect circular lists,
1399 just as in print_object. */
1400 if (loop_count
&& EQ (obj
, halftail
))
1402 print_preprocess (XCAR (obj
));
1405 if (!(loop_count
& 1))
1406 halftail
= XCDR (halftail
);
1409 case Lisp_Vectorlike
:
1410 size
= XVECTOR (obj
)->size
;
1411 if (size
& PSEUDOVECTOR_FLAG
)
1412 size
&= PSEUDOVECTOR_SIZE_MASK
;
1413 for (i
= 0; i
< size
; i
++)
1414 print_preprocess (XVECTOR (obj
)->contents
[i
]);
1425 print_preprocess_string (interval
, arg
)
1429 print_preprocess (interval
->plist
);
1432 /* A flag to control printing of `charset' text property.
1433 The default value is Qdefault. */
1434 Lisp_Object Vprint_charset_text_property
;
1435 extern Lisp_Object Qdefault
;
1437 static void print_check_string_charset_prop ();
1439 #define PRINT_STRING_NON_CHARSET_FOUND 1
1440 #define PRINT_STRING_UNSAFE_CHARSET_FOUND 2
1442 /* Bitwize or of the abobe macros. */
1443 static int print_check_string_result
;
1446 print_check_string_charset_prop (interval
, string
)
1452 if (NILP (interval
->plist
)
1453 || (print_check_string_result
== (PRINT_STRING_NON_CHARSET_FOUND
1454 | PRINT_STRING_UNSAFE_CHARSET_FOUND
)))
1456 for (val
= interval
->plist
; CONSP (val
) && ! EQ (XCAR (val
), Qcharset
);
1457 val
= XCDR (XCDR (val
)));
1460 print_check_string_result
|= PRINT_STRING_NON_CHARSET_FOUND
;
1463 if (! (print_check_string_result
& PRINT_STRING_NON_CHARSET_FOUND
))
1465 if (! EQ (val
, interval
->plist
)
1466 || CONSP (XCDR (XCDR (val
))))
1467 print_check_string_result
|= PRINT_STRING_NON_CHARSET_FOUND
;
1469 if (NILP (Vprint_charset_text_property
)
1470 || ! (print_check_string_result
& PRINT_STRING_UNSAFE_CHARSET_FOUND
))
1473 int charpos
= interval
->position
;
1474 int bytepos
= string_char_to_byte (string
, charpos
);
1475 Lisp_Object charset
;
1477 charset
= XCAR (XCDR (val
));
1478 for (i
= 0; i
< LENGTH (interval
); i
++)
1480 FETCH_STRING_CHAR_ADVANCE (c
, string
, charpos
, bytepos
);
1481 if (! ASCII_CHAR_P (c
)
1482 && ! EQ (CHARSET_NAME (CHAR_CHARSET (c
)), charset
))
1484 print_check_string_result
|= PRINT_STRING_UNSAFE_CHARSET_FOUND
;
1491 /* The value is (charset . nil). */
1492 static Lisp_Object print_prune_charset_plist
;
1495 print_prune_string_charset (string
)
1498 print_check_string_result
= 0;
1499 traverse_intervals (STRING_INTERVALS (string
), 0,
1500 print_check_string_charset_prop
, string
);
1501 if (! (print_check_string_result
& PRINT_STRING_UNSAFE_CHARSET_FOUND
))
1503 string
= Fcopy_sequence (string
);
1504 if (print_check_string_result
& PRINT_STRING_NON_CHARSET_FOUND
)
1506 if (NILP (print_prune_charset_plist
))
1507 print_prune_charset_plist
= Fcons (Qcharset
, Qnil
);
1508 Fremove_text_properties (make_number (0),
1509 make_number (SCHARS (string
)),
1510 print_prune_charset_plist
, string
);
1513 Fset_text_properties (make_number (0), make_number (SCHARS (string
)),
1520 print_object (obj
, printcharfun
, escapeflag
)
1522 register Lisp_Object printcharfun
;
1529 /* Detect circularities and truncate them. */
1530 if (STRINGP (obj
) || CONSP (obj
) || VECTORP (obj
)
1531 || COMPILEDP (obj
) || CHAR_TABLE_P (obj
) || SUB_CHAR_TABLE_P (obj
)
1532 || (! NILP (Vprint_gensym
)
1534 && !SYMBOL_INTERNED_P (obj
)))
1536 if (NILP (Vprint_circle
) && NILP (Vprint_gensym
))
1538 /* Simple but incomplete way. */
1540 for (i
= 0; i
< print_depth
; i
++)
1541 if (EQ (obj
, being_printed
[i
]))
1543 sprintf (buf
, "#%d", i
);
1544 strout (buf
, -1, -1, printcharfun
, 0);
1547 being_printed
[print_depth
] = obj
;
1551 /* With the print-circle feature. */
1553 for (i
= 0; i
< print_number_index
; i
++)
1554 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
), obj
))
1556 if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1558 /* Add a prefix #n= if OBJ has not yet been printed;
1559 that is, its status field is nil. */
1560 sprintf (buf
, "#%d=", i
+ 1);
1561 strout (buf
, -1, -1, printcharfun
, 0);
1562 /* OBJ is going to be printed. Set the status to t. */
1563 PRINT_NUMBER_STATUS (Vprint_number_table
, i
) = Qt
;
1568 /* Just print #n# if OBJ has already been printed. */
1569 sprintf (buf
, "#%d#", i
+ 1);
1570 strout (buf
, -1, -1, printcharfun
, 0);
1579 /* See similar code in print_preprocess. */
1580 if (print_depth
> PRINT_CIRCLE
)
1581 error ("Apparently circular structure being printed");
1582 #ifdef MAX_PRINT_CHARS
1583 if (max_print
&& print_chars
> max_print
)
1588 #endif /* MAX_PRINT_CHARS */
1590 switch (XGCTYPE (obj
))
1593 if (sizeof (int) == sizeof (EMACS_INT
))
1594 sprintf (buf
, "%d", XINT (obj
));
1595 else if (sizeof (long) == sizeof (EMACS_INT
))
1596 sprintf (buf
, "%ld", (long) XINT (obj
));
1599 strout (buf
, -1, -1, printcharfun
, 0);
1604 char pigbuf
[350]; /* see comments in float_to_string */
1606 float_to_string (pigbuf
, XFLOAT_DATA (obj
));
1607 strout (pigbuf
, -1, -1, printcharfun
, 0);
1613 print_string (obj
, printcharfun
);
1616 register int i
, i_byte
;
1617 struct gcpro gcpro1
;
1620 /* 1 means we must ensure that the next character we output
1621 cannot be taken as part of a hex character escape. */
1622 int need_nonhex
= 0;
1623 int multibyte
= STRING_MULTIBYTE (obj
);
1627 if (! EQ (Vprint_charset_text_property
, Qt
))
1628 obj
= print_prune_string_charset (obj
);
1630 if (!NULL_INTERVAL_P (STRING_INTERVALS (obj
)))
1638 size_byte
= SBYTES (obj
);
1640 for (i
= 0, i_byte
= 0; i_byte
< size_byte
;)
1642 /* Here, we must convert each multi-byte form to the
1643 corresponding character code before handing it to PRINTCHAR. */
1649 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
,
1650 size_byte
- i_byte
, len
);
1658 if (c
== '\n' && print_escape_newlines
)
1663 else if (c
== '\f' && print_escape_newlines
)
1669 && (CHAR_BYTE8_P (c
)
1670 || (! ASCII_CHAR_P (c
) && print_escape_multibyte
)))
1672 /* When multibyte is disabled,
1673 print multibyte string chars using hex escapes.
1674 For a char code that could be in a unibyte string,
1675 when found in a multibyte string, always use a hex escape
1676 so it reads back as multibyte. */
1677 unsigned char outbuf
[50];
1679 if (CHAR_BYTE8_P (c
))
1680 sprintf (outbuf
, "\\%03o", CHAR_TO_BYTE8 (c
));
1683 sprintf (outbuf
, "\\x%04x", c
);
1686 strout (outbuf
, -1, -1, printcharfun
, 0);
1688 else if (! multibyte
1689 && SINGLE_BYTE_CHAR_P (c
) && ! ASCII_BYTE_P (c
)
1690 && print_escape_nonascii
)
1692 /* When printing in a multibyte buffer
1693 or when explicitly requested,
1694 print single-byte non-ASCII string chars
1695 using octal escapes. */
1696 unsigned char outbuf
[5];
1697 sprintf (outbuf
, "\\%03o", c
);
1698 strout (outbuf
, -1, -1, printcharfun
, 0);
1702 /* If we just had a hex escape, and this character
1703 could be taken as part of it,
1704 output `\ ' to prevent that. */
1708 if ((c
>= 'a' && c
<= 'f')
1709 || (c
>= 'A' && c
<= 'F')
1710 || (c
>= '0' && c
<= '9'))
1711 strout ("\\ ", -1, -1, printcharfun
, 0);
1714 if (c
== '\"' || c
== '\\')
1721 if (!NULL_INTERVAL_P (STRING_INTERVALS (obj
)))
1723 traverse_intervals (STRING_INTERVALS (obj
),
1724 0, print_interval
, printcharfun
);
1734 register int confusing
;
1735 register unsigned char *p
= SDATA (SYMBOL_NAME (obj
));
1736 register unsigned char *end
= p
+ SBYTES (SYMBOL_NAME (obj
));
1738 int i
, i_byte
, size_byte
;
1741 name
= SYMBOL_NAME (obj
);
1743 if (p
!= end
&& (*p
== '-' || *p
== '+')) p
++;
1746 /* If symbol name begins with a digit, and ends with a digit,
1747 and contains nothing but digits and `e', it could be treated
1748 as a number. So set CONFUSING.
1750 Symbols that contain periods could also be taken as numbers,
1751 but periods are always escaped, so we don't have to worry
1753 else if (*p
>= '0' && *p
<= '9'
1754 && end
[-1] >= '0' && end
[-1] <= '9')
1756 while (p
!= end
&& ((*p
>= '0' && *p
<= '9')
1757 /* Needed for \2e10. */
1760 confusing
= (end
== p
);
1765 if (! NILP (Vprint_gensym
) && !SYMBOL_INTERNED_P (obj
))
1771 size_byte
= SBYTES (name
);
1773 for (i
= 0, i_byte
= 0; i_byte
< size_byte
;)
1775 /* Here, we must convert each multi-byte form to the
1776 corresponding character code before handing it to PRINTCHAR. */
1777 FETCH_STRING_CHAR_ADVANCE (c
, name
, i
, i_byte
);
1782 if (c
== '\"' || c
== '\\' || c
== '\''
1783 || c
== ';' || c
== '#' || c
== '(' || c
== ')'
1784 || c
== ',' || c
=='.' || c
== '`'
1785 || c
== '[' || c
== ']' || c
== '?' || c
<= 040
1787 PRINTCHAR ('\\'), confusing
= 0;
1795 /* If deeper than spec'd depth, print placeholder. */
1796 if (INTEGERP (Vprint_level
)
1797 && print_depth
> XINT (Vprint_level
))
1798 strout ("...", -1, -1, printcharfun
, 0);
1799 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1800 && (EQ (XCAR (obj
), Qquote
)))
1803 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1805 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1806 && (EQ (XCAR (obj
), Qfunction
)))
1810 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1812 else if (print_quoted
&& CONSP (XCDR (obj
)) && NILP (XCDR (XCDR (obj
)))
1813 && ! old_backquote_output
1814 && ((EQ (XCAR (obj
), Qbackquote
)
1815 || EQ (XCAR (obj
), Qcomma
)
1816 || EQ (XCAR (obj
), Qcomma_at
)
1817 || EQ (XCAR (obj
), Qcomma_dot
))))
1819 print_object (XCAR (obj
), printcharfun
, 0);
1820 print_object (XCAR (XCDR (obj
)), printcharfun
, escapeflag
);
1826 /* If the first element is a backquote form,
1827 print it old-style so it won't be misunderstood. */
1828 if (print_quoted
&& CONSP (XCAR (obj
))
1829 && CONSP (XCDR (XCAR (obj
)))
1830 && NILP (XCDR (XCDR (XCAR (obj
))))
1831 && EQ (XCAR (XCAR (obj
)), Qbackquote
))
1837 print_object (Qbackquote
, printcharfun
, 0);
1840 ++old_backquote_output
;
1841 print_object (XCAR (XCDR (tem
)), printcharfun
, 0);
1842 --old_backquote_output
;
1849 int print_length
, i
;
1850 Lisp_Object halftail
= obj
;
1852 /* Negative values of print-length are invalid in CL.
1853 Treat them like nil, as CMUCL does. */
1854 if (NATNUMP (Vprint_length
))
1855 print_length
= XFASTINT (Vprint_length
);
1862 /* Detect circular list. */
1863 if (NILP (Vprint_circle
))
1865 /* Simple but imcomplete way. */
1866 if (i
!= 0 && EQ (obj
, halftail
))
1868 sprintf (buf
, " . #%d", i
/ 2);
1869 strout (buf
, -1, -1, printcharfun
, 0);
1875 /* With the print-circle feature. */
1879 for (i
= 0; i
< print_number_index
; i
++)
1880 if (EQ (PRINT_NUMBER_OBJECT (Vprint_number_table
, i
),
1883 if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table
, i
)))
1885 strout (" . ", 3, 3, printcharfun
, 0);
1886 print_object (obj
, printcharfun
, escapeflag
);
1890 sprintf (buf
, " . #%d#", i
+ 1);
1891 strout (buf
, -1, -1, printcharfun
, 0);
1901 if (print_length
&& i
> print_length
)
1903 strout ("...", 3, 3, printcharfun
, 0);
1907 print_object (XCAR (obj
), printcharfun
, escapeflag
);
1911 halftail
= XCDR (halftail
);
1915 /* OBJ non-nil here means it's the end of a dotted list. */
1918 strout (" . ", 3, 3, printcharfun
, 0);
1919 print_object (obj
, printcharfun
, escapeflag
);
1927 case Lisp_Vectorlike
:
1932 strout ("#<process ", -1, -1, printcharfun
, 0);
1933 print_string (XPROCESS (obj
)->name
, printcharfun
);
1937 print_string (XPROCESS (obj
)->name
, printcharfun
);
1939 else if (BOOL_VECTOR_P (obj
))
1942 register unsigned char c
;
1943 struct gcpro gcpro1
;
1945 = ((XBOOL_VECTOR (obj
)->size
+ BOOL_VECTOR_BITS_PER_CHAR
- 1)
1946 / BOOL_VECTOR_BITS_PER_CHAR
);
1952 sprintf (buf
, "%ld", (long) XBOOL_VECTOR (obj
)->size
);
1953 strout (buf
, -1, -1, printcharfun
, 0);
1956 /* Don't print more characters than the specified maximum.
1957 Negative values of print-length are invalid. Treat them
1958 like a print-length of nil. */
1959 if (NATNUMP (Vprint_length
)
1960 && XFASTINT (Vprint_length
) < size_in_chars
)
1961 size_in_chars
= XFASTINT (Vprint_length
);
1963 for (i
= 0; i
< size_in_chars
; i
++)
1966 c
= XBOOL_VECTOR (obj
)->data
[i
];
1967 if (! ASCII_BYTE_P (c
))
1969 sprintf (buf
, "\\%03o", c
);
1970 strout (buf
, -1, -1, printcharfun
, 0);
1972 else if (c
== '\n' && print_escape_newlines
)
1977 else if (c
== '\f' && print_escape_newlines
)
1982 else if (c
> '\177')
1984 /* Use octal escapes to avoid encoding issues. */
1986 PRINTCHAR ('0' + ((c
>> 6) & 3));
1987 PRINTCHAR ('0' + ((c
>> 3) & 7));
1988 PRINTCHAR ('0' + (c
& 7));
1992 if (c
== '\"' || c
== '\\')
2001 else if (SUBRP (obj
))
2003 strout ("#<subr ", -1, -1, printcharfun
, 0);
2004 strout (XSUBR (obj
)->symbol_name
, -1, -1, printcharfun
, 0);
2007 else if (WINDOWP (obj
))
2009 strout ("#<window ", -1, -1, printcharfun
, 0);
2010 sprintf (buf
, "%ld", (long) XFASTINT (XWINDOW (obj
)->sequence_number
));
2011 strout (buf
, -1, -1, printcharfun
, 0);
2012 if (!NILP (XWINDOW (obj
)->buffer
))
2014 strout (" on ", -1, -1, printcharfun
, 0);
2015 print_string (XBUFFER (XWINDOW (obj
)->buffer
)->name
, printcharfun
);
2019 else if (HASH_TABLE_P (obj
))
2021 struct Lisp_Hash_Table
*h
= XHASH_TABLE (obj
);
2022 strout ("#<hash-table", -1, -1, printcharfun
, 0);
2023 if (SYMBOLP (h
->test
))
2027 strout (SDATA (SYMBOL_NAME (h
->test
)), -1, -1, printcharfun
, 0);
2029 strout (SDATA (SYMBOL_NAME (h
->weak
)), -1, -1, printcharfun
, 0);
2031 sprintf (buf
, "%ld/%ld", (long) XFASTINT (h
->count
),
2032 (long) XVECTOR (h
->next
)->size
);
2033 strout (buf
, -1, -1, printcharfun
, 0);
2035 sprintf (buf
, " 0x%lx", (unsigned long) h
);
2036 strout (buf
, -1, -1, printcharfun
, 0);
2039 else if (BUFFERP (obj
))
2041 if (NILP (XBUFFER (obj
)->name
))
2042 strout ("#<killed buffer>", -1, -1, printcharfun
, 0);
2043 else if (escapeflag
)
2045 strout ("#<buffer ", -1, -1, printcharfun
, 0);
2046 print_string (XBUFFER (obj
)->name
, printcharfun
);
2050 print_string (XBUFFER (obj
)->name
, printcharfun
);
2052 else if (WINDOW_CONFIGURATIONP (obj
))
2054 strout ("#<window-configuration>", -1, -1, printcharfun
, 0);
2056 else if (FRAMEP (obj
))
2058 strout ((FRAME_LIVE_P (XFRAME (obj
))
2059 ? "#<frame " : "#<dead frame "),
2060 -1, -1, printcharfun
, 0);
2061 print_string (XFRAME (obj
)->name
, printcharfun
);
2062 sprintf (buf
, " 0x%lx", (unsigned long) (XFRAME (obj
)));
2063 strout (buf
, -1, -1, printcharfun
, 0);
2068 EMACS_INT size
= XVECTOR (obj
)->size
;
2069 if (COMPILEDP (obj
))
2072 size
&= PSEUDOVECTOR_SIZE_MASK
;
2074 if (CHAR_TABLE_P (obj
) || SUB_CHAR_TABLE_P (obj
))
2076 /* We print a char-table as if it were a vector,
2077 lumping the parent and default slots in with the
2078 character slots. But we add #^ as a prefix. */
2081 if (SUB_CHAR_TABLE_P (obj
))
2083 size
&= PSEUDOVECTOR_SIZE_MASK
;
2085 if (size
& PSEUDOVECTOR_FLAG
)
2091 register Lisp_Object tem
;
2092 int real_size
= size
;
2094 /* Don't print more elements than the specified maximum. */
2095 if (NATNUMP (Vprint_length
)
2096 && XFASTINT (Vprint_length
) < size
)
2097 size
= XFASTINT (Vprint_length
);
2099 for (i
= 0; i
< size
; i
++)
2101 if (i
) PRINTCHAR (' ');
2102 tem
= XVECTOR (obj
)->contents
[i
];
2103 print_object (tem
, printcharfun
, escapeflag
);
2105 if (size
< real_size
)
2106 strout (" ...", 4, 4, printcharfun
, 0);
2113 switch (XMISCTYPE (obj
))
2115 case Lisp_Misc_Marker
:
2116 strout ("#<marker ", -1, -1, printcharfun
, 0);
2117 /* Do you think this is necessary? */
2118 if (XMARKER (obj
)->insertion_type
!= 0)
2119 strout ("(moves after insertion) ", -1, -1, printcharfun
, 0);
2120 if (!(XMARKER (obj
)->buffer
))
2121 strout ("in no buffer", -1, -1, printcharfun
, 0);
2124 sprintf (buf
, "at %d", marker_position (obj
));
2125 strout (buf
, -1, -1, printcharfun
, 0);
2126 strout (" in ", -1, -1, printcharfun
, 0);
2127 print_string (XMARKER (obj
)->buffer
->name
, printcharfun
);
2132 case Lisp_Misc_Overlay
:
2133 strout ("#<overlay ", -1, -1, printcharfun
, 0);
2134 if (!(XMARKER (OVERLAY_START (obj
))->buffer
))
2135 strout ("in no buffer", -1, -1, printcharfun
, 0);
2138 sprintf (buf
, "from %d to %d in ",
2139 marker_position (OVERLAY_START (obj
)),
2140 marker_position (OVERLAY_END (obj
)));
2141 strout (buf
, -1, -1, printcharfun
, 0);
2142 print_string (XMARKER (OVERLAY_START (obj
))->buffer
->name
,
2148 /* Remaining cases shouldn't happen in normal usage, but let's print
2149 them anyway for the benefit of the debugger. */
2150 case Lisp_Misc_Free
:
2151 strout ("#<misc free cell>", -1, -1, printcharfun
, 0);
2154 case Lisp_Misc_Intfwd
:
2155 sprintf (buf
, "#<intfwd to %ld>", (long) *XINTFWD (obj
)->intvar
);
2156 strout (buf
, -1, -1, printcharfun
, 0);
2159 case Lisp_Misc_Boolfwd
:
2160 sprintf (buf
, "#<boolfwd to %s>",
2161 (*XBOOLFWD (obj
)->boolvar
? "t" : "nil"));
2162 strout (buf
, -1, -1, printcharfun
, 0);
2165 case Lisp_Misc_Objfwd
:
2166 strout ("#<objfwd to ", -1, -1, printcharfun
, 0);
2167 print_object (*XOBJFWD (obj
)->objvar
, printcharfun
, escapeflag
);
2171 case Lisp_Misc_Buffer_Objfwd
:
2172 strout ("#<buffer_objfwd to ", -1, -1, printcharfun
, 0);
2173 print_object (PER_BUFFER_VALUE (current_buffer
,
2174 XBUFFER_OBJFWD (obj
)->offset
),
2175 printcharfun
, escapeflag
);
2179 case Lisp_Misc_Kboard_Objfwd
:
2180 strout ("#<kboard_objfwd to ", -1, -1, printcharfun
, 0);
2181 print_object (*(Lisp_Object
*)((char *) current_kboard
2182 + XKBOARD_OBJFWD (obj
)->offset
),
2183 printcharfun
, escapeflag
);
2187 case Lisp_Misc_Buffer_Local_Value
:
2188 strout ("#<buffer_local_value ", -1, -1, printcharfun
, 0);
2189 goto do_buffer_local
;
2190 case Lisp_Misc_Some_Buffer_Local_Value
:
2191 strout ("#<some_buffer_local_value ", -1, -1, printcharfun
, 0);
2193 strout ("[realvalue] ", -1, -1, printcharfun
, 0);
2194 print_object (XBUFFER_LOCAL_VALUE (obj
)->realvalue
,
2195 printcharfun
, escapeflag
);
2196 if (XBUFFER_LOCAL_VALUE (obj
)->found_for_buffer
)
2197 strout ("[local in buffer] ", -1, -1, printcharfun
, 0);
2199 strout ("[buffer] ", -1, -1, printcharfun
, 0);
2200 print_object (XBUFFER_LOCAL_VALUE (obj
)->buffer
,
2201 printcharfun
, escapeflag
);
2202 if (XBUFFER_LOCAL_VALUE (obj
)->check_frame
)
2204 if (XBUFFER_LOCAL_VALUE (obj
)->found_for_frame
)
2205 strout ("[local in frame] ", -1, -1, printcharfun
, 0);
2207 strout ("[frame] ", -1, -1, printcharfun
, 0);
2208 print_object (XBUFFER_LOCAL_VALUE (obj
)->frame
,
2209 printcharfun
, escapeflag
);
2211 strout ("[alist-elt] ", -1, -1, printcharfun
, 0);
2212 print_object (XCAR (XBUFFER_LOCAL_VALUE (obj
)->cdr
),
2213 printcharfun
, escapeflag
);
2214 strout ("[default-value] ", -1, -1, printcharfun
, 0);
2215 print_object (XCDR (XBUFFER_LOCAL_VALUE (obj
)->cdr
),
2216 printcharfun
, escapeflag
);
2220 case Lisp_Misc_Save_Value
:
2221 strout ("#<save_value ", -1, -1, printcharfun
, 0);
2222 sprintf(buf
, "ptr=0x%08lx int=%d",
2223 (unsigned long) XSAVE_VALUE (obj
)->pointer
,
2224 XSAVE_VALUE (obj
)->integer
);
2225 strout (buf
, -1, -1, printcharfun
, 0);
2237 /* We're in trouble if this happens!
2238 Probably should just abort () */
2239 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun
, 0);
2241 sprintf (buf
, "(MISC 0x%04x)", (int) XMISCTYPE (obj
));
2242 else if (VECTORLIKEP (obj
))
2243 sprintf (buf
, "(PVEC 0x%08x)", (int) XVECTOR (obj
)->size
);
2245 sprintf (buf
, "(0x%02x)", (int) XTYPE (obj
));
2246 strout (buf
, -1, -1, printcharfun
, 0);
2247 strout (" Save your buffers immediately and please report this bug>",
2248 -1, -1, printcharfun
, 0);
2256 /* Print a description of INTERVAL using PRINTCHARFUN.
2257 This is part of printing a string that has text properties. */
2260 print_interval (interval
, printcharfun
)
2262 Lisp_Object printcharfun
;
2264 if (NILP (interval
->plist
))
2267 print_object (make_number (interval
->position
), printcharfun
, 1);
2269 print_object (make_number (interval
->position
+ LENGTH (interval
)),
2272 print_object (interval
->plist
, printcharfun
, 1);
2279 Qtemp_buffer_setup_hook
= intern ("temp-buffer-setup-hook");
2280 staticpro (&Qtemp_buffer_setup_hook
);
2282 DEFVAR_LISP ("standard-output", &Vstandard_output
,
2283 doc
: /* Output stream `print' uses by default for outputting a character.
2284 This may be any function of one argument.
2285 It may also be a buffer (output is inserted before point)
2286 or a marker (output is inserted and the marker is advanced)
2287 or the symbol t (output appears in the echo area). */);
2288 Vstandard_output
= Qt
;
2289 Qstandard_output
= intern ("standard-output");
2290 staticpro (&Qstandard_output
);
2292 DEFVAR_LISP ("float-output-format", &Vfloat_output_format
,
2293 doc
: /* The format descriptor string used to print floats.
2294 This is a %-spec like those accepted by `printf' in C,
2295 but with some restrictions. It must start with the two characters `%.'.
2296 After that comes an integer precision specification,
2297 and then a letter which controls the format.
2298 The letters allowed are `e', `f' and `g'.
2299 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"
2300 Use `f' for decimal point notation \"DIGITS.DIGITS\".
2301 Use `g' to choose the shorter of those two formats for the number at hand.
2302 The precision in any of these cases is the number of digits following
2303 the decimal point. With `f', a precision of 0 means to omit the
2304 decimal point. 0 is not allowed with `e' or `g'.
2306 A value of nil means to use the shortest notation
2307 that represents the number without losing information. */);
2308 Vfloat_output_format
= Qnil
;
2309 Qfloat_output_format
= intern ("float-output-format");
2310 staticpro (&Qfloat_output_format
);
2312 DEFVAR_LISP ("print-length", &Vprint_length
,
2313 doc
: /* Maximum length of list to print before abbreviating.
2314 A value of nil means no limit. See also `eval-expression-print-length'. */);
2315 Vprint_length
= Qnil
;
2317 DEFVAR_LISP ("print-level", &Vprint_level
,
2318 doc
: /* Maximum depth of list nesting to print before abbreviating.
2319 A value of nil means no limit. See also `eval-expression-print-level'. */);
2320 Vprint_level
= Qnil
;
2322 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines
,
2323 doc
: /* Non-nil means print newlines in strings as `\\n'.
2324 Also print formfeeds as `\\f'. */);
2325 print_escape_newlines
= 0;
2327 DEFVAR_BOOL ("print-escape-nonascii", &print_escape_nonascii
,
2328 doc
: /* Non-nil means print unibyte non-ASCII chars in strings as \\OOO.
2329 \(OOO is the octal representation of the character code.)
2330 Only single-byte characters are affected, and only in `prin1'.
2331 When the output goes in a multibyte buffer, this feature is
2332 enabled regardless of the value of the variable. */);
2333 print_escape_nonascii
= 0;
2335 DEFVAR_BOOL ("print-escape-multibyte", &print_escape_multibyte
,
2336 doc
: /* Non-nil means print multibyte characters in strings as \\xXXXX.
2337 \(XXXX is the hex representation of the character code.)
2338 This affects only `prin1'. */);
2339 print_escape_multibyte
= 0;
2341 DEFVAR_BOOL ("print-quoted", &print_quoted
,
2342 doc
: /* Non-nil means print quoted forms with reader syntax.
2343 I.e., (quote foo) prints as 'foo, (function foo) as #'foo, and backquoted
2344 forms print as in the new syntax. */);
2347 DEFVAR_LISP ("print-gensym", &Vprint_gensym
,
2348 doc
: /* Non-nil means print uninterned symbols so they will read as uninterned.
2349 I.e., the value of (make-symbol \"foobar\") prints as #:foobar.
2350 When the uninterned symbol appears within a recursive data structure,
2351 and the symbol appears more than once, in addition use the #N# and #N=
2352 constructs as needed, so that multiple references to the same symbol are
2353 shared once again when the text is read back. */);
2354 Vprint_gensym
= Qnil
;
2356 DEFVAR_LISP ("print-circle", &Vprint_circle
,
2357 doc
: /* *Non-nil means print recursive structures using #N= and #N# syntax.
2358 If nil, printing proceeds recursively and may lead to
2359 `max-lisp-eval-depth' being exceeded or an error may occur:
2360 \"Apparently circular structure being printed.\" Also see
2361 `print-length' and `print-level'.
2362 If non-nil, shared substructures anywhere in the structure are printed
2363 with `#N=' before the first occurrence (in the order of the print
2364 representation) and `#N#' in place of each subsequent occurrence,
2365 where N is a positive decimal integer. */);
2366 Vprint_circle
= Qnil
;
2368 DEFVAR_LISP ("print-continuous-numbering", &Vprint_continuous_numbering
,
2369 doc
: /* *Non-nil means number continuously across print calls.
2370 This affects the numbers printed for #N= labels and #M# references.
2371 See also `print-circle', `print-gensym', and `print-number-table'.
2372 This variable should not be set with `setq'; bind it with a `let' instead. */);
2373 Vprint_continuous_numbering
= Qnil
;
2375 DEFVAR_LISP ("print-number-table", &Vprint_number_table
,
2376 doc
: /* A vector used internally to produce `#N=' labels and `#N#' references.
2377 The Lisp printer uses this vector to detect Lisp objects referenced more
2380 When you bind `print-continuous-numbering' to t, you should probably
2381 also bind `print-number-table' to nil. This ensures that the value of
2382 `print-number-table' can be garbage-collected once the printing is
2383 done. If all elements of `print-number-table' are nil, it means that
2384 the printing done so far has not found any shared structure or objects
2385 that need to be recorded in the table. */);
2386 Vprint_number_table
= Qnil
;
2388 DEFVAR_LISP ("print-charset-text-property", &Vprint_charset_text_property
,
2389 doc
: /* A flag to control printing of `charset' text property on printing a string.
2390 The value must be nil, t, or `default'.
2392 If the value is nil, don't print the text property `charset'.
2394 If the value is t, always print the text property `charset'.
2396 If the value is `default', print the text property `charset' only when
2397 the value is different from what is guessed in the current charset
2399 Vprint_charset_text_property
= Qdefault
;
2401 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
2402 staticpro (&Vprin1_to_string_buffer
);
2405 defsubr (&Sprin1_to_string
);
2406 defsubr (&Serror_message_string
);
2410 defsubr (&Swrite_char
);
2411 defsubr (&Sexternal_debugging_output
);
2412 #ifdef WITH_REDIRECT_DEBUGGING_OUTPUT
2413 defsubr (&Sredirect_debugging_output
);
2416 Qexternal_debugging_output
= intern ("external-debugging-output");
2417 staticpro (&Qexternal_debugging_output
);
2419 Qprint_escape_newlines
= intern ("print-escape-newlines");
2420 staticpro (&Qprint_escape_newlines
);
2422 Qprint_escape_multibyte
= intern ("print-escape-multibyte");
2423 staticpro (&Qprint_escape_multibyte
);
2425 Qprint_escape_nonascii
= intern ("print-escape-nonascii");
2426 staticpro (&Qprint_escape_nonascii
);
2428 print_prune_charset_plist
= Qnil
;
2429 staticpro (&print_prune_charset_plist
);
2431 defsubr (&Swith_output_to_temp_buffer
);
2434 /* arch-tag: bc797170-94ae-41de-86e3-75e20f8f7a39
2435 (do not change this comment) */