ptrdiff_t i;
ptrdiff_t size = SCHARS (string);
ptrdiff_t size_byte = SBYTES (string);
- struct gcpro gcpro1;
- GCPRO1 (string);
if (size == size_byte)
for (i = 0; i < size; i++)
printchar (SREF (string, i), printcharfun);
printchar (ch, printcharfun);
i += len;
}
- UNGCPRO;
}
}
\f
is used instead. */)
(Lisp_Object object, Lisp_Object printcharfun)
{
- struct gcpro gcpro1;
-
if (NILP (printcharfun))
printcharfun = Vstandard_output;
- GCPRO1 (object);
PRINTPREPARE;
printchar ('\n', printcharfun);
print (object, printcharfun, 1);
printchar ('\n', printcharfun);
PRINTFINISH;
- UNGCPRO;
return object;
}
{
struct buffer *old = current_buffer;
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
set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
value = Fbuffer_string ();
- GCPRO1 (value);
Ferase_buffer ();
set_buffer_internal (old);
- UNGCPRO;
return value;
}
Lisp_Object caller)
{
Lisp_Object errname, errmsg, file_error, tail;
- struct gcpro gcpro1;
if (context != 0)
write_string_1 (context, stream);
USE_SAFE_ALLOCA;
char *name = SAFE_ALLOCA (cnamelen);
memcpy (name, SDATA (cname), cnamelen);
- message_dolog (name, cnamelen, 0, 0);
+ message_dolog (name, cnamelen, 0, STRING_MULTIBYTE (cname));
message_dolog (": ", 2, 0, 0);
SAFE_FREE ();
}
/* Print an error message including the data items. */
tail = Fcdr_safe (data);
- GCPRO1 (tail);
/* For file-error, make error message by concatenating
all the data items. They are all strings. */
if (!STRINGP (errmsg))
write_string_1 ("peculiar error", stream);
else if (SCHARS (errmsg))
- Fprinc (errmsg, stream);
+ Fprinc (Fsubstitute_command_keys (errmsg), stream);
else
sep = NULL;
Fprin1 (obj, stream);
}
}
-
- UNGCPRO;
}
print_string (obj, printcharfun);
else
{
- register ptrdiff_t i, i_byte;
- struct gcpro gcpro1;
+ ptrdiff_t i, i_byte;
ptrdiff_t size_byte;
/* True means we must ensure that the next character we output
cannot be taken as part of a hex character escape. */
bool need_nonhex = false;
bool multibyte = STRING_MULTIBYTE (obj);
- GCPRO1 (obj);
-
if (! EQ (Vprint_charset_text_property, Qt))
obj = print_prune_string_charset (obj);
0, print_interval, printcharfun);
printchar (')', printcharfun);
}
-
- UNGCPRO;
}
break;
&& print_depth > XINT (Vprint_level))
print_c_string ("...", printcharfun);
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
- && (EQ (XCAR (obj), Qquote)))
+ && EQ (XCAR (obj), Qquote))
{
printchar ('\'', printcharfun);
print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
}
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
- && (EQ (XCAR (obj), Qfunction)))
+ && EQ (XCAR (obj), Qfunction))
{
print_c_string ("#'", printcharfun);
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), Qbackquote))
{
- print_object (XCAR (obj), printcharfun, 0);
+ printchar ('`', printcharfun);
new_backquote_output++;
print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
new_backquote_output--;
}
else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
&& new_backquote_output
- && ((EQ (XCAR (obj), Qbackquote)
- || EQ (XCAR (obj), Qcomma)
- || EQ (XCAR (obj), Qcomma_at)
- || EQ (XCAR (obj), Qcomma_dot))))
+ && (EQ (XCAR (obj), Qcomma)
+ || EQ (XCAR (obj), Qcomma_at)
+ || EQ (XCAR (obj), Qcomma_dot)))
{
- print_object (XCAR (obj), printcharfun, 0);
+ print_object (XCAR (obj), printcharfun, false);
new_backquote_output--;
print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
new_backquote_output++;
{
ptrdiff_t i;
unsigned char c;
- struct gcpro gcpro1;
EMACS_INT size = bool_vector_size (obj);
ptrdiff_t size_in_chars = bool_vector_bytes (size);
ptrdiff_t real_size_in_chars = size_in_chars;
- GCPRO1 (obj);
int len = sprintf (buf, "#&%"pI"d\"", size);
strout (buf, len, len, printcharfun);
if (size_in_chars < real_size_in_chars)
print_c_string (" ...", printcharfun);
printchar ('\"', printcharfun);
-
- UNGCPRO;
}
else if (SUBRP (obj))
{
{
ptrdiff_t amount = v->data[1].integer;
-#if GC_MARK_STACK
-
/* valid_lisp_object_p is reliable, so try to print up
to 8 saved objects. This code is rarely used, so
it's OK that valid_lisp_object_p is slow. */
}
if (i == limit && i < amount)
print_c_string (" ...", printcharfun);
-
-#else /* not GC_MARK_STACK */
-
- /* There is no reliable way to determine whether the objects
- are initialized, so do not try to print them. */
-
- i = sprintf (buf, "with %"pD"d objects", amount);
- strout (buf, i, i, printcharfun);
-
-#endif /* GC_MARK_STACK */
}
else
{
DEFVAR_BOOL ("print-escape-nonascii", print_escape_nonascii,
doc: /* Non-nil means print unibyte non-ASCII chars in strings as \\OOO.
-\(OOO is the octal representation of the character code.)
+(OOO is the octal representation of the character code.)
Only single-byte characters are affected, and only in `prin1'.
When the output goes in a multibyte buffer, this feature is
enabled regardless of the value of the variable. */);
DEFVAR_BOOL ("print-escape-multibyte", print_escape_multibyte,
doc: /* Non-nil means print multibyte characters in strings as \\xXXXX.
-\(XXXX is the hex representation of the character code.)
+(XXXX is the hex representation of the character code.)
This affects only `prin1'. */);
print_escape_multibyte = 0;
DEFVAR_BOOL ("print-quoted", print_quoted,
doc: /* Non-nil means print quoted forms with reader syntax.
-I.e., (quote foo) prints as 'foo, (function foo) as #'foo. */);
+I.e., (quote foo) prints as \\='foo, (function foo) as #\\='foo. */);
print_quoted = 0;
DEFVAR_LISP ("print-gensym", Vprint_gensym,