/* Lisp object printing and output streams.
- Copyright (C) 1985, 1986, 1988, 1993 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 88, 93, 94, 95 Free Software Foundation, Inc.
This file is part of GNU Emacs.
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include "config.h"
+#include <config.h>
#include <stdio.h>
#undef NULL
#include "lisp.h"
#include "process.h"
#include "dispextern.h"
#include "termchar.h"
+#include "keyboard.h"
#endif /* not standalone */
#ifdef USE_TEXT_PROPERTIES
Lisp_Object Qprint_escape_newlines;
-/* Nonzero means print newline before next minibuffer message.
+/* Nonzero means print newline to stdout before next minibuffer message.
Defined in xdisp.c */
extern int noninteractive_need_newline;
+
#ifdef MAX_PRINT_CHARS
static int print_chars;
static int max_print;
#define PRINTPREPARE \
original = printcharfun; \
if (NILP (printcharfun)) printcharfun = Qt; \
- if (XTYPE (printcharfun) == Lisp_Buffer) \
+ if (BUFFERP (printcharfun)) \
{ if (XBUFFER (printcharfun) != current_buffer) \
Fset_buffer (printcharfun); \
printcharfun = Qnil;} \
- if (XTYPE (printcharfun) == Lisp_Marker) \
+ if (MARKERP (printcharfun)) \
{ if (!(XMARKER (original)->buffer)) \
error ("Marker does not point anywhere"); \
if (XMARKER (original)->buffer != current_buffer) \
printcharfun = Qnil;}
#define PRINTFINISH \
- if (XTYPE (original) == Lisp_Marker) \
+ if (MARKERP (original)) \
Fset_marker (original, make_number (point), Qnil); \
if (old_point >= 0) \
SET_PT (old_point + (old_point >= start_point \
#define PRINTCHAR(ch) printchar (ch, printcharfun)
-/* Index of first unused element of FRAME_MESSAGE_BUF(selected_frame). */
+/* Index of first unused element of FRAME_MESSAGE_BUF(mini_frame). */
static int printbufidx;
static void
if (EQ (fun, Qt))
{
+ FRAME_PTR mini_frame
+ = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
+
if (noninteractive)
{
putchar (ch);
return;
}
- if (echo_area_glyphs != FRAME_MESSAGE_BUF (selected_frame)
+ if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame)
|| !message_buf_print)
{
- echo_area_glyphs = FRAME_MESSAGE_BUF (selected_frame);
+ message_log_maybe_newline ();
+ echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame);
printbufidx = 0;
+ echo_area_glyphs_length = 0;
message_buf_print = 1;
}
- if (printbufidx < FRAME_WIDTH (selected_frame) - 1)
- FRAME_MESSAGE_BUF (selected_frame)[printbufidx++] = ch;
- FRAME_MESSAGE_BUF (selected_frame)[printbufidx] = 0;
+ message_dolog (&ch, 1, 0);
+ if (printbufidx < FRAME_WIDTH (mini_frame) - 1)
+ FRAME_MESSAGE_BUF (mini_frame)[printbufidx++] = ch;
+ FRAME_MESSAGE_BUF (mini_frame)[printbufidx] = 0;
+ echo_area_glyphs_length = printbufidx;
return;
}
#endif /* not standalone */
- XFASTINT (ch1) = ch;
+ XSETFASTINT (ch1, ch);
call1 (fun, ch1);
}
}
if (EQ (printcharfun, Qt))
{
+ FRAME_PTR mini_frame
+ = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
+
i = size >= 0 ? size : strlen (ptr);
#ifdef MAX_PRINT_CHARS
if (max_print)
return;
}
- if (echo_area_glyphs != FRAME_MESSAGE_BUF (selected_frame)
+ if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame)
|| !message_buf_print)
{
- echo_area_glyphs = FRAME_MESSAGE_BUF (selected_frame);
+ message_log_maybe_newline ();
+ echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame);
printbufidx = 0;
+ echo_area_glyphs_length = 0;
message_buf_print = 1;
}
- if (i > FRAME_WIDTH (selected_frame) - printbufidx - 1)
- i = FRAME_WIDTH (selected_frame) - printbufidx - 1;
- bcopy (ptr, &FRAME_MESSAGE_BUF (selected_frame) [printbufidx], i);
+ message_dolog (ptr, i, 0);
+ if (i > FRAME_WIDTH (mini_frame) - printbufidx - 1)
+ i = FRAME_WIDTH (mini_frame) - printbufidx - 1;
+ bcopy (ptr, &FRAME_MESSAGE_BUF (mini_frame) [printbufidx], i);
printbufidx += i;
- FRAME_MESSAGE_BUF (selected_frame) [printbufidx] = 0;
+ echo_area_glyphs_length = printbufidx;
+ FRAME_MESSAGE_BUF (mini_frame) [printbufidx] = 0;
return;
}
}
\f
DEFUN ("write-char", Fwrite_char, Swrite_char, 1, 2, 0,
- "Output character CHAR to stream STREAM.\n\
-STREAM defaults to the value of `standard-output' (which see).")
+ "Output character CHAR to stream PRINTCHARFUN.\n\
+PRINTCHARFUN defaults to the value of `standard-output' (which see).")
(ch, printcharfun)
Lisp_Object ch, printcharfun;
{
Fset_buffer (Fget_buffer_create (build_string (bufname)));
+ current_buffer->directory = old->directory;
current_buffer->read_only = Qnil;
Ferase_buffer ();
- XSET (buf, Lisp_Buffer, current_buffer);
+ XSETBUFFER (buf, current_buffer);
specbind (Qstandard_output, buf);
set_buffer_internal (old);
{
int count = specpdl_ptr - specpdl;
Lisp_Object buf, val;
+ struct gcpro gcpro1;
+ GCPRO1 (args);
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
temp_output_buffer_setup (bufname);
buf = Vstandard_output;
+ UNGCPRO;
val = (*function) (args);
+ GCPRO1 (val);
temp_output_buffer_show (buf);
+ UNGCPRO;
return unbind_to (count, val);
}
static void print ();
DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
- "Output a newline to STREAM.\n\
-If STREAM is omitted or nil, the value of `standard-output' is used.")
+ "Output a newline to stream PRINTCHARFUN.\n\
+If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.")
(printcharfun)
Lisp_Object printcharfun;
{
"Output the printed representation of OBJECT, any Lisp object.\n\
Quoting characters are printed when needed to make output that `read'\n\
can handle, whenever this is possible.\n\
-Output stream is STREAM, or value of `standard-output' (which see).")
+Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
(obj, printcharfun)
Lisp_Object obj, printcharfun;
{
"Output the printed representation of OBJECT, any Lisp object.\n\
No quoting characters are used; no delimiters are printed around\n\
the contents of strings.\n\
-Output stream is STREAM, or value of standard-output (which see).")
+Output stream is PRINTCHARFUN, or value of standard-output (which see).")
(obj, printcharfun)
Lisp_Object obj, printcharfun;
{
"Output the printed representation of OBJECT, with newlines around it.\n\
Quoting characters are printed when needed to make output that `read'\n\
can handle, whenever this is possible.\n\
-Output stream is STREAM, or value of `standard-output' (which see).")
+Output stream is PRINTCHARFUN, or value of `standard-output' (which see).")
(obj, printcharfun)
Lisp_Object obj, printcharfun;
{
return character;
}
+
+/* This is the interface for debugging printing. */
+
+void
+debug_print (arg)
+ Lisp_Object arg;
+{
+ Fprin1 (arg, Qexternal_debugging_output);
+}
\f
#ifdef LISP_FLOAT_TYPE
double data;
{
unsigned char *cp;
- int width = -1;
+ int width;
if (NILP (Vfloat_output_format)
- || XTYPE (Vfloat_output_format) != Lisp_String)
+ || !STRINGP (Vfloat_output_format))
lose:
- sprintf (buf, "%.20g", data);
+ {
+ sprintf (buf, "%.17g", data);
+ width = -1;
+ }
else /* oink oink */
{
/* Check that the spec we have is fully valid.
cp += 2;
/* Check the width specification. */
+ width = -1;
if ('0' <= *cp && *cp <= '9')
for (width = 0; (*cp >= '0' && *cp <= '9'); cp++)
width = (width * 10) + (*cp - '0');
/* Make sure there is a decimal point with digit after, or an
exponent, so that the value is readable as a float. But don't do
- this with "%.0f"; it's legal for that not to produce a decimal
- point. */
- if (*cp != 'f' || width != 0)
+ this with "%.0f"; it's valid for that not to produce a decimal
+ point. Note that width can be 0 only for %.0f. */
+ if (width != 0)
{
for (cp = buf; *cp; cp++)
if ((*cp < '0' || *cp > '9') && *cp != '-')
#if 1 /* I'm not sure this is really worth doing. */
/* Detect circularities and truncate them.
No need to offer any alternative--this is better than an error. */
- if (XTYPE (obj) == Lisp_Cons || XTYPE (obj) == Lisp_Vector
- || XTYPE (obj) == Lisp_Compiled)
+ if (CONSP (obj) || VECTORP (obj) || COMPILEDP (obj))
{
int i;
for (i = 0; i < print_depth; i++)
}
#endif /* MAX_PRINT_CHARS */
-#ifdef SWITCH_ENUM_BUG
- switch ((int) XTYPE (obj))
-#else
- switch (XTYPE (obj))
-#endif
+ switch (XGCTYPE (obj))
{
- default:
- /* We're in trouble if this happens!
- Probably should just abort () */
- strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun);
- sprintf (buf, "(#o%3o)", (int) XTYPE (obj));
+ case Lisp_Int:
+ if (sizeof (int) == sizeof (EMACS_INT))
+ sprintf (buf, "%d", XINT (obj));
+ else if (sizeof (long) == sizeof (EMACS_INT))
+ sprintf (buf, "%ld", XINT (obj));
+ else
+ abort ();
strout (buf, -1, printcharfun);
- strout (" Save your buffers immediately and please report this bug>",
- -1, printcharfun);
break;
#ifdef LISP_FLOAT_TYPE
strout (pigbuf, -1, printcharfun);
}
break;
-#endif /* LISP_FLOAT_TYPE */
-
- case Lisp_Int:
- sprintf (buf, "%d", XINT (obj));
- strout (buf, -1, printcharfun);
- break;
+#endif
case Lisp_String:
if (!escapeflag)
PRINTCHAR ('\\');
PRINTCHAR ('n');
}
+ else if (c == '\f' && print_escape_newlines)
+ {
+ PRINTCHAR ('\\');
+ PRINTCHAR ('f');
+ }
else
{
if (c == '\"' || c == '\\')
register unsigned char c;
if (p != end && (*p == '-' || *p == '+')) p++;
- if (p == end)
+ if (p == end)
confusing = 0;
else
{
case Lisp_Cons:
/* If deeper than spec'd depth, print placeholder. */
- if (XTYPE (Vprint_level) == Lisp_Int
+ if (INTEGERP (Vprint_level)
&& print_depth > XINT (Vprint_level))
+ strout ("...", -1, printcharfun);
+ else
{
- strout ("...", -1, printcharfun);
- break;
- }
-
- PRINTCHAR ('(');
- {
- register int i = 0;
- register int max = 0;
-
- if (XTYPE (Vprint_length) == Lisp_Int)
- max = XINT (Vprint_length);
- /* Could recognize circularities in cdrs here,
- but that would make printing of long lists quadratic.
- It's not worth doing. */
- while (CONSP (obj))
+ PRINTCHAR ('(');
{
- if (i++)
- PRINTCHAR (' ');
- if (max && i > max)
+ register int i = 0;
+ register int max = 0;
+
+ if (INTEGERP (Vprint_length))
+ max = XINT (Vprint_length);
+ /* Could recognize circularities in cdrs here,
+ but that would make printing of long lists quadratic.
+ It's not worth doing. */
+ while (CONSP (obj))
{
- strout ("...", 3, printcharfun);
- break;
+ if (i++)
+ PRINTCHAR (' ');
+ if (max && i > max)
+ {
+ strout ("...", 3, printcharfun);
+ break;
+ }
+ print (Fcar (obj), printcharfun, escapeflag);
+ obj = Fcdr (obj);
}
- print (Fcar (obj), printcharfun, escapeflag);
- obj = Fcdr (obj);
}
- }
- if (!NILP (obj) && !CONSP (obj))
- {
- strout (" . ", 3, printcharfun);
- print (obj, printcharfun, escapeflag);
+ if (!NILP (obj) && !CONSP (obj))
+ {
+ strout (" . ", 3, printcharfun);
+ print (obj, printcharfun, escapeflag);
+ }
+ PRINTCHAR (')');
}
- PRINTCHAR (')');
- break;
-
- case Lisp_Compiled:
- strout ("#", -1, printcharfun);
- case Lisp_Vector:
- PRINTCHAR ('[');
- {
- register int i;
- register Lisp_Object tem;
- for (i = 0; i < XVECTOR (obj)->size; i++)
- {
- if (i) PRINTCHAR (' ');
- tem = XVECTOR (obj)->contents[i];
- print (tem, printcharfun, escapeflag);
- }
- }
- PRINTCHAR (']');
break;
+ case Lisp_Vectorlike:
+ if (PROCESSP (obj))
+ {
+ if (escapeflag)
+ {
+ strout ("#<process ", -1, printcharfun);
+ print_string (XPROCESS (obj)->name, printcharfun);
+ PRINTCHAR ('>');
+ }
+ else
+ print_string (XPROCESS (obj)->name, printcharfun);
+ }
+ else if (SUBRP (obj))
+ {
+ strout ("#<subr ", -1, printcharfun);
+ strout (XSUBR (obj)->symbol_name, -1, printcharfun);
+ PRINTCHAR ('>');
+ }
#ifndef standalone
- case Lisp_Buffer:
- if (NILP (XBUFFER (obj)->name))
- strout ("#<killed buffer>", -1, printcharfun);
- else if (escapeflag)
+ else if (WINDOWP (obj))
{
- strout ("#<buffer ", -1, printcharfun);
- print_string (XBUFFER (obj)->name, printcharfun);
+ strout ("#<window ", -1, printcharfun);
+ sprintf (buf, "%d", XFASTINT (XWINDOW (obj)->sequence_number));
+ strout (buf, -1, printcharfun);
+ if (!NILP (XWINDOW (obj)->buffer))
+ {
+ strout (" on ", -1, printcharfun);
+ print_string (XBUFFER (XWINDOW (obj)->buffer)->name, printcharfun);
+ }
PRINTCHAR ('>');
}
- else
- print_string (XBUFFER (obj)->name, printcharfun);
- break;
-
- case Lisp_Process:
- if (escapeflag)
+ else if (BUFFERP (obj))
+ {
+ if (NILP (XBUFFER (obj)->name))
+ strout ("#<killed buffer>", -1, printcharfun);
+ else if (escapeflag)
+ {
+ strout ("#<buffer ", -1, printcharfun);
+ print_string (XBUFFER (obj)->name, printcharfun);
+ PRINTCHAR ('>');
+ }
+ else
+ print_string (XBUFFER (obj)->name, printcharfun);
+ }
+ else if (WINDOW_CONFIGURATIONP (obj))
+ {
+ strout ("#<window-configuration>", -1, printcharfun);
+ }
+#ifdef MULTI_FRAME
+ else if (FRAMEP (obj))
{
- strout ("#<process ", -1, printcharfun);
- print_string (XPROCESS (obj)->name, printcharfun);
+ strout ((FRAME_LIVE_P (XFRAME (obj))
+ ? "#<frame " : "#<dead frame "),
+ -1, printcharfun);
+ print_string (XFRAME (obj)->name, printcharfun);
+ sprintf (buf, " 0x%lx", (unsigned long) (XFRAME (obj)));
+ strout (buf, -1, printcharfun);
PRINTCHAR ('>');
}
+#endif
+#endif /* not standalone */
else
- print_string (XPROCESS (obj)->name, printcharfun);
- break;
-
- case Lisp_Window:
- strout ("#<window ", -1, printcharfun);
- sprintf (buf, "%d", XFASTINT (XWINDOW (obj)->sequence_number));
- strout (buf, -1, printcharfun);
- if (!NILP (XWINDOW (obj)->buffer))
{
- strout (" on ", -1, printcharfun);
- print_string (XBUFFER (XWINDOW (obj)->buffer)->name, printcharfun);
+ int size = XVECTOR (obj)->size;
+ if (COMPILEDP (obj))
+ {
+ PRINTCHAR ('#');
+ size &= PSEUDOVECTOR_SIZE_MASK;
+ }
+ if (size & PSEUDOVECTOR_FLAG)
+ goto badtype;
+
+ PRINTCHAR ('[');
+ {
+ register int i;
+ register Lisp_Object tem;
+ for (i = 0; i < size; i++)
+ {
+ if (i) PRINTCHAR (' ');
+ tem = XVECTOR (obj)->contents[i];
+ print (tem, printcharfun, escapeflag);
+ }
+ }
+ PRINTCHAR (']');
}
- PRINTCHAR ('>');
break;
- case Lisp_Window_Configuration:
- strout ("#<window-configuration>", -1, printcharfun);
- break;
+#ifndef standalone
+ case Lisp_Misc:
+ switch (XMISCTYPE (obj))
+ {
+ case Lisp_Misc_Marker:
+ strout ("#<marker ", -1, printcharfun);
+ if (!(XMARKER (obj)->buffer))
+ strout ("in no buffer", -1, printcharfun);
+ else
+ {
+ sprintf (buf, "at %d", marker_position (obj));
+ strout (buf, -1, printcharfun);
+ strout (" in ", -1, printcharfun);
+ print_string (XMARKER (obj)->buffer->name, printcharfun);
+ }
+ PRINTCHAR ('>');
+ break;
-#ifdef MULTI_FRAME
- case Lisp_Frame:
- strout ((FRAME_LIVE_P (XFRAME (obj))
- ? "#<frame " : "#<dead frame "),
- -1, printcharfun);
- print_string (XFRAME (obj)->name, printcharfun);
- sprintf (buf, " 0x%x", (unsigned int) (XFRAME (obj)));
- strout (buf, -1, printcharfun);
- strout (">", -1, printcharfun);
- break;
-#endif /* MULTI_FRAME */
+ case Lisp_Misc_Overlay:
+ strout ("#<overlay ", -1, printcharfun);
+ if (!(XMARKER (OVERLAY_START (obj))->buffer))
+ strout ("in no buffer", -1, printcharfun);
+ else
+ {
+ sprintf (buf, "from %d to %d in ",
+ marker_position (OVERLAY_START (obj)),
+ marker_position (OVERLAY_END (obj)));
+ strout (buf, -1, printcharfun);
+ print_string (XMARKER (OVERLAY_START (obj))->buffer->name,
+ printcharfun);
+ }
+ PRINTCHAR ('>');
+ break;
- case Lisp_Marker:
- strout ("#<marker ", -1, printcharfun);
- if (!(XMARKER (obj)->buffer))
- strout ("in no buffer", -1, printcharfun);
- else
- {
- sprintf (buf, "at %d", marker_position (obj));
+ /* Remaining cases shouldn't happen in normal usage, but let's print
+ them anyway for the benefit of the debugger. */
+ case Lisp_Misc_Free:
+ strout ("#<misc free cell>", -1, printcharfun);
+ break;
+
+ case Lisp_Misc_Intfwd:
+ sprintf (buf, "#<intfwd to %d>", *XINTFWD (obj)->intvar);
strout (buf, -1, printcharfun);
- strout (" in ", -1, printcharfun);
- print_string (XMARKER (obj)->buffer->name, printcharfun);
- }
- PRINTCHAR ('>');
- break;
+ break;
- case Lisp_Overlay:
- strout ("#<overlay ", -1, printcharfun);
- if (!(XMARKER (OVERLAY_START (obj))->buffer))
- strout ("in no buffer", -1, printcharfun);
- else
- {
- sprintf (buf, "from %d to %d in ",
- marker_position (OVERLAY_START (obj)),
- marker_position (OVERLAY_END (obj)));
+ case Lisp_Misc_Boolfwd:
+ sprintf (buf, "#<boolfwd to %s>",
+ (*XBOOLFWD (obj)->boolvar ? "t" : "nil"));
strout (buf, -1, printcharfun);
- print_string (XMARKER (OVERLAY_START (obj))->buffer->name,
- printcharfun);
+ break;
+
+ case Lisp_Misc_Objfwd:
+ strout (buf, "#<objfwd to ", -1, printcharfun);
+ print (*XOBJFWD (obj)->objvar, printcharfun, escapeflag);
+ PRINTCHAR ('>');
+ break;
+
+ case Lisp_Misc_Buffer_Objfwd:
+ strout (buf, "#<buffer_objfwd to ", -1, printcharfun);
+ print (*(Lisp_Object *)((char *)current_buffer
+ + XBUFFER_OBJFWD (obj)->offset),
+ printcharfun, escapeflag);
+ PRINTCHAR ('>');
+ break;
+
+ case Lisp_Misc_Kboard_Objfwd:
+ strout (buf, "#<kboard_objfwd to ", -1, printcharfun);
+ print (*(Lisp_Object *)((char *) current_kboard
+ + XKBOARD_OBJFWD (obj)->offset),
+ printcharfun, escapeflag);
+ PRINTCHAR ('>');
+ break;
+
+ case Lisp_Misc_Buffer_Local_Value:
+ strout ("#<buffer_local_value ", -1, printcharfun);
+ goto do_buffer_local;
+ case Lisp_Misc_Some_Buffer_Local_Value:
+ strout ("#<some_buffer_local_value ", -1, printcharfun);
+ do_buffer_local:
+ strout ("[realvalue] ", -1, printcharfun);
+ print (XBUFFER_LOCAL_VALUE (obj)->car, printcharfun, escapeflag);
+ strout ("[buffer] ", -1, printcharfun);
+ print (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->car,
+ printcharfun, escapeflag);
+ strout ("[alist-elt] ", -1, printcharfun);
+ print (XCONS (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->cdr)->car,
+ printcharfun, escapeflag);
+ strout ("[default-value] ", -1, printcharfun);
+ print (XCONS (XCONS (XBUFFER_LOCAL_VALUE (obj)->cdr)->cdr)->cdr,
+ printcharfun, escapeflag);
+ PRINTCHAR ('>');
+ break;
+
+ default:
+ goto badtype;
}
- PRINTCHAR ('>');
break;
-
#endif /* standalone */
- case Lisp_Subr:
- strout ("#<subr ", -1, printcharfun);
- strout (XSUBR (obj)->symbol_name, -1, printcharfun);
- PRINTCHAR ('>');
- break;
+ default:
+ badtype:
+ {
+ /* We're in trouble if this happens!
+ Probably should just abort () */
+ strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun);
+ if (MISCP (obj))
+ sprintf (buf, "(MISC 0x%04x)", (int) XMISCTYPE (obj));
+ else if (VECTORLIKEP (obj))
+ sprintf (buf, "(PVEC 0x%08x)", (int) XVECTOR (obj)->size);
+ else
+ sprintf (buf, "(0x%02x)", (int) XTYPE (obj));
+ strout (buf, -1, printcharfun);
+ strout (" Save your buffers immediately and please report this bug>",
+ -1, printcharfun);
+ }
}
print_depth--;
The precision in any of these cases is the number of digits following\n\
the decimal point. With `f', a precision of 0 means to omit the\n\
decimal point. 0 is not allowed with `e' or `g'.\n\n\
-A value of nil means to use `%.20g'.");
+A value of nil means to use `%.17g'.");
Vfloat_output_format = Qnil;
Qfloat_output_format = intern ("float-output-format");
staticpro (&Qfloat_output_format);
Vprint_level = Qnil;
DEFVAR_BOOL ("print-escape-newlines", &print_escape_newlines,
- "Non-nil means print newlines in strings as backslash-n.");
+ "Non-nil means print newlines in strings as backslash-n.\n\
+Also print formfeeds as backslash-f.");
print_escape_newlines = 0;
/* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
HCoop / bpt / emacs.git / blobdiff