1 /* Lisp object printing and output streams.
2 Copyright (C) 1985, 1986, 1988, 1993 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 (XTYPE (printcharfun) == Lisp_Buffer) \
148 { if (XBUFFER (printcharfun) != current_buffer) \
149 Fset_buffer (printcharfun); \
150 printcharfun = Qnil;} \
151 if (XTYPE (printcharfun) == Lisp_Marker) \
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 (XTYPE (original) == Lisp_Marker) \
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(selected_frame). */
173 static int printbufidx
;
182 #ifdef MAX_PRINT_CHARS
185 #endif /* MAX_PRINT_CHARS */
199 noninteractive_need_newline
= 1;
203 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (selected_frame
)
204 || !message_buf_print
)
206 echo_area_glyphs
= FRAME_MESSAGE_BUF (selected_frame
);
208 message_buf_print
= 1;
211 if (printbufidx
< FRAME_WIDTH (selected_frame
) - 1)
212 FRAME_MESSAGE_BUF (selected_frame
)[printbufidx
++] = ch
;
213 FRAME_MESSAGE_BUF (selected_frame
)[printbufidx
] = 0;
217 #endif /* not standalone */
224 strout (ptr
, size
, printcharfun
)
227 Lisp_Object printcharfun
;
231 if (EQ (printcharfun
, Qnil
))
233 insert (ptr
, size
>= 0 ? size
: strlen (ptr
));
234 #ifdef MAX_PRINT_CHARS
236 print_chars
+= size
>= 0 ? size
: strlen(ptr
);
237 #endif /* MAX_PRINT_CHARS */
240 if (EQ (printcharfun
, Qt
))
242 i
= size
>= 0 ? size
: strlen (ptr
);
243 #ifdef MAX_PRINT_CHARS
246 #endif /* MAX_PRINT_CHARS */
250 fwrite (ptr
, 1, i
, stdout
);
251 noninteractive_need_newline
= 1;
255 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (selected_frame
)
256 || !message_buf_print
)
258 echo_area_glyphs
= FRAME_MESSAGE_BUF (selected_frame
);
260 message_buf_print
= 1;
263 if (i
> FRAME_WIDTH (selected_frame
) - printbufidx
- 1)
264 i
= FRAME_WIDTH (selected_frame
) - printbufidx
- 1;
265 bcopy (ptr
, &FRAME_MESSAGE_BUF (selected_frame
) [printbufidx
], i
);
267 FRAME_MESSAGE_BUF (selected_frame
) [printbufidx
] = 0;
274 PRINTCHAR (ptr
[i
++]);
277 PRINTCHAR (ptr
[i
++]);
280 /* Print the contents of a string STRING using PRINTCHARFUN.
281 It isn't safe to use strout, because printing one char can relocate. */
283 print_string (string
, printcharfun
)
285 Lisp_Object printcharfun
;
287 if (EQ (printcharfun
, Qnil
) || EQ (printcharfun
, Qt
))
288 /* In predictable cases, strout is safe: output to buffer or frame. */
289 strout (XSTRING (string
)->data
, XSTRING (string
)->size
, printcharfun
);
292 /* Otherwise, fetch the string address for each character. */
294 int size
= XSTRING (string
)->size
;
297 for (i
= 0; i
< size
; i
++)
298 PRINTCHAR (XSTRING (string
)->data
[i
]);
303 DEFUN ("write-char", Fwrite_char
, Swrite_char
, 1, 2, 0,
304 "Output character CHAR to stream STREAM.\n\
305 STREAM defaults to the value of `standard-output' (which see).")
307 Lisp_Object ch
, printcharfun
;
309 struct buffer
*old
= current_buffer
;
312 Lisp_Object original
;
314 if (NILP (printcharfun
))
315 printcharfun
= Vstandard_output
;
316 CHECK_NUMBER (ch
, 0);
318 PRINTCHAR (XINT (ch
));
323 /* Used from outside of print.c to print a block of SIZE chars at DATA
324 on the default output stream.
325 Do not use this on the contents of a Lisp string. */
327 write_string (data
, size
)
331 struct buffer
*old
= current_buffer
;
332 Lisp_Object printcharfun
;
335 Lisp_Object original
;
337 printcharfun
= Vstandard_output
;
340 strout (data
, size
, printcharfun
);
344 /* Used from outside of print.c to print a block of SIZE chars at DATA
345 on a specified stream PRINTCHARFUN.
346 Do not use this on the contents of a Lisp string. */
348 write_string_1 (data
, size
, printcharfun
)
351 Lisp_Object printcharfun
;
353 struct buffer
*old
= current_buffer
;
356 Lisp_Object original
;
359 strout (data
, size
, printcharfun
);
367 temp_output_buffer_setup (bufname
)
370 register struct buffer
*old
= current_buffer
;
371 register Lisp_Object buf
;
373 Fset_buffer (Fget_buffer_create (build_string (bufname
)));
375 current_buffer
->read_only
= Qnil
;
378 XSET (buf
, Lisp_Buffer
, current_buffer
);
379 specbind (Qstandard_output
, buf
);
381 set_buffer_internal (old
);
385 internal_with_output_to_temp_buffer (bufname
, function
, args
)
387 Lisp_Object (*function
) ();
390 int count
= specpdl_ptr
- specpdl
;
391 Lisp_Object buf
, val
;
393 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
394 temp_output_buffer_setup (bufname
);
395 buf
= Vstandard_output
;
397 val
= (*function
) (args
);
399 temp_output_buffer_show (buf
);
401 return unbind_to (count
, val
);
404 DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer
, Swith_output_to_temp_buffer
,
406 "Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.\n\
407 The buffer is cleared out initially, and marked as unmodified when done.\n\
408 All output done by BODY is inserted in that buffer by default.\n\
409 The buffer is displayed in another window, but not selected.\n\
410 The value of the last form in BODY is returned.\n\
411 If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\n\
412 If variable `temp-buffer-show-function' is non-nil, call it at the end\n\
413 to get the buffer displayed. It gets one argument, the buffer to display.")
419 int count
= specpdl_ptr
- specpdl
;
420 Lisp_Object buf
, val
;
423 name
= Feval (Fcar (args
));
426 CHECK_STRING (name
, 0);
427 temp_output_buffer_setup (XSTRING (name
)->data
);
428 buf
= Vstandard_output
;
430 val
= Fprogn (Fcdr (args
));
432 temp_output_buffer_show (buf
);
434 return unbind_to (count
, val
);
436 #endif /* not standalone */
438 static void print ();
440 DEFUN ("terpri", Fterpri
, Sterpri
, 0, 1, 0,
441 "Output a newline to STREAM.\n\
442 If STREAM is omitted or nil, the value of `standard-output' is used.")
444 Lisp_Object printcharfun
;
446 struct buffer
*old
= current_buffer
;
449 Lisp_Object original
;
451 if (NILP (printcharfun
))
452 printcharfun
= Vstandard_output
;
459 DEFUN ("prin1", Fprin1
, Sprin1
, 1, 2, 0,
460 "Output the printed representation of OBJECT, any Lisp object.\n\
461 Quoting characters are printed when needed to make output that `read'\n\
462 can handle, whenever this is possible.\n\
463 Output stream is STREAM, or value of `standard-output' (which see).")
465 Lisp_Object obj
, printcharfun
;
467 struct buffer
*old
= current_buffer
;
470 Lisp_Object original
;
472 #ifdef MAX_PRINT_CHARS
474 #endif /* MAX_PRINT_CHARS */
475 if (NILP (printcharfun
))
476 printcharfun
= Vstandard_output
;
479 print (obj
, printcharfun
, 1);
484 /* a buffer which is used to hold output being built by prin1-to-string */
485 Lisp_Object Vprin1_to_string_buffer
;
487 DEFUN ("prin1-to-string", Fprin1_to_string
, Sprin1_to_string
, 1, 2, 0,
488 "Return a string containing the printed representation of OBJECT,\n\
489 any Lisp object. Quoting characters are used when needed to make output\n\
490 that `read' can handle, whenever this is possible, unless the optional\n\
491 second argument NOESCAPE is non-nil.")
493 Lisp_Object obj
, noescape
;
495 struct buffer
*old
= current_buffer
;
498 Lisp_Object original
, printcharfun
;
501 printcharfun
= Vprin1_to_string_buffer
;
504 print (obj
, printcharfun
, NILP (noescape
));
505 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
507 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
508 obj
= Fbuffer_string ();
512 set_buffer_internal (old
);
518 DEFUN ("princ", Fprinc
, Sprinc
, 1, 2, 0,
519 "Output the printed representation of OBJECT, any Lisp object.\n\
520 No quoting characters are used; no delimiters are printed around\n\
521 the contents of strings.\n\
522 Output stream is STREAM, or value of standard-output (which see).")
524 Lisp_Object obj
, printcharfun
;
526 struct buffer
*old
= current_buffer
;
529 Lisp_Object original
;
531 if (NILP (printcharfun
))
532 printcharfun
= Vstandard_output
;
535 print (obj
, printcharfun
, 0);
540 DEFUN ("print", Fprint
, Sprint
, 1, 2, 0,
541 "Output the printed representation of OBJECT, with newlines around it.\n\
542 Quoting characters are printed when needed to make output that `read'\n\
543 can handle, whenever this is possible.\n\
544 Output stream is STREAM, or value of `standard-output' (which see).")
546 Lisp_Object obj
, printcharfun
;
548 struct buffer
*old
= current_buffer
;
551 Lisp_Object original
;
554 #ifdef MAX_PRINT_CHARS
556 max_print
= MAX_PRINT_CHARS
;
557 #endif /* MAX_PRINT_CHARS */
558 if (NILP (printcharfun
))
559 printcharfun
= Vstandard_output
;
564 print (obj
, printcharfun
, 1);
567 #ifdef MAX_PRINT_CHARS
570 #endif /* MAX_PRINT_CHARS */
575 /* The subroutine object for external-debugging-output is kept here
576 for the convenience of the debugger. */
577 Lisp_Object Qexternal_debugging_output
;
579 DEFUN ("external-debugging-output", Fexternal_debugging_output
, Sexternal_debugging_output
, 1, 1, 0,
580 "Write CHARACTER to stderr.\n\
581 You can call print while debugging emacs, and pass it this function\n\
582 to make it write to the debugging output.\n")
584 Lisp_Object character
;
586 CHECK_NUMBER (character
, 0);
587 putc (XINT (character
), stderr
);
592 #ifdef LISP_FLOAT_TYPE
595 * The buffer should be at least as large as the max string size of the
596 * largest float, printed in the biggest notation. This is undoubtably
597 * 20d float_output_format, with the negative of the C-constant "HUGE"
600 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
602 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
603 * case of -1e307 in 20d float_output_format. What is one to do (short of
604 * re-writing _doprnt to be more sane)?
609 float_to_string (buf
, data
)
616 if (NILP (Vfloat_output_format
)
617 || XTYPE (Vfloat_output_format
) != Lisp_String
)
620 sprintf (buf
, "%.17g", data
);
625 /* Check that the spec we have is fully valid.
626 This means not only valid for printf,
627 but meant for floats, and reasonable. */
628 cp
= XSTRING (Vfloat_output_format
)->data
;
637 /* Check the width specification. */
639 if ('0' <= *cp
&& *cp
<= '9')
640 for (width
= 0; (*cp
>= '0' && *cp
<= '9'); cp
++)
641 width
= (width
* 10) + (*cp
- '0');
643 if (*cp
!= 'e' && *cp
!= 'f' && *cp
!= 'g')
646 /* A precision of zero is valid for %f; everything else requires
647 at least one. Width may be omitted anywhere. */
649 && (width
< (*cp
!= 'f')
656 sprintf (buf
, XSTRING (Vfloat_output_format
)->data
, data
);
659 /* Make sure there is a decimal point with digit after, or an
660 exponent, so that the value is readable as a float. But don't do
661 this with "%.0f"; it's valid for that not to produce a decimal
662 point. Note that width can be 0 only for %.0f. */
665 for (cp
= buf
; *cp
; cp
++)
666 if ((*cp
< '0' || *cp
> '9') && *cp
!= '-')
669 if (*cp
== '.' && cp
[1] == 0)
683 #endif /* LISP_FLOAT_TYPE */
686 print (obj
, printcharfun
, escapeflag
)
688 register Lisp_Object printcharfun
;
695 #if 1 /* I'm not sure this is really worth doing. */
696 /* Detect circularities and truncate them.
697 No need to offer any alternative--this is better than an error. */
698 if (XTYPE (obj
) == Lisp_Cons
|| XTYPE (obj
) == Lisp_Vector
699 || XTYPE (obj
) == Lisp_Compiled
)
702 for (i
= 0; i
< print_depth
; i
++)
703 if (EQ (obj
, being_printed
[i
]))
705 sprintf (buf
, "#%d", i
);
706 strout (buf
, -1, printcharfun
);
712 being_printed
[print_depth
] = obj
;
715 if (print_depth
> PRINT_CIRCLE
)
716 error ("Apparently circular structure being printed");
717 #ifdef MAX_PRINT_CHARS
718 if (max_print
&& print_chars
> max_print
)
723 #endif /* MAX_PRINT_CHARS */
725 #ifdef SWITCH_ENUM_BUG
726 switch ((int) XTYPE (obj
))
732 /* We're in trouble if this happens!
733 Probably should just abort () */
734 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun
);
735 sprintf (buf
, "(#o%3o)", (int) XTYPE (obj
));
736 strout (buf
, -1, printcharfun
);
737 strout (" Save your buffers immediately and please report this bug>",
741 #ifdef LISP_FLOAT_TYPE
744 char pigbuf
[350]; /* see comments in float_to_string */
746 float_to_string (pigbuf
, XFLOAT(obj
)->data
);
747 strout (pigbuf
, -1, printcharfun
);
750 #endif /* LISP_FLOAT_TYPE */
753 sprintf (buf
, "%d", XINT (obj
));
754 strout (buf
, -1, printcharfun
);
759 print_string (obj
, printcharfun
);
763 register unsigned char c
;
768 #ifdef USE_TEXT_PROPERTIES
769 if (!NULL_INTERVAL_P (XSTRING (obj
)->intervals
))
777 for (i
= 0; i
< XSTRING (obj
)->size
; i
++)
780 c
= XSTRING (obj
)->data
[i
];
781 if (c
== '\n' && print_escape_newlines
)
788 if (c
== '\"' || c
== '\\')
795 #ifdef USE_TEXT_PROPERTIES
796 if (!NULL_INTERVAL_P (XSTRING (obj
)->intervals
))
798 traverse_intervals (XSTRING (obj
)->intervals
,
799 0, 0, print_interval
, printcharfun
);
810 register int confusing
;
811 register unsigned char *p
= XSYMBOL (obj
)->name
->data
;
812 register unsigned char *end
= p
+ XSYMBOL (obj
)->name
->size
;
813 register unsigned char c
;
815 if (p
!= end
&& (*p
== '-' || *p
== '+')) p
++;
820 while (p
!= end
&& *p
>= '0' && *p
<= '9')
822 confusing
= (end
== p
);
825 p
= XSYMBOL (obj
)->name
->data
;
832 if (c
== '\"' || c
== '\\' || c
== '\'' || c
== ';' || c
== '#' ||
833 c
== '(' || c
== ')' || c
== ',' || c
=='.' || c
== '`' ||
834 c
== '[' || c
== ']' || c
== '?' || c
<= 040 || confusing
)
835 PRINTCHAR ('\\'), confusing
= 0;
843 /* If deeper than spec'd depth, print placeholder. */
844 if (XTYPE (Vprint_level
) == Lisp_Int
845 && print_depth
> XINT (Vprint_level
))
847 strout ("...", -1, printcharfun
);
854 register int max
= 0;
856 if (XTYPE (Vprint_length
) == Lisp_Int
)
857 max
= XINT (Vprint_length
);
858 /* Could recognize circularities in cdrs here,
859 but that would make printing of long lists quadratic.
860 It's not worth doing. */
867 strout ("...", 3, printcharfun
);
870 print (Fcar (obj
), printcharfun
, escapeflag
);
874 if (!NILP (obj
) && !CONSP (obj
))
876 strout (" . ", 3, printcharfun
);
877 print (obj
, printcharfun
, escapeflag
);
883 strout ("#", -1, printcharfun
);
888 register Lisp_Object tem
;
889 for (i
= 0; i
< XVECTOR (obj
)->size
; i
++)
891 if (i
) PRINTCHAR (' ');
892 tem
= XVECTOR (obj
)->contents
[i
];
893 print (tem
, printcharfun
, escapeflag
);
901 if (NILP (XBUFFER (obj
)->name
))
902 strout ("#<killed buffer>", -1, printcharfun
);
905 strout ("#<buffer ", -1, printcharfun
);
906 print_string (XBUFFER (obj
)->name
, printcharfun
);
910 print_string (XBUFFER (obj
)->name
, printcharfun
);
916 strout ("#<process ", -1, printcharfun
);
917 print_string (XPROCESS (obj
)->name
, printcharfun
);
921 print_string (XPROCESS (obj
)->name
, printcharfun
);
925 strout ("#<window ", -1, printcharfun
);
926 sprintf (buf
, "%d", XFASTINT (XWINDOW (obj
)->sequence_number
));
927 strout (buf
, -1, printcharfun
);
928 if (!NILP (XWINDOW (obj
)->buffer
))
930 strout (" on ", -1, printcharfun
);
931 print_string (XBUFFER (XWINDOW (obj
)->buffer
)->name
, printcharfun
);
936 case Lisp_Window_Configuration
:
937 strout ("#<window-configuration>", -1, printcharfun
);
942 strout ((FRAME_LIVE_P (XFRAME (obj
))
943 ? "#<frame " : "#<dead frame "),
945 print_string (XFRAME (obj
)->name
, printcharfun
);
946 sprintf (buf
, " 0x%x", (unsigned int) (XFRAME (obj
)));
947 strout (buf
, -1, printcharfun
);
948 strout (">", -1, printcharfun
);
950 #endif /* MULTI_FRAME */
953 strout ("#<marker ", -1, printcharfun
);
954 if (!(XMARKER (obj
)->buffer
))
955 strout ("in no buffer", -1, printcharfun
);
958 sprintf (buf
, "at %d", marker_position (obj
));
959 strout (buf
, -1, printcharfun
);
960 strout (" in ", -1, printcharfun
);
961 print_string (XMARKER (obj
)->buffer
->name
, printcharfun
);
967 strout ("#<overlay ", -1, printcharfun
);
968 if (!(XMARKER (OVERLAY_START (obj
))->buffer
))
969 strout ("in no buffer", -1, printcharfun
);
972 sprintf (buf
, "from %d to %d in ",
973 marker_position (OVERLAY_START (obj
)),
974 marker_position (OVERLAY_END (obj
)));
975 strout (buf
, -1, printcharfun
);
976 print_string (XMARKER (OVERLAY_START (obj
))->buffer
->name
,
982 #endif /* standalone */
985 strout ("#<subr ", -1, printcharfun
);
986 strout (XSUBR (obj
)->symbol_name
, -1, printcharfun
);
994 #ifdef USE_TEXT_PROPERTIES
996 /* Print a description of INTERVAL using PRINTCHARFUN.
997 This is part of printing a string that has text properties. */
1000 print_interval (interval
, printcharfun
)
1002 Lisp_Object printcharfun
;
1005 print (make_number (interval
->position
), printcharfun
, 1);
1007 print (make_number (interval
->position
+ LENGTH (interval
)),
1010 print (interval
->plist
, printcharfun
, 1);
1013 #endif /* USE_TEXT_PROPERTIES */
1018 staticpro (&Qprint_escape_newlines
);
1019 Qprint_escape_newlines
= intern ("print-escape-newlines");
1021 DEFVAR_LISP ("standard-output", &Vstandard_output
,
1022 "Output stream `print' uses by default for outputting a character.\n\
1023 This may be any function of one argument.\n\
1024 It may also be a buffer (output is inserted before point)\n\
1025 or a marker (output is inserted and the marker is advanced)\n\
1026 or the symbol t (output appears in the minibuffer line).");
1027 Vstandard_output
= Qt
;
1028 Qstandard_output
= intern ("standard-output");
1029 staticpro (&Qstandard_output
);
1031 #ifdef LISP_FLOAT_TYPE
1032 DEFVAR_LISP ("float-output-format", &Vfloat_output_format
,
1033 "The format descriptor string used to print floats.\n\
1034 This is a %-spec like those accepted by `printf' in C,\n\
1035 but with some restrictions. It must start with the two characters `%.'.\n\
1036 After that comes an integer precision specification,\n\
1037 and then a letter which controls the format.\n\
1038 The letters allowed are `e', `f' and `g'.\n\
1039 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"\n\
1040 Use `f' for decimal point notation \"DIGITS.DIGITS\".\n\
1041 Use `g' to choose the shorter of those two formats for the number at hand.\n\
1042 The precision in any of these cases is the number of digits following\n\
1043 the decimal point. With `f', a precision of 0 means to omit the\n\
1044 decimal point. 0 is not allowed with `e' or `g'.\n\n\
1045 A value of nil means to use `%.17g'.");
1046 Vfloat_output_format
= Qnil
;
1047 Qfloat_output_format
= intern ("float-output-format");
1048 staticpro (&Qfloat_output_format
);
1049 #endif /* LISP_FLOAT_TYPE */
1051 DEFVAR_LISP ("print-length", &Vprint_length
,
1052 "Maximum length of list to print before abbreviating.\n\
1053 A value of nil means no limit.");
1054 Vprint_length
= Qnil
;
1056 DEFVAR_LISP ("print-level", &Vprint_level
,
1057 "Maximum depth of list nesting to print before abbreviating.\n\
1058 A value of nil means no limit.");
1059 Vprint_level
= Qnil
;
1061 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines
,
1062 "Non-nil means print newlines in strings as backslash-n.");
1063 print_escape_newlines
= 0;
1065 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
1066 staticpro (&Vprin1_to_string_buffer
);
1069 defsubr (&Sprin1_to_string
);
1073 defsubr (&Swrite_char
);
1074 defsubr (&Sexternal_debugging_output
);
1076 Qexternal_debugging_output
= intern ("external-debugging-output");
1077 staticpro (&Qexternal_debugging_output
);
1080 defsubr (&Swith_output_to_temp_buffer
);
1081 #endif /* not standalone */