1 /* Lisp object printing and output streams.
2 Copyright (C) 1985, 1986, 1988, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
31 #include "dispextern.h"
33 #endif /* not standalone */
35 #ifdef USE_TEXT_PROPERTIES
36 #include "intervals.h"
39 Lisp_Object Vstandard_output
, Qstandard_output
;
41 #ifdef LISP_FLOAT_TYPE
42 Lisp_Object Vfloat_output_format
, Qfloat_output_format
;
43 #endif /* LISP_FLOAT_TYPE */
45 /* Avoid actual stack overflow in print. */
48 /* Detect most circularities to print finite output. */
49 #define PRINT_CIRCLE 200
50 Lisp_Object being_printed
[PRINT_CIRCLE
];
52 /* Maximum length of list to print in full; noninteger means
53 effectively infinity */
55 Lisp_Object Vprint_length
;
57 /* Maximum depth of list to print in full; noninteger means
58 effectively infinity. */
60 Lisp_Object Vprint_level
;
62 /* Nonzero means print newlines in strings as \n. */
64 int print_escape_newlines
;
66 Lisp_Object Qprint_escape_newlines
;
68 /* Nonzero means print newline before next minibuffer message.
71 extern int noninteractive_need_newline
;
72 #ifdef MAX_PRINT_CHARS
73 static int print_chars
;
75 #endif /* MAX_PRINT_CHARS */
77 void print_interval ();
80 /* Convert between chars and GLYPHs */
84 register GLYPH
*glyphs
;
94 str_to_glyph_cpy (str
, glyphs
)
98 register GLYPH
*gp
= glyphs
;
99 register char *cp
= str
;
106 str_to_glyph_ncpy (str
, glyphs
, n
)
111 register GLYPH
*gp
= glyphs
;
112 register char *cp
= str
;
119 glyph_to_str_cpy (glyphs
, str
)
123 register GLYPH
*gp
= glyphs
;
124 register char *cp
= str
;
127 *str
++ = *gp
++ & 0377;
131 /* Low level output routines for characters and strings */
133 /* Lisp functions to do output using a stream
134 must have the stream in a variable called printcharfun
135 and must start with PRINTPREPARE and end with PRINTFINISH.
136 Use PRINTCHAR to output one character,
137 or call strout to output a block of characters.
138 Also, each one must have the declarations
139 struct buffer *old = current_buffer;
140 int old_point = -1, start_point;
141 Lisp_Object original;
144 #define PRINTPREPARE \
145 original = printcharfun; \
146 if (NILP (printcharfun)) printcharfun = Qt; \
147 if (BUFFERP (printcharfun)) \
148 { if (XBUFFER (printcharfun) != current_buffer) \
149 Fset_buffer (printcharfun); \
150 printcharfun = Qnil;} \
151 if (MARKERP (printcharfun)) \
152 { if (!(XMARKER (original)->buffer)) \
153 error ("Marker does not point anywhere"); \
154 if (XMARKER (original)->buffer != current_buffer) \
155 set_buffer_internal (XMARKER (original)->buffer); \
157 SET_PT (marker_position (printcharfun)); \
158 start_point = point; \
159 printcharfun = Qnil;}
161 #define PRINTFINISH \
162 if (MARKERP (original)) \
163 Fset_marker (original, make_number (point), Qnil); \
164 if (old_point >= 0) \
165 SET_PT (old_point + (old_point >= start_point \
166 ? point - start_point : 0)); \
167 if (old != current_buffer) \
168 set_buffer_internal (old)
170 #define PRINTCHAR(ch) printchar (ch, printcharfun)
172 /* Index of first unused element of FRAME_MESSAGE_BUF(mini_frame). */
173 static int printbufidx
;
182 #ifdef MAX_PRINT_CHARS
185 #endif /* MAX_PRINT_CHARS */
197 = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
202 noninteractive_need_newline
= 1;
206 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (mini_frame
)
207 || !message_buf_print
)
209 echo_area_glyphs
= FRAME_MESSAGE_BUF (mini_frame
);
211 echo_area_glyphs_length
= 0;
212 message_buf_print
= 1;
215 if (printbufidx
< FRAME_WIDTH (mini_frame
) - 1)
216 FRAME_MESSAGE_BUF (mini_frame
)[printbufidx
++] = ch
;
217 FRAME_MESSAGE_BUF (mini_frame
)[printbufidx
] = 0;
218 echo_area_glyphs_length
= printbufidx
;
222 #endif /* not standalone */
224 XSETFASTINT (ch1
, ch
);
229 strout (ptr
, size
, printcharfun
)
232 Lisp_Object printcharfun
;
236 if (EQ (printcharfun
, Qnil
))
238 insert (ptr
, size
>= 0 ? size
: strlen (ptr
));
239 #ifdef MAX_PRINT_CHARS
241 print_chars
+= size
>= 0 ? size
: strlen(ptr
);
242 #endif /* MAX_PRINT_CHARS */
245 if (EQ (printcharfun
, Qt
))
248 = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)));
250 i
= size
>= 0 ? size
: strlen (ptr
);
251 #ifdef MAX_PRINT_CHARS
254 #endif /* MAX_PRINT_CHARS */
258 fwrite (ptr
, 1, i
, stdout
);
259 noninteractive_need_newline
= 1;
263 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (mini_frame
)
264 || !message_buf_print
)
266 echo_area_glyphs
= FRAME_MESSAGE_BUF (mini_frame
);
268 echo_area_glyphs_length
= 0;
269 message_buf_print
= 1;
272 if (i
> FRAME_WIDTH (mini_frame
) - printbufidx
- 1)
273 i
= FRAME_WIDTH (mini_frame
) - printbufidx
- 1;
274 bcopy (ptr
, &FRAME_MESSAGE_BUF (mini_frame
) [printbufidx
], i
);
276 echo_area_glyphs_length
= printbufidx
;
277 FRAME_MESSAGE_BUF (mini_frame
) [printbufidx
] = 0;
284 PRINTCHAR (ptr
[i
++]);
287 PRINTCHAR (ptr
[i
++]);
290 /* Print the contents of a string STRING using PRINTCHARFUN.
291 It isn't safe to use strout, because printing one char can relocate. */
293 print_string (string
, printcharfun
)
295 Lisp_Object printcharfun
;
297 if (EQ (printcharfun
, Qnil
) || EQ (printcharfun
, Qt
))
298 /* In predictable cases, strout is safe: output to buffer or frame. */
299 strout (XSTRING (string
)->data
, XSTRING (string
)->size
, printcharfun
);
302 /* Otherwise, fetch the string address for each character. */
304 int size
= XSTRING (string
)->size
;
307 for (i
= 0; i
< size
; i
++)
308 PRINTCHAR (XSTRING (string
)->data
[i
]);
313 DEFUN ("write-char", Fwrite_char
, Swrite_char
, 1, 2, 0,
314 "Output character CHAR to stream PRINTCHARFUN.\n\
315 PRINTCHARFUN defaults to the value of `standard-output' (which see).")
317 Lisp_Object ch
, printcharfun
;
319 struct buffer
*old
= current_buffer
;
322 Lisp_Object original
;
324 if (NILP (printcharfun
))
325 printcharfun
= Vstandard_output
;
326 CHECK_NUMBER (ch
, 0);
328 PRINTCHAR (XINT (ch
));
333 /* Used from outside of print.c to print a block of SIZE chars at DATA
334 on the default output stream.
335 Do not use this on the contents of a Lisp string. */
337 write_string (data
, size
)
341 struct buffer
*old
= current_buffer
;
342 Lisp_Object printcharfun
;
345 Lisp_Object original
;
347 printcharfun
= Vstandard_output
;
350 strout (data
, size
, printcharfun
);
354 /* Used from outside of print.c to print a block of SIZE chars at DATA
355 on a specified stream PRINTCHARFUN.
356 Do not use this on the contents of a Lisp string. */
358 write_string_1 (data
, size
, printcharfun
)
361 Lisp_Object printcharfun
;
363 struct buffer
*old
= current_buffer
;
366 Lisp_Object original
;
369 strout (data
, size
, printcharfun
);
377 temp_output_buffer_setup (bufname
)
380 register struct buffer
*old
= current_buffer
;
381 register Lisp_Object buf
;
383 Fset_buffer (Fget_buffer_create (build_string (bufname
)));
385 current_buffer
->read_only
= Qnil
;
388 XSETBUFFER (buf
, current_buffer
);
389 specbind (Qstandard_output
, buf
);
391 set_buffer_internal (old
);
395 internal_with_output_to_temp_buffer (bufname
, function
, args
)
397 Lisp_Object (*function
) ();
400 int count
= specpdl_ptr
- specpdl
;
401 Lisp_Object buf
, val
;
405 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
406 temp_output_buffer_setup (bufname
);
407 buf
= Vstandard_output
;
410 val
= (*function
) (args
);
413 temp_output_buffer_show (buf
);
416 return unbind_to (count
, val
);
419 DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer
, Swith_output_to_temp_buffer
,
421 "Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.\n\
422 The buffer is cleared out initially, and marked as unmodified when done.\n\
423 All output done by BODY is inserted in that buffer by default.\n\
424 The buffer is displayed in another window, but not selected.\n\
425 The value of the last form in BODY is returned.\n\
426 If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\n\
427 If variable `temp-buffer-show-function' is non-nil, call it at the end\n\
428 to get the buffer displayed. It gets one argument, the buffer to display.")
434 int count
= specpdl_ptr
- specpdl
;
435 Lisp_Object buf
, val
;
438 name
= Feval (Fcar (args
));
441 CHECK_STRING (name
, 0);
442 temp_output_buffer_setup (XSTRING (name
)->data
);
443 buf
= Vstandard_output
;
445 val
= Fprogn (Fcdr (args
));
447 temp_output_buffer_show (buf
);
449 return unbind_to (count
, val
);
451 #endif /* not standalone */
453 static void print ();
455 DEFUN ("terpri", Fterpri
, Sterpri
, 0, 1, 0,
456 "Output a newline to stream PRINTCHARFUN.\n\
457 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.")
459 Lisp_Object printcharfun
;
461 struct buffer
*old
= current_buffer
;
464 Lisp_Object original
;
466 if (NILP (printcharfun
))
467 printcharfun
= Vstandard_output
;
474 DEFUN ("prin1", Fprin1
, Sprin1
, 1, 2, 0,
475 "Output the printed representation of OBJECT, any Lisp object.\n\
476 Quoting characters are printed when needed to make output that `read'\n\
477 can handle, whenever this is possible.\n\
478 Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
480 Lisp_Object obj
, printcharfun
;
482 struct buffer
*old
= current_buffer
;
485 Lisp_Object original
;
487 #ifdef MAX_PRINT_CHARS
489 #endif /* MAX_PRINT_CHARS */
490 if (NILP (printcharfun
))
491 printcharfun
= Vstandard_output
;
494 print (obj
, printcharfun
, 1);
499 /* a buffer which is used to hold output being built by prin1-to-string */
500 Lisp_Object Vprin1_to_string_buffer
;
502 DEFUN ("prin1-to-string", Fprin1_to_string
, Sprin1_to_string
, 1, 2, 0,
503 "Return a string containing the printed representation of OBJECT,\n\
504 any Lisp object. Quoting characters are used when needed to make output\n\
505 that `read' can handle, whenever this is possible, unless the optional\n\
506 second argument NOESCAPE is non-nil.")
508 Lisp_Object obj
, noescape
;
510 struct buffer
*old
= current_buffer
;
513 Lisp_Object original
, printcharfun
;
516 printcharfun
= Vprin1_to_string_buffer
;
519 print (obj
, printcharfun
, NILP (noescape
));
520 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
522 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
523 obj
= Fbuffer_string ();
527 set_buffer_internal (old
);
533 DEFUN ("princ", Fprinc
, Sprinc
, 1, 2, 0,
534 "Output the printed representation of OBJECT, any Lisp object.\n\
535 No quoting characters are used; no delimiters are printed around\n\
536 the contents of strings.\n\
537 Output stream is PRINTCHARFUN, or value of standard-output (which see).")
539 Lisp_Object obj
, printcharfun
;
541 struct buffer
*old
= current_buffer
;
544 Lisp_Object original
;
546 if (NILP (printcharfun
))
547 printcharfun
= Vstandard_output
;
550 print (obj
, printcharfun
, 0);
555 DEFUN ("print", Fprint
, Sprint
, 1, 2, 0,
556 "Output the printed representation of OBJECT, with newlines around it.\n\
557 Quoting characters are printed when needed to make output that `read'\n\
558 can handle, whenever this is possible.\n\
559 Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
561 Lisp_Object obj
, printcharfun
;
563 struct buffer
*old
= current_buffer
;
566 Lisp_Object original
;
569 #ifdef MAX_PRINT_CHARS
571 max_print
= MAX_PRINT_CHARS
;
572 #endif /* MAX_PRINT_CHARS */
573 if (NILP (printcharfun
))
574 printcharfun
= Vstandard_output
;
579 print (obj
, printcharfun
, 1);
582 #ifdef MAX_PRINT_CHARS
585 #endif /* MAX_PRINT_CHARS */
590 /* The subroutine object for external-debugging-output is kept here
591 for the convenience of the debugger. */
592 Lisp_Object Qexternal_debugging_output
;
594 DEFUN ("external-debugging-output", Fexternal_debugging_output
, Sexternal_debugging_output
, 1, 1, 0,
595 "Write CHARACTER to stderr.\n\
596 You can call print while debugging emacs, and pass it this function\n\
597 to make it write to the debugging output.\n")
599 Lisp_Object character
;
601 CHECK_NUMBER (character
, 0);
602 putc (XINT (character
), stderr
);
607 /* This is the interface for debugging printing. */
613 Fprin1 (arg
, Qexternal_debugging_output
);
616 #ifdef LISP_FLOAT_TYPE
619 * The buffer should be at least as large as the max string size of the
620 * largest float, printed in the biggest notation. This is undoubtably
621 * 20d float_output_format, with the negative of the C-constant "HUGE"
624 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
626 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
627 * case of -1e307 in 20d float_output_format. What is one to do (short of
628 * re-writing _doprnt to be more sane)?
633 float_to_string (buf
, data
)
640 if (NILP (Vfloat_output_format
)
641 || !STRINGP (Vfloat_output_format
))
644 sprintf (buf
, "%.17g", data
);
649 /* Check that the spec we have is fully valid.
650 This means not only valid for printf,
651 but meant for floats, and reasonable. */
652 cp
= XSTRING (Vfloat_output_format
)->data
;
661 /* Check the width specification. */
663 if ('0' <= *cp
&& *cp
<= '9')
664 for (width
= 0; (*cp
>= '0' && *cp
<= '9'); cp
++)
665 width
= (width
* 10) + (*cp
- '0');
667 if (*cp
!= 'e' && *cp
!= 'f' && *cp
!= 'g')
670 /* A precision of zero is valid for %f; everything else requires
671 at least one. Width may be omitted anywhere. */
673 && (width
< (*cp
!= 'f')
680 sprintf (buf
, XSTRING (Vfloat_output_format
)->data
, data
);
683 /* Make sure there is a decimal point with digit after, or an
684 exponent, so that the value is readable as a float. But don't do
685 this with "%.0f"; it's valid for that not to produce a decimal
686 point. Note that width can be 0 only for %.0f. */
689 for (cp
= buf
; *cp
; cp
++)
690 if ((*cp
< '0' || *cp
> '9') && *cp
!= '-')
693 if (*cp
== '.' && cp
[1] == 0)
707 #endif /* LISP_FLOAT_TYPE */
710 print (obj
, printcharfun
, escapeflag
)
712 register Lisp_Object printcharfun
;
719 #if 1 /* I'm not sure this is really worth doing. */
720 /* Detect circularities and truncate them.
721 No need to offer any alternative--this is better than an error. */
722 if (CONSP (obj
) || VECTORP (obj
) || COMPILEDP (obj
))
725 for (i
= 0; i
< print_depth
; i
++)
726 if (EQ (obj
, being_printed
[i
]))
728 sprintf (buf
, "#%d", i
);
729 strout (buf
, -1, printcharfun
);
735 being_printed
[print_depth
] = obj
;
738 if (print_depth
> PRINT_CIRCLE
)
739 error ("Apparently circular structure being printed");
740 #ifdef MAX_PRINT_CHARS
741 if (max_print
&& print_chars
> max_print
)
746 #endif /* MAX_PRINT_CHARS */
748 #ifdef SWITCH_ENUM_BUG
749 switch ((int) XTYPE (obj
))
755 /* We're in trouble if this happens!
756 Probably should just abort () */
757 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun
);
758 sprintf (buf
, "(#o%3o)", (int) XTYPE (obj
));
759 strout (buf
, -1, printcharfun
);
760 strout (" Save your buffers immediately and please report this bug>",
764 #ifdef LISP_FLOAT_TYPE
767 char pigbuf
[350]; /* see comments in float_to_string */
769 float_to_string (pigbuf
, XFLOAT(obj
)->data
);
770 strout (pigbuf
, -1, printcharfun
);
773 #endif /* LISP_FLOAT_TYPE */
776 sprintf (buf
, "%d", XINT (obj
));
777 strout (buf
, -1, printcharfun
);
782 print_string (obj
, printcharfun
);
786 register unsigned char c
;
791 #ifdef USE_TEXT_PROPERTIES
792 if (!NULL_INTERVAL_P (XSTRING (obj
)->intervals
))
800 for (i
= 0; i
< XSTRING (obj
)->size
; i
++)
803 c
= XSTRING (obj
)->data
[i
];
804 if (c
== '\n' && print_escape_newlines
)
809 else if (c
== '\f' && print_escape_newlines
)
816 if (c
== '\"' || c
== '\\')
823 #ifdef USE_TEXT_PROPERTIES
824 if (!NULL_INTERVAL_P (XSTRING (obj
)->intervals
))
826 traverse_intervals (XSTRING (obj
)->intervals
,
827 0, 0, print_interval
, printcharfun
);
838 register int confusing
;
839 register unsigned char *p
= XSYMBOL (obj
)->name
->data
;
840 register unsigned char *end
= p
+ XSYMBOL (obj
)->name
->size
;
841 register unsigned char c
;
843 if (p
!= end
&& (*p
== '-' || *p
== '+')) p
++;
848 while (p
!= end
&& *p
>= '0' && *p
<= '9')
850 confusing
= (end
== p
);
853 p
= XSYMBOL (obj
)->name
->data
;
860 if (c
== '\"' || c
== '\\' || c
== '\'' || c
== ';' || c
== '#' ||
861 c
== '(' || c
== ')' || c
== ',' || c
=='.' || c
== '`' ||
862 c
== '[' || c
== ']' || c
== '?' || c
<= 040 || confusing
)
863 PRINTCHAR ('\\'), confusing
= 0;
871 /* If deeper than spec'd depth, print placeholder. */
872 if (INTEGERP (Vprint_level
)
873 && print_depth
> XINT (Vprint_level
))
875 strout ("...", -1, printcharfun
);
882 register int max
= 0;
884 if (INTEGERP (Vprint_length
))
885 max
= XINT (Vprint_length
);
886 /* Could recognize circularities in cdrs here,
887 but that would make printing of long lists quadratic.
888 It's not worth doing. */
895 strout ("...", 3, printcharfun
);
898 print (Fcar (obj
), printcharfun
, escapeflag
);
902 if (!NILP (obj
) && !CONSP (obj
))
904 strout (" . ", 3, printcharfun
);
905 print (obj
, printcharfun
, escapeflag
);
911 strout ("#", -1, printcharfun
);
916 register Lisp_Object tem
;
917 for (i
= 0; i
< XVECTOR (obj
)->size
; i
++)
919 if (i
) PRINTCHAR (' ');
920 tem
= XVECTOR (obj
)->contents
[i
];
921 print (tem
, printcharfun
, escapeflag
);
929 if (NILP (XBUFFER (obj
)->name
))
930 strout ("#<killed buffer>", -1, printcharfun
);
933 strout ("#<buffer ", -1, printcharfun
);
934 print_string (XBUFFER (obj
)->name
, printcharfun
);
938 print_string (XBUFFER (obj
)->name
, printcharfun
);
944 strout ("#<process ", -1, printcharfun
);
945 print_string (XPROCESS (obj
)->name
, printcharfun
);
949 print_string (XPROCESS (obj
)->name
, printcharfun
);
953 strout ("#<window ", -1, printcharfun
);
954 sprintf (buf
, "%d", XFASTINT (XWINDOW (obj
)->sequence_number
));
955 strout (buf
, -1, printcharfun
);
956 if (!NILP (XWINDOW (obj
)->buffer
))
958 strout (" on ", -1, printcharfun
);
959 print_string (XBUFFER (XWINDOW (obj
)->buffer
)->name
, printcharfun
);
964 case Lisp_Window_Configuration
:
965 strout ("#<window-configuration>", -1, printcharfun
);
970 strout ((FRAME_LIVE_P (XFRAME (obj
))
971 ? "#<frame " : "#<dead frame "),
973 print_string (XFRAME (obj
)->name
, printcharfun
);
974 if (sizeof (EMACS_INT
) > 4)
975 sprintf (buf
, " 0x%lx", (EMACS_UINT
) (XFRAME (obj
)));
977 sprintf (buf
, " 0x%x", (EMACS_UINT
) (XFRAME (obj
)));
978 strout (buf
, -1, printcharfun
);
979 strout (">", -1, printcharfun
);
981 #endif /* MULTI_FRAME */
984 switch (XMISC (obj
)->type
)
986 case Lisp_Misc_Marker
:
987 strout ("#<marker ", -1, printcharfun
);
988 if (!(XMARKER (obj
)->buffer
))
989 strout ("in no buffer", -1, printcharfun
);
992 sprintf (buf
, "at %d", marker_position (obj
));
993 strout (buf
, -1, printcharfun
);
994 strout (" in ", -1, printcharfun
);
995 print_string (XMARKER (obj
)->buffer
->name
, printcharfun
);
1006 strout ("#<overlay ", -1, printcharfun
);
1007 if (!(XMARKER (OVERLAY_START (obj
))->buffer
))
1008 strout ("in no buffer", -1, printcharfun
);
1011 sprintf (buf
, "from %d to %d in ",
1012 marker_position (OVERLAY_START (obj
)),
1013 marker_position (OVERLAY_END (obj
)));
1014 strout (buf
, -1, printcharfun
);
1015 print_string (XMARKER (OVERLAY_START (obj
))->buffer
->name
,
1021 #endif /* standalone */
1024 strout ("#<subr ", -1, printcharfun
);
1025 strout (XSUBR (obj
)->symbol_name
, -1, printcharfun
);
1033 #ifdef USE_TEXT_PROPERTIES
1035 /* Print a description of INTERVAL using PRINTCHARFUN.
1036 This is part of printing a string that has text properties. */
1039 print_interval (interval
, printcharfun
)
1041 Lisp_Object printcharfun
;
1044 print (make_number (interval
->position
), printcharfun
, 1);
1046 print (make_number (interval
->position
+ LENGTH (interval
)),
1049 print (interval
->plist
, printcharfun
, 1);
1052 #endif /* USE_TEXT_PROPERTIES */
1057 staticpro (&Qprint_escape_newlines
);
1058 Qprint_escape_newlines
= intern ("print-escape-newlines");
1060 DEFVAR_LISP ("standard-output", &Vstandard_output
,
1061 "Output stream `print' uses by default for outputting a character.\n\
1062 This may be any function of one argument.\n\
1063 It may also be a buffer (output is inserted before point)\n\
1064 or a marker (output is inserted and the marker is advanced)\n\
1065 or the symbol t (output appears in the minibuffer line).");
1066 Vstandard_output
= Qt
;
1067 Qstandard_output
= intern ("standard-output");
1068 staticpro (&Qstandard_output
);
1070 #ifdef LISP_FLOAT_TYPE
1071 DEFVAR_LISP ("float-output-format", &Vfloat_output_format
,
1072 "The format descriptor string used to print floats.\n\
1073 This is a %-spec like those accepted by `printf' in C,\n\
1074 but with some restrictions. It must start with the two characters `%.'.\n\
1075 After that comes an integer precision specification,\n\
1076 and then a letter which controls the format.\n\
1077 The letters allowed are `e', `f' and `g'.\n\
1078 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"\n\
1079 Use `f' for decimal point notation \"DIGITS.DIGITS\".\n\
1080 Use `g' to choose the shorter of those two formats for the number at hand.\n\
1081 The precision in any of these cases is the number of digits following\n\
1082 the decimal point. With `f', a precision of 0 means to omit the\n\
1083 decimal point. 0 is not allowed with `e' or `g'.\n\n\
1084 A value of nil means to use `%.17g'.");
1085 Vfloat_output_format
= Qnil
;
1086 Qfloat_output_format
= intern ("float-output-format");
1087 staticpro (&Qfloat_output_format
);
1088 #endif /* LISP_FLOAT_TYPE */
1090 DEFVAR_LISP ("print-length", &Vprint_length
,
1091 "Maximum length of list to print before abbreviating.\n\
1092 A value of nil means no limit.");
1093 Vprint_length
= Qnil
;
1095 DEFVAR_LISP ("print-level", &Vprint_level
,
1096 "Maximum depth of list nesting to print before abbreviating.\n\
1097 A value of nil means no limit.");
1098 Vprint_level
= Qnil
;
1100 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines
,
1101 "Non-nil means print newlines in strings as backslash-n.\n\
1102 Also print formfeeds as backslash-f.");
1103 print_escape_newlines
= 0;
1105 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
1106 staticpro (&Vprin1_to_string_buffer
);
1109 defsubr (&Sprin1_to_string
);
1113 defsubr (&Swrite_char
);
1114 defsubr (&Sexternal_debugging_output
);
1116 Qexternal_debugging_output
= intern ("external-debugging-output");
1117 staticpro (&Qexternal_debugging_output
);
1120 defsubr (&Swith_output_to_temp_buffer
);
1121 #endif /* not standalone */