1 /* Lisp object printing and output streams.
2 Copyright (C) 1985, 1986, 1988, 1992 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 Lisp_Object Vstandard_output
, Qstandard_output
;
37 #ifdef LISP_FLOAT_TYPE
38 Lisp_Object Vfloat_output_format
, Qfloat_output_format
;
39 #endif /* LISP_FLOAT_TYPE */
41 /* Avoid actual stack overflow in print. */
44 /* Detect most circularities to print finite output. */
45 #define PRINT_CIRCLE 200
46 Lisp_Object being_printed
[PRINT_CIRCLE
];
48 /* Maximum length of list to print in full; noninteger means
49 effectively infinity */
51 Lisp_Object Vprint_length
;
53 /* Maximum depth of list to print in full; noninteger means
54 effectively infinity. */
56 Lisp_Object Vprint_level
;
58 /* Nonzero means print newlines in strings as \n. */
60 int print_escape_newlines
;
62 Lisp_Object Qprint_escape_newlines
;
64 /* Nonzero means print newline before next minibuffer message.
67 extern int noninteractive_need_newline
;
68 #ifdef MAX_PRINT_CHARS
69 static int print_chars
;
71 #endif /* MAX_PRINT_CHARS */
74 /* Convert between chars and GLYPHs */
78 register GLYPH
*glyphs
;
88 str_to_glyph_cpy (str
, glyphs
)
92 register GLYPH
*gp
= glyphs
;
93 register char *cp
= str
;
100 str_to_glyph_ncpy (str
, glyphs
, n
)
105 register GLYPH
*gp
= glyphs
;
106 register char *cp
= str
;
113 glyph_to_str_cpy (glyphs
, str
)
117 register GLYPH
*gp
= glyphs
;
118 register char *cp
= str
;
121 *str
++ = *gp
++ & 0377;
125 /* Low level output routines for charaters and strings */
127 /* Lisp functions to do output using a stream
128 must have the stream in a variable called printcharfun
129 and must start with PRINTPREPARE and end with PRINTFINISH.
130 Use PRINTCHAR to output one character,
131 or call strout to output a block of characters.
132 Also, each one must have the declarations
133 struct buffer *old = current_buffer;
134 int old_point = -1, start_point;
135 Lisp_Object original;
138 #define PRINTPREPARE \
139 original = printcharfun; \
140 if (NILP (printcharfun)) printcharfun = Qt; \
141 if (XTYPE (printcharfun) == Lisp_Buffer) \
142 { if (XBUFFER (printcharfun) != current_buffer) Fset_buffer (printcharfun); \
143 printcharfun = Qnil;}\
144 if (XTYPE (printcharfun) == Lisp_Marker) \
145 { if (XMARKER (original)->buffer != current_buffer) \
146 set_buffer_internal (XMARKER (original)->buffer); \
148 SET_PT (marker_position (printcharfun)); \
149 start_point = point; \
150 printcharfun = Qnil;}
152 #define PRINTFINISH \
153 if (XTYPE (original) == Lisp_Marker) \
154 Fset_marker (original, make_number (point), Qnil); \
155 if (old_point >= 0) \
156 SET_PT ((old_point >= start_point ? point - start_point : 0) + old_point); \
157 if (old != current_buffer) \
158 set_buffer_internal (old)
160 #define PRINTCHAR(ch) printchar (ch, printcharfun)
162 /* Index of first unused element of FRAME_MESSAGE_BUF(selected_frame). */
163 static int printbufidx
;
172 #ifdef MAX_PRINT_CHARS
175 #endif /* MAX_PRINT_CHARS */
189 noninteractive_need_newline
= 1;
193 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (selected_frame
)
194 || !message_buf_print
)
196 echo_area_glyphs
= FRAME_MESSAGE_BUF (selected_frame
);
198 message_buf_print
= 1;
201 if (printbufidx
< FRAME_WIDTH (selected_frame
) - 1)
202 FRAME_MESSAGE_BUF (selected_frame
)[printbufidx
++] = ch
;
203 FRAME_MESSAGE_BUF (selected_frame
)[printbufidx
] = 0;
207 #endif /* not standalone */
214 strout (ptr
, size
, printcharfun
)
217 Lisp_Object printcharfun
;
221 if (EQ (printcharfun
, Qnil
))
223 insert (ptr
, size
>= 0 ? size
: strlen (ptr
));
224 #ifdef MAX_PRINT_CHARS
226 print_chars
+= size
>= 0 ? size
: strlen(ptr
);
227 #endif /* MAX_PRINT_CHARS */
230 if (EQ (printcharfun
, Qt
))
232 i
= size
>= 0 ? size
: strlen (ptr
);
233 #ifdef MAX_PRINT_CHARS
236 #endif /* MAX_PRINT_CHARS */
240 fwrite (ptr
, 1, i
, stdout
);
241 noninteractive_need_newline
= 1;
245 if (echo_area_glyphs
!= FRAME_MESSAGE_BUF (selected_frame
)
246 || !message_buf_print
)
248 echo_area_glyphs
= FRAME_MESSAGE_BUF (selected_frame
);
250 message_buf_print
= 1;
253 if (i
> FRAME_WIDTH (selected_frame
) - printbufidx
- 1)
254 i
= FRAME_WIDTH (selected_frame
) - printbufidx
- 1;
255 bcopy (ptr
, &FRAME_MESSAGE_BUF (selected_frame
) [printbufidx
], i
);
257 FRAME_MESSAGE_BUF (selected_frame
) [printbufidx
] = 0;
264 PRINTCHAR (ptr
[i
++]);
267 PRINTCHAR (ptr
[i
++]);
270 /* Print the contents of a string STRING using PRINTCHARFUN.
271 It isn't safe to use strout, because printing one char can relocate. */
273 print_string (string
, printcharfun
)
275 Lisp_Object printcharfun
;
277 if (EQ (printcharfun
, Qnil
) || EQ (printcharfun
, Qt
))
278 /* In predictable cases, strout is safe: output to buffer or frame. */
279 strout (XSTRING (string
)->data
, XSTRING (string
)->size
, printcharfun
);
282 /* Otherwise, fetch the string address for each character. */
284 int size
= XSTRING (string
)->size
;
287 for (i
= 0; i
< size
; i
++)
288 PRINTCHAR (XSTRING (string
)->data
[i
]);
293 DEFUN ("write-char", Fwrite_char
, Swrite_char
, 1, 2, 0,
294 "Output character CHAR to stream STREAM.\n\
295 STREAM defaults to the value of `standard-output' (which see).")
297 Lisp_Object ch
, printcharfun
;
299 struct buffer
*old
= current_buffer
;
302 Lisp_Object original
;
304 if (NILP (printcharfun
))
305 printcharfun
= Vstandard_output
;
306 CHECK_NUMBER (ch
, 0);
308 PRINTCHAR (XINT (ch
));
313 /* Used from outside of print.c to print a block of SIZE chars at DATA
314 on the default output stream.
315 Do not use this on the contents of a Lisp string. */
317 write_string (data
, size
)
321 struct buffer
*old
= current_buffer
;
322 Lisp_Object printcharfun
;
325 Lisp_Object original
;
327 printcharfun
= Vstandard_output
;
330 strout (data
, size
, printcharfun
);
334 /* Used from outside of print.c to print a block of SIZE chars at DATA
335 on a specified stream PRINTCHARFUN.
336 Do not use this on the contents of a Lisp string. */
338 write_string_1 (data
, size
, printcharfun
)
341 Lisp_Object printcharfun
;
343 struct buffer
*old
= current_buffer
;
346 Lisp_Object original
;
349 strout (data
, size
, printcharfun
);
357 temp_output_buffer_setup (bufname
)
360 register struct buffer
*old
= current_buffer
;
361 register Lisp_Object buf
;
363 Fset_buffer (Fget_buffer_create (build_string (bufname
)));
365 current_buffer
->read_only
= Qnil
;
368 XSET (buf
, Lisp_Buffer
, current_buffer
);
369 specbind (Qstandard_output
, buf
);
371 set_buffer_internal (old
);
375 internal_with_output_to_temp_buffer (bufname
, function
, args
)
377 Lisp_Object (*function
) ();
380 int count
= specpdl_ptr
- specpdl
;
381 Lisp_Object buf
, val
;
383 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
384 temp_output_buffer_setup (bufname
);
385 buf
= Vstandard_output
;
387 val
= (*function
) (args
);
389 temp_output_buffer_show (buf
);
391 return unbind_to (count
, val
);
394 DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer
, Swith_output_to_temp_buffer
,
396 "Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.\n\
397 The buffer is cleared out initially, and marked as unmodified when done.\n\
398 All output done by BODY is inserted in that buffer by default.\n\
399 The buffer is displayed in another window, but not selected.\n\
400 The value of the last form in BODY is returned.\n\
401 If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\n\
402 If variable `temp-buffer-show-hook' is non-nil, call it at the end\n\
403 to get the buffer displayed. It gets one argument, the buffer to display.")
409 int count
= specpdl_ptr
- specpdl
;
410 Lisp_Object buf
, val
;
413 name
= Feval (Fcar (args
));
416 CHECK_STRING (name
, 0);
417 temp_output_buffer_setup (XSTRING (name
)->data
);
418 buf
= Vstandard_output
;
420 val
= Fprogn (Fcdr (args
));
422 temp_output_buffer_show (buf
);
424 return unbind_to (count
, val
);
426 #endif /* not standalone */
428 static void print ();
430 DEFUN ("terpri", Fterpri
, Sterpri
, 0, 1, 0,
431 "Output a newline to STREAM.\n\
432 If STREAM is omitted or nil, the value of `standard-output' is used.")
434 Lisp_Object printcharfun
;
436 struct buffer
*old
= current_buffer
;
439 Lisp_Object original
;
441 if (NILP (printcharfun
))
442 printcharfun
= Vstandard_output
;
449 DEFUN ("prin1", Fprin1
, Sprin1
, 1, 2, 0,
450 "Output the printed representation of OBJECT, any Lisp object.\n\
451 Quoting characters are printed when needed to make output that `read'\n\
452 can handle, whenever this is possible.\n\
453 Output stream is STREAM, or value of `standard-output' (which see).")
455 Lisp_Object obj
, printcharfun
;
457 struct buffer
*old
= current_buffer
;
460 Lisp_Object original
;
462 #ifdef MAX_PRINT_CHARS
464 #endif /* MAX_PRINT_CHARS */
465 if (NILP (printcharfun
))
466 printcharfun
= Vstandard_output
;
469 print (obj
, printcharfun
, 1);
474 /* a buffer which is used to hold output being built by prin1-to-string */
475 Lisp_Object Vprin1_to_string_buffer
;
477 DEFUN ("prin1-to-string", Fprin1_to_string
, Sprin1_to_string
, 1, 2, 0,
478 "Return a string containing the printed representation of OBJECT,\n\
479 any Lisp object. Quoting characters are used when needed to make output\n\
480 that `read' can handle, whenever this is possible, unless the optional\n\
481 second argument NOESCAPE is non-nil.")
483 Lisp_Object obj
, noescape
;
485 struct buffer
*old
= current_buffer
;
488 Lisp_Object original
, printcharfun
;
491 printcharfun
= Vprin1_to_string_buffer
;
494 print (obj
, printcharfun
, NILP (noescape
));
495 /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
497 set_buffer_internal (XBUFFER (Vprin1_to_string_buffer
));
498 obj
= Fbuffer_string ();
502 set_buffer_internal (old
);
508 DEFUN ("princ", Fprinc
, Sprinc
, 1, 2, 0,
509 "Output the printed representation of OBJECT, any Lisp object.\n\
510 No quoting characters are used; no delimiters are printed around\n\
511 the contents of strings.\n\
512 Output stream is STREAM, or value of standard-output (which see).")
514 Lisp_Object obj
, printcharfun
;
516 struct buffer
*old
= current_buffer
;
519 Lisp_Object original
;
521 if (NILP (printcharfun
))
522 printcharfun
= Vstandard_output
;
525 print (obj
, printcharfun
, 0);
530 DEFUN ("print", Fprint
, Sprint
, 1, 2, 0,
531 "Output the printed representation of OBJECT, with newlines around it.\n\
532 Quoting characters are printed when needed to make output that `read'\n\
533 can handle, whenever this is possible.\n\
534 Output stream is STREAM, or value of `standard-output' (which see).")
536 Lisp_Object obj
, printcharfun
;
538 struct buffer
*old
= current_buffer
;
541 Lisp_Object original
;
544 #ifdef MAX_PRINT_CHARS
546 max_print
= MAX_PRINT_CHARS
;
547 #endif /* MAX_PRINT_CHARS */
548 if (NILP (printcharfun
))
549 printcharfun
= Vstandard_output
;
554 print (obj
, printcharfun
, 1);
557 #ifdef MAX_PRINT_CHARS
560 #endif /* MAX_PRINT_CHARS */
565 /* The subroutine object for external-debugging-output is kept here
566 for the convenience of the debugger. */
567 Lisp_Object Qexternal_debugging_output
;
569 DEFUN ("external-debugging-output", Fexternal_debugging_output
, Sexternal_debugging_output
, 1, 1, 0,
570 "Write CHARACTER to stderr.\n\
571 You can call print while debugging emacs, and pass it this function\n\
572 to make it write to the debugging output.\n")
574 Lisp_Object character
;
576 CHECK_NUMBER (character
, 0);
577 putc (XINT (character
), stderr
);
582 #ifdef LISP_FLOAT_TYPE
585 * The buffer should be at least as large as the max string size of the
586 * largest float, printed in the biggest notation. This is undoubtably
587 * 20d float_output_format, with the negative of the C-constant "HUGE"
590 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
592 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
593 * case of -1e307 in 20d float_output_format. What is one to do (short of
594 * re-writing _doprnt to be more sane)?
599 float_to_string (buf
, data
)
603 register unsigned char *cp
, c
;
606 if (NILP (Vfloat_output_format
)
607 || XTYPE (Vfloat_output_format
) != Lisp_String
)
609 sprintf (buf
, "%.20g", data
);
612 /* Check that the spec we have is fully valid.
613 This means not only valid for printf,
614 but meant for floats, and reasonable. */
615 cp
= XSTRING (Vfloat_output_format
)->data
;
624 ((c
= *cp
) >= '0' && c
<= '9');
631 if (*cp
!= 'e' && *cp
!= 'f' && *cp
!= 'g')
634 if (width
< (*cp
!= 'e') || width
> DBL_DIG
)
640 sprintf (buf
, XSTRING (Vfloat_output_format
)->data
, data
);
643 /* Make sure there is a decimal point or an exponent,
644 so that the value is readable as a float. */
645 for (cp
= buf
; *cp
; cp
++)
646 if (*cp
< '0' || *cp
> '9')
656 #endif /* LISP_FLOAT_TYPE */
659 print (obj
, printcharfun
, escapeflag
)
660 #ifndef RTPC_REGISTER_BUG
661 register Lisp_Object obj
;
665 register Lisp_Object printcharfun
;
672 #if 1 /* I'm not sure this is really worth doing. */
673 /* Detect circularities and truncate them.
674 No need to offer any alternative--this is better than an error. */
675 if (XTYPE (obj
) == Lisp_Cons
|| XTYPE (obj
) == Lisp_Vector
676 || XTYPE (obj
) == Lisp_Compiled
)
679 for (i
= 0; i
< print_depth
; i
++)
680 if (EQ (obj
, being_printed
[i
]))
682 sprintf (buf
, "#%d", i
);
683 strout (buf
, -1, printcharfun
);
689 being_printed
[print_depth
] = obj
;
692 if (print_depth
> PRINT_CIRCLE
)
693 error ("Apparently circular structure being printed");
694 #ifdef MAX_PRINT_CHARS
695 if (max_print
&& print_chars
> max_print
)
700 #endif /* MAX_PRINT_CHARS */
702 #ifdef SWITCH_ENUM_BUG
703 switch ((int) XTYPE (obj
))
709 /* We're in trouble if this happens!
710 Probably should just abort () */
711 strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun
);
712 sprintf (buf
, "(#o%3o)", (int) XTYPE (obj
));
713 strout (buf
, -1, printcharfun
);
714 strout (" Save your buffers immediately and please report this bug>",
718 #ifdef LISP_FLOAT_TYPE
721 char pigbuf
[350]; /* see comments in float_to_string */
723 float_to_string (pigbuf
, XFLOAT(obj
)->data
);
724 strout (pigbuf
, -1, printcharfun
);
727 #endif /* LISP_FLOAT_TYPE */
730 sprintf (buf
, "%d", XINT (obj
));
731 strout (buf
, -1, printcharfun
);
736 print_string (obj
, printcharfun
);
740 register unsigned char c
;
744 /* You can't gcpro register variables, so copy obj to a
745 non-register variable so we can gcpro it without
746 making it non-register. */
751 for (i
= 0; i
< XSTRING (obj
)->size
; i
++)
754 c
= XSTRING (obj
)->data
[i
];
755 if (c
== '\n' && print_escape_newlines
)
762 if (c
== '\"' || c
== '\\')
774 register int confusing
;
775 register unsigned char *p
= XSYMBOL (obj
)->name
->data
;
776 register unsigned char *end
= p
+ XSYMBOL (obj
)->name
->size
;
777 register unsigned char c
;
779 if (p
!= end
&& (*p
== '-' || *p
== '+')) p
++;
784 while (p
!= end
&& *p
>= '0' && *p
<= '9')
786 confusing
= (end
== p
);
789 p
= XSYMBOL (obj
)->name
->data
;
796 if (c
== '\"' || c
== '\\' || c
== '\'' || c
== ';' || c
== '#' ||
797 c
== '(' || c
== ')' || c
== ',' || c
=='.' || c
== '`' ||
798 c
== '[' || c
== ']' || c
== '?' || c
<= 040 || confusing
)
799 PRINTCHAR ('\\'), confusing
= 0;
807 /* If deeper than spec'd depth, print placeholder. */
808 if (XTYPE (Vprint_level
) == Lisp_Int
809 && print_depth
> XINT (Vprint_level
))
811 strout ("...", -1, printcharfun
);
818 register int max
= 0;
820 if (XTYPE (Vprint_length
) == Lisp_Int
)
821 max
= XINT (Vprint_length
);
822 /* Could recognize circularities in cdrs here,
823 but that would make printing of long lists quadratic.
824 It's not worth doing. */
831 strout ("...", 3, printcharfun
);
834 print (Fcar (obj
), printcharfun
, escapeflag
);
838 if (!NILP (obj
) && !CONSP (obj
))
840 strout (" . ", 3, printcharfun
);
841 print (obj
, printcharfun
, escapeflag
);
847 strout ("#", -1, printcharfun
);
852 register Lisp_Object tem
;
853 for (i
= 0; i
< XVECTOR (obj
)->size
; i
++)
855 if (i
) PRINTCHAR (' ');
856 tem
= XVECTOR (obj
)->contents
[i
];
857 print (tem
, printcharfun
, escapeflag
);
865 if (NILP (XBUFFER (obj
)->name
))
866 strout ("#<killed buffer>", -1, printcharfun
);
869 strout ("#<buffer ", -1, printcharfun
);
870 print_string (XBUFFER (obj
)->name
, printcharfun
);
874 print_string (XBUFFER (obj
)->name
, printcharfun
);
880 strout ("#<process ", -1, printcharfun
);
881 print_string (XPROCESS (obj
)->name
, printcharfun
);
885 print_string (XPROCESS (obj
)->name
, printcharfun
);
889 strout ("#<window ", -1, printcharfun
);
890 sprintf (buf
, "%d", XFASTINT (XWINDOW (obj
)->sequence_number
));
891 strout (buf
, -1, printcharfun
);
892 if (!NILP (XWINDOW (obj
)->buffer
))
894 strout (" on ", -1, printcharfun
);
895 print_string (XBUFFER (XWINDOW (obj
)->buffer
)->name
, printcharfun
);
900 case Lisp_Window_Configuration
:
901 strout ("#<window-configuration>", -1, printcharfun
);
906 strout ((FRAME_LIVE_P (XFRAME (obj
))
907 ? "#<frame " : "#<dead frame "),
909 print_string (XFRAME (obj
)->name
, printcharfun
);
910 sprintf (buf
, " 0x%x", (unsigned int) (XFRAME (obj
)));
911 strout (buf
, -1, printcharfun
);
912 strout (">", -1, printcharfun
);
914 #endif /* MULTI_FRAME */
917 strout ("#<marker ", -1, printcharfun
);
918 if (!(XMARKER (obj
)->buffer
))
919 strout ("in no buffer", -1, printcharfun
);
922 sprintf (buf
, "at %d", marker_position (obj
));
923 strout (buf
, -1, printcharfun
);
924 strout (" in ", -1, printcharfun
);
925 print_string (XMARKER (obj
)->buffer
->name
, printcharfun
);
929 #endif /* standalone */
932 strout ("#<subr ", -1, printcharfun
);
933 strout (XSUBR (obj
)->symbol_name
, -1, printcharfun
);
944 staticpro (&Qprint_escape_newlines
);
945 Qprint_escape_newlines
= intern ("print-escape-newlines");
947 DEFVAR_LISP ("standard-output", &Vstandard_output
,
948 "Output stream `print' uses by default for outputting a character.\n\
949 This may be any function of one argument.\n\
950 It may also be a buffer (output is inserted before point)\n\
951 or a marker (output is inserted and the marker is advanced)\n\
952 or the symbol t (output appears in the minibuffer line).");
953 Vstandard_output
= Qt
;
954 Qstandard_output
= intern ("standard-output");
955 staticpro (&Qstandard_output
);
957 #ifdef LISP_FLOAT_TYPE
958 DEFVAR_LISP ("float-output-format", &Vfloat_output_format
,
959 "The format descriptor string used to print floats.\n\
960 This is a %-spec like those accepted by `printf' in C,\n\
961 but with some restrictions. It must start with the two characters `%.'.\n\
962 After that comes an integer precision specification,\n\
963 and then a letter which controls the format.\n\
964 The letters allowed are `e', `f' and `g'.\n\
965 Use `e' for exponential notation \"DIG.DIGITSeEXPT\"\n\
966 Use `f' for decimal point notation \"DIGITS.DIGITS\".\n\
967 Use `g' to choose the shorter of those two formats for the number at hand.\n\
968 The precision in any of these cases is the number of digits following\n\
969 the decimal point. With `f', a precision of 0 means to omit the\n\
970 decimal point. 0 is not allowed with `f' or `g'.\n\n\
971 A value of nil means to use `%.20g'.");
972 Vfloat_output_format
= Qnil
;
973 Qfloat_output_format
= intern ("float-output-format");
974 staticpro (&Qfloat_output_format
);
975 #endif /* LISP_FLOAT_TYPE */
977 DEFVAR_LISP ("print-length", &Vprint_length
,
978 "Maximum length of list to print before abbreviating.\n\
979 A value of nil means no limit.");
980 Vprint_length
= Qnil
;
982 DEFVAR_LISP ("print-level", &Vprint_level
,
983 "Maximum depth of list nesting to print before abbreviating.\n\
984 A value of nil means no limit.");
987 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines
,
988 "Non-nil means print newlines in strings as backslash-n.");
989 print_escape_newlines
= 0;
991 /* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
992 staticpro (&Vprin1_to_string_buffer
);
995 defsubr (&Sprin1_to_string
);
999 defsubr (&Swrite_char
);
1000 defsubr (&Sexternal_debugging_output
);
1002 Qexternal_debugging_output
= intern ("external-debugging-output");
1003 staticpro (&Qexternal_debugging_output
);
1006 defsubr (&Swith_output_to_temp_buffer
);
1007 #endif /* not standalone */