\f
int stdout_needs_newline;
+void debug_backtrace(void);
+
static void
std_handle_out_external(FILE * stream, Lisp_Object lstream,
const Extbyte * extptr, Extcount extlen,
}
-#define SXE_VSNPRINT_VA(ret,sbuf,buf,size,spec,tries,type,fmt,args) \
+#define SXE_VSNPRINT_VA(ret__,sbuf__,buf__,size__,spec__,tries__,type__,fmt__,args__) \
do { \
- --tries; \
- ret = vsnprintf((char*)buf,size,fmt,args); \
- if ( retval == 0 ) { \
+ --tries__; \
+ ret__ = vsnprintf((char*)buf__,size__,fmt__,args__); \
+ if ( ret__ == 0 ) { \
/* Nothing to write */ \
break; \
- } else if ( ret < 0 ) { \
- XMALLOC_UNBIND(buf,size,spec); \
- size *= 2; \
- XMALLOC_OR_ALLOCA(buf,size,type); \
- ret = 0; \
- } else if ( (size_t)ret > (size_t)size ) { \
+ } else if ( ret__ < 0 ) { \
+ XMALLOC_UNBIND(buf__,size__,spec__); \
+ size__ *= 2; \
+ XMALLOC_OR_ALLOCA(buf__,size__,type__); \
+ } else if ( (size_t)ret__ > (size_t)size__ ) { \
/* We need more space, so we need to allocate it */ \
- XMALLOC_UNBIND(buf,size,spec); \
- size = ret + 1; \
- XMALLOC_OR_ALLOCA(buf,size,type); \
- ret = 0; \
+ XMALLOC_UNBIND(buf__,size__,spec__); \
+ size__ = ret__ + 1; \
+ XMALLOC_OR_ALLOCA(buf__,size__,type__); \
+ ret__ = -1; \
} \
- } while( ret == 0 && tries > 0 )
+ } while( ret__ < 0 && tries__ > 0 )
int write_fmt_str(Lisp_Object stream, const char* fmt, ...)
char *kludge;
va_list args;
int bufsize, retval, tries = 3;
- /* write_fmt_str is used for small prints usually... */
- char buffer[64+1];
+ /* write_fmt_str is used for small prints usually... */
+ char buffer[64+1];
int speccount = specpdl_depth();
va_start(args, fmt);
kludge = buffer;
SXE_VSNPRINT_VA(retval,buffer,kludge,bufsize,speccount,tries,Bufbyte,fmt,args);
-
+
if (retval == 0)
/* nothing to write */
return retval;
- use_fprintf = ! initialized ||fatal_error_in_progress ||
+ use_fprintf = ! initialized ||fatal_error_in_progress ||
inhibit_non_essential_printing_operations;
if (retval > 0) {
int retval;
va_list args;
va_start(args, fmt);
- retval = std_handle_out_va(stdout,
- (initialized && !fatal_error_in_progress
- ? GETTEXT(fmt) : fmt),
+ retval = std_handle_out_va(stdout,
+ (initialized && !fatal_error_in_progress
+ ? GETTEXT(fmt) : fmt),
args);
va_end(args);
return retval;
va_start(args, fmt);
stderr_out("\nSXEmacs: ");
- std_handle_out_va(stderr,
- (initialized && !fatal_error_in_progress
- ? GETTEXT(fmt) : fmt),
+ std_handle_out_va(stderr,
+ (initialized && !fatal_error_in_progress
+ ? GETTEXT(fmt) : fmt),
args);
stderr_out("\n");
Lisp_Object coding_system, int must_flush)
{
Extcount extlen;
- const Extbyte *extptr;
+ const Extbyte *extptr = NULL;
/* #### yuck! sometimes this function is called with string data,
and the following call may gc. */
Bufbyte *puta = (Bufbyte *) alloca(len);
memcpy(puta, str + offset, len);
- if (initialized && !inhibit_non_essential_printing_operations)
+ if (initialized && !inhibit_non_essential_printing_operations) {
TO_EXTERNAL_FORMAT(DATA, (puta, len),
ALLOCA, (extptr, extlen),
coding_system);
- else {
+ }
+ if( extptr == NULL ) {
extptr = (Extbyte *) puta;
extlen = (Bytecount) len;
}
}
+
if (stream) {
std_handle_out_external(stream, Qnil, extptr, extlen,
stream == stdout
|| stream == stderr, must_flush);
- } else {
+ } else if(con != NULL) {
assert(CONSOLE_TTY_P(con));
std_handle_out_external(0, CONSOLE_TTY_DATA(con)->outstream,
extptr, extlen,
CONSOLE_TTY_DATA(con)->is_stdio,
must_flush);
+ } else {
+ error("Error attempting to write write '%s' with no stream nor console", str);
+ debug_backtrace();
+ abort();
}
}
Lisp_Object Vfloat_output_format;
+void float_to_string(char *buf, fpfloat data, int maxlen);
+
/*
* This buffer should be at least as large as the max string size of the
* largest float, printed in the biggest notation. This is undoubtedly
* I assume that IEEE-754 format numbers can take 329 bytes for the worst
* case of -1e307 in 20d float_output_format. What is one to do (short of
* re-writing _doprnt to be more sane)?
- * -wsr
+ * -wsr
*/
void float_to_string(char *buf, fpfloat data, int maxlen)
{
len = snprintf(buf, sizeof(buf), "%s object %p", badness_string, val);
break;
default:
- len = snprintf(buf, sizeof(buf), "%s unknown badness %d",
+ len = snprintf(buf, sizeof(buf), "%s unknown badness %d",
badness_string, badness);
break;
}
output. */
#endif
- /* Try out custom printing */
- if (UNLIKELY(!(bool)inhibit_autoloads && !(bool)nodumpfile) &&
+ /* Try out custom printing */
+ if (UNLIKELY(!(bool)inhibit_autoloads && !(bool)nodumpfile) &&
!EQ(Qnil, Vcustom_object_printer) &&
- !EQ(Qnil, apply1(Vcustom_object_printer,
- Fcons(obj, Fcons(printcharfun, Qnil))))) {
- return;
+ !EQ(Qnil, apply1(Vcustom_object_printer,
+ Fcons(obj, Fcons(printcharfun, Qnil))))) {
+ return;
}
/* Detect circularities and truncate them.
Bufbyte str[MAX_EMCHAR_LEN];
Bytecount len;
int extlen;
- const Extbyte *extptr;
+ const Extbyte *extptr = NULL;
CHECK_CHAR_COERCE_INT(character);
len = set_charptr_emchar(str, XCHAR(character));
TO_EXTERNAL_FORMAT(DATA, (str, len),
ALLOCA, (extptr, extlen), Qterminal);
- memcpy(alternate_do_string + alternate_do_pointer, extptr, extlen);
- alternate_do_pointer += extlen;
- alternate_do_string[alternate_do_pointer] = 0;
+ if ( extptr != NULL ) {
+ memcpy(alternate_do_string + alternate_do_pointer, extptr, extlen);
+ alternate_do_pointer += extlen;
+ alternate_do_string[alternate_do_pointer] = 0;
+ } else {
+ /* Better bad transcoding than nothing I guess... */
+ memcpy(alternate_do_string + alternate_do_pointer, str, len);
+ alternate_do_pointer += len;
+ alternate_do_string[alternate_do_pointer] = 0;
+ }
return character;
}
*/
(char_or_string, stdout_p, device))
{
- FILE *file = 0;
- struct console *con = 0;
+ FILE *file = NULL;
+ struct console *con = NULL;
if (NILP(device)) {
if (!NILP(stdout_p))
/* Debugging kludge -- unbuffered */
/* This function provided for the benefit of the debugger. */
-void debug_backtrace(void);
void debug_backtrace(void)
{
/* This function can GC */
projects / sxemacs / blobdiff