/* Lisp object printing and output streams.
- Copyright (C) 1985, 86, 88, 93, 94, 95, 97 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86, 88, 93, 94, 95, 97, 98, 1999
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
#include "lisp.h"
-
-#ifndef standalone
#include "buffer.h"
#include "charset.h"
#include "frame.h"
#include "dispextern.h"
#include "termchar.h"
#include "keyboard.h"
-#endif /* not standalone */
-
-#ifdef USE_TEXT_PROPERTIES
#include "intervals.h"
-#endif
Lisp_Object Vstandard_output, Qstandard_output;
+Lisp_Object Qtemp_buffer_setup_hook;
+
/* These are used to print like we read. */
extern Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
#if STDC_HEADERS
#include <float.h>
-#include <stdlib.h>
#endif
/* Default to values appropriate for IEEE floating point. */
/* Size allocated in print_buffer. */
int print_buffer_size;
-/* Size used in print_buffer. */
+/* Chars stored in print_buffer. */
int print_buffer_pos;
+/* Bytes stored in print_buffer. */
+int print_buffer_pos_byte;
/* Maximum length of list to print in full; noninteger means
effectively infinity */
int print_escape_newlines;
+/* Nonzero means to print single-byte non-ascii characters in strings as
+ octal escapes. */
+
+int print_escape_nonascii;
+
+/* Nonzero means to print multibyte characters in strings as hex escapes. */
+
+int print_escape_multibyte;
+
Lisp_Object Qprint_escape_newlines;
+Lisp_Object Qprint_escape_multibyte, Qprint_escape_nonascii;
/* Nonzero means print (quote foo) forms as 'foo, etc. */
int print_quoted;
-/* Non-nil means print #: before uninterned symbols.
- Neither t nor nil means so that and don't clear Vprint_gensym_alist
- on entry to and exit from print functions. */
+/* Non-nil means print #: before uninterned symbols. */
Lisp_Object Vprint_gensym;
-/* Association list of certain objects that are `eq' in the form being
- printed and which should be `eq' when read back in, using the #n=object
- and #n# reader forms. Each element has the form (object . n). */
+/* Non-nil means print recursive structures using #n= and #n# syntax. */
+
+Lisp_Object Vprint_circle;
-Lisp_Object Vprint_gensym_alist;
+/* Non-nil means keep continuous number for #n= and #n# syntax
+ between several print functions. */
+
+Lisp_Object Vprint_continuous_numbering;
+
+/* Vprint_number_table is a vector like [OBJ1 STAT1 OBJ2 STAT2 ...],
+ where OBJn are objects going to be printed, and STATn are their status,
+ which may be different meanings during process. See the comments of
+ the functions print and print_preprocess for details.
+ print_number_index keeps the last position the next object should be added,
+ twice of which is the actual vector position in Vprint_number_table. */
+int print_number_index;
+Lisp_Object Vprint_number_table;
+
+/* PRINT_NUMBER_OBJECT returns the I'th object in Vprint_number_table TABLE.
+ PRINT_NUMBER_STATUS returns the status of the I'th object in TABLE.
+ See the comment of the variable Vprint_number_table. */
+#define PRINT_NUMBER_OBJECT(table,i) XVECTOR ((table))->contents[(i) * 2]
+#define PRINT_NUMBER_STATUS(table,i) XVECTOR ((table))->contents[(i) * 2 + 1]
/* Nonzero means print newline to stdout before next minibuffer message.
Defined in xdisp.c */
#endif /* MAX_PRINT_CHARS */
void print_interval ();
-\f
-#if 0
-/* Convert between chars and GLYPHs */
-
-int
-glyphlen (glyphs)
- register GLYPH *glyphs;
-{
- register int i = 0;
-
- while (glyphs[i])
- i++;
- return i;
-}
-void
-str_to_glyph_cpy (str, glyphs)
- char *str;
- GLYPH *glyphs;
-{
- register GLYPH *gp = glyphs;
- register char *cp = str;
-
- while (*cp)
- *gp++ = *cp++;
-}
-
-void
-str_to_glyph_ncpy (str, glyphs, n)
- char *str;
- GLYPH *glyphs;
- register int n;
-{
- register GLYPH *gp = glyphs;
- register char *cp = str;
-
- while (n-- > 0)
- *gp++ = *cp++;
-}
-
-void
-glyph_to_str_cpy (glyphs, str)
- GLYPH *glyphs;
- char *str;
-{
- register GLYPH *gp = glyphs;
- register char *cp = str;
-
- while (*gp)
- *str++ = *gp++ & 0377;
-}
-#endif
\f
/* Low level output routines for characters and strings */
and must start with PRINTPREPARE, end with PRINTFINISH,
and use PRINTDECLARE to declare common variables.
Use PRINTCHAR to output one character,
- or call strout to output a block of characters.
-*/
-
-#define PRINTDECLARE \
- struct buffer *old = current_buffer; \
- int old_point = -1, start_point; \
- int specpdl_count = specpdl_ptr - specpdl; \
- int free_print_buffer = 0; \
+ or call strout to output a block of characters. */
+
+#define PRINTDECLARE \
+ struct buffer *old = current_buffer; \
+ int old_point = -1, start_point; \
+ int old_point_byte, start_point_byte; \
+ int specpdl_count = specpdl_ptr - specpdl; \
+ int free_print_buffer = 0; \
+ int multibyte = !NILP (current_buffer->enable_multibyte_characters); \
Lisp_Object original
-#define PRINTPREPARE \
- original = printcharfun; \
- if (NILP (printcharfun)) printcharfun = Qt; \
- if (BUFFERP (printcharfun)) \
- { \
- if (XBUFFER (printcharfun) != current_buffer) \
- Fset_buffer (printcharfun); \
- printcharfun = Qnil; \
- } \
- if (MARKERP (printcharfun)) \
- { \
- if (!(XMARKER (original)->buffer)) \
- error ("Marker does not point anywhere"); \
- if (XMARKER (original)->buffer != current_buffer) \
- set_buffer_internal (XMARKER (original)->buffer); \
- old_point = PT; \
- SET_PT (marker_position (printcharfun)); \
- start_point = PT; \
- printcharfun = Qnil; \
- } \
- if (NILP (printcharfun)) \
- { \
- if (print_buffer != 0) \
- record_unwind_protect (print_unwind, \
- make_string (print_buffer, \
- print_buffer_pos)); \
- else \
- { \
- print_buffer_size = 1000; \
- print_buffer = (char *) xmalloc (print_buffer_size); \
- free_print_buffer = 1; \
- } \
- print_buffer_pos = 0; \
- } \
- if (!CONSP (Vprint_gensym)) \
- Vprint_gensym_alist = Qnil
-
-#define PRINTFINISH \
- if (NILP (printcharfun)) \
- insert (print_buffer, print_buffer_pos); \
- if (free_print_buffer) \
- { \
- xfree (print_buffer); \
- print_buffer = 0; \
- } \
- unbind_to (specpdl_count, Qnil); \
- if (MARKERP (original)) \
- Fset_marker (original, make_number (PT), Qnil); \
- if (old_point >= 0) \
- SET_PT (old_point + (old_point >= start_point \
- ? PT - start_point : 0)); \
- if (old != current_buffer) \
- set_buffer_internal (old); \
- if (!CONSP (Vprint_gensym)) \
- Vprint_gensym_alist = Qnil
+#define PRINTPREPARE \
+ original = printcharfun; \
+ if (NILP (printcharfun)) printcharfun = Qt; \
+ if (BUFFERP (printcharfun)) \
+ { \
+ if (XBUFFER (printcharfun) != current_buffer) \
+ Fset_buffer (printcharfun); \
+ printcharfun = Qnil; \
+ } \
+ if (MARKERP (printcharfun)) \
+ { \
+ if (!(XMARKER (original)->buffer)) \
+ error ("Marker does not point anywhere"); \
+ if (XMARKER (original)->buffer != current_buffer) \
+ set_buffer_internal (XMARKER (original)->buffer); \
+ old_point = PT; \
+ old_point_byte = PT_BYTE; \
+ SET_PT_BOTH (marker_position (printcharfun), \
+ marker_byte_position (printcharfun)); \
+ start_point = PT; \
+ start_point_byte = PT_BYTE; \
+ printcharfun = Qnil; \
+ } \
+ if (NILP (printcharfun)) \
+ { \
+ Lisp_Object string; \
+ if (NILP (current_buffer->enable_multibyte_characters) \
+ && ! print_escape_multibyte) \
+ specbind (Qprint_escape_multibyte, Qt); \
+ if (! NILP (current_buffer->enable_multibyte_characters) \
+ && ! print_escape_nonascii) \
+ specbind (Qprint_escape_nonascii, Qt); \
+ if (print_buffer != 0) \
+ { \
+ string = make_string_from_bytes (print_buffer, \
+ print_buffer_pos, \
+ print_buffer_pos_byte); \
+ record_unwind_protect (print_unwind, string); \
+ } \
+ else \
+ { \
+ print_buffer_size = 1000; \
+ print_buffer = (char *) xmalloc (print_buffer_size); \
+ free_print_buffer = 1; \
+ } \
+ print_buffer_pos = 0; \
+ print_buffer_pos_byte = 0; \
+ } \
+ if (EQ (printcharfun, Qt) && ! noninteractive) \
+ setup_echo_area_for_printing (multibyte);
+
+#define PRINTFINISH \
+ if (NILP (printcharfun)) \
+ { \
+ if (print_buffer_pos != print_buffer_pos_byte \
+ && NILP (current_buffer->enable_multibyte_characters)) \
+ { \
+ unsigned char *temp \
+ = (unsigned char *) alloca (print_buffer_pos + 1); \
+ copy_text (print_buffer, temp, print_buffer_pos_byte, \
+ 1, 0); \
+ insert_1_both (temp, print_buffer_pos, \
+ print_buffer_pos, 0, 1, 0); \
+ } \
+ else \
+ insert_1_both (print_buffer, print_buffer_pos, \
+ print_buffer_pos_byte, 0, 1, 0); \
+ } \
+ if (free_print_buffer) \
+ { \
+ xfree (print_buffer); \
+ print_buffer = 0; \
+ } \
+ unbind_to (specpdl_count, Qnil); \
+ if (MARKERP (original)) \
+ set_marker_both (original, Qnil, PT, PT_BYTE); \
+ if (old_point >= 0) \
+ SET_PT_BOTH (old_point + (old_point >= start_point \
+ ? PT - start_point : 0), \
+ old_point_byte + (old_point_byte >= start_point_byte \
+ ? PT_BYTE - start_point_byte : 0)); \
+ if (old != current_buffer) \
+ set_buffer_internal (old);
#define PRINTCHAR(ch) printchar (ch, printcharfun)
-/* Nonzero if there is no room to print any more characters
- so print might as well return right away. */
-
-#define PRINTFULLP() \
- (EQ (printcharfun, Qt) && !noninteractive \
- && printbufidx >= FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)))))
-
/* This is used to restore the saved contents of print_buffer
when there is a recursive call to print. */
+
static Lisp_Object
print_unwind (saved_text)
Lisp_Object saved_text;
bcopy (XSTRING (saved_text)->data, print_buffer, XSTRING (saved_text)->size);
}
-/* Index of first unused element of FRAME_MESSAGE_BUF (mini_frame). */
-static int printbufidx;
+
+/* Print character CH using method FUN. FUN nil means print to
+ print_buffer. FUN t means print to echo area or stdout if
+ non-interactive. If FUN is neither nil nor t, call FUN with CH as
+ argument. */
static void
printchar (ch, fun)
unsigned int ch;
Lisp_Object fun;
{
- Lisp_Object ch1;
-
#ifdef MAX_PRINT_CHARS
if (max_print)
print_chars++;
#endif /* MAX_PRINT_CHARS */
-#ifndef standalone
- if (EQ (fun, Qnil))
- {
- int len;
- char work[4], *str;
-
- QUIT;
- len = CHAR_STRING (ch, work, str);
- if (print_buffer_pos + len >= print_buffer_size)
- print_buffer = (char *) xrealloc (print_buffer,
- print_buffer_size *= 2);
- bcopy (str, print_buffer + print_buffer_pos, len);
- print_buffer_pos += len;
- return;
- }
- if (EQ (fun, Qt))
+ if (!NILP (fun) && !EQ (fun, Qt))
+ call1 (fun, make_number (ch));
+ else
{
- FRAME_PTR mini_frame
- = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
unsigned char work[4], *str;
int len = CHAR_STRING (ch, work, str);
-
+
QUIT;
-
- if (noninteractive)
+
+ if (NILP (fun))
{
- while (len--)
- putchar (*str), str++;
+ if (print_buffer_pos_byte + len >= print_buffer_size)
+ print_buffer = (char *) xrealloc (print_buffer,
+ print_buffer_size *= 2);
+ bcopy (str, print_buffer + print_buffer_pos_byte, len);
+ print_buffer_pos += 1;
+ print_buffer_pos_byte += len;
+ }
+ else if (noninteractive)
+ {
+ fwrite (str, 1, len, stdout);
noninteractive_need_newline = 1;
- return;
}
-
- if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame)
- || !message_buf_print)
+ else
{
- message_log_maybe_newline ();
- echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame);
- printbufidx = 0;
- echo_area_glyphs_length = 0;
- message_buf_print = 1;
-
- if (minibuffer_auto_raise)
- {
- Lisp_Object mini_window;
-
- /* Get the frame containing the minibuffer
- that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
-
- Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
- }
+ int multibyte_p
+ = !NILP (current_buffer->enable_multibyte_characters);
+
+ if (!message_buf_print)
+ setup_echo_area_for_printing (multibyte_p);
+
+ insert_char (ch);
+ message_dolog (str, len, 0, multibyte_p);
}
-
- message_dolog (str, len, 0);
- if (printbufidx < FRAME_MESSAGE_BUF_SIZE (mini_frame) - len)
- bcopy (str, &FRAME_MESSAGE_BUF (mini_frame)[printbufidx], len),
- printbufidx += len;
- FRAME_MESSAGE_BUF (mini_frame)[printbufidx] = 0;
- echo_area_glyphs_length = printbufidx;
-
- return;
}
-#endif /* not standalone */
-
- XSETFASTINT (ch1, ch);
- call1 (fun, ch1);
}
+
+/* Output SIZE characters, SIZE_BYTE bytes from string PTR using
+ method PRINTCHARFUN. If SIZE < 0, use the string length of PTR for
+ both SIZE and SIZE_BYTE. PRINTCHARFUN nil means output to
+ print_buffer. PRINTCHARFUN t means output to the echo area or to
+ stdout if non-interactive. If neither nil nor t, call Lisp
+ function PRINTCHARFUN for each character printed. MULTIBYTE
+ non-zero means PTR contains multibyte characters. */
+
static void
-strout (ptr, size, printcharfun)
+strout (ptr, size, size_byte, printcharfun, multibyte)
char *ptr;
- int size;
+ int size, size_byte;
Lisp_Object printcharfun;
+ int multibyte;
{
- int i = 0;
-
if (size < 0)
- size = strlen (ptr);
+ size_byte = size = strlen (ptr);
- if (EQ (printcharfun, Qnil))
+ if (NILP (printcharfun))
{
- if (print_buffer_pos + size > print_buffer_size)
+ if (print_buffer_pos_byte + size_byte > print_buffer_size)
{
- print_buffer_size = print_buffer_size * 2 + size;
+ print_buffer_size = print_buffer_size * 2 + size_byte;
print_buffer = (char *) xrealloc (print_buffer,
print_buffer_size);
}
- bcopy (ptr, print_buffer + print_buffer_pos, size);
+ bcopy (ptr, print_buffer + print_buffer_pos_byte, size_byte);
print_buffer_pos += size;
+ print_buffer_pos_byte += size_byte;
#ifdef MAX_PRINT_CHARS
if (max_print)
print_chars += size;
#endif /* MAX_PRINT_CHARS */
- return;
}
- if (EQ (printcharfun, Qt))
+ else if (noninteractive && EQ (printcharfun, Qt))
{
- FRAME_PTR mini_frame
- = XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)));
-
- QUIT;
-
+ fwrite (ptr, 1, size_byte, stdout);
+ noninteractive_need_newline = 1;
+ }
+ else if (EQ (printcharfun, Qt))
+ {
+ /* Output to echo area. We're trying to avoid a little overhead
+ here, that's the reason we don't call printchar to do the
+ job. */
+ int i;
+ int multibyte_p
+ = !NILP (current_buffer->enable_multibyte_characters);
+
+ if (!message_buf_print)
+ setup_echo_area_for_printing (multibyte_p);
+
+ message_dolog (ptr, size_byte, 0, multibyte_p);
+
+ if (size == size_byte)
+ {
+ for (i = 0; i < size; ++i)
+ insert_char (*ptr++);
+ }
+ else
+ {
+ int len;
+ for (i = 0; i < size_byte; i += len)
+ {
+ int ch = STRING_CHAR_AND_LENGTH (ptr + i, size_byte - i, len);
+ insert_char (ch);
+ }
+ }
+
#ifdef MAX_PRINT_CHARS
if (max_print)
print_chars += size;
#endif /* MAX_PRINT_CHARS */
+ }
+ else
+ {
+ /* PRINTCHARFUN is a Lisp function. */
+ int i = 0;
- if (noninteractive)
- {
- fwrite (ptr, 1, size, stdout);
- noninteractive_need_newline = 1;
- return;
- }
-
- if (echo_area_glyphs != FRAME_MESSAGE_BUF (mini_frame)
- || !message_buf_print)
+ if (size == size_byte)
{
- message_log_maybe_newline ();
- echo_area_glyphs = FRAME_MESSAGE_BUF (mini_frame);
- printbufidx = 0;
- echo_area_glyphs_length = 0;
- message_buf_print = 1;
-
- if (minibuffer_auto_raise)
+ while (i < size_byte)
{
- Lisp_Object mini_window;
-
- /* Get the frame containing the minibuffer
- that the selected frame is using. */
- mini_window = FRAME_MINIBUF_WINDOW (selected_frame);
-
- Fraise_frame (WINDOW_FRAME (XWINDOW (mini_window)));
+ int ch = ptr[i++];
+ PRINTCHAR (ch);
}
}
-
- message_dolog (ptr, size, 0);
- if (size > FRAME_MESSAGE_BUF_SIZE (mini_frame) - printbufidx - 1)
+ else
{
- size = FRAME_MESSAGE_BUF_SIZE (mini_frame) - printbufidx - 1;
- /* Rewind incomplete multi-byte form. */
- while (size && (unsigned char) ptr[size] >= 0xA0) size--;
+ while (i < size_byte)
+ {
+ /* Here, we must convert each multi-byte form to the
+ corresponding character code before handing it to
+ PRINTCHAR. */
+ int len;
+ int ch = STRING_CHAR_AND_LENGTH (ptr + i, size_byte - i, len);
+ PRINTCHAR (ch);
+ i += len;
+ }
}
- bcopy (ptr, &FRAME_MESSAGE_BUF (mini_frame) [printbufidx], size);
- printbufidx += size;
- echo_area_glyphs_length = printbufidx;
- FRAME_MESSAGE_BUF (mini_frame) [printbufidx] = 0;
-
- return;
- }
-
- i = 0;
- while (i < size)
- {
- /* Here, we must convert each multi-byte form to the
- corresponding character code before handing it to PRINTCHAR. */
- int len;
- int ch = STRING_CHAR_AND_LENGTH (ptr + i, size - i, len);
-
- PRINTCHAR (ch);
- i += len;
}
}
It isn't safe to use strout in many cases,
because printing one char can relocate. */
+static void
print_string (string, printcharfun)
Lisp_Object string;
Lisp_Object printcharfun;
{
if (EQ (printcharfun, Qt) || NILP (printcharfun))
- /* strout is safe for output to a frame (echo area) or to print_buffer. */
- strout (XSTRING (string)->data, XSTRING (string)->size, printcharfun);
+ {
+ int chars;
+
+ if (STRING_MULTIBYTE (string))
+ chars = XSTRING (string)->size;
+ else if (EQ (printcharfun, Qt)
+ ? ! NILP (buffer_defaults.enable_multibyte_characters)
+ : ! NILP (current_buffer->enable_multibyte_characters))
+ chars = multibyte_chars_in_text (XSTRING (string)->data,
+ STRING_BYTES (XSTRING (string)));
+ else
+ chars = STRING_BYTES (XSTRING (string));
+
+ /* strout is safe for output to a frame (echo area) or to print_buffer. */
+ strout (XSTRING (string)->data,
+ chars, STRING_BYTES (XSTRING (string)),
+ printcharfun, STRING_MULTIBYTE (string));
+ }
else
{
- /* Otherwise, fetch the string address for each character. */
+ /* Otherwise, string may be relocated by printing one char.
+ So re-fetch the string address for each character. */
int i;
int size = XSTRING (string)->size;
+ int size_byte = STRING_BYTES (XSTRING (string));
struct gcpro gcpro1;
GCPRO1 (string);
- for (i = 0; i < size; i++)
- PRINTCHAR (XSTRING (string)->data[i]);
+ if (size == size_byte)
+ for (i = 0; i < size; i++)
+ PRINTCHAR (XSTRING (string)->data[i]);
+ else
+ for (i = 0; i < size_byte; i++)
+ {
+ /* Here, we must convert each multi-byte form to the
+ corresponding character code before handing it to PRINTCHAR. */
+ int len;
+ int ch = STRING_CHAR_AND_LENGTH (XSTRING (string)->data + i,
+ size_byte - i, len);
+ if (!CHAR_VALID_P (ch, 0))
+ {
+ ch = XSTRING (string)->data[i];
+ len = 1;
+ }
+ PRINTCHAR (ch);
+ i += len;
+ }
UNGCPRO;
}
}
return character;
}
-/* Used from outside of print.c to print a block of SIZE chars at DATA
- on the default output stream.
+/* Used from outside of print.c to print a block of SIZE
+ single-byte chars at DATA on the default output stream.
Do not use this on the contents of a Lisp string. */
+void
write_string (data, size)
char *data;
int size;
printcharfun = Vstandard_output;
PRINTPREPARE;
- strout (data, size, printcharfun);
+ strout (data, size, size, printcharfun, 0);
PRINTFINISH;
}
-/* Used from outside of print.c to print a block of SIZE chars at DATA
- on a specified stream PRINTCHARFUN.
+/* Used from outside of print.c to print a block of SIZE
+ single-byte chars at DATA on a specified stream PRINTCHARFUN.
Do not use this on the contents of a Lisp string. */
+void
write_string_1 (data, size, printcharfun)
char *data;
int size;
PRINTDECLARE;
PRINTPREPARE;
- strout (data, size, printcharfun);
+ strout (data, size, size, printcharfun, 0);
PRINTFINISH;
}
-#ifndef standalone
-
void
temp_output_buffer_setup (bufname)
char *bufname;
{
+ int count = specpdl_ptr - specpdl;
register struct buffer *old = current_buffer;
register Lisp_Object buf;
+ record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
+
Fset_buffer (Fget_buffer_create (build_string (bufname)));
current_buffer->directory = old->directory;
current_buffer->read_only = Qnil;
+ current_buffer->filename = Qnil;
+ current_buffer->undo_list = Qt;
+ current_buffer->overlays_before = Qnil;
+ current_buffer->overlays_after = Qnil;
+ current_buffer->enable_multibyte_characters
+ = buffer_defaults.enable_multibyte_characters;
Ferase_buffer ();
-
XSETBUFFER (buf, current_buffer);
- specbind (Qstandard_output, buf);
- set_buffer_internal (old);
+ call1 (Vrun_hooks, Qtemp_buffer_setup_hook);
+
+ unbind_to (count, Qnil);
+
+ specbind (Qstandard_output, buf);
}
Lisp_Object
internal_with_output_to_temp_buffer (bufname, function, args)
char *bufname;
- Lisp_Object (*function) ();
+ Lisp_Object (*function) P_ ((Lisp_Object));
Lisp_Object args;
{
int count = specpdl_ptr - specpdl;
All output done by BODY is inserted in that buffer by default.\n\
The buffer is displayed in another window, but not selected.\n\
The value of the last form in BODY is returned.\n\
-If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\n\
+If BODY does not finish normally, the buffer BUFNAME is not displayed.\n\
+\n\
+The hook `temp-buffer-setup-hook' is run before BODY,\n\
+with the buffer BUFNAME temporarily current.\n\
+The hook `temp-buffer-show-hook' is run after the buffer is displayed,\n\
+with the buffer temporarily current, and the window that was used\n\
+to display it temporarily selected.\n\
+\n\
If variable `temp-buffer-show-function' is non-nil, call it at the end\n\
-to get the buffer displayed. It gets one argument, the buffer to display.")
+to get the buffer displayed instead of just displaying the non-selected\n\
+buffer and calling the hook. It gets one argument, the buffer to display.")
(args)
Lisp_Object args;
{
return unbind_to (count, val);
}
-#endif /* not standalone */
+
\f
static void print ();
+static void print_preprocess ();
+static void print_preprocess_string ();
+static void print_object ();
DEFUN ("terpri", Fterpri, Sterpri, 0, 1, 0,
"Output a newline to stream PRINTCHARFUN.\n\
if (NILP (printcharfun))
printcharfun = Vstandard_output;
PRINTPREPARE;
- print_depth = 0;
print (object, printcharfun, 1);
PRINTFINISH;
return object;
printcharfun = Vprin1_to_string_buffer;
PRINTPREPARE;
- print_depth = 0;
print (object, printcharfun, NILP (noescape));
/* Make Vprin1_to_string_buffer be the default buffer after PRINTFINSH */
PRINTFINISH;
if (NILP (printcharfun))
printcharfun = Vstandard_output;
PRINTPREPARE;
- print_depth = 0;
print (object, printcharfun, 0);
PRINTFINISH;
return object;
printcharfun = Vstandard_output;
GCPRO1 (object);
PRINTPREPARE;
- print_depth = 0;
PRINTCHAR ('\n');
print (object, printcharfun, 1);
PRINTCHAR ('\n');
Lisp_Object obj;
{
struct buffer *old = current_buffer;
- Lisp_Object original, printcharfun, value;
+ Lisp_Object value;
struct gcpro gcpro1;
/* If OBJ is (error STRING), just return STRING.
That is not only faster, it also avoids the need to allocate
space here when the error is due to memory full. */
- if (CONSP (obj) && EQ (XCONS (obj)->car, Qerror)
- && CONSP (XCONS (obj)->cdr)
- && STRINGP (XCONS (XCONS (obj)->cdr)->car)
- && NILP (XCONS (XCONS (obj)->cdr)->cdr))
- return XCONS (XCONS (obj)->cdr)->car;
+ if (CONSP (obj) && EQ (XCAR (obj), Qerror)
+ && CONSP (XCDR (obj))
+ && STRINGP (XCAR (XCDR (obj)))
+ && NILP (XCDR (XCDR (obj))))
+ return XCAR (XCDR (obj));
- print_error_message (obj, Vprin1_to_string_buffer, NULL);
+ print_error_message (obj, Vprin1_to_string_buffer);
set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
value = Fbuffer_string ();
/* Print an error message for the error DATA
onto Lisp output stream STREAM (suitable for the print functions). */
+void
print_error_message (data, stream)
Lisp_Object data, stream;
{
/* For file-error, make error message by concatenating
all the data items. They are all strings. */
- if (!NILP (file_error) && !NILP (tail))
- errmsg = XCONS (tail)->car, tail = XCONS (tail)->cdr;
+ if (!NILP (file_error) && CONSP (tail))
+ errmsg = XCAR (tail), tail = XCDR (tail);
if (STRINGP (errmsg))
Fprinc (errmsg, stream);
unsigned char *cp;
int width;
+ /* Check for plus infinity in a way that won't lose
+ if there is no plus infinity. */
+ if (data == data / 2 && data > 1.0)
+ {
+ strcpy (buf, "1.0e+INF");
+ return;
+ }
+ /* Likewise for minus infinity. */
+ if (data == data / 2 && data < -1.0)
+ {
+ strcpy (buf, "-1.0e+INF");
+ return;
+ }
+ /* Check for NaN in a way that won't fail if there are no NaNs. */
+ if (! (data * 0.0 >= 0.0))
+ {
+ /* Prepend "-" if the NaN's sign bit is negative.
+ The sign bit of a double is the bit that is 1 in -0.0. */
+ int i;
+ union { double d; char c[sizeof (double)]; } u_data, u_minus_zero;
+ u_data.d = data;
+ u_minus_zero.d = - 0.0;
+ for (i = 0; i < sizeof (double); i++)
+ if (u_data.c[i] & u_minus_zero.c[i])
+ {
+ *buf++ = '-';
+ break;
+ }
+
+ strcpy (buf, "0.0e+NaN");
+ return;
+ }
+
if (NILP (Vfloat_output_format)
|| !STRINGP (Vfloat_output_format))
lose:
register Lisp_Object printcharfun;
int escapeflag;
{
- char buf[30];
+ print_depth = 0;
- QUIT;
+ /* Reset print_number_index and Vprint_number_table only when
+ the variable Vprint_continuous_numbering is nil. Otherwise,
+ the values of these variables will be kept between several
+ print functions. */
+ if (NILP (Vprint_continuous_numbering))
+ {
+ print_number_index = 0;
+ Vprint_number_table = Qnil;
+ }
-#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 (CONSP (obj) || VECTORP (obj) || COMPILEDP (obj))
+ /* Construct Vprint_number_table for print-gensym and print-circle. */
+ if (!NILP (Vprint_gensym) || !NILP (Vprint_circle))
{
- int i;
- for (i = 0; i < print_depth; i++)
- if (EQ (obj, being_printed[i]))
+ int i, start, index;
+ /* Construct Vprint_number_table. */
+ start = index = print_number_index;
+ print_preprocess (obj);
+ /* Remove unnecessary objects, which appear only once in OBJ;
+ that is, whose status is Qnil. */
+ for (i = start; i < print_number_index; i++)
+ if (!NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
{
- sprintf (buf, "#%d", i);
- strout (buf, -1, printcharfun);
- return;
+ PRINT_NUMBER_OBJECT (Vprint_number_table, index)
+ = PRINT_NUMBER_OBJECT (Vprint_number_table, i);
+ /* Reset the status field for the next print step. Now this
+ field means whether the object has already been printed. */
+ PRINT_NUMBER_STATUS (Vprint_number_table, index) = Qnil;
+ index++;
}
+ print_number_index = index;
+ }
+
+ print_object (obj, printcharfun, escapeflag);
+}
+
+/* Construct Vprint_number_table according to the structure of OBJ.
+ OBJ itself and all its elements will be added to Vprint_number_table
+ recursively if it is a list, vector, compiled function, char-table,
+ string (its text properties will be traced), or a symbol that has
+ no obarray (this is for the print-gensym feature).
+ The status fields of Vprint_number_table mean whether each object appears
+ more than once in OBJ: Qnil at the first time, and Qt after that . */
+static void
+print_preprocess (obj)
+ Lisp_Object obj;
+{
+ int i, size;
+
+ loop:
+ if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
+ || COMPILEDP (obj) || CHAR_TABLE_P (obj)
+ || (! NILP (Vprint_gensym)
+ && SYMBOLP (obj) && NILP (XSYMBOL (obj)->obarray)))
+ {
+ /* In case print-circle is nil and print-gensym is t,
+ add OBJ to Vprint_number_table only when OBJ is a symbol. */
+ if (! NILP (Vprint_circle) || SYMBOLP (obj))
+ {
+ for (i = 0; i < print_number_index; i++)
+ if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+ {
+ /* OBJ appears more than once. Let's remember that. */
+ PRINT_NUMBER_STATUS (Vprint_number_table, i) = Qt;
+ return;
+ }
+
+ /* OBJ is not yet recorded. Let's add to the table. */
+ if (print_number_index == 0)
+ {
+ /* Initialize the table. */
+ Vprint_number_table = Fmake_vector (make_number (40), Qnil);
+ }
+ else if (XVECTOR (Vprint_number_table)->size == print_number_index * 2)
+ {
+ /* Reallocate the table. */
+ int i = print_number_index * 4;
+ Lisp_Object old_table = Vprint_number_table;
+ Vprint_number_table = Fmake_vector (make_number (i), Qnil);
+ for (i = 0; i < print_number_index; i++)
+ {
+ PRINT_NUMBER_OBJECT (Vprint_number_table, i)
+ = PRINT_NUMBER_OBJECT (old_table, i);
+ PRINT_NUMBER_STATUS (Vprint_number_table, i)
+ = PRINT_NUMBER_STATUS (old_table, i);
+ }
+ }
+ PRINT_NUMBER_OBJECT (Vprint_number_table, print_number_index) = obj;
+ /* If Vprint_continuous_numbering is non-nil and OBJ is a gensym,
+ always print the gensym with a number. This is a special for
+ the lisp function byte-compile-output-docform. */
+ if (! NILP (Vprint_continuous_numbering) && SYMBOLP (obj)
+ && NILP (XSYMBOL (obj)->obarray))
+ PRINT_NUMBER_STATUS (Vprint_number_table, print_number_index) = Qt;
+ print_number_index++;
+ }
+
+ switch (XGCTYPE (obj))
+ {
+ case Lisp_String:
+ /* A string may have text properties, which can be circular. */
+ traverse_intervals (XSTRING (obj)->intervals, 0, 0,
+ print_preprocess_string, Qnil);
+ break;
+
+ case Lisp_Cons:
+ print_preprocess (XCAR (obj));
+ obj = XCDR (obj);
+ goto loop;
+
+ case Lisp_Vectorlike:
+ size = XVECTOR (obj)->size & PSEUDOVECTOR_SIZE_MASK;
+ for (i = 0; i < size; i++)
+ print_preprocess (XVECTOR (obj)->contents[i]);
+ }
+ }
+}
+
+static void
+print_preprocess_string (interval, arg)
+ INTERVAL interval;
+ Lisp_Object arg;
+{
+ print_preprocess (interval->plist);
+}
+
+static void
+print_object (obj, printcharfun, escapeflag)
+ Lisp_Object obj;
+ register Lisp_Object printcharfun;
+ int escapeflag;
+{
+ char buf[30];
+
+ QUIT;
+
+ /* Detect circularities and truncate them. */
+ if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
+ || COMPILEDP (obj) || CHAR_TABLE_P (obj)
+ || (! NILP (Vprint_gensym)
+ && SYMBOLP (obj) && NILP (XSYMBOL (obj)->obarray)))
+ {
+ if (NILP (Vprint_circle) && NILP (Vprint_gensym))
+ {
+ /* Simple but incomplete way. */
+ int i;
+ for (i = 0; i < print_depth; i++)
+ if (EQ (obj, being_printed[i]))
+ {
+ sprintf (buf, "#%d", i);
+ strout (buf, -1, -1, printcharfun, 0);
+ return;
+ }
+ being_printed[print_depth] = obj;
+ }
+ else
+ {
+ /* With the print-circle feature. */
+ int i;
+ for (i = 0; i < print_number_index; i++)
+ if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+ {
+ if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
+ {
+ /* Add a prefix #n= if OBJ has not yet been printed;
+ that is, its status field is nil. */
+ sprintf (buf, "#%d=", i + 1);
+ strout (buf, -1, -1, printcharfun, 0);
+ /* OBJ is going to be printed. Set the status to t. */
+ PRINT_NUMBER_STATUS (Vprint_number_table, i) = Qt;
+ break;
+ }
+ else
+ {
+ /* Just print #n# if OBJ has already been printed. */
+ sprintf (buf, "#%d#", i + 1);
+ strout (buf, -1, -1, printcharfun, 0);
+ return;
+ }
+ }
+ }
}
-#endif
- being_printed[print_depth] = obj;
print_depth++;
if (print_depth > PRINT_CIRCLE)
if (sizeof (int) == sizeof (EMACS_INT))
sprintf (buf, "%d", XINT (obj));
else if (sizeof (long) == sizeof (EMACS_INT))
- sprintf (buf, "%ld", XINT (obj));
+ sprintf (buf, "%ld", (long) XINT (obj));
else
abort ();
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
break;
#ifdef LISP_FLOAT_TYPE
{
char pigbuf[350]; /* see comments in float_to_string */
- float_to_string (pigbuf, XFLOAT(obj)->data);
- strout (pigbuf, -1, printcharfun);
+ float_to_string (pigbuf, XFLOAT_DATA (obj));
+ strout (pigbuf, -1, -1, printcharfun, 0);
}
break;
#endif
print_string (obj, printcharfun);
else
{
- register int i;
- register unsigned char c;
+ register int i, i_byte;
struct gcpro gcpro1;
+ unsigned char *str;
+ int size_byte;
+ /* 1 means we must ensure that the next character we output
+ cannot be taken as part of a hex character escape. */
+ int need_nonhex = 0;
GCPRO1 (obj);
-#ifdef USE_TEXT_PROPERTIES
if (!NULL_INTERVAL_P (XSTRING (obj)->intervals))
{
PRINTCHAR ('#');
PRINTCHAR ('(');
}
-#endif
PRINTCHAR ('\"');
- for (i = 0; i < XSTRING (obj)->size; i++)
+ str = XSTRING (obj)->data;
+ size_byte = STRING_BYTES (XSTRING (obj));
+
+ for (i = 0, i_byte = 0; i_byte < size_byte;)
{
+ /* Here, we must convert each multi-byte form to the
+ corresponding character code before handing it to PRINTCHAR. */
+ int len;
+ int c;
+
+ if (STRING_MULTIBYTE (obj))
+ {
+ c = STRING_CHAR_AND_LENGTH (str + i_byte,
+ size_byte - i_byte, len);
+ if (CHAR_VALID_P (c, 0))
+ i_byte += len;
+ else
+ c = str[i_byte++];
+ }
+ else
+ c = str[i_byte++];
+
QUIT;
- c = XSTRING (obj)->data[i];
+
if (c == '\n' && print_escape_newlines)
{
PRINTCHAR ('\\');
PRINTCHAR ('\\');
PRINTCHAR ('f');
}
+ else if (! SINGLE_BYTE_CHAR_P (c) && print_escape_multibyte)
+ {
+ /* When multibyte is disabled,
+ print multibyte string chars using hex escapes. */
+ unsigned char outbuf[50];
+ sprintf (outbuf, "\\x%x", c);
+ strout (outbuf, -1, -1, printcharfun, 0);
+ need_nonhex = 1;
+ }
+ else if (SINGLE_BYTE_CHAR_P (c) && ! ASCII_BYTE_P (c)
+ && print_escape_nonascii)
+ {
+ /* When printing in a multibyte buffer
+ or when explicitly requested,
+ print single-byte non-ASCII string chars
+ using octal escapes. */
+ unsigned char outbuf[5];
+ sprintf (outbuf, "\\%03o", c);
+ strout (outbuf, -1, -1, printcharfun, 0);
+ }
else
{
+ /* If we just had a hex escape, and this character
+ could be taken as part of it,
+ output `\ ' to prevent that. */
+ if (need_nonhex)
+ {
+ need_nonhex = 0;
+ if ((c >= 'a' && c <= 'f')
+ || (c >= 'A' && c <= 'F')
+ || (c >= '0' && c <= '9'))
+ strout ("\\ ", -1, -1, printcharfun, 0);
+ }
+
if (c == '\"' || c == '\\')
PRINTCHAR ('\\');
PRINTCHAR (c);
}
PRINTCHAR ('\"');
-#ifdef USE_TEXT_PROPERTIES
if (!NULL_INTERVAL_P (XSTRING (obj)->intervals))
{
traverse_intervals (XSTRING (obj)->intervals,
0, 0, print_interval, printcharfun);
PRINTCHAR (')');
}
-#endif
UNGCPRO;
}
{
register int confusing;
register unsigned char *p = XSYMBOL (obj)->name->data;
- register unsigned char *end = p + XSYMBOL (obj)->name->size;
- register unsigned char c;
- int i;
+ register unsigned char *end = p + STRING_BYTES (XSYMBOL (obj)->name);
+ register int c;
+ int i, i_byte, size_byte;
+ Lisp_Object name;
+
+ XSETSTRING (name, XSYMBOL (obj)->name);
if (p != end && (*p == '-' || *p == '+')) p++;
if (p == end)
else
confusing = 0;
- /* If we print an uninterned symbol as part of a complex object and
- the flag print-gensym is non-nil, prefix it with #n= to read the
- object back with the #n# reader syntax later if needed. */
if (! NILP (Vprint_gensym) && NILP (XSYMBOL (obj)->obarray))
{
- if (print_depth > 1)
- {
- Lisp_Object tem;
- tem = Fassq (obj, Vprint_gensym_alist);
- if (CONSP (tem))
- {
- PRINTCHAR ('#');
- print (XCDR (tem), printcharfun, escapeflag);
- PRINTCHAR ('#');
- break;
- }
- else
- {
- if (CONSP (Vprint_gensym_alist))
- XSETFASTINT (tem, XFASTINT (XCDR (XCAR (Vprint_gensym_alist))) + 1);
- else
- XSETFASTINT (tem, 1);
- Vprint_gensym_alist = Fcons (Fcons (obj, tem), Vprint_gensym_alist);
-
- PRINTCHAR ('#');
- print (tem, printcharfun, escapeflag);
- PRINTCHAR ('=');
- }
- }
PRINTCHAR ('#');
PRINTCHAR (':');
}
- for (i = 0; i < XSYMBOL (obj)->name->size; i++)
+ size_byte = STRING_BYTES (XSTRING (name));
+
+ for (i = 0, i_byte = 0; i_byte < size_byte;)
{
+ /* Here, we must convert each multi-byte form to the
+ corresponding character code before handing it to PRINTCHAR. */
+
+ if (STRING_MULTIBYTE (name))
+ FETCH_STRING_CHAR_ADVANCE (c, name, i, i_byte);
+ else
+ c = XSTRING (name)->data[i_byte++];
+
QUIT;
- c = XSYMBOL (obj)->name->data[i];
if (escapeflag)
{
/* If deeper than spec'd depth, print placeholder. */
if (INTEGERP (Vprint_level)
&& print_depth > XINT (Vprint_level))
- strout ("...", -1, printcharfun);
+ strout ("...", -1, -1, printcharfun, 0);
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
&& (EQ (XCAR (obj), Qquote)))
{
PRINTCHAR ('\'');
- print (XCAR (XCDR (obj)), printcharfun, escapeflag);
+ print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
}
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
&& (EQ (XCAR (obj), Qfunction)))
{
PRINTCHAR ('#');
PRINTCHAR ('\'');
- print (XCAR (XCDR (obj)), printcharfun, escapeflag);
+ print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
}
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
&& ((EQ (XCAR (obj), Qbackquote)
|| EQ (XCAR (obj), Qcomma_at)
|| EQ (XCAR (obj), Qcomma_dot))))
{
- print (XCAR (obj), printcharfun, 0);
- print (XCAR (XCDR (obj)), printcharfun, escapeflag);
+ print_object (XCAR (obj), printcharfun, 0);
+ print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
}
else
{
PRINTCHAR ('(');
{
register int i = 0;
- register int max = 0;
+ register int print_length = 0;
+ Lisp_Object halftail = obj;
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. */
+ print_length = XINT (Vprint_length);
while (CONSP (obj))
{
+ /* Detect circular list. */
+ if (NILP (Vprint_circle))
+ {
+ /* Simple but imcomplete way. */
+ if (i != 0 && EQ (obj, halftail))
+ {
+ sprintf (buf, " . #%d", i / 2);
+ strout (buf, -1, -1, printcharfun, 0);
+ goto end_of_list;
+ }
+ }
+ else
+ {
+ /* With the print-circle feature. */
+ if (i != 0)
+ {
+ int i;
+ for (i = 0; i < print_number_index; i++)
+ if (PRINT_NUMBER_OBJECT (Vprint_number_table, i) == obj)
+ {
+ if (NILP (PRINT_NUMBER_STATUS (Vprint_number_table, i)))
+ {
+ strout (" . ", 3, 3, printcharfun, 0);
+ print_object (obj, printcharfun, escapeflag);
+ }
+ else
+ {
+ sprintf (buf, " . #%d#", i + 1);
+ strout (buf, -1, -1, printcharfun, 0);
+ }
+ goto end_of_list;
+ }
+ }
+ }
if (i++)
PRINTCHAR (' ');
- if (max && i > max)
+ if (print_length && i > print_length)
{
- strout ("...", 3, printcharfun);
- break;
+ strout ("...", 3, 3, printcharfun, 0);
+ goto end_of_list;
}
- print (XCAR (obj), printcharfun, escapeflag);
+ print_object (XCAR (obj), printcharfun, escapeflag);
obj = XCDR (obj);
+ if (!(i & 1))
+ halftail = XCDR (halftail);
}
}
if (!NILP (obj))
{
- strout (" . ", 3, printcharfun);
- print (obj, printcharfun, escapeflag);
+ strout (" . ", 3, 3, printcharfun, 0);
+ print_object (obj, printcharfun, escapeflag);
}
+ end_of_list:
PRINTCHAR (')');
}
break;
{
if (escapeflag)
{
- strout ("#<process ", -1, printcharfun);
+ strout ("#<process ", -1, -1, printcharfun, 0);
print_string (XPROCESS (obj)->name, printcharfun);
PRINTCHAR ('>');
}
PRINTCHAR ('#');
PRINTCHAR ('&');
sprintf (buf, "%d", XBOOL_VECTOR (obj)->size);
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
PRINTCHAR ('\"');
/* Don't print more characters than the specified maximum. */
}
else if (SUBRP (obj))
{
- strout ("#<subr ", -1, printcharfun);
- strout (XSUBR (obj)->symbol_name, -1, printcharfun);
+ strout ("#<subr ", -1, -1, printcharfun, 0);
+ strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun, 0);
PRINTCHAR ('>');
}
-#ifndef standalone
else if (WINDOWP (obj))
{
- strout ("#<window ", -1, printcharfun);
+ strout ("#<window ", -1, -1, printcharfun, 0);
sprintf (buf, "%d", XFASTINT (XWINDOW (obj)->sequence_number));
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
if (!NILP (XWINDOW (obj)->buffer))
{
- strout (" on ", -1, printcharfun);
+ strout (" on ", -1, -1, printcharfun, 0);
print_string (XBUFFER (XWINDOW (obj)->buffer)->name, printcharfun);
}
PRINTCHAR ('>');
}
+ else if (HASH_TABLE_P (obj))
+ {
+ struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
+ strout ("#<hash-table", -1, -1, printcharfun, 0);
+ if (SYMBOLP (h->test))
+ {
+ PRINTCHAR (' ');
+ PRINTCHAR ('\'');
+ strout (XSYMBOL (h->test)->name->data, -1, -1, printcharfun, 0);
+ PRINTCHAR (' ');
+ strout (XSYMBOL (h->weak)->name->data, -1, -1, printcharfun, 0);
+ PRINTCHAR (' ');
+ sprintf (buf, "%d/%d", XFASTINT (h->count),
+ XVECTOR (h->next)->size);
+ strout (buf, -1, -1, printcharfun, 0);
+ }
+ sprintf (buf, " 0x%lx", (unsigned long) h);
+ strout (buf, -1, -1, printcharfun, 0);
+ PRINTCHAR ('>');
+ }
else if (BUFFERP (obj))
{
if (NILP (XBUFFER (obj)->name))
- strout ("#<killed buffer>", -1, printcharfun);
+ strout ("#<killed buffer>", -1, -1, printcharfun, 0);
else if (escapeflag)
{
- strout ("#<buffer ", -1, printcharfun);
+ strout ("#<buffer ", -1, -1, printcharfun, 0);
print_string (XBUFFER (obj)->name, printcharfun);
PRINTCHAR ('>');
}
}
else if (WINDOW_CONFIGURATIONP (obj))
{
- strout ("#<window-configuration>", -1, printcharfun);
+ strout ("#<window-configuration>", -1, -1, printcharfun, 0);
}
else if (FRAMEP (obj))
{
strout ((FRAME_LIVE_P (XFRAME (obj))
? "#<frame " : "#<dead frame "),
- -1, printcharfun);
+ -1, -1, printcharfun, 0);
print_string (XFRAME (obj)->name, printcharfun);
- sprintf (buf, " 0x%lx", (unsigned long) (XFRAME (obj)));
- strout (buf, -1, printcharfun);
+ sprintf (buf, " 0x%lx\\ ", (unsigned long) (XFRAME (obj)));
+ strout (buf, -1, -1, printcharfun, 0);
PRINTCHAR ('>');
}
-#endif /* not standalone */
else
{
int size = XVECTOR (obj)->size;
{
if (i) PRINTCHAR (' ');
tem = XVECTOR (obj)->contents[i];
- print (tem, printcharfun, escapeflag);
+ print_object (tem, printcharfun, escapeflag);
}
}
PRINTCHAR (']');
}
break;
-#ifndef standalone
case Lisp_Misc:
switch (XMISCTYPE (obj))
{
case Lisp_Misc_Marker:
- strout ("#<marker ", -1, printcharfun);
-#if 0
+ strout ("#<marker ", -1, -1, printcharfun, 0);
/* Do you think this is necessary? */
if (XMARKER (obj)->insertion_type != 0)
- strout ("(before-insertion) ", -1, printcharfun);
-#endif /* 0 */
+ strout ("(before-insertion) ", -1, -1, printcharfun, 0);
if (!(XMARKER (obj)->buffer))
- strout ("in no buffer", -1, printcharfun);
+ strout ("in no buffer", -1, -1, printcharfun, 0);
else
{
sprintf (buf, "at %d", marker_position (obj));
- strout (buf, -1, printcharfun);
- strout (" in ", -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
+ strout (" in ", -1, -1, printcharfun, 0);
print_string (XMARKER (obj)->buffer->name, printcharfun);
}
PRINTCHAR ('>');
break;
case Lisp_Misc_Overlay:
- strout ("#<overlay ", -1, printcharfun);
+ strout ("#<overlay ", -1, -1, printcharfun, 0);
if (!(XMARKER (OVERLAY_START (obj))->buffer))
- strout ("in no buffer", -1, printcharfun);
+ strout ("in no buffer", -1, -1, printcharfun, 0);
else
{
sprintf (buf, "from %d to %d in ",
marker_position (OVERLAY_START (obj)),
marker_position (OVERLAY_END (obj)));
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
print_string (XMARKER (OVERLAY_START (obj))->buffer->name,
printcharfun);
}
/* 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);
+ strout ("#<misc free cell>", -1, -1, printcharfun, 0);
break;
case Lisp_Misc_Intfwd:
sprintf (buf, "#<intfwd to %d>", *XINTFWD (obj)->intvar);
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
break;
case Lisp_Misc_Boolfwd:
sprintf (buf, "#<boolfwd to %s>",
(*XBOOLFWD (obj)->boolvar ? "t" : "nil"));
- strout (buf, -1, printcharfun);
+ strout (buf, -1, -1, printcharfun, 0);
break;
case Lisp_Misc_Objfwd:
- strout ("#<objfwd to ", -1, printcharfun);
- print (*XOBJFWD (obj)->objvar, printcharfun, escapeflag);
+ strout ("#<objfwd to ", -1, -1, printcharfun, 0);
+ print_object (*XOBJFWD (obj)->objvar, printcharfun, escapeflag);
PRINTCHAR ('>');
break;
case Lisp_Misc_Buffer_Objfwd:
- strout ("#<buffer_objfwd to ", -1, printcharfun);
- print (*(Lisp_Object *)((char *)current_buffer
- + XBUFFER_OBJFWD (obj)->offset),
+ strout ("#<buffer_objfwd to ", -1, -1, printcharfun, 0);
+ print_object (*(Lisp_Object *)((char *)current_buffer
+ + XBUFFER_OBJFWD (obj)->offset),
printcharfun, escapeflag);
PRINTCHAR ('>');
break;
case Lisp_Misc_Kboard_Objfwd:
- strout ("#<kboard_objfwd to ", -1, printcharfun);
- print (*(Lisp_Object *)((char *) current_kboard
- + XKBOARD_OBJFWD (obj)->offset),
+ strout ("#<kboard_objfwd to ", -1, -1, printcharfun, 0);
+ print_object (*(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);
+ strout ("#<buffer_local_value ", -1, -1, printcharfun, 0);
goto do_buffer_local;
case Lisp_Misc_Some_Buffer_Local_Value:
- strout ("#<some_buffer_local_value ", -1, printcharfun);
+ strout ("#<some_buffer_local_value ", -1, -1, printcharfun, 0);
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);
+ strout ("[realvalue] ", -1, -1, printcharfun, 0);
+ print_object (XBUFFER_LOCAL_VALUE (obj)->realvalue,
+ printcharfun, escapeflag);
+ if (XBUFFER_LOCAL_VALUE (obj)->found_for_buffer)
+ strout ("[local in buffer] ", -1, -1, printcharfun, 0);
+ else
+ strout ("[buffer] ", -1, -1, printcharfun, 0);
+ print_object (XBUFFER_LOCAL_VALUE (obj)->buffer,
+ printcharfun, escapeflag);
+ if (XBUFFER_LOCAL_VALUE (obj)->check_frame)
+ {
+ if (XBUFFER_LOCAL_VALUE (obj)->found_for_frame)
+ strout ("[local in frame] ", -1, -1, printcharfun, 0);
+ else
+ strout ("[frame] ", -1, -1, printcharfun, 0);
+ print_object (XBUFFER_LOCAL_VALUE (obj)->frame,
+ printcharfun, escapeflag);
+ }
+ strout ("[alist-elt] ", -1, -1, printcharfun, 0);
+ print_object (XCAR (XBUFFER_LOCAL_VALUE (obj)->cdr),
+ printcharfun, escapeflag);
+ strout ("[default-value] ", -1, -1, printcharfun, 0);
+ print_object (XCDR (XBUFFER_LOCAL_VALUE (obj)->cdr),
+ printcharfun, escapeflag);
PRINTCHAR ('>');
break;
goto badtype;
}
break;
-#endif /* standalone */
default:
badtype:
{
/* We're in trouble if this happens!
Probably should just abort () */
- strout ("#<EMACS BUG: INVALID DATATYPE ", -1, printcharfun);
+ strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun, 0);
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 (buf, -1, -1, printcharfun, 0);
strout (" Save your buffers immediately and please report this bug>",
- -1, printcharfun);
+ -1, -1, printcharfun, 0);
}
}
print_depth--;
}
\f
-#ifdef USE_TEXT_PROPERTIES
/* Print a description of INTERVAL using PRINTCHARFUN.
This is part of printing a string that has text properties. */
Lisp_Object printcharfun;
{
PRINTCHAR (' ');
- print (make_number (interval->position), printcharfun, 1);
+ print_object (make_number (interval->position), printcharfun, 1);
PRINTCHAR (' ');
- print (make_number (interval->position + LENGTH (interval)),
+ print_object (make_number (interval->position + LENGTH (interval)),
printcharfun, 1);
PRINTCHAR (' ');
- print (interval->plist, printcharfun, 1);
+ print_object (interval->plist, printcharfun, 1);
}
-#endif /* USE_TEXT_PROPERTIES */
\f
void
syms_of_print ()
{
+ Qtemp_buffer_setup_hook = intern ("temp-buffer-setup-hook");
+ staticpro (&Qtemp_buffer_setup_hook);
+
DEFVAR_LISP ("standard-output", &Vstandard_output,
"Output stream `print' uses by default for outputting a character.\n\
This may be any function of one argument.\n\
Also print formfeeds as backslash-f.");
print_escape_newlines = 0;
+ DEFVAR_BOOL ("print-escape-nonascii", &print_escape_nonascii,
+ "Non-nil means print unibyte non-ASCII chars in strings as \\OOO.\n\
+\(OOO is the octal representation of the character code.)\n\
+Only single-byte characters are affected, and only in `prin1'.");
+ print_escape_nonascii = 0;
+
+ DEFVAR_BOOL ("print-escape-multibyte", &print_escape_multibyte,
+ "Non-nil means print multibyte characters in strings as \\xXXXX.\n\
+\(XXX is the hex representation of the character code.)\n\
+This affects only `prin1'.");
+ print_escape_multibyte = 0;
+
DEFVAR_BOOL ("print-quoted", &print_quoted,
"Non-nil means print quoted forms with reader syntax.\n\
I.e., (quote foo) prints as 'foo, (function foo) as #'foo, and, backquoted\n\
DEFVAR_LISP ("print-gensym", &Vprint_gensym,
"Non-nil means print uninterned symbols so they will read as uninterned.\n\
I.e., the value of (make-symbol \"foobar\") prints as #:foobar.\n\
-When the uninterned symbol appears within a larger data structure,\n\
-in addition use the #...# and #...= constructs as needed,\n\
-so that multiple references to the same symbol are shared once again\n\
-when the text is read back.\n\
-\n\
-If the value of `print-gensym' is a cons cell, then in addition refrain from\n\
-clearing `print-gensym-alist' on entry to and exit from printing functions,\n\
-so that the use of #...# and #...= can carry over for several separately\n\
-printed objects.");
+When the uninterned symbol appears within a recursive data structure\n\
+and the symbol appears more than once, in addition use the #N# and #N=\n\
+constructs as needed, so that multiple references to the same symbol are\n\
+shared once again when the text is read back.");
Vprint_gensym = Qnil;
- DEFVAR_LISP ("print-gensym-alist", &Vprint_gensym_alist,
- "Association list of elements (GENSYM . N) to guide use of #N# and #N=.\n\
-In each element, GENSYM is an uninterned symbol that has been associated\n\
-with #N= for the specified value of N.");
- Vprint_gensym_alist = Qnil;
+ DEFVAR_LISP ("print-circle", &Vprint_circle,
+ "*Non-nil means print recursive structures using #N= and #N# syntax.\n\
+If nil, printing proceeds recursively and may lead to\n\
+`max-lisp-eval-depth' being exceeded or an error may occur:\n\
+\"Apparently circular structure being printed.\" Also see\n\
+`print-length' and `print-level'.\n\
+If non-nil, shared substructures anywhere in the structure are printed\n\
+with `#N=' before the first occurrence (in the order of the print\n\
+representation) and `#N#' in place of each subsequent occurrence,\n\
+where N is a positive decimal integer.");
+ Vprint_circle = Qnil;
+
+ DEFVAR_LISP ("print-continuous-numbering", &Vprint_continuous_numbering,
+ "*Non-nil means keep numbering between several print functions.\n\
+See `print-gensym' nad `print-circle'. See also `print-number-table'.");
+ Vprint_continuous_numbering = Qnil;
+
+ DEFVAR_LISP ("print-number-table", &Vprint_number_table,
+ "A vector keeping the information of the current printed object.\n\
+This variable shouldn't be modified in Lisp level, but should be binded\n\
+with nil using let at the same position with `print-continuous-numbering',\n\
+so that the value of this variable can be freed after printing.");
+ Vprint_number_table = Qnil;
/* prin1_to_string_buffer initialized in init_buffer_once in buffer.c */
staticpro (&Vprin1_to_string_buffer);
Qprint_escape_newlines = intern ("print-escape-newlines");
staticpro (&Qprint_escape_newlines);
-#ifndef standalone
+ Qprint_escape_multibyte = intern ("print-escape-multibyte");
+ staticpro (&Qprint_escape_multibyte);
+
+ Qprint_escape_nonascii = intern ("print-escape-nonascii");
+ staticpro (&Qprint_escape_nonascii);
+
defsubr (&Swith_output_to_temp_buffer);
-#endif /* not standalone */
}