1 /* Lisp object printing and output streams.
2 Copyright (C) 1985, 1986, 1988, 1992-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995, 1996, 2000, 2002 Ben Wing.
5 This file is part of XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: Not synched with FSF. */
24 /* This file has been Mule-ized. */
26 /* Seriously hacked on by Ben Wing for Mule. */
31 #include "backtrace.h"
34 #include "console-tty.h"
35 #include "console-stream.h"
42 #include "console-msw.h"
46 /* Define if not in float.h */
51 Lisp_Object Vstandard_output, Qstandard_output;
53 /* The subroutine object for external-debugging-output is kept here
54 for the convenience of the debugger. */
55 Lisp_Object Qexternal_debugging_output, Qalternate_debugging_output;
57 #ifdef HAVE_MS_WINDOWS
58 Lisp_Object Qmswindows_debugging_output;
61 /* Avoid actual stack overflow in print. */
62 static int print_depth;
64 /* Detect most circularities to print finite output. */
65 #define PRINT_CIRCLE 200
66 static Lisp_Object being_printed[PRINT_CIRCLE];
68 /* Maximum length of list or vector to print in full; noninteger means
69 effectively infinity */
71 Lisp_Object Vprint_length;
72 Lisp_Object Qprint_length;
74 /* Maximum length of string to print in full; noninteger means
75 effectively infinity */
77 Lisp_Object Vprint_string_length;
78 Lisp_Object Qprint_string_length;
80 /* Maximum depth of list to print in full; noninteger means
81 effectively infinity. */
83 Lisp_Object Vprint_level;
85 /* Label to use when making echo-area messages. */
87 Lisp_Object Vprint_message_label;
89 /* Nonzero means print newlines in strings as \n. */
91 int print_escape_newlines;
94 /* Non-nil means print #: before uninterned symbols.
95 Neither t nor nil means so that and don't clear Vprint_gensym_alist
96 on entry to and exit from print functions. */
97 Lisp_Object Vprint_gensym;
98 Lisp_Object Vprint_gensym_alist;
100 Lisp_Object Qdisplay_error;
101 Lisp_Object Qprint_message_label;
103 /* Force immediate output of all printed data. Used for debugging. */
104 int print_unbuffered;
106 FILE *termscript; /* Stdio stream being used for copy of all output. */
110 int stdout_needs_newline;
113 std_handle_out_external (FILE *stream, Lisp_Object lstream,
114 const Extbyte *extptr, Extcount extlen,
115 /* is this really stdout/stderr?
116 (controls termscript writing) */
117 int output_is_std_handle,
123 HANDLE errhand = GetStdHandle (STD_INPUT_HANDLE);
124 int no_useful_stderr = errhand == 0 || errhand == INVALID_HANDLE_VALUE;
126 if (!no_useful_stderr)
127 no_useful_stderr = !PeekNamedPipe (errhand, 0, 0, 0, 0, 0);
128 /* we typically have no useful stdout/stderr under windows if we're
129 being invoked graphically. */
130 if (no_useful_stderr)
131 mswindows_output_console_string (extptr, extlen);
135 fwrite (extptr, 1, extlen, stream);
137 /* Q122442 says that pipes are "treated as files, not as
138 devices", and that this is a feature. Before I found that
139 article, I thought it was a bug. Thanks MS, I feel much
148 Lstream_write (XLSTREAM (lstream), extptr, extlen);
150 if (output_is_std_handle)
154 fwrite (extptr, 1, extlen, termscript);
157 stdout_needs_newline = (extptr[extlen - 1] != '\n');
161 /* #### The following function should be replaced a call to the
162 emacs_doprnt_*() functions. This is the only way to ensure that
163 I18N3 works properly (many implementations of the *printf()
164 functions, including the ones included in glibc, do not implement
165 the %###$ argument-positioning syntax).
167 Note, however, that to do this, we'd have to
169 1) pre-allocate all the lstreams and do whatever else was necessary
170 to make sure that no allocation occurs, since these functions may be
171 called from fatal_error_signal().
173 2) (to be really correct) make a new lstream that outputs using
174 mswindows_output_console_string(). */
177 std_handle_out_va (FILE *stream, const char *fmt, va_list args)
179 Bufbyte kludge[8192];
184 retval = vsprintf ((char *) kludge, fmt, args);
185 if (initialized && !inhibit_non_essential_printing_operations)
186 TO_EXTERNAL_FORMAT (DATA, (kludge, strlen ((char *) kludge)),
187 ALLOCA, (extptr, extlen),
191 extptr = (Extbyte *) kludge;
192 extlen = (Extcount) strlen ((char *) kludge);
195 std_handle_out_external (stream, Qnil, extptr, extlen, 1, 1);
199 /* Output portably to stderr or its equivalent; call GETTEXT on the
200 format string. Automatically flush when done. */
203 stderr_out (const char *fmt, ...)
207 va_start (args, fmt);
210 (stderr, initialized && !fatal_error_in_progress ? GETTEXT (fmt) : fmt,
216 /* Output portably to stdout or its equivalent; call GETTEXT on the
217 format string. Automatically flush when done. */
220 stdout_out (const char *fmt, ...)
224 va_start (args, fmt);
227 (stdout, initialized && !fatal_error_in_progress ? GETTEXT (fmt) : fmt,
234 fatal (const char *fmt, ...)
237 va_start (args, fmt);
239 stderr_out ("\nXEmacs: ");
240 std_handle_out_va (stderr, GETTEXT (fmt), args);
247 /* Write a string (in internal format) to stdio stream STREAM. */
250 write_string_to_stdio_stream (FILE *stream, struct console *con,
252 Bytecount offset, Bytecount len,
253 Lisp_Object coding_system,
257 const Extbyte *extptr;
259 /* #### yuck! sometimes this function is called with string data,
260 and the following call may gc. */
262 Bufbyte *puta = (Bufbyte *) alloca (len);
263 memcpy (puta, str + offset, len);
265 if (initialized && !inhibit_non_essential_printing_operations)
266 TO_EXTERNAL_FORMAT (DATA, (puta, len),
267 ALLOCA, (extptr, extlen),
271 extptr = (Extbyte *) puta;
272 extlen = (Bytecount) len;
277 std_handle_out_external (stream, Qnil, extptr, extlen,
278 stream == stdout || stream == stderr, must_flush);
281 assert (CONSOLE_TTY_P (con));
282 std_handle_out_external (0, CONSOLE_TTY_DATA (con)->outstream,
284 CONSOLE_TTY_DATA (con)->is_stdio, must_flush);
288 /* Write a string to the output location specified in FUNCTION.
289 Arguments NONRELOC, RELOC, OFFSET, and LEN are as in
290 buffer_insert_string_1() in insdel.c. */
293 output_string (Lisp_Object function, const Bufbyte *nonreloc,
294 Lisp_Object reloc, Bytecount offset, Bytecount len)
296 /* This function can GC */
298 /* We change the value of nonreloc (fetching it from reloc as
299 necessary), but we don't want to pass this changed value on to
300 other functions that take both a nonreloc and a reloc, or things
301 may get confused and an assertion failure in
302 fixup_internal_substring() may get triggered. */
303 const Bufbyte *newnonreloc = nonreloc;
304 struct gcpro gcpro1, gcpro2;
306 /* Emacs won't print while GCing, but an external debugger might */
307 if (gc_in_progress) return;
309 /* Perhaps not necessary but probably safer. */
310 GCPRO2 (function, reloc);
312 fixup_internal_substring (newnonreloc, reloc, offset, &len);
315 newnonreloc = XSTRING_DATA (reloc);
317 cclen = bytecount_to_charcount (newnonreloc + offset, len);
319 if (LSTREAMP (function))
323 /* Protect against Lstream_write() causing a GC and
324 relocating the string. For small strings, we do it by
325 alloc'ing the string and using a copy; for large strings,
329 Bufbyte *copied = alloca_array (Bufbyte, len);
330 memcpy (copied, newnonreloc + offset, len);
331 Lstream_write (XLSTREAM (function), copied, len);
335 int speccount = specpdl_depth ();
336 record_unwind_protect (restore_gc_inhibit,
337 make_int (gc_currently_forbidden));
338 gc_currently_forbidden = 1;
339 Lstream_write (XLSTREAM (function), newnonreloc + offset, len);
340 unbind_to (speccount, Qnil);
344 Lstream_write (XLSTREAM (function), newnonreloc + offset, len);
346 if (print_unbuffered)
347 Lstream_flush (XLSTREAM (function));
349 else if (BUFFERP (function))
351 CHECK_LIVE_BUFFER (function);
352 buffer_insert_string (XBUFFER (function), nonreloc, reloc, offset, len);
354 else if (MARKERP (function))
356 /* marker_position() will err if marker doesn't point anywhere. */
357 Bufpos spoint = marker_position (function);
359 buffer_insert_string_1 (XMARKER (function)->buffer,
360 spoint, nonreloc, reloc, offset, len,
362 Fset_marker (function, make_int (spoint + cclen),
363 Fmarker_buffer (function));
365 else if (FRAMEP (function))
367 /* This gets used by functions not invoking print_prepare(),
368 such as Fwrite_char, Fterpri, etc.. */
369 struct frame *f = XFRAME (function);
370 CHECK_LIVE_FRAME (function);
372 if (!EQ (Vprint_message_label, echo_area_status (f)))
373 clear_echo_area_from_print (f, Qnil, 1);
374 echo_area_append (f, nonreloc, reloc, offset, len, Vprint_message_label);
376 else if (EQ (function, Qt) || EQ (function, Qnil))
378 write_string_to_stdio_stream (stdout, 0, newnonreloc, offset, len,
379 Qterminal, print_unbuffered);
383 Charcount ccoff = bytecount_to_charcount (newnonreloc, offset);
386 for (iii = ccoff; iii < cclen + ccoff; iii++)
389 make_char (charptr_emchar_n (newnonreloc, iii)));
391 newnonreloc = XSTRING_DATA (reloc);
398 #define RESET_PRINT_GENSYM do { \
399 if (!CONSP (Vprint_gensym)) \
400 Vprint_gensym_alist = Qnil; \
404 canonicalize_printcharfun (Lisp_Object printcharfun)
406 if (NILP (printcharfun))
407 printcharfun = Vstandard_output;
409 if (EQ (printcharfun, Qt) || NILP (printcharfun))
410 printcharfun = Fselected_frame (Qnil); /* print to minibuffer */
416 print_prepare (Lisp_Object printcharfun, Lisp_Object *frame_kludge)
418 /* Emacs won't print while GCing, but an external debugger might */
424 printcharfun = canonicalize_printcharfun (printcharfun);
426 /* Here we could safely return the canonicalized PRINTCHARFUN.
427 However, if PRINTCHARFUN is a frame, printing of complex
428 structures becomes very expensive, because `append-message'
429 (called by echo_area_append) gets called as many times as
430 output_string() is called (and that's a *lot*). append-message
431 tries to keep top of the message-stack in sync with the contents
432 of " *Echo Area" buffer, consing a new string for each component
433 of the printed structure. For instance, if you print (a a),
434 append-message will cons up the following strings:
442 and will use only the last one. With larger objects, this turns
443 into an O(n^2) consing frenzy that locks up XEmacs in incessant
446 We prevent this by creating a resizing_buffer stream and letting
447 the printer write into it. print_finish() will notice this
448 stream, and invoke echo_area_append() with the stream's buffer,
450 if (FRAMEP (printcharfun))
452 CHECK_LIVE_FRAME (printcharfun);
453 *frame_kludge = printcharfun;
454 printcharfun = make_resizing_buffer_output_stream ();
461 print_finish (Lisp_Object stream, Lisp_Object frame_kludge)
463 /* Emacs won't print while GCing, but an external debugger might */
469 /* See the comment in print_prepare(). */
470 if (FRAMEP (frame_kludge))
472 struct frame *f = XFRAME (frame_kludge);
473 Lstream *str = XLSTREAM (stream);
474 CHECK_LIVE_FRAME (frame_kludge);
477 if (!EQ (Vprint_message_label, echo_area_status (f)))
478 clear_echo_area_from_print (f, Qnil, 1);
479 echo_area_append (f, resizing_buffer_stream_ptr (str),
480 Qnil, 0, Lstream_byte_count (str),
481 Vprint_message_label);
482 Lstream_delete (str);
486 /* Used for printing a single-byte character (*not* any Emchar). */
487 #define write_char_internal(string_of_length_1, stream) \
488 output_string (stream, (const Bufbyte *) (string_of_length_1), \
491 /* NOTE: Do not call this with the data of a Lisp_String, as
492 printcharfun might cause a GC, which might cause the string's data
493 to be relocated. To princ a Lisp string, use:
495 print_internal (string, printcharfun, 0);
497 Also note that STREAM should be the result of
498 canonicalize_printcharfun() (i.e. Qnil means stdout, not
499 Vstandard_output, etc.) */
501 write_string_1 (const Bufbyte *str, Bytecount size, Lisp_Object stream)
503 /* This function can GC */
504 #ifdef ERROR_CHECK_BUFPOS
507 output_string (stream, str, Qnil, 0, size);
511 write_c_string (const char *str, Lisp_Object stream)
513 /* This function can GC */
514 write_string_1 ((const Bufbyte *) str, strlen (str), stream);
518 write_fmt_string (Lisp_Object stream, const char *fmt, ...)
524 vsprintf (bigbuf, fmt, va);
526 write_c_string (bigbuf, stream);
530 DEFUN ("write-char", Fwrite_char, 1, 2, 0, /*
531 Output character CHARACTER to stream STREAM.
532 STREAM defaults to the value of `standard-output' (which see).
536 /* This function can GC */
537 Bufbyte str[MAX_EMCHAR_LEN];
540 CHECK_CHAR_COERCE_INT (character);
541 len = set_charptr_emchar (str, XCHAR (character));
542 output_string (canonicalize_printcharfun (stream), str, Qnil, 0, len);
547 temp_output_buffer_setup (Lisp_Object bufname)
549 /* This function can GC */
550 struct buffer *old = current_buffer;
554 /* #### This function should accept a Lisp_Object instead of a char *,
555 so that proper translation on the buffer name can occur. */
558 Fset_buffer (Fget_buffer_create (bufname));
560 current_buffer->read_only = Qnil;
561 Ferase_buffer (Qnil);
563 XSETBUFFER (buf, current_buffer);
564 specbind (Qstandard_output, buf);
566 set_buffer_internal (old);
570 internal_with_output_to_temp_buffer (Lisp_Object bufname,
571 Lisp_Object (*function) (Lisp_Object arg),
573 Lisp_Object same_frame)
575 int speccount = specpdl_depth ();
576 struct gcpro gcpro1, gcpro2, gcpro3;
577 Lisp_Object buf = Qnil;
579 GCPRO3 (buf, arg, same_frame);
581 temp_output_buffer_setup (bufname);
582 buf = Vstandard_output;
584 arg = (*function) (arg);
586 temp_output_buffer_show (buf, same_frame);
589 return unbind_to (speccount, arg);
592 DEFUN ("with-output-to-temp-buffer", Fwith_output_to_temp_buffer, 1, UNEVALLED, 0, /*
593 Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.
594 The buffer is cleared out initially, and marked as unmodified when done.
595 All output done by BODY is inserted in that buffer by default.
596 The buffer is displayed in another window, but not selected.
597 The value of the last form in BODY is returned.
598 If BODY does not finish normally, the buffer BUFNAME is not displayed.
600 If variable `temp-buffer-show-function' is non-nil, call it at the end
601 to get the buffer displayed. It gets one argument, the buffer to display.
605 /* This function can GC */
606 Lisp_Object name = Qnil;
607 int speccount = specpdl_depth ();
608 struct gcpro gcpro1, gcpro2;
609 Lisp_Object val = Qnil;
612 /* #### should set the buffer to be translating. See print_internal(). */
616 name = Feval (XCAR (args));
620 temp_output_buffer_setup (name);
623 val = Fprogn (XCDR (args));
625 temp_output_buffer_show (Vstandard_output, Qnil);
627 return unbind_to (speccount, val);
630 DEFUN ("terpri", Fterpri, 0, 1, 0, /*
631 Output a newline to STREAM.
632 If STREAM is omitted or nil, the value of `standard-output' is used.
636 /* This function can GC */
637 write_char_internal ("\n", canonicalize_printcharfun (stream));
641 DEFUN ("prin1", Fprin1, 1, 2, 0, /*
642 Output the printed representation of OBJECT, any Lisp object.
643 Quoting characters are printed when needed to make output that `read'
644 can handle, whenever this is possible.
645 Output stream is STREAM, or value of `standard-output' (which see).
649 /* This function can GC */
650 Lisp_Object frame = Qnil;
651 struct gcpro gcpro1, gcpro2;
652 GCPRO2 (object, stream);
655 stream = print_prepare (stream, &frame);
656 print_internal (object, stream, 1);
657 print_finish (stream, frame);
663 DEFUN ("prin1-to-string", Fprin1_to_string, 1, 2, 0, /*
664 Return a string containing the printed representation of OBJECT,
665 any Lisp object. Quoting characters are used when needed to make output
666 that `read' can handle, whenever this is possible, unless the optional
667 second argument NOESCAPE is non-nil.
671 /* This function can GC */
672 Lisp_Object result = Qnil;
673 Lisp_Object stream = make_resizing_buffer_output_stream ();
674 Lstream *str = XLSTREAM (stream);
675 /* gcpro OBJECT in case a caller forgot to do so */
676 struct gcpro gcpro1, gcpro2, gcpro3;
677 GCPRO3 (object, stream, result);
681 print_internal (object, stream, NILP (noescape));
685 result = make_string (resizing_buffer_stream_ptr (str),
686 Lstream_byte_count (str));
687 Lstream_delete (str);
691 DEFUN ("princ", Fprinc, 1, 2, 0, /*
692 Output the printed representation of OBJECT, any Lisp object.
693 No quoting characters are used; no delimiters are printed around
694 the contents of strings.
695 Output stream is STREAM, or value of `standard-output' (which see).
699 /* This function can GC */
700 Lisp_Object frame = Qnil;
701 struct gcpro gcpro1, gcpro2;
703 GCPRO2 (object, stream);
704 stream = print_prepare (stream, &frame);
706 print_internal (object, stream, 0);
707 print_finish (stream, frame);
712 DEFUN ("print", Fprint, 1, 2, 0, /*
713 Output the printed representation of OBJECT, with newlines around it.
714 Quoting characters are printed when needed to make output that `read'
715 can handle, whenever this is possible.
716 Output stream is STREAM, or value of `standard-output' (which see).
720 /* This function can GC */
721 Lisp_Object frame = Qnil;
722 struct gcpro gcpro1, gcpro2;
724 GCPRO2 (object, stream);
725 stream = print_prepare (stream, &frame);
727 write_char_internal ("\n", stream);
728 print_internal (object, stream, 1);
729 write_char_internal ("\n", stream);
730 print_finish (stream, frame);
735 /* Print an error message for the error DATA to STREAM. This is a
736 complete implementation of `display-error', which used to be in
737 Lisp (see prim/cmdloop.el). It was ported to C so it can be used
738 efficiently by Ferror_message_string. Fdisplay_error and
739 Ferror_message_string are trivial wrappers around this function.
741 STREAM should be the result of canonicalize_printcharfun(). */
743 print_error_message (Lisp_Object error_object, Lisp_Object stream)
745 /* This function can GC */
746 Lisp_Object type = Fcar_safe (error_object);
747 Lisp_Object method = Qnil;
750 /* No need to GCPRO anything under the assumption that ERROR_OBJECT
753 if (! (CONSP (error_object) && SYMBOLP (type)
754 && CONSP (Fget (type, Qerror_conditions, Qnil))))
757 tail = XCDR (error_object);
765 tail = Fget (type, Qerror_conditions, Qnil);
768 if (!(CONSP (tail) && SYMBOLP (XCAR (tail))))
770 else if (!NILP (Fget (XCAR (tail), Qdisplay_error, Qnil)))
772 method = Fget (XCAR (tail), Qdisplay_error, Qnil);
781 int speccount = specpdl_depth ();
782 Lisp_Object frame = Qnil;
786 specbind (Qprint_message_label, Qerror);
787 stream = print_prepare (stream, &frame);
789 tail = Fcdr (error_object);
790 if (EQ (type, Qerror))
792 print_internal (Fcar (tail), stream, 0);
797 Lisp_Object errmsg = Fget (type, Qerror_message, Qnil);
799 print_internal (type, stream, 0);
801 print_internal (LISP_GETTEXT (errmsg), stream, 0);
805 write_c_string (first ? ": " : ", ", stream);
806 print_internal (Fcar (tail), stream, 1);
810 print_finish (stream, frame);
812 unbind_to (speccount, Qnil);
820 write_c_string (GETTEXT ("Peculiar error "), stream);
821 print_internal (error_object, stream, 1);
826 call2 (method, error_object, stream);
830 DEFUN ("error-message-string", Ferror_message_string, 1, 1, 0, /*
831 Convert ERROR-OBJECT to an error message, and return it.
833 The format of ERROR-OBJECT should be (ERROR-SYMBOL . DATA). The
834 message is equivalent to the one that would be issued by
835 `display-error' with the same argument.
839 /* This function can GC */
840 Lisp_Object result = Qnil;
841 Lisp_Object stream = make_resizing_buffer_output_stream ();
845 print_error_message (error_object, stream);
846 Lstream_flush (XLSTREAM (stream));
847 result = make_string (resizing_buffer_stream_ptr (XLSTREAM (stream)),
848 Lstream_byte_count (XLSTREAM (stream)));
849 Lstream_delete (XLSTREAM (stream));
855 DEFUN ("display-error", Fdisplay_error, 2, 2, 0, /*
856 Display ERROR-OBJECT on STREAM in a user-friendly way.
858 (error_object, stream))
860 /* This function can GC */
861 print_error_message (error_object, canonicalize_printcharfun (stream));
866 #ifdef LISP_FLOAT_TYPE
868 Lisp_Object Vfloat_output_format;
871 * This buffer should be at least as large as the max string size of the
872 * largest float, printed in the biggest notation. This is undoubtedly
873 * 20d float_output_format, with the negative of the C-constant "HUGE"
876 * On the vax the worst case is -1e38 in 20d format which takes 61 bytes.
878 * I assume that IEEE-754 format numbers can take 329 bytes for the worst
879 * case of -1e307 in 20d float_output_format. What is one to do (short of
880 * re-writing _doprnt to be more sane)?
884 float_to_string (char *buf, double data)
889 if (NILP (Vfloat_output_format)
890 || !STRINGP (Vfloat_output_format))
892 sprintf (buf, "%.16g", data);
895 /* Check that the spec we have is fully valid.
896 This means not only valid for printf,
897 but meant for floats, and reasonable. */
898 cp = XSTRING_DATA (Vfloat_output_format);
906 for (width = 0; (c = *cp, isdigit (c)); cp++)
912 if (*cp != 'e' && *cp != 'f' && *cp != 'g' && *cp != 'E' && *cp != 'G')
915 if (width < (int) (*cp != 'e' && *cp != 'E') || width > DBL_DIG)
921 sprintf (buf, (char *) XSTRING_DATA (Vfloat_output_format),
925 /* added by jwz: don't allow "1.0" to print as "1"; that destroys
926 the read-equivalence of lisp objects. (* x 1) and (* x 1.0) do
927 not do the same thing, so it's important that the printed
928 representation of that form not be corrupted by the printer.
931 Bufbyte *s = (Bufbyte *) buf; /* don't use signed chars here!
932 isdigit() can't hack them! */
935 /* if there's a non-digit, then there is a decimal point, or
936 it's in exponential notation, both of which are ok. */
939 /* otherwise, we need to hack it. */
946 /* Some machines print "0.4" as ".4". I don't like that. */
947 if (buf [0] == '.' || (buf [0] == '-' && buf [1] == '.'))
950 for (i = strlen (buf) + 1; i >= 0; i--)
952 buf [(buf [0] == '-' ? 1 : 0)] = '0';
955 #endif /* LISP_FLOAT_TYPE */
957 /* Print NUMBER to BUFFER.
958 This is equivalent to sprintf (buffer, "%ld", number), only much faster.
960 BUFFER should accept 24 bytes. This should suffice for the longest
961 numbers on 64-bit machines, including the `-' sign and the trailing
962 '\0'. Returns a pointer to the trailing '\0'. */
964 long_to_string (char *buffer, long number)
966 #if (SIZEOF_LONG != 4) && (SIZEOF_LONG != 8)
968 sprintf (buffer, "%ld", number);
969 return buffer + strlen (buffer);
970 #else /* (SIZEOF_LONG == 4) || (SIZEOF_LONG == 8) */
980 #define FROB(figure) do { \
981 if (force || number >= figure) \
982 *p++ = (char) (number / figure + '0'), number %= figure, force = 1; \
985 FROB (1000000000000000000L);
986 FROB (100000000000000000L);
987 FROB (10000000000000000L);
988 FROB (1000000000000000L);
989 FROB (100000000000000L);
990 FROB (10000000000000L);
991 FROB (1000000000000L);
992 FROB (100000000000L);
994 #endif /* SIZEOF_LONG == 8 */
1005 *p++ = (char) (number + '0');
1008 #endif /* (SIZEOF_LONG == 4) || (SIZEOF_LONG == 8) */
1012 print_vector_internal (const char *start, const char *end,
1014 Lisp_Object printcharfun, int escapeflag)
1016 /* This function can GC */
1018 int len = XVECTOR_LENGTH (obj);
1020 struct gcpro gcpro1, gcpro2;
1021 GCPRO2 (obj, printcharfun);
1023 if (INTP (Vprint_length))
1025 int max = XINT (Vprint_length);
1026 if (max < len) last = max;
1029 write_c_string (start, printcharfun);
1030 for (i = 0; i < last; i++)
1032 Lisp_Object elt = XVECTOR_DATA (obj)[i];
1033 if (i != 0) write_char_internal (" ", printcharfun);
1034 print_internal (elt, printcharfun, escapeflag);
1038 write_c_string (" ...", printcharfun);
1039 write_c_string (end, printcharfun);
1043 print_cons (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1045 /* This function can GC */
1046 struct gcpro gcpro1, gcpro2;
1048 /* If print_readably is on, print (quote -foo-) as '-foo-
1049 (Yeah, this should really be what print-pretty does, but we
1050 don't have the rest of a pretty printer, and this actually
1051 has non-negligible impact on size/speed of .elc files.)
1053 if (print_readably &&
1054 EQ (XCAR (obj), Qquote) &&
1055 CONSP (XCDR (obj)) &&
1056 NILP (XCDR (XCDR (obj))))
1058 obj = XCAR (XCDR (obj));
1059 GCPRO2 (obj, printcharfun);
1060 write_char_internal ("\'", printcharfun);
1062 print_internal (obj, printcharfun, escapeflag);
1066 GCPRO2 (obj, printcharfun);
1067 write_char_internal ("(", printcharfun);
1071 int max = INTP (Vprint_length) ? XINT (Vprint_length) : INT_MAX;
1072 Lisp_Object tortoise;
1073 /* Use tortoise/hare to make sure circular lists don't infloop */
1075 for (tortoise = obj, len = 0;
1077 obj = XCDR (obj), len++)
1080 write_char_internal (" ", printcharfun);
1081 if (EQ (obj, tortoise) && len > 0)
1084 error ("printing unreadable circular list");
1086 write_c_string ("... <circular list>", printcharfun);
1090 tortoise = XCDR (tortoise);
1093 write_c_string ("...", printcharfun);
1096 print_internal (XCAR (obj), printcharfun, escapeflag);
1101 write_c_string (" . ", printcharfun);
1102 print_internal (obj, printcharfun, escapeflag);
1106 write_char_internal (")", printcharfun);
1111 print_vector (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1113 print_vector_internal ("[", "]", obj, printcharfun, escapeflag);
1117 print_string (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1119 Lisp_String *s = XSTRING (obj);
1120 /* We distinguish between Bytecounts and Charcounts, to make
1121 Vprint_string_length work correctly under Mule. */
1122 Charcount size = string_char_length (s);
1123 Charcount max = size;
1124 Bytecount bcmax = string_length (s);
1125 struct gcpro gcpro1, gcpro2;
1126 GCPRO2 (obj, printcharfun);
1128 if (INTP (Vprint_string_length) &&
1129 XINT (Vprint_string_length) < max)
1131 max = XINT (Vprint_string_length);
1132 bcmax = charcount_to_bytecount (string_data (s), max);
1142 /* This deals with GC-relocation and Mule. */
1143 output_string (printcharfun, 0, obj, 0, bcmax);
1145 write_c_string (" ...", printcharfun);
1149 Bytecount i, last = 0;
1151 write_char_internal ("\"", printcharfun);
1152 for (i = 0; i < bcmax; i++)
1154 Bufbyte ch = string_byte (s, i);
1155 if (ch == '\"' || ch == '\\'
1156 || (ch == '\n' && print_escape_newlines))
1160 output_string (printcharfun, 0, obj, last,
1165 write_c_string ("\\n", printcharfun);
1169 write_char_internal ("\\", printcharfun);
1170 /* This is correct for Mule because the
1171 character is either \ or " */
1172 write_char_internal (string_data (s) + i, printcharfun);
1179 output_string (printcharfun, 0, obj, last,
1183 write_c_string (" ...", printcharfun);
1184 write_char_internal ("\"", printcharfun);
1190 default_object_printer (Lisp_Object obj, Lisp_Object printcharfun,
1193 struct lcrecord_header *header =
1194 (struct lcrecord_header *) XPNTR (obj);
1198 error ("printing unreadable object #<%s 0x%x>",
1199 LHEADER_IMPLEMENTATION (&header->lheader)->name,
1202 sprintf (buf, "#<%s 0x%x>",
1203 LHEADER_IMPLEMENTATION (&header->lheader)->name,
1205 write_c_string (buf, printcharfun);
1209 internal_object_printer (Lisp_Object obj, Lisp_Object printcharfun,
1213 sprintf (buf, "#<INTERNAL OBJECT (XEmacs bug?) (%s) 0x%lx>",
1214 XRECORD_LHEADER_IMPLEMENTATION (obj)->name,
1215 (unsigned long) XPNTR (obj));
1216 write_c_string (buf, printcharfun);
1219 enum printing_badness
1221 BADNESS_INTEGER_OBJECT,
1222 BADNESS_POINTER_OBJECT,
1227 printing_major_badness (Lisp_Object printcharfun,
1228 Char_ASCII *badness_string, int type, void *val,
1229 enum printing_badness badness)
1235 case BADNESS_INTEGER_OBJECT:
1236 sprintf (buf, "%s %d object %ld", badness_string, type,
1240 case BADNESS_POINTER_OBJECT:
1241 sprintf (buf, "%s %d object %p", badness_string, type, val);
1244 case BADNESS_NO_TYPE:
1245 sprintf (buf, "%s object %p", badness_string, val);
1249 /* Don't ABORT or signal if called from debug_print() or already
1251 if (!inhibit_non_essential_printing_operations)
1253 #ifdef ERROR_CHECK_TYPES
1255 #else /* not ERROR_CHECK_TYPES */
1257 type_error (Qinternal_error, "printing %s", buf);
1258 #endif /* not ERROR_CHECK_TYPES */
1260 write_fmt_string (printcharfun,
1261 "#<EMACS BUG: %s Save your buffers immediately and "
1262 "please report this bug>", buf);
1266 print_internal (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1268 /* This function can GC */
1272 /* Emacs won't print while GCing, but an external debugger might */
1273 if (gc_in_progress) return;
1276 /* #### Both input and output streams should have a flag associated
1277 with them indicating whether output to that stream, or strings
1278 read from the stream, get translated using Fgettext(). Such a
1279 stream is called a "translating stream". For the minibuffer and
1280 external-debugging-output this is always true on output, and
1281 with-output-to-temp-buffer sets the flag to true for the buffer
1282 it creates. This flag should also be user-settable. Perhaps it
1283 should be split up into two flags, one for input and one for
1287 /* Detect circularities and truncate them.
1288 No need to offer any alternative--this is better than an error. */
1289 if (CONSP (obj) || VECTORP (obj) || COMPILED_FUNCTIONP (obj))
1292 for (i = 0; i < print_depth; i++)
1293 if (EQ (obj, being_printed[i]))
1297 long_to_string (buf + 1, i);
1298 write_c_string (buf, printcharfun);
1303 being_printed[print_depth] = obj;
1306 if (print_depth > PRINT_CIRCLE)
1307 error ("Apparently circular structure being printed");
1309 switch (XTYPE (obj))
1311 case Lisp_Type_Int_Even:
1312 case Lisp_Type_Int_Odd:
1314 /* ASCII Decimal representation uses 2.4 times as many bits as
1316 char buf[3 * sizeof (EMACS_INT) + 5];
1317 long_to_string (buf, XINT (obj));
1318 write_c_string (buf, printcharfun);
1322 case Lisp_Type_Char:
1324 /* God intended that this be #\..., you know. */
1326 Emchar ch = XCHAR (obj);
1334 case '\t': *p++ = 't'; break;
1335 case '\n': *p++ = 'n'; break;
1336 case '\r': *p++ = 'r'; break;
1340 if ((ch + 64) == '\\')
1347 /* syntactically special characters should be escaped. */
1370 *p++ = '\\', *p++ = '^', *p++ = '?';
1374 *p++ = '\\', *p++ = '^';
1375 p += set_charptr_emchar ((Bufbyte *) p, ch + 64);
1379 p += set_charptr_emchar ((Bufbyte *) p, ch);
1382 output_string (printcharfun, (Bufbyte *) buf, Qnil, 0, p - buf);
1387 case Lisp_Type_Record:
1389 struct lrecord_header *lheader = XRECORD_LHEADER (obj);
1391 /* Try to check for various sorts of bogus pointers if we're in a
1392 situation where it may be likely -- i.e. called from
1393 debug_print() or we're already crashing. In such cases,
1394 (further) crashing is counterproductive. */
1396 if (inhibit_non_essential_printing_operations &&
1397 !debug_can_access_memory (lheader, sizeof (*lheader)))
1399 write_fmt_string (printcharfun,
1400 "#<EMACS BUG: BAD MEMORY ACCESS %p>",
1405 if (CONSP (obj) || VECTORP (obj))
1407 /* If deeper than spec'd depth, print placeholder. */
1408 if (INTP (Vprint_level)
1409 && print_depth > XINT (Vprint_level))
1411 write_c_string ("...", printcharfun);
1416 if (lheader->type == lrecord_type_free)
1418 printing_major_badness (printcharfun, "freed lrecord", 0,
1419 lheader, BADNESS_NO_TYPE);
1422 else if (lheader->type == lrecord_type_undefined)
1424 printing_major_badness (printcharfun, "lrecord_type_undefined", 0,
1425 lheader, BADNESS_NO_TYPE);
1428 else if (lheader->type >= lrecord_type_count)
1430 printing_major_badness (printcharfun, "illegal lrecord type",
1431 (int) (lheader->type),
1432 lheader, BADNESS_POINTER_OBJECT);
1436 /* Further checks for bad memory in critical situations. We don't
1437 normally do these because they may be expensive or weird
1438 (e.g. under Unix we typically have to set a SIGSEGV handler and
1439 try to trigger a seg fault). */
1441 if (inhibit_non_essential_printing_operations)
1443 const struct lrecord_implementation *imp =
1444 LHEADER_IMPLEMENTATION (lheader);
1446 if (!debug_can_access_memory
1447 (lheader, imp->size_in_bytes_method ?
1448 imp->size_in_bytes_method (lheader) :
1451 write_fmt_string (printcharfun,
1452 "#<EMACS BUG: type %s BAD MEMORY ACCESS %p>",
1453 LHEADER_IMPLEMENTATION (lheader)->name,
1460 Lisp_String *l = (Lisp_String *) lheader;
1461 if (!debug_can_access_memory (l->data, l->size))
1465 "#<EMACS BUG: %p (CAN'T ACCESS STRING DATA %p)>",
1472 if (LHEADER_IMPLEMENTATION (lheader)->printer)
1473 ((LHEADER_IMPLEMENTATION (lheader)->printer)
1474 (obj, printcharfun, escapeflag));
1476 default_object_printer (obj, printcharfun, escapeflag);
1482 /* We're in trouble if this happens! */
1483 printing_major_badness (printcharfun, "illegal data type", XTYPE (obj),
1484 LISP_TO_VOID (obj), BADNESS_INTEGER_OBJECT);
1493 #ifdef LISP_FLOAT_TYPE
1495 print_float (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1497 char pigbuf[350]; /* see comments in float_to_string */
1499 float_to_string (pigbuf, XFLOAT_DATA (obj));
1500 write_c_string (pigbuf, printcharfun);
1502 #endif /* LISP_FLOAT_TYPE */
1505 print_symbol (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
1507 /* This function can GC */
1508 /* #### Bug!! (intern "") isn't printed in some distinguished way */
1509 /* #### (the reader also loses on it) */
1510 Lisp_String *name = symbol_name (XSYMBOL (obj));
1511 Bytecount size = string_length (name);
1512 struct gcpro gcpro1, gcpro2;
1516 /* This deals with GC-relocation */
1517 Lisp_Object nameobj;
1518 XSETSTRING (nameobj, name);
1519 output_string (printcharfun, 0, nameobj, 0, size);
1522 GCPRO2 (obj, printcharfun);
1524 /* If we print an uninterned symbol as part of a complex object and
1525 the flag print-gensym is non-nil, prefix it with #n= to read the
1526 object back with the #n# reader syntax later if needed. */
1527 if (!NILP (Vprint_gensym)
1528 /* #### Test whether this produces a noticeable slow-down for
1529 printing when print-gensym is non-nil. */
1530 && !EQ (obj, oblookup (Vobarray,
1531 string_data (symbol_name (XSYMBOL (obj))),
1532 string_length (symbol_name (XSYMBOL (obj))))))
1534 if (print_depth > 1)
1536 Lisp_Object tem = Fassq (obj, Vprint_gensym_alist);
1539 write_char_internal ("#", printcharfun);
1540 print_internal (XCDR (tem), printcharfun, escapeflag);
1541 write_char_internal ("#", printcharfun);
1547 if (CONSP (Vprint_gensym_alist))
1549 /* Vprint_gensym_alist is exposed to Lisp, so we
1550 have to be careful. */
1551 CHECK_CONS (XCAR (Vprint_gensym_alist));
1552 CHECK_INT (XCDR (XCAR (Vprint_gensym_alist)));
1553 XSETINT (tem, XINT (XCDR (XCAR (Vprint_gensym_alist))) + 1);
1557 Vprint_gensym_alist = Fcons (Fcons (obj, tem), Vprint_gensym_alist);
1559 write_char_internal ("#", printcharfun);
1560 print_internal (tem, printcharfun, escapeflag);
1561 write_char_internal ("=", printcharfun);
1564 write_c_string ("#:", printcharfun);
1567 /* Does it look like an integer or a float? */
1569 Bufbyte *data = string_data (name);
1570 Bytecount confusing = 0;
1573 goto not_yet_confused; /* Really confusing */
1574 else if (isdigit (data[0]))
1577 goto not_yet_confused;
1578 else if (data[0] == '-' || data[0] == '+')
1581 goto not_yet_confused;
1583 for (; confusing < size; confusing++)
1585 if (!isdigit (data[confusing]))
1593 #ifdef LISP_FLOAT_TYPE
1595 /* #### Ugh, this is needlessly complex and slow for what we
1596 need here. It might be a good idea to copy equivalent code
1597 from FSF. --hniksic */
1598 confusing = isfloat_string ((char *) data);
1601 write_char_internal ("\\", printcharfun);
1605 Lisp_Object nameobj;
1609 XSETSTRING (nameobj, name);
1610 for (i = 0; i < size; i++)
1612 switch (string_byte (name, i))
1614 case 0: case 1: case 2: case 3:
1615 case 4: case 5: case 6: case 7:
1616 case 8: case 9: case 10: case 11:
1617 case 12: case 13: case 14: case 15:
1618 case 16: case 17: case 18: case 19:
1619 case 20: case 21: case 22: case 23:
1620 case 24: case 25: case 26: case 27:
1621 case 28: case 29: case 30: case 31:
1622 case ' ': case '\"': case '\\': case '\'':
1623 case ';': case '#' : case '(' : case ')':
1624 case ',': case '.' : case '`' :
1625 case '[': case ']' : case '?' :
1627 output_string (printcharfun, 0, nameobj, last, i - last);
1628 write_char_internal ("\\", printcharfun);
1632 output_string (printcharfun, 0, nameobj, last, size - last);
1638 /* Useful on systems or in places where writing to stdout is unavailable or
1641 static int alternate_do_pointer;
1642 static char alternate_do_string[5000];
1644 DEFUN ("alternate-debugging-output", Falternate_debugging_output, 1, 1, 0, /*
1645 Append CHARACTER to the array `alternate_do_string'.
1646 This can be used in place of `external-debugging-output' as a function
1647 to be passed to `print'. Before calling `print', set `alternate_do_pointer'
1652 Bufbyte str[MAX_EMCHAR_LEN];
1655 const Extbyte *extptr;
1657 CHECK_CHAR_COERCE_INT (character);
1658 len = set_charptr_emchar (str, XCHAR (character));
1659 TO_EXTERNAL_FORMAT (DATA, (str, len),
1660 ALLOCA, (extptr, extlen),
1662 memcpy (alternate_do_string + alternate_do_pointer, extptr, extlen);
1663 alternate_do_pointer += extlen;
1664 alternate_do_string[alternate_do_pointer] = 0;
1668 DEFUN ("external-debugging-output", Fexternal_debugging_output, 1, 3, 0, /*
1669 Write CHAR-OR-STRING to stderr or stdout.
1670 If optional arg STDOUT-P is non-nil, write to stdout; otherwise, write
1671 to stderr. You can use this function to write directly to the terminal.
1672 This function can be used as the STREAM argument of Fprint() or the like.
1674 Under MS Windows, this writes output to the console window (which is
1675 created, if necessary), unless XEmacs is being run noninteractively
1676 \(i.e. using the `-batch' argument).
1678 If you have opened a termscript file (using `open-termscript'), then
1679 the output also will be logged to this file.
1681 (char_or_string, stdout_p, device))
1684 struct console *con = 0;
1688 if (!NILP (stdout_p))
1695 CHECK_LIVE_DEVICE (device);
1696 if (!DEVICE_TTY_P (XDEVICE (device)) &&
1697 !DEVICE_STREAM_P (XDEVICE (device)))
1698 signal_simple_error ("Must be tty or stream device", device);
1699 con = XCONSOLE (DEVICE_CONSOLE (XDEVICE (device)));
1700 if (DEVICE_TTY_P (XDEVICE (device)))
1702 else if (!NILP (stdout_p))
1703 file = CONSOLE_STREAM_DATA (con)->out;
1705 file = CONSOLE_STREAM_DATA (con)->err;
1708 if (STRINGP (char_or_string))
1709 write_string_to_stdio_stream (file, con,
1710 XSTRING_DATA (char_or_string),
1711 0, XSTRING_LENGTH (char_or_string),
1715 Bufbyte str[MAX_EMCHAR_LEN];
1718 CHECK_CHAR_COERCE_INT (char_or_string);
1719 len = set_charptr_emchar (str, XCHAR (char_or_string));
1720 write_string_to_stdio_stream (file, con, str, 0, len, Qterminal, 1);
1723 return char_or_string;
1726 DEFUN ("open-termscript", Fopen_termscript, 1, 1, "FOpen termscript file: ", /*
1727 Start writing all terminal output to FILENAME as well as the terminal.
1728 FILENAME = nil means just close any termscript file currently open.
1732 /* This function can GC */
1733 if (termscript != 0)
1735 fclose (termscript);
1739 if (! NILP (filename))
1741 filename = Fexpand_file_name (filename, Qnil);
1742 termscript = fopen ((char *) XSTRING_DATA (filename), "w");
1743 if (termscript == NULL)
1744 report_file_error ("Opening termscript", list1 (filename));
1750 /* Debugging kludge -- unbuffered */
1751 static int debug_print_length = 50;
1752 static int debug_print_level = 15;
1753 static int debug_print_readably = -1;
1756 debug_print_no_newline (Lisp_Object debug_print_obj)
1758 /* This function can GC */
1759 int save_print_readably = print_readably;
1760 int save_print_depth = print_depth;
1761 Lisp_Object save_Vprint_length = Vprint_length;
1762 Lisp_Object save_Vprint_level = Vprint_level;
1763 Lisp_Object save_Vinhibit_quit = Vinhibit_quit;
1764 struct gcpro gcpro1, gcpro2, gcpro3;
1765 GCPRO3 (save_Vprint_level, save_Vprint_length, save_Vinhibit_quit);
1768 stderr_out ("** gc-in-progress! Bad idea to print anything! **\n");
1771 print_readably = debug_print_readably != -1 ? debug_print_readably : 0;
1773 inhibit_non_essential_printing_operations = 1;
1774 /* Could use unwind-protect, but why bother? */
1775 if (debug_print_length > 0)
1776 Vprint_length = make_int (debug_print_length);
1777 if (debug_print_level > 0)
1778 Vprint_level = make_int (debug_print_level);
1780 print_internal (debug_print_obj, Qexternal_debugging_output, 1);
1781 alternate_do_pointer = 0;
1782 print_internal (debug_print_obj, Qalternate_debugging_output, 1);
1784 /* Write out to the debugger, as well */
1785 print_internal (debug_print_obj, Qmswindows_debugging_output, 1);
1788 Vinhibit_quit = save_Vinhibit_quit;
1789 Vprint_level = save_Vprint_level;
1790 Vprint_length = save_Vprint_length;
1791 print_depth = save_print_depth;
1792 print_readably = save_print_readably;
1793 inhibit_non_essential_printing_operations = 0;
1799 debug_print (Lisp_Object debug_print_obj)
1801 debug_print_no_newline (debug_print_obj);
1805 /* Debugging kludge -- unbuffered */
1806 /* This function provided for the benefit of the debugger. */
1807 void debug_backtrace (void);
1809 debug_backtrace (void)
1811 /* This function can GC */
1812 int old_print_readably = print_readably;
1813 int old_print_depth = print_depth;
1814 Lisp_Object old_print_length = Vprint_length;
1815 Lisp_Object old_print_level = Vprint_level;
1816 Lisp_Object old_inhibit_quit = Vinhibit_quit;
1818 struct gcpro gcpro1, gcpro2, gcpro3;
1819 GCPRO3 (old_print_level, old_print_length, old_inhibit_quit);
1822 stderr_out ("** gc-in-progress! Bad idea to print anything! **\n");
1827 inhibit_non_essential_printing_operations = 1;
1828 /* Could use unwind-protect, but why bother? */
1829 if (debug_print_length > 0)
1830 Vprint_length = make_int (debug_print_length);
1831 if (debug_print_level > 0)
1832 Vprint_level = make_int (debug_print_level);
1834 Fbacktrace (Qexternal_debugging_output, Qt);
1837 Vinhibit_quit = old_inhibit_quit;
1838 Vprint_level = old_print_level;
1839 Vprint_length = old_print_length;
1840 print_depth = old_print_depth;
1841 print_readably = old_print_readably;
1842 inhibit_non_essential_printing_operations = 0;
1849 debug_short_backtrace (int length)
1852 struct backtrace *bt = backtrace_list;
1854 while (length > 0 && bt)
1860 if (COMPILED_FUNCTIONP (*bt->function))
1862 #if defined(COMPILED_FUNCTION_ANNOTATION_HACK)
1864 compiled_function_annotation (XCOMPILED_FUNCTION (*bt->function));
1866 Lisp_Object ann = Qnil;
1870 stderr_out ("<compiled-function from ");
1871 debug_print_no_newline (ann);
1876 stderr_out ("<compiled-function of unknown origin>");
1880 debug_print_no_newline (*bt->function);
1888 #endif /* debugging kludge */
1892 syms_of_print (void)
1894 defsymbol (&Qstandard_output, "standard-output");
1896 defsymbol (&Qprint_length, "print-length");
1898 defsymbol (&Qprint_string_length, "print-string-length");
1900 defsymbol (&Qdisplay_error, "display-error");
1901 defsymbol (&Qprint_message_label, "print-message-label");
1904 DEFSUBR (Fprin1_to_string);
1907 DEFSUBR (Ferror_message_string);
1908 DEFSUBR (Fdisplay_error);
1910 DEFSUBR (Fwrite_char);
1911 DEFSUBR (Falternate_debugging_output);
1912 DEFSUBR (Fexternal_debugging_output);
1913 DEFSUBR (Fopen_termscript);
1914 defsymbol (&Qexternal_debugging_output, "external-debugging-output");
1915 defsymbol (&Qalternate_debugging_output, "alternate-debugging-output");
1916 #ifdef HAVE_MS_WINDOWS
1917 defsymbol (&Qmswindows_debugging_output, "mswindows-debugging-output");
1919 DEFSUBR (Fwith_output_to_temp_buffer);
1923 reinit_vars_of_print (void)
1925 alternate_do_pointer = 0;
1929 vars_of_print (void)
1931 reinit_vars_of_print ();
1933 DEFVAR_LISP ("standard-output", &Vstandard_output /*
1934 Output stream `print' uses by default for outputting a character.
1935 This may be any function of one argument.
1936 It may also be a buffer (output is inserted before point)
1937 or a marker (output is inserted and the marker is advanced)
1938 or the symbol t (output appears in the minibuffer line).
1940 Vstandard_output = Qt;
1942 #ifdef LISP_FLOAT_TYPE
1943 DEFVAR_LISP ("float-output-format", &Vfloat_output_format /*
1944 The format descriptor string that lisp uses to print floats.
1945 This is a %-spec like those accepted by `printf' in C,
1946 but with some restrictions. It must start with the two characters `%.'.
1947 After that comes an integer precision specification,
1948 and then a letter which controls the format.
1949 The letters allowed are `e', `f' and `g'.
1950 Use `e' for exponential notation "DIG.DIGITSeEXPT"
1951 Use `f' for decimal point notation "DIGITS.DIGITS".
1952 Use `g' to choose the shorter of those two formats for the number at hand.
1953 The precision in any of these cases is the number of digits following
1954 the decimal point. With `f', a precision of 0 means to omit the
1955 decimal point. 0 is not allowed with `f' or `g'.
1957 A value of nil means to use `%.16g'.
1959 Regardless of the value of `float-output-format', a floating point number
1960 will never be printed in such a way that it is ambiguous with an integer;
1961 that is, a floating-point number will always be printed with a decimal
1962 point and/or an exponent, even if the digits following the decimal point
1963 are all zero. This is to preserve read-equivalence.
1965 Vfloat_output_format = Qnil;
1966 #endif /* LISP_FLOAT_TYPE */
1968 DEFVAR_LISP ("print-length", &Vprint_length /*
1969 Maximum length of list or vector to print before abbreviating.
1970 A value of nil means no limit.
1972 Vprint_length = Qnil;
1974 DEFVAR_LISP ("print-string-length", &Vprint_string_length /*
1975 Maximum length of string to print before abbreviating.
1976 A value of nil means no limit.
1978 Vprint_string_length = Qnil;
1980 DEFVAR_LISP ("print-level", &Vprint_level /*
1981 Maximum depth of list nesting to print before abbreviating.
1982 A value of nil means no limit.
1984 Vprint_level = Qnil;
1986 DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines /*
1987 Non-nil means print newlines in strings as backslash-n.
1989 print_escape_newlines = 0;
1991 DEFVAR_BOOL ("print-readably", &print_readably /*
1992 If non-nil, then all objects will be printed in a readable form.
1993 If an object has no readable representation, then an error is signalled.
1994 When print-readably is true, compiled-function objects will be written in
1995 #[...] form instead of in #<compiled-function [...]> form, and two-element
1996 lists of the form (quote object) will be written as the equivalent 'object.
1997 Do not SET this variable; bind it instead.
2001 /* #### I think this should default to t. But we'd better wait
2002 until we see that it works out. */
2003 DEFVAR_LISP ("print-gensym", &Vprint_gensym /*
2004 If non-nil, then uninterned symbols will be printed specially.
2005 Uninterned symbols are those which are not present in `obarray', that is,
2006 those which were made with `make-symbol' or by calling `intern' with a
2009 When print-gensym is true, such symbols will be preceded by "#:",
2010 which causes the reader to create a new symbol instead of interning
2011 and returning an existing one. Beware: the #: syntax creates a new
2012 symbol each time it is seen, so if you print an object which contains
2013 two pointers to the same uninterned symbol, `read' will not duplicate
2016 If the value of `print-gensym' is a cons cell, then in addition
2017 refrain from clearing `print-gensym-alist' on entry to and exit from
2018 printing functions, so that the use of #...# and #...= can carry over
2019 for several separately printed objects.
2021 Vprint_gensym = Qnil;
2023 DEFVAR_LISP ("print-gensym-alist", &Vprint_gensym_alist /*
2024 Association list of elements (GENSYM . N) to guide use of #N# and #N=.
2025 In each element, GENSYM is an uninterned symbol that has been associated
2026 with #N= for the specified value of N.
2028 Vprint_gensym_alist = Qnil;
2030 DEFVAR_LISP ("print-message-label", &Vprint_message_label /*
2031 Label for minibuffer messages created with `print'. This should
2032 generally be bound with `let' rather than set. (See `display-message'.)
2034 Vprint_message_label = Qprint;