Big round of changes to switch the code base to use the stream

abstraction instead of directly using C standard I/O,
to eliminate most uses of C formatted I/O,
and fix numerous bugs, such variadic argument lists which
lack a terminating ``nao'' sentinel.

Bug 28033 is addressed by this patch, since streams no longer provide
printf-compatible formatting. The native formatter is extended with
some additional capabilities to take over.

The work on literal objects is expanded and they are now used
throughout the code base.

Fixed bad realloc in string output stream: reallocating by number
of wide chars rather than bytes.

13 files changed, 756 insertions, 569 deletions

diff --git a/ChangeLog b/ChangeLog
index 376dfb31..0cb0e42e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,99 @@
+2009-11-16  Kaz Kylheku  <kkylheku@gmail.com>
+
+	Big round of changes to switch the code base to use the stream
+	abstraction instead of directly using C standard I/O,
+	to eliminate most uses of C formatted I/O,
+	and fix numerous bugs, such variadic argument lists which
+	lack a terminating ``nao'' sentinel. 
+	
+	Bug 28033 is addressed by this patch, since streams no longer provide
+	printf-compatible formatting. The native formatter is extended with
+	some additional capabilities to take over.
+
+	The work on literal objects is expanded and they are now used
+	throughout the code base.
+
+	Fixed bad realloc in string output stream: reallocating by number
+	of wide chars rather than bytes.
+
+	* gc.c (sweep): Debugging code switched from fprintf to format.
+
+	* lib.c (typ_check, type_check2, car, cdr, car_l, cdr_l, list,
+	num, chrp, apply, cobj_print_op, dump): Retargetted, with help of new
+	literals, to new funtions that take string objects, rather than raw C
+	strings.
+	(obj_print, obj_pprint): Revamped with support for LIT type.
+	Retargetted to not use C style I/O functions in streams.
+
+	* lib.h (lit): Macro retargetted to another macro so that it expands
+	its argument.
+	(lit_noex): New macro, like lit, but does not macro-expand argument.
+	(auto_str): New macro.
+	(static_str): New macro.
+
+	* match.c (debugf, debuglf, sem_error, file_err): Converted from C
+	string to string object.
+	(dest_bind, match_line, LOG_MISMATCH, LOG_MATCH, match_files):
+	Retargetted to new interfaces that take string objects rather than raw
+	C strings.
+	(complex_stream): New function.
+	(do_output_line, do_output, extract): Retargetted from C streams to
+	object streams.	
+
+	* parser.h (yyerrorf): Declaration updated.
+
+	* parser.l (yyerror): Call new yyerrorf interface, using auto_str
+	macro to dress up C string as a temporary object.
+	(yyerrorf): Changed from C strings to object strings.	
+	(yybadtoken, grammar): Retargetted to new yyerrorf.
+
+	* stream.c (strm_ops): put_string and put_char function pointers
+	changed to take object strings rather than C strings.  vcformat and
+	vformat virtuals removed. C formatting is not supported, and vformat is
+	handled above the stream switch level in one place for all streams.
+	(common_vformat, stdio_vcformat, string_out_vcformat, cformat,
+	put_cstring, put_cchar): Functions removed.	
+	(stdio_stream_print, stdio_stream_destroy, stdio_maybe_write_error,
+	stdio_put_string, stdio_put_char, stdio_close, pipe_close,
+	string_out_put_char, make_pipe_stream, make_string_input_stream,
+	make_string_output_stream, make_dir_stream, close_stream,
+	get_line, put_line, get_char, put_char, put_string): Retargetted to new
+	string object interfaces.
+	(stdio_ops, pipe_ops): stdio_vcformat and common_vcformat initializers
+	(string_out_ops): string_out_vcformat and common_vcformat initializers
+	removed.
+	(string_in_ops, byte_in_ops, dir_ops): Two null initializers removed.
+	(string_out_put_string): Converted to object string interface.
+	Unnecessary chk_realloc call suppressed.
+	(get_string_from_stream): Fixed bad call to realloc with incorrect
+	size.
+	(vformat_num, vformat_str): New functions, helper to vformat.
+	(vformat): Rewritten. Is now the formatting engine.
+	(format, put_string, put_char): Interface converted from C string to
+	object string.
+
+	* stream.h (vformat, format): Declarations updated.
+	(vcformat, cformat, put_cstring, put_cchar): Declarations removed.
+
+	* txr.c (oom_realloc_handler, help, txr_main): Retargetted to object
+	stream and strings.
+
+	* unwind.c (uw_throw, type_mismatch, uw_register_subtype): Retargetted
+	to new string object interfaces.
+	(uw_throwf, uw_errorf): Interface changed from C string to object
+	string.
+	(uw_throwcf, uw_errorcf): Functions removed.
+
+	* unwind.h (uw_throwf, uw_errorf, type_mismatch): Declarations updated.
+	(uw_throwcf, uw_errorcf): Declarations removed.
+	(internal_error): Macro interface changed and retargetted to
+	object strings. Also, num hygiene problem worked around with local
+	extern declaration.
+	(numeric_assert, range_bug_unless): Retargetted to object strings.
+
+	* utf8.c (utf8_to, utf8_dup_from_uc, utf8_dup_from,
+	utf8_dup_to_uc): Casts of chk_malloc return value added.
+
 2009-11-15  Kaz Kylheku  <kkylheku@gmail.com>
 
 	Use the 11 tag bit pattern to denote a new type: LIT. This is a
diff --git a/gc.c b/gc.c
index 850fab3f..3167fe4d 100644
--- a/gc.c
+++ b/gc.c
@@ -324,9 +324,9 @@ static void sweep(void)
         continue;
 
       if (0 && dbg) {
-        fwprintf(stderr, L"%ls: finalizing: ", progname);
+        format(std_error, lit("~a: finalizing: "), progname, nao);
         obj_print(block, std_error);
-        putwc('\n', stderr);
+        put_char(std_error, chr('\n'));
       }
       finalize(block);
       block->t.type |= FREE;
diff --git a/lib.c b/lib.c
index a04b1ee6..258d63de 100644
--- a/lib.c
+++ b/lib.c
@@ -128,14 +128,14 @@ obj_t *typeof(obj_t *obj)
 obj_t *type_check(obj_t *obj, int type)
 {
   if (!is_ptr(obj) || obj->t.type != type)
-    type_mismatch(L"~s is not of type ~s", obj, code2type(type), nao);
+    type_mismatch(lit("~s is not of type ~s"), obj, code2type(type), nao);
   return t;
 }
 
 obj_t *type_check2(obj_t *obj, int t1, int t2)
 {
   if (!is_ptr(obj) || (obj->t.type != t1 && obj->t.type != t2))
-    type_mismatch(L"~s is not of type ~s or ~s", obj,
+    type_mismatch(lit("~s is not of type ~s or ~s"), obj,
                   code2type(t1), code2type(t2), nao);
   return t;
 }
@@ -144,7 +144,7 @@ obj_t *type_check3(obj_t *obj, int t1, int t2, int t3)
 {
   if (!is_ptr(obj) || (obj->t.type != t1 && obj->t.type != t2
                        && obj->t.type != t3))
-    type_mismatch(L"~s is not of type ~s, ~s nor ~s", obj,
+    type_mismatch(lit("~s is not of type ~s, ~s nor ~s"), obj,
                   code2type(t1), code2type(t2), code2type(t3), nao);
   return t;
 }
@@ -165,7 +165,7 @@ obj_t *car(obj_t *cons)
       return cons->lc.car;
     }
   default:
-    type_mismatch(L"~s is not a cons", cons, nao);
+    type_mismatch(lit("~s is not a cons"), cons, nao);
   }
 }
 
@@ -185,7 +185,7 @@ obj_t *cdr(obj_t *cons)
       return cons->lc.cdr;
     }
   default:
-    type_mismatch(L"~s is not a cons", cons, nao);
+    type_mismatch(lit("~s is not a cons"), cons, nao);
   }
 }
 
@@ -198,7 +198,7 @@ obj_t **car_l(obj_t *cons)
     funcall1(cons->lc.func, cons);
     return &cons->lc.car;
   default:
-    type_mismatch(L"~s is not a cons", cons, nao);
+    type_mismatch(lit("~s is not a cons"), cons, nao);
   }
 }
 
@@ -211,7 +211,7 @@ obj_t **cdr_l(obj_t *cons)
     funcall1(cons->lc.func, cons);
     return &cons->lc.cdr;
   default:
-    type_mismatch(L"~s is not a cons", cons, nao);
+    type_mismatch(lit("~s is not a cons"), cons, nao);
   }
 }
 
@@ -561,7 +561,7 @@ obj_t *list(obj_t *first, ...)
     do {
       *ptr++ = next;
       if (ptr == array + 32)
-        internal_error(L"runaway arguments in list function");
+        internal_error("runaway arguments in list function");
       next = va_arg(vl, obj_t *);
     } while (next != nao);
 
@@ -624,7 +624,7 @@ obj_t *num(long val)
 long c_num(obj_t *num)
 {
   if (!is_num(num))
-    type_mismatch(L"~s is not a number", num, nao);
+    type_mismatch(lit("~s is not a number"), num, nao);
   return ((long) num) >> TAG_SHIFT;
 }
 
@@ -1012,7 +1012,7 @@ obj_t *chrp(obj_t *chr)
 wchar_t c_chr(obj_t *chr)
 {
   if (!is_chr(chr))
-    type_mismatch(L"~s is not a character", chr, nao);
+    type_mismatch(lit("~s is not a character"), chr, nao);
   return ((wchar_t) chr) >> TAG_SHIFT;
 }
 
@@ -1184,7 +1184,7 @@ obj_t *apply(obj_t *fun, obj_t *arglist)
   type_check (fun, FUN);
 
   type_assert (listp(arglist),
-               (L"apply arglist ~s is not a list", arglist, nao));
+               (lit("apply arglist ~s is not a list"), arglist, nao));
 
   *p++ = car(arglist); arglist = cdr(arglist);
   *p++ = car(arglist); arglist = cdr(arglist);
@@ -1563,9 +1563,9 @@ obj_t *cobj(void *handle, obj_t *cls_sym, struct cobj_ops *ops)
 
 void cobj_print_op(obj_t *obj, obj_t *out)
 {
-  put_cstring(out, L"#<");
+  put_string(out, lit("#<"));
   obj_print(obj->co.cls, out);
-  cformat(out, L": %p>", obj->co.handle);
+  format(out, lit(": ~p>"), obj->co.handle, nao);
 }
 
 obj_t *assoc(obj_t *list, obj_t *key)
@@ -1844,7 +1844,7 @@ static void obj_init(void)
 void obj_print(obj_t *obj, obj_t *out)
 {
   if (obj == nil) {
-    put_cstring(out, L"nil");
+    put_string(out, lit("nil"));
     return;
   }
 
@@ -1853,110 +1853,110 @@ void obj_print(obj_t *obj, obj_t *out)
   case LCONS:
     {
       obj_t *iter;
-      put_cchar(out, '(');
+      put_char(out, chr('('));
       for (iter = obj; consp(iter); iter = cdr(iter)) {
         obj_print(car(iter), out);
         if (nullp(cdr(iter))) {
-          put_cchar(out, ')');
+          put_char(out, chr(')'));
         } else if (consp(cdr(iter))) {
-          put_cchar(out, ' ');
+          put_char(out, chr(' '));
         } else {
-          put_cstring(out, L" . ");
+          put_string(out, lit(" . "));
           obj_print(cdr(iter), out);
-          put_cchar(out, ')');
+          put_char(out, chr(')'));
         }
       }
     }
     return;
-  case STR:
   case LIT:
+  case STR:
     {
       const wchar_t *ptr;
-      put_cchar(out, '"');
+      put_char(out, chr('"'));
       for (ptr = c_str(obj); *ptr; ptr++) {
         switch (*ptr) {
-        case L'\a': put_cstring(out, L"\\a"); break;
-        case L'\b': put_cstring(out, L"\\b"); break;
-        case L'\t': put_cstring(out, L"\\t"); break;
-        case L'\n': put_cstring(out, L"\\n"); break;
-        case L'\v': put_cstring(out, L"\\v"); break;
-        case L'\f': put_cstring(out, L"\\f"); break;
-        case L'\r': put_cstring(out, L"\\r"); break;
-        case L'"': put_cstring(out, L"\\\""); break;
-        case L'\\': put_cstring(out, L"\\\\"); break;
-        case 27: put_cstring(out, L"\\e"); break;
+        case '\a': put_string(out, lit("\\a")); break;
+        case '\b': put_string(out, lit("\\b")); break;
+        case '\t': put_string(out, lit("\\t")); break;
+        case '\n': put_string(out, lit("\\n")); break;
+        case '\v': put_string(out, lit("\\v")); break;
+        case '\f': put_string(out, lit("\\f")); break;
+        case '\r': put_string(out, lit("\\r")); break;
+        case '"': put_string(out, lit("\\\"")); break;
+        case '\\': put_string(out, lit("\\\\")); break;
+        case 27: put_string(out, lit("\\e")); break;
         default:
           if (iswprint(*ptr))
-            put_cchar(out, *ptr);
+            put_char(out, chr(*ptr));
           else
-            cformat(out, L"\\%03o", (int) *ptr);
+            format(out, lit("\\~03o"), num(*ptr), nao);
         }
       }
-      put_cchar(out, '"');
+      put_char(out, chr('"'));
     }
     return;
   case CHR:
     {
-      int ch = c_chr(obj);
+      wchar_t ch = c_chr(obj);
 
-      put_cchar(out, '\'');
+      put_char(out, chr('\''));
       switch (ch) {
-      case L'\a': put_cstring(out, L"\\a"); break;
-      case L'\b': put_cstring(out, L"\\b"); break;
-      case L'\t': put_cstring(out, L"\\t"); break;
-      case L'\n': put_cstring(out, L"\\n"); break;
-      case L'\v': put_cstring(out, L"\\v"); break;
-      case L'\f': put_cstring(out, L"\\f"); break;
-      case L'\r': put_cstring(out, L"\\r"); break;
-      case L'"': put_cstring(out, L"\\\""); break;
-      case L'\\': put_cstring(out, L"\\\\"); break;
-      case 27: put_cstring(out, L"\\e"); break;
+      case '\a': put_string(out, lit("\\a")); break;
+      case '\b': put_string(out, lit("\\b")); break;
+      case '\t': put_string(out, lit("\\t")); break;
+      case '\n': put_string(out, lit("\\n")); break;
+      case '\v': put_string(out, lit("\\v")); break;
+      case '\f': put_string(out, lit("\\f")); break;
+      case '\r': put_string(out, lit("\\r")); break;
+      case '"': put_string(out, lit("\\\"")); break;
+      case '\\': put_string(out, lit("\\\\")); break;
+      case 27: put_string(out, lit("\\e")); break;
       default:
         if (iswprint(ch))
-          put_cchar(out, ch);
+          put_char(out, chr(ch));
         else
-          cformat(out, L"\\%03o", ch);
+          format(out, lit("\\~03o"), num(ch), nao);
       }
-      put_cchar(out, '\'');
+      put_char(out, chr('\''));
     }
     return;
   case NUM:
-    cformat(out, L"%ld", c_num(obj));
+    format(out, lit("~s"), obj, nao);
     return;
   case SYM:
     put_string(out, symbol_name(obj));
     return;
   case FUN:
-    cformat(out, L"#<function: f%d>", (int) obj->f.functype);
+    format(out, lit("#<function: f~a>"), num(obj->f.functype), nao);
     return;
   case VEC:
     {
       long i, fill = c_num(obj->v.vec[vec_fill]);
-      put_cstring(out, L"#(");
+      put_string(out, lit("#("));
       for (i = 0; i < fill; i++) {
         obj_print(obj->v.vec[i], out);
         if (i < fill - 1)
-          put_cchar(out, ' ');
+          put_char(out, chr(' '));
       }
-      put_cchar(out, ')');
+      put_char(out, chr(')'));
     }
     return;
   case LSTR:
     obj_print(obj->ls.prefix, out);
-    put_cstring(out, L"#<... lazy string>");
+    put_string(out, lit("#<... lazy string>"));
     return;
   case COBJ:
     obj->co.ops->print(obj, out);
     return;
   }
 
-  cformat(out, L"#<garbage: %p>", (void *) obj);
+  format(out, lit("#<garbage: ~p>"), (void *) obj, nao);
 }
 
 void obj_pprint(obj_t *obj, obj_t *out)
 {
   if (obj == nil) {
-    put_cstring(out, L"nil");
+    put_string(out, lit("nil"));
     return;
   }
 
@@ -1965,21 +1965,22 @@ void obj_pprint(obj_t *obj, obj_t *out)
   case LCONS:
     {
       obj_t *iter;
-      put_cchar(out, '(');
+      put_char(out, chr('('));
       for (iter = obj; consp(iter); iter = cdr(iter)) {
         obj_pprint(car(iter), out);
         if (nullp(cdr(iter))) {
-          put_cchar(out, ')');
+          put_char(out, chr(')'));
         } else if (consp(cdr(iter))) {
-          put_cchar(out, ' ');
+          put_char(out, chr(' '));
         } else {
-          put_cstring(out, L" . ");
+          put_string(out, lit(" . "));
           obj_pprint(cdr(iter), out);
-          put_cchar(out, ')');
+          put_char(out, chr(')'));
         }
       }
     }
     return;
+  case LIT:
   case STR:
     put_string(out, obj);
     return;
@@ -1987,36 +1988,36 @@ void obj_pprint(obj_t *obj, obj_t *out)
     put_char(out, obj);
     return;
   case NUM:
-    cformat(out, L"%ld", c_num(obj));
+    format(out, lit("~s"), obj, nao);
     return;
   case SYM:
     put_string(out, symbol_name(obj));
     return;
   case FUN:
-    cformat(out, L"#<function: f%d>", (int) obj->f.functype);
+    format(out, lit("#<function: f~a>"), num(obj->f.functype), nao);
     return;
   case VEC:
     {
       long i, fill = c_num(obj->v.vec[vec_fill]);
-      put_cstring(out, L"#(");
+      put_string(out, lit("#("));
       for (i = 0; i < fill; i++) {
         obj_pprint(obj->v.vec[i], out);
         if (i < fill - 1)
-          put_cchar(out, ' ');
+          put_char(out, chr(' '));
       }
-      put_cchar(out, ')');
+      put_char(out, chr(')'));
     }
     return;
   case LSTR:
     obj_pprint(obj->ls.prefix, out);
-    put_cstring(out, L"...");
+    put_string(out, lit("..."));
     return;
   case COBJ:
     obj->co.ops->print(obj, out);
     return;
   }
 
-  cformat(out, L"#<garbage: %p>", (void *) obj);
+  format(out, lit("#<garbage: ~p>"), (void *) obj, nao);
 }
 
 void init(const wchar_t *pn, void *(*oom)(void *, size_t),
@@ -2037,7 +2038,7 @@ void init(const wchar_t *pn, void *(*oom)(void *, size_t),
 void dump(obj_t *obj, obj_t *out)
 {
   obj_print(obj, out);
-  put_cchar(out, '\n');
+  put_char(out, chr('\n'));
 }
 
 /*
diff --git a/lib.h b/lib.h
index 4db6ebf8..47f33e1a 100644
--- a/lib.h
+++ b/lib.h
@@ -51,7 +51,10 @@ typedef enum functype
 #define is_chr(obj) (tag(obj) == TAG_CHR)
 #define is_lit(obj) (tag(obj) == TAG_LIT)
 #define type(obj) (tag(obj) ? ((type_t) tag(obj)) : (obj)->t.type)
-#define lit(strlit) ((obj_t *) ((long) (L ## strlit) | TAG_LIT))
+#define lit_noex(strlit) ((obj_t *) ((long) (L ## strlit) | TAG_LIT))
+#define lit(strlit) lit_noex(strlit)
+#define auto_str(str) ((obj_t *) ((long) (str) | TAG_LIT))
+#define static_str(str) ((obj_t *) ((long) (str) | TAG_LIT))
 #define litptr(obj) ((wchar_t *) ((long) obj & ~TAG_MASK))
 
 typedef union obj obj_t;
diff --git a/match.c b/match.c
index 4e260705..ea028583 100644
--- a/match.c
+++ b/match.c
@@ -45,50 +45,39 @@
 
 int output_produced;
 
-static void debugf(const wchar_t *fmt, ...)
+static void debugf(obj_t *fmt, ...)
 {
   if (opt_loglevel >= 2) {
     va_list vl;
     va_start (vl, fmt);
-    format(std_error, L"~a: ", prog_string, nao);
+    format(std_error, lit("~a: "), prog_string, nao);
     vformat(std_error, fmt, vl);
-    put_cchar(std_error, '\n');
+    put_char(std_error, chr('\n'));
     va_end (vl);
   }
 }
 
-static void debuglf(obj_t *line, const wchar_t *fmt, ...)
+static void debuglf(obj_t *line, obj_t *fmt, ...)
 {
   if (opt_loglevel >= 2) {
     va_list vl;
     va_start (vl, fmt);
-    format(std_error, L"~a: (~a:~a) ", prog_string, spec_file_str, line, nao);
+    format(std_error, lit("~a: (~a:~a) "), prog_string,
+           spec_file_str, line, nao);
     vformat(std_error, fmt, vl);
-    put_cchar(std_error, '\n');
+    put_char(std_error, chr('\n'));
     va_end (vl);
   }
 }
 
-static void debuglcf(obj_t *line, const wchar_t *fmt, ...)
-{
-  if (opt_loglevel >= 2) {
-    va_list vl;
-    va_start (vl, fmt);
-    format(std_error, L"~a: (~a:~a) ", prog_string, spec_file_str, line, nao);
-    vcformat(std_error, fmt, vl);
-    put_cchar(std_error, '\n');
-    va_end (vl);
-  }
-}
-
-static void sem_error(obj_t *line, const wchar_t *fmt, ...)
+static void sem_error(obj_t *line, obj_t *fmt, ...)
 {
   va_list vl;
   obj_t *stream = make_string_output_stream();
 
   va_start (vl, fmt);
   if (line)
-    format(stream, L"(~a:~a) ", spec_file_str, line, nao);
+    format(stream, lit("(~a:~a) "), spec_file_str, line, nao);
   (void) vformat(stream, fmt, vl);
   va_end (vl);
 
@@ -96,14 +85,14 @@ static void sem_error(obj_t *line, const wchar_t *fmt, ...)
   abort();
 }
 
-static void file_err(obj_t *line, const wchar_t *fmt, ...)
+static void file_err(obj_t *line, obj_t *fmt, ...)
 {
   va_list vl;
   obj_t *stream = make_string_output_stream();
 
   va_start (vl, fmt);
   if (line)
-    format(stream, L"(~a:~a) ", spec_file_str, line, nao);
+    format(stream, lit("(~a:~a) "), spec_file_str, line, nao);
   (void) vformat(stream, fmt, vl);
   va_end (vl);
 
@@ -243,7 +232,7 @@ obj_t *dest_bind(obj_t *bindings, obj_t *pattern, obj_t *value)
         return bindings;
       if (tree_find(cdr(existing), value))
         return bindings;
-      debugf(L"bind variable mismatch: ~a", pattern, nao);
+      debugf(lit("bind variable mismatch: ~a"), pattern, nao);
       return t;
     }
     return cons(cons(pattern, value), bindings);
@@ -276,19 +265,19 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
                   obj_t *file)
 {
 #define LOG_MISMATCH(KIND)                                              \
-  debuglf(spec_lineno, KIND L" mismatch, position ~a (~a:~a)", pos,     \
+  debuglf(spec_lineno, lit(KIND " mismatch, position ~a (~a:~a)"), pos, \
             file, data_lineno, nao);                                    \
-  debuglf(spec_lineno, L"  ~a", dataline, nao);                         \
+  debuglf(spec_lineno, lit("  ~a"), dataline, nao);                     \
   if (c_num(pos) < 77)                                                  \
-    debuglcf(spec_lineno, L"  %*ls^", (int) c_num(pos), L"")
+    debuglf(spec_lineno, lit("  ~*~a^"), pos, lit(""), nao)
 
 #define LOG_MATCH(KIND, EXTENT)                                         \
-  debuglf(spec_lineno, KIND L" matched, position ~a-~a (~a:~a)",        \
+  debuglf(spec_lineno, lit(KIND " matched, position ~a-~a (~a:~a)"),    \
             pos, EXTENT, file, data_lineno, nao);                       \
-  debuglf(spec_lineno, L"  ~a", dataline, nao);                         \
+  debuglf(spec_lineno, lit("  ~a"), dataline, nao);                     \
   if (c_num(EXTENT) < 77)                                               \
-    debuglcf(spec_lineno, L"  %*ls%-*ls^", (int) c_num(pos),            \
-              L"", (int) (c_num(EXTENT) - c_num(pos)), L"^")
+    debuglf(spec_lineno, lit("  ~*~a~-*~a^"), pos, lit(""),             \
+              minus(EXTENT, pos), lit("^"), nao)
 
   for (;;) {
     obj_t *elem;
@@ -322,18 +311,18 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
 
               if (length_str_lt(dataline, past) || lt(past, pos))
               {
-                LOG_MISMATCH(L"fixed field size");
+                LOG_MISMATCH("fixed field size");
                 return nil;
               }
 
               if (!tree_find(trim_str(sub_str(dataline, pos, past)),
                              cdr(pair)))
               {
-                LOG_MISMATCH(L"fixed field contents");
+                LOG_MISMATCH("fixed field contents");
                 return nil;
               }
 
-              LOG_MATCH(L"fixed field", past);
+              LOG_MATCH("fixed field", past);
               pos = past;
               specline = cdr(specline);
             } else {
@@ -344,20 +333,20 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
             if (consp(modifier)) {
               obj_t *past = match_regex(dataline, car(modifier), pos);
               if (nullp(past)) {
-                LOG_MISMATCH(L"var positive regex");
+                LOG_MISMATCH("var positive regex");
                 return nil;
               }
-              LOG_MATCH(L"var positive regex", past);
+              LOG_MATCH("var positive regex", past);
               bindings = acons_new(bindings, sym, sub_str(dataline, pos, past));
               pos = past;
             } else if (nump(modifier)) {
               obj_t *past = plus(pos, modifier);
               if (length_str_lt(dataline, past) || lt(past, pos))
               {
-                LOG_MISMATCH(L"count based var");
+                LOG_MISMATCH("count based var");
                 return nil;
               }
-              LOG_MATCH(L"count based var", past);
+              LOG_MATCH("count based var", past);
               bindings = acons_new(bindings, sym, trim_str(sub_str(dataline, pos, past)));
               pos = past;
             } else {
@@ -367,10 +356,10 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
           } else if (type(pat) == STR) {
             obj_t *find = search_str(dataline, pat, pos, modifier);
             if (!find) {
-              LOG_MISMATCH(L"var delimiting string");
+              LOG_MISMATCH("var delimiting string");
               return nil;
             }
-            LOG_MATCH(L"var delimiting string", find);
+            LOG_MATCH("var delimiting string", find);
             bindings = acons_new(bindings, sym, sub_str(dataline, pos, find));
             pos = plus(find, length_str(pat));
           } else if (consp(pat) && typeof(first(pat)) == regex) {
@@ -378,10 +367,10 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
             obj_t *fpos = car(find);
             obj_t *flen = cdr(find);
             if (!find) {
-              LOG_MISMATCH(L"var delimiting regex");
+              LOG_MISMATCH("var delimiting regex");
               return nil;
             }
-            LOG_MATCH(L"var delimiting regex", fpos);
+            LOG_MATCH("var delimiting regex", fpos);
             bindings = acons_new(bindings, sym, sub_str(dataline, pos, fpos));
             pos = plus(fpos, flen);
           } else if (consp(pat) && first(pat) == var) {
@@ -391,7 +380,7 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
             obj_t *pair = assoc(bindings, second_sym); /* var exists already? */
 
             if (!pair)
-              sem_error(spec_lineno, L"consecutive unbound variables", nao);
+              sem_error(spec_lineno, lit("consecutive unbound variables"), nao);
 
             /* Re-generate a new spec with an edited version of
                the element we just processed, and repeat. */
@@ -408,14 +397,14 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
           } else if (consp(pat) && (consp(first(pat)) || stringp(first(pat)))) {
             cons_bind (find, len, search_str(dataline, pat, pos, modifier));
             if (!find) {
-              LOG_MISMATCH(L"string");
+              LOG_MISMATCH("string");
               return nil;
             }
             bindings = acons_new(bindings, sym, sub_str(dataline, pos, find));
             pos = plus(find, len);
           } else {
             sem_error(spec_lineno,
-                      L"variable followed by invalid element", nao);
+                      lit("variable followed by invalid element"), nao);
           }
         } else if (typeof(directive) == regex) {
           obj_t *past = match_regex(dataline, directive, pos);
@@ -477,7 +466,7 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
 
 
           if (!bindings_coll) {
-            debuglf(spec_lineno, L"nothing was collected", nao);
+            debuglf(spec_lineno, lit("nothing was collected"), nao);
             return nil;
           }
 
@@ -491,15 +480,15 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
           obj_t *newpos;
 
           if (find == nil || !equal(find, pos)) {
-            LOG_MISMATCH(L"string tree");
+            LOG_MISMATCH("string tree");
             return nil;
           }
 
           newpos = plus(find, len);
-          LOG_MATCH(L"string tree", newpos);
+          LOG_MATCH("string tree", newpos);
           pos = newpos;
         } else {
-          sem_error(spec_lineno, L"unknown directive: ~a", directive, nao);
+          sem_error(spec_lineno, lit("unknown directive: ~a"), directive, nao);
         }
       }
       break;
@@ -517,7 +506,7 @@ obj_t *match_line(obj_t *bindings, obj_t *specline, obj_t *dataline,
         break;
       }
     default:
-      sem_error(spec_lineno, L"unsupported object in spec: ~s", elem, nao);
+      sem_error(spec_lineno, lit("unsupported object in spec: ~s"), elem, nao);
     }
 
     specline = cdr(specline);
@@ -698,6 +687,21 @@ obj_t *complex_snarf(fpip_t fp, obj_t *name)
   internal_error("bad input source type");
 }
 
+obj_t *complex_stream(fpip_t fp, obj_t *name)
+{
+  switch (fp.close) {
+  case fpip_fclose:
+    return make_stdio_stream(fp.f, name, t, nil);
+  case fpip_pclose:
+    return make_pipe_stream(fp.f, name, t, nil);
+  case fpip_closedir:
+    uw_throwf(query_error, lit("cannot output to directory: ~a"), name, nao);
+  }
+
+  internal_error("bad input source type");
+}
+
+
 obj_t *robust_length(obj_t *obj)
 {
   if (obj == nil)
@@ -750,7 +754,7 @@ obj_t *extract_bindings(obj_t *bindings, obj_t *output_spec)
 }
 
 void do_output_line(obj_t *bindings, obj_t *specline,
-                    obj_t *spec_lineno, FILE *out)
+                    obj_t *spec_lineno, obj_t *out)
 {
   for (; specline; specline = rest(specline)) {
     obj_t *elem = first(specline);
@@ -763,8 +767,9 @@ void do_output_line(obj_t *bindings, obj_t *specline,
         if (directive == var) {
           obj_t *str = cat_str(subst_vars(cons(elem, nil), bindings), nil);
           if (str == nil)
-            sem_error(spec_lineno, L"bad substitution: ~a", second(elem), nao);
-          fputws(c_str(str), out);
+            sem_error(spec_lineno, lit("bad substitution: ~a"),
+                      second(elem), nao);
+          put_string(out, str);
         } else if (directive == rep) {
           obj_t *main_clauses = second(elem);
           obj_t *single_clauses = third(elem);
@@ -803,22 +808,23 @@ void do_output_line(obj_t *bindings, obj_t *specline,
           }
 
         } else {
-          sem_error(spec_lineno, L"unknown directive: ~a", directive, nao);
+          sem_error(spec_lineno, lit("unknown directive: ~a"), directive, nao);
         }
       }
       break;
     case STR:
-      fputws(c_str(elem), out);
+      put_string(out, elem);
       break;
     case 0:
       break;
     default:
-      sem_error(spec_lineno, L"unsupported object in output spec: ~s", elem);
+      sem_error(spec_lineno,
+                lit("unsupported object in output spec: ~s"), elem, nao);
     }
   }
 }
 
-void do_output(obj_t *bindings, obj_t *specs, FILE *out)
+void do_output(obj_t *bindings, obj_t *specs, obj_t *out)
 {
   if (equal(specs, null_list))
     return;
@@ -871,7 +877,7 @@ void do_output(obj_t *bindings, obj_t *specs, FILE *out)
     }
 
     do_output_line(bindings, specline, spec_lineno, out);
-    putwc('\n', out);
+    put_char(out, chr('\n'));
   }
 }
 
@@ -893,21 +899,21 @@ obj_t *match_files(obj_t *spec, obj_t *files,
     obj_t *first_spec_item = second(first(spec));
 
     if (consp(first_spec_item) && eq(first(first_spec_item), next)) {
-      debugf(L"not opening source ~a since query starts with next directive",
-             name, nao);
+      debugf(lit("not opening source ~a "
+                 "since query starts with next directive"), name, nao);
     } else {
-      debugf(L"opening data source ~a", name, nao);
+      debugf(lit("opening data source ~a"), name, nao);
 
       if (complex_open_failed(fp)) {
         if (consp(source_spec) && car(source_spec) == nothrow) {
-          debugf(L"could not open ~a: treating as failed match due to nothrow",
-                 name, nao);
+          debugf(lit("could not open ~a: "
+                     "treating as failed match due to nothrow"), name, nao);
           return nil;
         } else if (errno != 0)
-          file_err(nil, L"could not open ~a (error ~a/~a)", name,
+          file_err(nil, lit("could not open ~a (error ~a/~a)"), name,
                    num(errno), string_utf8(strerror(errno)), nao);
         else
-          file_err(nil, L"could not open ~a", name, nao);
+          file_err(nil, lit("could not open ~a"), name, nao);
         return nil;
       }
 
@@ -936,7 +942,7 @@ repeat_spec_same_data:
 
         if (rest(specline))
           sem_error(spec_linenum,
-                    L"unexpected material after skip directive", nao);
+                    lit("unexpected material after skip directive"), nao);
 
         if ((spec = rest(spec)) == nil)
           break;
@@ -949,12 +955,12 @@ repeat_spec_same_data:
                                  data, num(data_lineno));
 
             if (result) {
-              debuglf(spec_linenum, L"skip matched ~a:~a", first(files),
+              debuglf(spec_linenum, lit("skip matched ~a:~a"), first(files),
                       num(data_lineno), nao);
               break;
             }
 
-            debuglf(spec_linenum, L"skip didn't match ~a:~a", first(files),
+            debuglf(spec_linenum, lit("skip didn't match ~a:~a"), first(files),
                     num(data_lineno), nao);
             data = rest(data);
             data_lineno++;
@@ -967,12 +973,12 @@ repeat_spec_same_data:
             return result;
         }
 
-        debuglf(spec_linenum, L"skip failed", nao);
+        debuglf(spec_linenum, lit("skip failed"), nao);
         return nil;
       } else if (sym == trailer) {
         if (rest(specline))
           sem_error(spec_linenum,
-                    L"unexpected material after trailer directive", nao);
+                    lit("unexpected material after trailer directive"), nao);
 
         if ((spec = rest(spec)) == nil)
           break;
@@ -994,7 +1000,7 @@ repeat_spec_same_data:
 
         if ((spec = rest(spec)) == nil) {
           sem_error(spec_linenum,
-                    L"freeform must be followed by a query line", nao);
+                    lit("freeform must be followed by a query line"), nao);
         } else {
           obj_t *limit = or2(if2(nump(first(vals)), first(vals)),
                              if2(nump(second(vals)), second(vals)));
@@ -1008,7 +1014,7 @@ repeat_spec_same_data:
                                 spec_linenum, num(data_lineno), first(files)));
 
           if (!success) {
-            debuglf(spec_linenum, L"freeform match failure", nao);
+            debuglf(spec_linenum, lit("freeform match failure"), nao);
             return nil;
           }
 
@@ -1026,7 +1032,7 @@ repeat_spec_same_data:
         obj_t *name = first(rest(first_spec));
         if (rest(specline))
           sem_error(spec_linenum,
-                    L"unexpected material after block directive", nao);
+                    lit("unexpected material after block directive"), nao);
         if ((spec = rest(spec)) == nil)
           break;
         {
@@ -1039,7 +1045,7 @@ repeat_spec_same_data:
         obj_t *target = first(rest(first_spec));
 
         if (rest(specline))
-          sem_error(spec_linenum, L"unexpected material after ~a", sym, nao);
+          sem_error(spec_linenum, lit("unexpected material after ~a"), sym, nao);
 
         uw_block_return(target,
                         if2(sym == accept,
@@ -1047,15 +1053,16 @@ repeat_spec_same_data:
                                  if3(data, cons(data, num(data_lineno)), t))));
         /* TODO: uw_block_return could just throw this */
         if (target)
-          sem_error(spec_linenum, L"~a: no block named ~a in scope",
+          sem_error(spec_linenum, lit("~a: no block named ~a in scope"),
                     sym, target, nao);
         else
-          sem_error(spec_linenum, L"%~a: no anonymous block in scope", sym, nao);
+          sem_error(spec_linenum, lit("%~a: no anonymous block in scope"),
+                    sym, nao);
         return nil;
       } else if (sym == next) {
         if (rest(first_spec) && rest(specline))
-          sem_error(spec_linenum,
-                    L"invalid combination of old and new next syntax", nao);
+          sem_error(spec_linenum, lit("invalid combination of old "
+                                      "and new next syntax"), nao);
 
         if ((spec = rest(spec)) == nil)
           break;
@@ -1081,7 +1088,7 @@ repeat_spec_same_data:
             obj_t *name = cdr(val);
 
             if (!val)
-              sem_error(spec_linenum, L"next: unbound variable in form ~a",
+              sem_error(spec_linenum, lit("next: unbound variable in form ~a"),
                         first(source), nao);
 
             if (eq(second(source), nothrow)) {
@@ -1090,7 +1097,7 @@ repeat_spec_same_data:
               } else {
                 files = rest(files);
                 if (!files) {
-                  debuglf(spec_linenum, L"next: out of arguments", nao);
+                  debuglf(spec_linenum, lit("next: out of arguments"), nao);
                   return nil;
                 }
                 files = cons(cons(nothrow, first(files)), rest(files));
@@ -1101,7 +1108,7 @@ repeat_spec_same_data:
               } else {
                 files = rest(files);
                 if (!files)
-                  sem_error(spec_linenum, L"next: out of arguments", nao);
+                  sem_error(spec_linenum, lit("next: out of arguments"), nao);
                 files = cons(cons(nothrow, first(files)), rest(files));
               }
             }
@@ -1110,14 +1117,15 @@ repeat_spec_same_data:
           obj_t *sub = subst_vars(rest(specline), bindings);
           obj_t *str = cat_str(sub, nil);
           if (str == nil) {
-            sem_error(spec_linenum, L"bad substitution in next file spec", nao);
+            sem_error(spec_linenum, lit("bad substitution in next file spec"),
+                      nao);
             continue;
           }
           files = cons(cons(nothrow, str), files);
         } else {
           files = rest(files);
           if (!files)
-            sem_error(spec_linenum, L"next: out of arguments", nao);
+            sem_error(spec_linenum, lit("next: out of arguments"), nao);
         }
 
         /* We recursively process the file list, but the new
@@ -1171,17 +1179,17 @@ repeat_spec_same_data:
         }
 
         if (sym == all && !all_match) {
-          debuglf(spec_linenum, L"all: some clauses didn't match", nao);
+          debuglf(spec_linenum, lit("all: some clauses didn't match"), nao);
           return nil;
         }
 
         if ((sym == some || sym == cases) && !some_match) {
-          debuglf(spec_linenum, L"some/cases: no clauses matched", nao);
+          debuglf(spec_linenum, lit("some/cases: no clauses matched"), nao);
           return nil;
         }
 
         if (sym == none && some_match) {
-          debuglf(spec_linenum, L"none: some clauses matched", nao);
+          debuglf(spec_linenum, lit("none: some clauses matched"), nao);
           return nil;
         }
 
@@ -1227,8 +1235,8 @@ repeat_spec_same_data:
           }
 
           if (success) {
-            debuglcf(spec_linenum, L"collect matched %ls:%ld",
-                     c_str(first(files)), data_lineno);
+            debuglf(spec_linenum, lit("collect matched ~a:~a"),
+                    first(files), num(data_lineno), nao);
 
             for (iter = new_bindings; iter && iter != bindings;
                 iter = cdr(iter))
@@ -1253,14 +1261,13 @@ repeat_spec_same_data:
                 new_lineno++;
               }
 
-              debuglcf(spec_linenum,
-                       L"collect advancing from line %ld to %ld",
-                       data_lineno, new_lineno);
+              debuglf(spec_linenum, lit("collect advancing from line ~a to ~a"),
+                      num(data_lineno), num(new_lineno), nao);
 
               data = new_data;
               data_lineno = new_lineno;
             } else {
-              debuglf(spec_linenum, L"collect consumed entire file", nao);
+              debuglf(spec_linenum, lit("collect consumed entire file"), nao);
               data = nil;
             }
           } else {
@@ -1272,12 +1279,12 @@ repeat_spec_same_data:
         uw_block_end;
 
         if (!result) {
-          debuglf(spec_linenum, L"collect explicitly failed", nao);
+          debuglf(spec_linenum, lit("collect explicitly failed"), nao);
           return nil;
         }
 
         if (!bindings_coll) {
-          debuglf(spec_linenum, L"nothing was collected", nao);
+          debuglf(spec_linenum, lit("nothing was collected"), nao);
           return nil;
         }
 
@@ -1298,7 +1305,8 @@ repeat_spec_same_data:
           obj_t *sym = first(iter);
 
           if (!symbolp(sym)) {
-            sem_error(spec_linenum, L"non-symbol in flatten directive", nao);
+            sem_error(spec_linenum, lit("non-symbol in flatten directive"),
+                      nao);
           } else {
             obj_t *existing = assoc(bindings, sym);
 
@@ -1324,7 +1332,7 @@ repeat_spec_same_data:
         obj_t *merged = nil;
 
         if (!target || !symbolp(target))
-          sem_error(spec_linenum, L"bad merge directive", nao);
+          sem_error(spec_linenum, lit("bad merge directive"), nao);
 
         for (; args; args = rest(args)) {
           obj_t *other_sym = first(args);
@@ -1333,9 +1341,10 @@ repeat_spec_same_data:
             obj_t *other_lookup = assoc(bindings, other_sym);
 
             if (!symbolp(other_sym))
-              sem_error(spec_linenum, L"non-symbol in merge directive", nao);
+              sem_error(spec_linenum, lit("non-symbol in merge directive"),
+                        nao);
             else if (!other_lookup)
-              sem_error(spec_linenum, L"merge: nonexistent symbol ~a",
+              sem_error(spec_linenum, lit("merge: nonexistent symbol ~a"),
                         other_sym, nao);
 
             if (merged)
@@ -1358,7 +1367,8 @@ repeat_spec_same_data:
         obj_t *val = eval_form(form, bindings);
 
         if (!val)
-          sem_error(spec_linenum, L"bind: unbound variable on right side", nao);
+          sem_error(spec_linenum, lit("bind: unbound variable on right side"),
+                    nao);
 
         bindings = dest_bind(bindings, pattern, cdr(val));
 
@@ -1376,7 +1386,7 @@ repeat_spec_same_data:
           obj_t *sym = first(iter);
 
           if (!symbolp(sym)) {
-            sem_error(spec_linenum, L"non-symbol in cat directive", nao);
+            sem_error(spec_linenum, lit("non-symbol in cat directive"), nao);
           } else {
             obj_t *existing = assoc(bindings, sym);
             obj_t *sep = nil;
@@ -1413,8 +1423,8 @@ repeat_spec_same_data:
             obj_t *val = eval_form(form, bindings);
 
             if (!val)
-              sem_error(spec_linenum, L"output: unbound variable in form ~a",
-                        form, nao);
+              sem_error(spec_linenum,
+                        lit("output: unbound variable in form ~a"), form, nao);
 
             nt = eq(second(new_style_dest), nothrow);
             dest = or2(cdr(val), string(L"-"));
@@ -1423,22 +1433,23 @@ repeat_spec_same_data:
 
         fpip_t fp = (errno = 0, complex_open(dest, t));
 
-        debugf(L"opening data sink ~a", dest, nao);
+        debugf(lit("opening data sink ~a"), dest, nao);
 
         if (complex_open_failed(fp)) {
           if (nt) {
-            debugf(L"could not open ~a: treating as failed match due to nothrow",
-                   dest, nao);
+            debugf(lit("could not open ~a: "
+                       "treating as failed match due to nothrow"), dest, nao);
             return nil;
           } else if (errno != 0) {
-            file_err(nil, L"could not open ~a (error ~a/~a)", dest,
+            file_err(nil, lit("could not open ~a (error ~a/~a)"), dest,
                      num(errno), string_utf8(strerror(errno)), nao);
           } else {
-            file_err(nil, L"could not open ~a", dest, nao);
+            file_err(nil, lit("could not open ~a"), dest, nao);
           }
         } else {
-          do_output(bindings, specs, fp.f);
-          complex_close(fp);
+          obj_t *stream = complex_stream(fp, dest);
+          do_output(bindings, specs, stream);
+          close_stream(stream, t);
         }
 
         if ((spec = rest(spec)) == nil)
@@ -1452,7 +1463,8 @@ repeat_spec_same_data:
         obj_t *params = second(args);
 
         if (rest(specline))
-          sem_error(spec_linenum, L"unexpected material after define", nao);
+          sem_error(spec_linenum,
+                    lit("unexpected material after define"), nao);
 
         uw_set_func(name, cons(params, body));
 
@@ -1595,7 +1607,8 @@ repeat_spec_same_data:
       } else if (sym == defex) {
         obj_t *types = rest(first_spec);
         if (!all_satisfy(types, func_n1(symbolp), nil))
-          sem_error(spec_linenum, L"defex arguments must all be symbols", nao);
+          sem_error(spec_linenum, lit("defex arguments must all be symbols"),
+                    nao);
         (void) reduce_left(func_n2(uw_register_subtype), types, nil, nil);
         if ((spec = rest(spec)) == nil)
           break;
@@ -1604,7 +1617,7 @@ repeat_spec_same_data:
         obj_t *type = second(first_spec);
         obj_t *args = rest(rest(first_spec));
         if (!symbolp(type))
-          sem_error(spec_linenum, L"throw: ~a is not a type symbol",
+          sem_error(spec_linenum, lit("throw: ~a is not a type symbol"),
                     first(first_spec), nao);
         {
           obj_t *values = mapcar(bind2other(func_n2(eval_form), bindings),
@@ -1623,7 +1636,7 @@ repeat_spec_same_data:
           obj_t *bindings_cp = copy_alist(bindings);
 
           if (!equal(length(args), length(params)))
-            sem_error(spec_linenum, L"function ~a takes ~a argument(s)",
+            sem_error(spec_linenum, lit("function ~a takes ~a argument(s)"),
                       sym, length(params), nao);
 
           for (piter = params, aiter = args; piter;
@@ -1646,7 +1659,8 @@ repeat_spec_same_data:
               obj_t *val = eval_form(arg, bindings);
               if (!val)
                 sem_error(spec_linenum,
-                          L"unbound variable in function argument form", nao);
+                          lit("unbound variable in function argument form"),
+                          nao);
               bindings_cp = acons_new(bindings_cp, param, cdr(val));
             }
           }
@@ -1660,7 +1674,7 @@ repeat_spec_same_data:
             uw_block_end;
 
             if (!result) {
-              debuglf(spec_linenum, L"function failed", nao);
+              debuglf(spec_linenum, lit("function failed"), nao);
               return nil;
             }
 
@@ -1676,8 +1690,9 @@ repeat_spec_same_data:
                   if (newbind) {
                     bindings = dest_bind(bindings, arg, cdr(newbind));
                     if (bindings == t) {
-                      debuglf(spec_linenum, L"binding mismatch on ~a "
-                                L"when returning from ~a", arg, sym, nao);
+                      debuglf(spec_linenum,
+                              lit("binding mismatch on ~a "
+                                  "when returning from ~a"), arg, sym, nao);
                       return nil;
                     }
                   }
@@ -1685,13 +1700,15 @@ repeat_spec_same_data:
               }
 
               if (consp(success)) {
-                debuglcf(spec_linenum,
-                        L"function matched; advancing from line %ld to %ld",
-                        data_lineno, c_num(cdr(success)));
+                debuglf(spec_linenum,
+                        lit("function matched; "
+                            "advancing from line ~a to ~a"),
+                        num(data_lineno), cdr(success), nao);
                 data = car(success);
                 data_lineno = c_num(cdr(success));
               } else {
-                debuglf(spec_linenum, L"function consumed entire file", nao);
+                debuglf(spec_linenum, lit("function consumed entire file"),
+                        nao);
                 data = nil;
               }
             }
@@ -1714,7 +1731,7 @@ repeat_spec_same_data:
                             spec_linenum, num(data_lineno), first(files)));
 
       if (nump(success) && c_num(success) < c_num(length_str(dataline))) {
-        debuglf(spec_linenum, L"spec only matches line to position ~a: ~a",
+        debuglf(spec_linenum, lit("spec only matches line to position ~a: ~a"),
                 success, dataline, nao);
         return nil;
       }
@@ -1743,7 +1760,7 @@ int extract(obj_t *spec, obj_t *files, obj_t *predefined_bindings)
     }
 
     if (!success)
-      fputws(L"false", stdout);
+      put_line(std_output, lit("false"));
   }
 
   return success ? 0 : EXIT_FAILURE;
diff --git a/parser.h b/parser.h
index 38d0ad3f..85f0f582 100644
--- a/parser.h
+++ b/parser.h
@@ -32,5 +32,5 @@ extern const wchar_t *spec_file;
 extern obj_t *spec_file_str;
 int yyparse(void);
 obj_t *get_spec(void);
-void yyerrorf(const wchar_t *s, ...);
+void yyerrorf(obj_t *s, ...);
 void yybadtoken(int tok, const char *context);
diff --git a/parser.l b/parser.l
index 39392d7f..4d48c238 100644
--- a/parser.l
+++ b/parser.l
@@ -67,17 +67,17 @@ int errors;
 
 void yyerror(const char *s)
 {
-  yyerrorf(L"%s", s);
+  yyerrorf(lit("~a"), auto_str(s), nao);
 }
 
-void yyerrorf(const wchar_t *s, ...)
+void yyerrorf(obj_t *fmt, ...)
 {
   if (opt_loglevel >= 1) {
     va_list vl;
-    va_start (vl, s);
-    fwprintf(stderr, L"%ls: (%ls:%ld): ", progname, spec_file, lineno);
-    vfwprintf(stderr, s, vl);
-    putwc('\n', stderr);
+    va_start (vl, fmt);
+    format(std_error, lit("~a: (~a:~a): "), progname, spec_file, lineno);
+    vformat(std_error, fmt, vl);
+    put_char(std_error, chr('\n'));
     va_end (vl);
   }
   errors++;
@@ -85,48 +85,48 @@ void yyerrorf(const wchar_t *s, ...)
 
 void yybadtoken(int tok, const char *context)
 {
-  const wchar_t *problem = 0;
+  const obj_t *problem = nil;
 
   switch (tok) {
-  case TEXT:    problem = L"text"; break;
-  case IDENT:   problem = L"identifier"; break;
-  case ALL:     problem = L"\"all\""; break;
-  case SOME:    problem = L"\"some\""; break;
-  case NONE:    problem = L"\"none\""; break;
-  case MAYBE:   problem = L"\"maybe\""; break;
-  case CASES:   problem = L"\"cases\""; break;
-  case AND:     problem = L"\"and\""; break;
-  case OR:      problem = L"\"or\""; break;
-  case END:     problem = L"\"end\""; break;
-  case COLLECT: problem = L"\"collect\""; break;
-  case UNTIL:   problem = L"\"until\""; break;
-  case COLL:    problem = L"\"coll\""; break;
-  case OUTPUT:  problem = L"\"output\""; break;
-  case REPEAT:  problem = L"\"repeat\""; break;
-  case REP:     problem = L"\"rep\""; break;
-  case SINGLE:  problem = L"\"single\""; break;
-  case FIRST:   problem = L"\"first\""; break;
-  case LAST:    problem = L"\"last\""; break;
-  case EMPTY:   problem = L"\"empty\""; break;
-  case DEFINE:  problem = L"\"define\""; break;
-  case TRY:     problem = L"\"try\""; break;
-  case CATCH:   problem = L"\"catch\""; break;
-  case FINALLY: problem = L"\"finally\""; break;
-  case NUMBER:  problem = L"\"number\""; break;
-  case REGCHAR: problem = L"regular expression character"; break;
-  case LITCHAR: problem = L"string literal character"; break;
+  case TEXT:    problem = lit("text"); break;
+  case IDENT:   problem = lit("identifier"); break;
+  case ALL:     problem = lit("\"all\""); break;
+  case SOME:    problem = lit("\"some\""); break;
+  case NONE:    problem = lit("\"none\""); break;
+  case MAYBE:   problem = lit("\"maybe\""); break;
+  case CASES:   problem = lit("\"cases\""); break;
+  case AND:     problem = lit("\"and\""); break;
+  case OR:      problem = lit("\"or\""); break;
+  case END:     problem = lit("\"end\""); break;
+  case COLLECT: problem = lit("\"collect\""); break;
+  case UNTIL:   problem = lit("\"until\""); break;
+  case COLL:    problem = lit("\"coll\""); break;
+  case OUTPUT:  problem = lit("\"output\""); break;
+  case REPEAT:  problem = lit("\"repeat\""); break;
+  case REP:     problem = lit("\"rep\""); break;
+  case SINGLE:  problem = lit("\"single\""); break;
+  case FIRST:   problem = lit("\"first\""); break;
+  case LAST:    problem = lit("\"last\""); break;
+  case EMPTY:   problem = lit("\"empty\""); break;
+  case DEFINE:  problem = lit("\"define\""); break;
+  case TRY:     problem = lit("\"try\""); break;
+  case CATCH:   problem = lit("\"catch\""); break;
+  case FINALLY: problem = lit("\"finally\""); break;
+  case NUMBER:  problem = lit("\"number\""); break;
+  case REGCHAR: problem = lit("regular expression character"); break;
+  case LITCHAR: problem = lit("string literal character"); break;
   }
 
   if (problem != 0)
     if (context)
-      yyerrorf(L"misplaced %ls in %ls", problem, context);
+      yyerrorf(lit("misplaced ~a in ~a"), problem, context, nao);
     else
-      yyerrorf(L"unexpected %ls", problem);
+      yyerrorf(lit("unexpected ~a"), problem, nao);
   else
     if (context)
-      yyerrorf(L"unterminated %ls", context);
+      yyerrorf(lit("unterminated ~a"), context, nao);
     else
-      yyerrorf(L"unexpected end of input");
+      yyerrorf(lit("unexpected end of input"), nao);
 }
 
 static wchar_t char_esc(int letter)
@@ -396,12 +396,14 @@ UONLY   {U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
                                 }
 
 <SPECIAL,NESTED>{UANYN} {
-                          yyerrorf(L"bad character in directive: '%s'", yytext);
+                          yyerrorf(lit("bad character in directive: '~a'"),
+                                   string_utf8(yytext), nao);
                         }
 
 <SPECIAL,NESTED>.       {
-                          yyerrorf(L"non-UTF-8 byte in directive: '\\x%02x'",
-                                   (unsigned char) yytext[0]);
+                          yyerrorf(lit("non-UTF-8 byte in directive: "
+                                       "'\\x~02x'"),
+                                   num((unsigned char) yytext[0]), nao);
                         }
 
 <REGEX>[/]      {
@@ -458,8 +460,8 @@ UONLY   {U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
                 }
 
 <REGEX>.        {
-                   yyerrorf(L"non-UTF-8 byte in regex: '\\x%02x'",
-                            (unsigned char) yytext[0]);
+                   yyerrorf(lit("non-UTF-8 byte in regex: '\\x~02x'"),
+                            num((unsigned char) yytext[0]), nao);
                 }
 
 <INITIAL>({UONLY}|[^@\n])+        {
@@ -547,8 +549,8 @@ UONLY   {U2}{U}|{U3}{U}{U}|{U4}{U}{U}{U}
                               }
 
 <STRLIT,CHRLIT,QSILIT>. {
-                          yyerrorf(L"non-UTF-8 byte in literal: '\\x%02x'",
-                                   (unsigned char) yytext[0]);
+                           yyerrorf(lit("non-UTF-8 byte in regex: '\\x~02x'"),
+                                    num((unsigned char) yytext[0]), nao);
                         }
 
 %%
diff --git a/stream.c b/stream.c
index 7d31c89d..1546ff50 100644
--- a/stream.c
+++ b/stream.c
@@ -50,13 +50,11 @@ obj_t *std_input, *std_output, *std_error;
 
 struct strm_ops {
   struct cobj_ops cobj_ops;
-  obj_t *(*put_string)(obj_t *, const wchar_t *);
-  obj_t *(*put_char)(obj_t *, wchar_t);
+  obj_t *(*put_string)(obj_t *, obj_t *);
+  obj_t *(*put_char)(obj_t *, obj_t *);
   obj_t *(*get_line)(obj_t *);
   obj_t *(*get_char)(obj_t *);
   obj_t *(*get_byte)(obj_t *);
-  obj_t *(*vcformat)(obj_t *, const wchar_t *fmt, va_list vl);
-  obj_t *(*vformat)(obj_t *, const wchar_t *fmt, va_list vl);
   obj_t *(*close)(obj_t *, obj_t *);
 };
 
@@ -70,47 +68,6 @@ static void common_destroy(obj_t *obj)
   (void) close_stream(obj, nil);
 }
 
-obj_t *common_vformat(obj_t *stream, const wchar_t *fmt, va_list vl)
-{
-  wchar_t ch;
-
-  for (; (ch = *fmt) != 0; fmt++) {
-    obj_t *obj;
-
-    if (ch == '~') {
-      ch = *++fmt;
-      if (ch == 0)
-        abort();
-      switch (ch) {
-      case '~':
-        put_cchar(stream, ch);
-        continue;
-      case 'a':
-        obj = va_arg(vl, obj_t *);
-        if (obj == nao)
-          abort();
-        obj_pprint(obj, stream);
-        continue;
-      case 's':
-        obj = va_arg(vl, obj_t *);
-        if (obj == nao)
-          abort();
-        obj_print(obj, stream);
-        continue;
-      default:
-        abort();
-      }
-      continue;
-    }
-
-    put_cchar(stream, ch);
-  }
-
-  if (va_arg(vl, obj_t *) != nao)
-    internal_error("unterminated format argument list");
-  return t;
-}
-
 struct stdio_handle {
   FILE *f;
 #ifdef BROKEN_POPEN_GETWC
@@ -122,7 +79,7 @@ struct stdio_handle {
 void stdio_stream_print(obj_t *stream, obj_t *out)
 {
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
-  format(out, L"#<~s ~s>", stream->co.cls, h->descr, nao);
+  format(out, lit("#<~s ~s>"), stream->co.cls, h->descr, nao);
 }
 
 void stdio_stream_destroy(obj_t *stream)
@@ -143,8 +100,8 @@ static obj_t *stdio_maybe_read_error(obj_t *stream)
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
   if (ferror(h->f)) {
     clearerr(h->f);
-    uw_throwf(file_error, L"error reading ~a: ~a/~s",
-              stream, num(errno), string_utf8(strerror(errno)));
+    uw_throwf(file_error, lit("error reading ~a: ~a/~s"),
+              stream, num(errno), string_utf8(strerror(errno)), nao);
   }
   return nil;
 }
@@ -154,22 +111,23 @@ static obj_t *stdio_maybe_write_error(obj_t *stream)
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
   if (ferror(h->f)) {
     clearerr(h->f);
-    uw_throwf(file_error, L"error writing ~a: ~a/~s",
-              stream, num(errno), string_utf8(strerror(errno)));
+    uw_throwf(file_error, lit("error writing ~a: ~a/~s"),
+              stream, num(errno), string_utf8(strerror(errno)), nao);
   }
   return nil;
 }
 
-static obj_t *stdio_put_string(obj_t *stream, const wchar_t *s)
+static obj_t *stdio_put_string(obj_t *stream, obj_t *s)
 {
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
-  return (h->f && fputws(s, h->f) != -1) ? t : stdio_maybe_write_error(stream);
+  return (h->f && fputws(c_str(s), h->f) != -1)
+         ? t : stdio_maybe_write_error(stream);
 }
 
-static obj_t *stdio_put_char(obj_t *stream, wchar_t ch)
+static obj_t *stdio_put_char(obj_t *stream, obj_t *ch)
 {
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
-  return (h->f && putwc(ch, h->f) != WEOF)
+  return (h->f && putwc(c_chr(ch), h->f) != WEOF)
          ? t : stdio_maybe_write_error(stream);
 }
 
@@ -238,17 +196,6 @@ obj_t *stdio_get_byte(obj_t *stream)
   return nil;
 }
 
-obj_t *stdio_vcformat(obj_t *stream, const wchar_t *fmt, va_list vl)
-{
-  struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
-
-  if (h->f) {
-    int n = vfwprintf(h->f, fmt, vl);
-    return (n >= 0) ? num(n) : stdio_maybe_write_error(stream);
-  }
-  return nil;
-}
-
 static obj_t *stdio_close(obj_t *stream, obj_t *throw_on_error)
 {
   struct stdio_handle *h = (struct stdio_handle *) stream->co.handle;
@@ -257,8 +204,8 @@ static obj_t *stdio_close(obj_t *stream, obj_t *throw_on_error)
     int result = fclose(h->f);
     h->f = 0;
     if (result == EOF && throw_on_error) {
-      uw_throwf(file_error, L"error closing ~a: ~a/~s",
-                stream, num(errno), string_utf8(strerror(errno)));
+      uw_throwf(file_error, lit("error closing ~a: ~a/~s"),
+                stream, num(errno), string_utf8(strerror(errno)), nao);
     }
     return result != EOF ? t : nil;
   }
@@ -275,8 +222,6 @@ static struct strm_ops stdio_ops = {
   stdio_get_line,
   stdio_get_char,
   stdio_get_byte,
-  stdio_vcformat,
-  common_vformat,
   stdio_close
 };
 
@@ -296,22 +241,23 @@ static obj_t *pipe_close(obj_t *stream, obj_t *throw_on_error)
     if (status != 0 && throw_on_error) {
       if (status < 0) {
         uw_throwf(process_error,
-                  L"unable to obtain status of command ~a: ~a/~s",
+                  lit("unable to obtain status of command ~a: ~a/~s"),
                   stream, num(errno), string_utf8(strerror(errno)), nao);
       } else if (WIFEXITED(status)) {
         int exitstatus = WEXITSTATUS(status);
-        uw_throwf(process_error, L"pipe ~a terminated with status ~a",
+        uw_throwf(process_error, lit("pipe ~a terminated with status ~a"),
                   stream, num(exitstatus), nao);
       } else if (WIFSIGNALED(status)) {
         int termsig = WTERMSIG(status);
-        uw_throwf(process_error, L"pipe ~a terminated by signal ~a",
+        uw_throwf(process_error, lit("pipe ~a terminated by signal ~a"),
                   stream, num(termsig), nao);
 
       } else if (WIFSTOPPED(status) || WIFCONTINUED(status)) {
-        uw_throwf(process_error, L"processes of closed pipe ~a still running",
+        uw_throwf(process_error,
+                  lit("processes of closed pipe ~a still running"),
                   stream, nao);
       } else {
-        uw_throwf(file_error, L"strange status in when closing pipe ~a",
+        uw_throwf(file_error, lit("strange status in when closing pipe ~a"),
                   stream, nao);
       }
     }
@@ -331,8 +277,6 @@ static struct strm_ops pipe_ops = {
   stdio_get_line,
   stdio_get_char,
   stdio_get_byte,
-  stdio_vcformat,
-  common_vformat,
   pipe_close
 };
 
@@ -382,8 +326,6 @@ static struct strm_ops string_in_ops = {
   string_in_get_line,
   string_in_get_char,
   0,
-  0,
-  0,
   0
 };
 
@@ -412,8 +354,6 @@ static struct strm_ops byte_in_ops = {
   0,
   0,
   byte_in_get_byte,
-  0,
-  0,
   0
 };
 
@@ -436,14 +376,15 @@ static void string_out_stream_destroy(obj_t *stream)
   }
 }
 
-static obj_t *string_out_put_string(obj_t *stream, const wchar_t *s)
+static obj_t *string_out_put_string(obj_t *stream, obj_t *str)
 {
   struct string_output *so = (struct string_output *) stream->co.handle;
 
   if (so == 0) {
     return nil;
   } else {
-    size_t len = wcslen(s);
+    const wchar_t *s = c_str(str);
+    size_t len = c_num(length_str(str));
     size_t old_size = so->size;
     size_t required_size = len + so->fill + 1;
 
@@ -456,67 +397,20 @@ static obj_t *string_out_put_string(obj_t *stream, const wchar_t *s)
         return nil;
     }
 
-    so->buf = chk_realloc(so->buf, so->size * sizeof *so->buf);
-    memcpy(so->buf + so->fill, s, (len + 1) * sizeof *so->buf);
+    if (so->size != old_size)
+      so->buf = chk_realloc(so->buf, so->size * sizeof *so->buf);
+    wmemcpy(so->buf + so->fill, s, len + 1);
     so->fill += len;
     return t;
   }
 }
 
-static obj_t *string_out_put_char(obj_t *stream, wchar_t ch)
+static obj_t *string_out_put_char(obj_t *stream, obj_t *ch)
 {
   wchar_t mini[2];
-  mini[0] = ch;
+  mini[0] = c_chr(ch);
   mini[1] = 0;
-  return string_out_put_string(stream, mini);
-}
-
-obj_t *string_out_vcformat(obj_t *stream, const wchar_t *fmt, va_list vl)
-{
-  struct string_output *so = (struct string_output *) stream->co.handle;
-
-  if (so == 0) {
-    return nil;
-  } else {
-    int nchars, nchars2;
-    wchar_t dummy_buf[1];
-    size_t old_size = so->size;
-    size_t required_size;
-    va_list vl_copy;
-
-#if defined va_copy
-    va_copy (vl_copy, vl);
-#elif defined __va_copy
-    __va_copy (vl_copy, vl);
-#else
-    vl_copy = vl;
-#endif
-
-    nchars = vswprintf(dummy_buf, 0, fmt, vl_copy);
-
-#if defined va_copy || defined __va_copy
-    va_end (vl_copy);
-#endif
-
-    bug_unless (nchars >= 0);
-
-    required_size = so->fill + nchars + 1;
-
-    if (required_size < so->fill)
-      return nil;
-
-    while (so->size <= required_size) {
-      so->size *= 2;
-      if (so->size < old_size)
-        return nil;
-    }
-
-    so->buf = chk_realloc(so->buf, so->size * sizeof *so->buf);
-    nchars2 = vswprintf(so->buf + so->fill, so->size-so->fill, fmt, vl);
-    bug_unless (nchars == nchars2);
-    so->fill += nchars;
-    return t;
-  }
+  return string_out_put_string(stream, auto_str(mini));
 }
 
 static struct strm_ops string_out_ops = {
@@ -529,8 +423,6 @@ static struct strm_ops string_out_ops = {
   0,
   0,
   0,
-  string_out_vcformat,
-  common_vformat,
   0,
 };
 
@@ -573,8 +465,6 @@ static struct strm_ops dir_ops = {
   dir_get_line,
   0,
   0,
-  0,
-  0,
   dir_close
 };
 
@@ -605,7 +495,7 @@ obj_t *make_pipe_stream(FILE *f, obj_t *descr, obj_t *input, obj_t *output)
     /* Don't leave h uninitialized; it is gc-reachable through stream cobj. */
     h->f = h->f_orig_pipe = 0;
     h->descr = descr;
-    uw_throwf(process_error, L"unable to create pipe ~a: ~a/~s", descr,
+    uw_throwf(process_error, lit("unable to create pipe ~a: ~a/~s"), descr,
               num(error), string_utf8(strerror(error)), nao);
   }
 
@@ -625,7 +515,7 @@ obj_t *make_string_input_stream(obj_t *string)
 
 obj_t *make_string_byte_input_stream(obj_t *string)
 {
-  type_assert (stringp(string), (L"~a is not a string", string));
+  type_assert (stringp(string), (lit("~a is not a string"), string, nao));
 
   {
     struct byte_input *bi = (struct byte_input *) chk_malloc(sizeof *bi);
@@ -650,7 +540,8 @@ obj_t *make_string_output_stream(void)
 obj_t *get_string_from_stream(obj_t *stream)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t,
+               (lit("~a is not a stream"), stream, nao));
 
   if (stream->co.ops == &string_out_ops.cobj_ops) {
     struct string_output *so = (struct string_output *) stream->co.handle;
@@ -661,7 +552,7 @@ obj_t *get_string_from_stream(obj_t *stream)
     if (!so)
       return out;
 
-    so->buf = chk_realloc(so->buf, so->fill + 1);
+    so->buf = chk_realloc(so->buf, (so->fill + 1) * sizeof *so->buf);
     out = string_own(so->buf);
     free(so);
     return out;
@@ -681,7 +572,8 @@ obj_t *make_dir_stream(DIR *dir)
 obj_t *close_stream(obj_t *stream, obj_t *throw_on_error)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
@@ -692,7 +584,8 @@ obj_t *close_stream(obj_t *stream, obj_t *throw_on_error)
 obj_t *get_line(obj_t *stream)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
@@ -703,7 +596,8 @@ obj_t *get_line(obj_t *stream)
 obj_t *get_char(obj_t *stream)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
@@ -714,7 +608,8 @@ obj_t *get_char(obj_t *stream)
 obj_t *get_byte(obj_t *stream)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
@@ -722,57 +617,269 @@ obj_t *get_byte(obj_t *stream)
   }
 }
 
-obj_t *vformat(obj_t *stream, const wchar_t *str, va_list vl)
+static obj_t *vformat_num(obj_t *stream, const char *str,
+                          int width, int left, int pad, int precision)
 {
-  type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  int len = strlen(str);
+  int truewidth = (width < precision) ? width : precision;
+  int slack = (len < truewidth) ? truewidth - len : 0;
+  int padlen = (len < precision) ? precision - len : 0;
+  int i;
 
-  {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    return ops->vformat ? ops->vformat(stream, str, vl) : nil;
-  }
+  if (!left)
+    for (i = 0; i < slack; i++)
+      if (!put_char(stream, pad ? chr('0') : chr(' ')))
+        return nil;
+
+  for (i = 0; i < padlen; i++)
+    if (!put_char(stream, pad ? chr('0') : chr(' ')))
+      return nil;
+
+  while (*str)
+    if (!put_char(stream, chr(*str++)))
+      return nil;
+
+  if (left)
+    for (i = 0; i < slack; i++)
+      if (!put_char(stream, chr(' ')))
+        return nil;
+
+  return t;
 }
 
-obj_t *vcformat(obj_t *stream, const wchar_t *string, va_list vl)
+obj_t *vformat_str(obj_t *stream, obj_t *str, int width, int left,
+                   int precision)
 {
-  type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  const wchar_t *cstr = c_str(str);
+  int len = c_num(length_str(str));
+  int truelen = (precision && precision < len) ? precision : len;
+  int slack = (truelen < width) ? width - truelen : 0;
+  int i;
 
-  {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    return ops->vcformat ? ops->vcformat(stream, string, vl) : nil;
-  }
+  if (!left)
+    for (i = 0; i < slack; i++)
+      if (!put_char(stream, chr(' ')))
+        return nil;
+
+  for (i = 0; i < truelen; i++)
+    if (!put_char(stream, chr(cstr[i])))
+      return nil;
+
+  if (left)
+    for (i = 0; i < slack; i++)
+      if (!put_char(stream, chr(' ')))
+        return nil;
+
+  return t;
 }
 
-obj_t *format(obj_t *stream, const wchar_t *str, ...)
+obj_t *vformat(obj_t *stream, obj_t *fmtstr, va_list vl)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    va_list vl;
-    obj_t *ret;
+    const wchar_t *fmt = c_str(fmtstr);
+    enum {
+      vf_init, vf_width, vf_digits, vf_precision, vf_spec
+    } state = vf_init, saved_state = vf_init;
+    int width = 0, precision = 0, digits = 0;
+    int left = 0, zeropad = 0;
+    long val;
+    void *ptr;
+    char num_buf[64];
 
-    va_start (vl, str);
-    ret = ops->vformat ? ops->vformat(stream, str, vl) : nil;
-    va_end (vl);
-    return ret;
+    for (;;) {
+      obj_t *obj;
+      wchar_t ch = *fmt++;
+
+      switch (state) {
+      case vf_init:
+        switch (ch) {
+        case 0:
+          break;
+        case '~':
+          state = vf_width;
+          width = 0;
+          left = 0;
+          zeropad = 0;
+          precision = 0;
+          digits = 0;
+          continue;
+        default:
+          put_char(stream, chr(ch));
+          continue;
+        }
+        break;
+      case vf_width:
+        switch (ch) {
+        case '~':
+          put_char(stream, chr('~'));
+          continue;
+        case '-':
+          left = 1;
+          continue;
+        case ',':
+          state = vf_precision;
+          continue;
+        case '0':
+          saved_state = state;
+          state = vf_digits;
+          zeropad = 1;
+          continue;
+        case '1': case '2': case '3': case '4': case '5':
+        case '6': case '7': case '8': case '9':
+          saved_state = state;
+          state = vf_digits;
+          digits = ch - '0';
+          continue;
+        case '*':
+          obj = va_arg(vl, obj_t *);
+          width = c_num(obj);
+          state = vf_precision;
+          continue;
+        default:
+          state = vf_spec;
+          --fmt;
+          continue;
+        }
+        break;
+      case vf_precision:
+        switch (ch) {
+        case '0': case '1': case '2': case '3': case '4': case '5':
+        case '6': case '7': case '8': case '9':
+          saved_state = state;
+          state = vf_digits;
+          digits = ch - '0';
+          continue;
+        case '*':
+          obj = va_arg(vl, obj_t *);
+          width = c_num(obj);
+          precision = vf_precision;
+          continue;
+        default:
+          state = vf_spec;
+          continue;
+        }
+        break;
+      case vf_digits:
+        switch (ch) {
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+          digits = (digits * 10) + (ch - '0');
+          if (digits > 999999)
+            goto toobig;
+          continue;
+        default:
+          switch (saved_state) {
+          case vf_width:
+            if (width < 0) {
+              width = -digits;
+              left = 1;
+            } else {
+              width = digits;
+            }
+            state = (ch == ',') ? vf_precision : vf_spec;
+            continue;
+          case vf_precision:
+            precision = digits;
+            state = vf_spec;
+            --fmt;
+            continue;
+          default:
+            internal_error("unexpected state in formatter");
+          }
+        }
+        break;
+      case vf_spec:
+        state = vf_init;
+        switch (ch) {
+        case 'x':
+          obj = va_arg(vl, obj_t *);
+          val = c_num(obj);
+          sprintf(num_buf, "%lx", val);
+          goto output_num;
+        case 'X':
+          obj = va_arg(vl, obj_t *);
+          val = c_num(obj);
+          sprintf(num_buf, "%lX", val);
+          goto output_num;
+        case 'o':
+          obj = va_arg(vl, obj_t *);
+          val = c_num(obj);
+          sprintf(num_buf, "%lo", val);
+          goto output_num;
+        case 'a':
+          obj = va_arg(vl, obj_t *);
+          if (obj == nao)
+            goto premature;
+          if (nump(obj)) {
+            val = c_num(obj);
+            sprintf(num_buf, "%ld", val);
+            goto output_num;
+          } else if (stringp(obj)) {
+            if (!vformat_str(stream, obj, width, left, precision))
+              return nil;
+            continue;
+          }
+          obj_pprint(obj, stream);
+          continue;
+        case 's':
+          obj = va_arg(vl, obj_t *);
+          if (obj == nao)
+            goto premature;
+          if (nump(obj)) {
+            val = c_num(obj);
+            sprintf(num_buf, "%ld", val);
+            if (vformat_num(stream, num_buf, 0, 0, 0, 0))
+              return nil;
+            continue;
+          }
+          obj_print(obj, stream);
+          continue;
+        case 'p':
+          ptr = va_arg(vl, void *);
+          val = (int) ptr;
+          sprintf(num_buf, "0x%lx", val);
+          goto output_num;
+        default:
+          abort();
+        output_num:
+          if (!vformat_num(stream, num_buf, width, left,
+                           precision ? 0 : zeropad,
+                           precision ? precision : 1))
+            return nil;
+          continue;
+        }
+        continue;
+      }
+
+      break;
+    }
   }
+
+
+  if (va_arg(vl, obj_t *) != nao)
+    internal_error("unterminated format argument list");
+  return t;
+premature:
+  internal_error("insufficient arguments for format");
+toobig:
+  internal_error("ridiculous precision or field width in format");
 }
 
-obj_t *cformat(obj_t *stream, const wchar_t *string, ...)
+obj_t *format(obj_t *stream, obj_t *str, ...)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                             stream, nao));
 
   {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
     va_list vl;
     obj_t *ret;
-
-    va_start (vl, string);
-    ret = ops->vformat ? ops->vcformat(stream, string, vl) : nil;
+    va_start (vl, str);
+    ret = vformat(stream, str, vl);
     va_end (vl);
     return ret;
   }
@@ -781,40 +888,20 @@ obj_t *cformat(obj_t *stream, const wchar_t *string, ...)
 obj_t *put_string(obj_t *stream, obj_t *string)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
-
-  {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    return ops->put_string ? ops->put_string(stream, c_str(string)) : nil;
-  }
-}
-
-obj_t *put_cstring(obj_t *stream, const wchar_t *str)
-{
-  type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    return ops->put_string ? ops->put_string(stream, str) : nil;
+    return ops->put_string ? ops->put_string(stream, string) : nil;
   }
 }
 
 obj_t *put_char(obj_t *stream, obj_t *ch)
 {
   type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
-
-  {
-    struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
-    return ops->put_char ? ops->put_char(stream, c_chr(ch)) : nil;
-  }
-}
-
-obj_t *put_cchar(obj_t *stream, wchar_t ch)
-{
-  type_check (stream, COBJ);
-  type_assert (stream->co.cls == stream_t, (L"~a is not a stream", stream));
+  type_assert (stream->co.cls == stream_t, (lit("~a is not a stream"),
+                                            stream, nao));
 
   {
     struct strm_ops *ops = (struct strm_ops *) stream->co.ops;
@@ -824,7 +911,7 @@ obj_t *put_cchar(obj_t *stream, wchar_t ch)
 
 obj_t *put_line(obj_t *stream, obj_t *string)
 {
-  return (put_string(stream, string), put_cchar(stream, '\n'));
+  return (put_string(stream, string), put_char(stream, chr('\n')));
 }
 
 void stream_init(void)
diff --git a/stream.h b/stream.h
index b4354168..9929cc5e 100644
--- a/stream.h
+++ b/stream.h
@@ -37,14 +37,10 @@ obj_t *close_stream(obj_t *stream, obj_t *throw_on_error);
 obj_t *get_line(obj_t *);
 obj_t *get_char(obj_t *);
 obj_t *get_byte(obj_t *);
-obj_t *vformat(obj_t *stream, const wchar_t *string, va_list);
-obj_t *vcformat(obj_t *stream, const wchar_t *string, va_list);
-obj_t *format(obj_t *stream, const wchar_t *string, ...);
-obj_t *cformat(obj_t *stream, const wchar_t *string, ...);
+obj_t *vformat(obj_t *stream, obj_t *string, va_list);
+obj_t *format(obj_t *stream, obj_t *string, ...);
 obj_t *put_string(obj_t *stream, obj_t *string);
 obj_t *put_line(obj_t *stream, obj_t *string);
-obj_t *put_cstring(obj_t *stream, const wchar_t *);
 obj_t *put_char(obj_t *stream, obj_t *ch);
-obj_t *put_cchar(obj_t *stream, wchar_t ch);
 
 void stream_init(void);
diff --git a/txr.c b/txr.c
index bb2814a5..8f95ffdd 100644
--- a/txr.c
+++ b/txr.c
@@ -54,66 +54,67 @@ obj_t *spec_file_str;
  */
 void *oom_realloc_handler(void *old, size_t size)
 {
-  fwprintf(stderr, L"%ls: out of memory\n", progname);
-  fputws(L"false", stderr);
+  format(std_error, lit("~a: out of memory\n"), prog_string, nao);
+  put_line(std_error, lit("false"));
   abort();
 }
 
 void help(void)
 {
-  const wchar_t *text =
-L"\n"
-L"txr version %ls\n"
-L"\n"
-L"copyright 2009, Kaz Kylheku <kkylheku@gmail.com>\n"
-L"\n"
-L"usage:\n"
-L"\n"
-L"  %ls [ options ] query-file { data-file }*\n"
-L"\n"
-L"The query-file or data-file arguments may be specified as -, in which case\n"
-L"standard input is used. All data-file arguments which begin with a !\n"
-L"character are treated as command pipes. Those which begin with a $\n"
-L"are interpreted as directories to read. Leading arguments which begin\n"
-L"with a - followed by one or more characters, and which are not arguments to\n"
-L"options are interpreted as options. The -- option indicates the end of the\n"
-L"options.\n"
-L"\n"
-L"If no data-file arguments sare supplied, then the query itself must open a\n"
-L"a data source prior to attempting to make any pattern match, or it will\n"
-L"simply fail due to a match which has run out of data.\n"
-L"\n"
-L"options:\n"
-L"\n"
-L"-Dvar=value            Pre-define variable var, with the given value.\n"
-L"                       A list value can be specified using commas.\n"
-L"-Dvar                  Predefine variable var, with empty string value.\n"
-L"-q                     Quiet: don't report errors during query matching.\n"
-L"-v                     Verbose: extra logging from matcher.\n"
-L"-b                     Don't dump list of bindings.\n"
-L"-a num                 Generate array variables up to num-dimensions.\n"
-L"                       Default is 1. Additional dimensions are fudged\n"
-L"                       by generating numeric suffixes\n"
-L"-c query-text          The query is read from the query-text argument\n"
-L"                       itself. The query-file argument is omitted in\n"
-L"                       this case; the first argument is a data file.\n"
-L"-f query-file          Specify the query-file as an option argument.\n"
-L"                       option, instead of the query-file argument.\n"
-L"                       This allows #! scripts to pass options through\n"
-L"                       to the utility.\n"
-L"--help                 You already know!\n"
-L"--version              Display program version\n"
-L"\n"
-L"Options that take no argument can be combined. The -q and -v options\n"
-L"are mutually exclusive; the right-most one dominates.\n"
-L"\n"
-  ;
-  fwprintf(stdout, text, version, progname);
+  obj_t *text = lit(
+"\n"
+"txr version ~a\n"
+"\n"
+"copyright 2009, Kaz Kylheku <kkylheku@gmail.com>\n"
+"\n"
+"usage:\n"
+"\n"
+"  ~a [ options ] query-file { data-file }*\n"
+"\n"
+"The query-file or data-file arguments may be specified as -, in which case\n"
+"standard input is used. All data-file arguments which begin with a !\n"
+"character are treated as command pipes. Those which begin with a $\n"
+"are interpreted as directories to read. Leading arguments which begin\n"
+"with a - followed by one or more characters, and which are not arguments to\n"
+"options are interpreted as options. The -- option indicates the end of the\n"
+"options.\n"
+"\n"
+"If no data-file arguments sare supplied, then the query itself must open a\n"
+"a data source prior to attempting to make any pattern match, or it will\n"
+"simply fail due to a match which has run out of data.\n"
+"\n"
+"options:\n"
+"\n"
+"-Dvar=value            Pre-define variable var, with the given value.\n"
+"                       A list value can be specified using commas.\n"
+"-Dvar                  Predefine variable var, with empty string value.\n"
+"-q                     Quiet: don't report errors during query matching.\n"
+"-v                     Verbose: extra logging from matcher.\n"
+"-b                     Don't dump list of bindings.\n"
+"-a num                 Generate array variables up to num-dimensions.\n"
+"                       Default is 1. Additional dimensions are fudged\n"
+"                       by generating numeric suffixes\n"
+"-c query-text          The query is read from the query-text argument\n"
+"                       itself. The query-file argument is omitted in\n"
+"                       this case; the first argument is a data file.\n"
+"-f query-file          Specify the query-file as an option argument.\n"
+"                       option, instead of the query-file argument.\n"
+"                       This allows #! scripts to pass options through\n"
+"                       to the utility.\n"
+"--help                 You already know!\n"
+"--version              Display program version\n"
+"\n"
+"Options that take no argument can be combined. The -q and -v options\n"
+"are mutually exclusive; the right-most one dominates.\n"
+"\n"
+);
+  format(std_output, text, auto_str(version), prog_string, nao);
 }
 
 void hint(void)
 {
-  fwprintf(stderr, L"%ls: incorrect arguments: try --help\n", progname);
+  format(std_error, lit("~a: incorrect arguments: try --help\n"),
+         prog_string, nao);
 }
 
 obj_t *remove_hash_bang_line(obj_t *spec)
@@ -215,7 +216,8 @@ static int txr_main(int argc, char **argv)
     }
 
     if (!strcmp(*argv, "--version")) {
-      wprintf(L"%ls: version %ls\n", progname, version);
+      format(std_output, lit("~a: version ~a\n"),
+             prog_string, auto_str(version), nao);
       return 0;
     }
 
@@ -230,7 +232,8 @@ static int txr_main(int argc, char **argv)
       char opt = (*argv)[1];
 
       if (argc == 1) {
-        fwprintf(stderr, L"%ls: option %c needs argument\n", progname, opt);
+        format(std_error, lit("~a: option -~a needs argument\n"),
+               prog_string, chr(opt), nao);
 
         return EXIT_FAILURE;
       }
@@ -241,8 +244,9 @@ static int txr_main(int argc, char **argv)
       case 'a':
         val = strtol(*argv, &errp, 10);
         if (*errp != 0) {
-          fwprintf(stderr, L"%ls: option %c needs numeric argument, not %s\n",
-                   progname, opt, *argv);
+          format(std_error, lit("~a: option -~a needs numeric argument, "
+                                "not ~a\n"), prog_string, chr(opt),
+                                string_utf8(*argv), nao);
           return EXIT_FAILURE;
         }
 
@@ -282,15 +286,16 @@ static int txr_main(int argc, char **argv)
         case 'a':
         case 'c':
         case 'D':
-          fwprintf(stderr, L"%ls: option -%c does not clump\n",
-                   progname, *popt);
+          format(std_error, lit("~a: option -~a does not clump\n"),
+                   prog_string, chr(*popt), nao);
           return EXIT_FAILURE;
         case '-':
-          fwprintf(stderr, L"%ls: unrecognized long option: --%s\n",
-                   progname, popt + 1);
+          format(std_error, lit("~a: unrecognized long option: --~a\n"),
+                 prog_string, string_utf8(popt + 1), nao);
           return EXIT_FAILURE;
         default:
-          fwprintf(stderr, L"%ls: unrecognized option: %c\n", progname, *popt);
+          format(std_error, lit("~a: unrecognized option: -~a\n"),
+                 prog_string, chr(*popt), nao);
           return EXIT_FAILURE;
         }
       }
@@ -300,7 +305,8 @@ static int txr_main(int argc, char **argv)
   }
 
   if (specstring && spec_file_str) {
-    fwprintf(stderr, L"%ls: cannot specify both -f and -c\n", progname);
+    format(std_error, lit("~a: cannot specify both -f and -c\n"),
+           prog_string, nao);
     return EXIT_FAILURE;
   }
 
@@ -315,7 +321,7 @@ static int txr_main(int argc, char **argv)
     if (wcscmp(c_str(spec_file_str), L"-") != 0) {
       FILE *in = w_fopen(c_str(spec_file_str), L"r");
       if (in == 0)
-        uw_throwcf(file_error, L"unable to open %ls", c_str(spec_file_str));
+        uw_throwf(file_error, lit("unable to open ~a"), spec_file_str, nao);
       yyin_stream = make_stdio_stream(in, spec_file_str, t, nil);
     } else {
       spec_file = L"stdin";
@@ -328,9 +334,10 @@ static int txr_main(int argc, char **argv)
 
     if (strcmp(*argv, "-") != 0) {
       FILE *in = fopen(*argv, "r");
+      obj_t *name = string_utf8(*argv);
       if (in == 0)
-        uw_throwcf(file_error, L"unable to open %s", *argv);
-      yyin_stream = make_stdio_stream(in, string_utf8(*argv), t, nil);
+        uw_throwf(file_error, lit("unable to open ~a"), name, nao);
+      yyin_stream = make_stdio_stream(in, name, t, nil);
       spec_file = utf8_dup_from(*argv);
     } else {
       spec_file = L"stdin";
@@ -353,8 +360,8 @@ static int txr_main(int argc, char **argv)
     opt_loglevel = match_loglevel;
 
     if (opt_loglevel >= 2) {
-      format(std_error, L"spec:\n~s\n", spec, nao);
-      format(std_error, L"bindings:\n~s\n", bindings, nao);
+      format(std_error, lit("spec:\n~s\n"), spec, nao);
+      format(std_error, lit("bindings:\n~s\n"), bindings, nao);
     }
 
     {
diff --git a/unwind.c b/unwind.c
index 43c93184..3e3083da 100644
--- a/unwind.c
+++ b/unwind.c
@@ -217,15 +217,15 @@ obj_t *uw_throw(obj_t *sym, obj_t *exception)
   if (ex == 0) {
     if (opt_loglevel >= 1) {
       obj_t *s = stringp(exception);
-      format(std_error, L"~a: unhandled exception of type ~a:\n",
+      format(std_error, lit("~a: unhandled exception of type ~a:\n"),
              prog_string, sym, nao);
-      format(std_error, s ? L"~a: ~a\n" : L"~a: ~s\n",
+      format(std_error, s ? lit("~a: ~a\n") : lit("~a: ~s\n"),
              prog_string, exception, nao);
     }
     if (uw_exception_subtype_p(sym, query_error) ||
         uw_exception_subtype_p(sym, file_error)) {
       if (!output_produced)
-        put_cstring(std_output, L"false\n");
+        put_line(std_output, lit("false"));
       exit(EXIT_FAILURE);
     }
     abort();
@@ -238,7 +238,7 @@ obj_t *uw_throw(obj_t *sym, obj_t *exception)
   abort();
 }
 
-obj_t *uw_throwf(obj_t *sym, const wchar_t *fmt, ...)
+obj_t *uw_throwf(obj_t *sym, obj_t *fmt, ...)
 {
   va_list vl;
   obj_t *stream = make_string_output_stream();
@@ -251,7 +251,7 @@ obj_t *uw_throwf(obj_t *sym, const wchar_t *fmt, ...)
   abort();
 }
 
-obj_t *uw_errorf(const wchar_t *fmt, ...)
+obj_t *uw_errorf(obj_t *fmt, ...)
 {
   va_list vl;
   obj_t *stream = make_string_output_stream();
@@ -264,33 +264,7 @@ obj_t *uw_errorf(const wchar_t *fmt, ...)
   abort();
 }
 
-obj_t *uw_throwcf(obj_t *sym, const wchar_t *fmt, ...)
-{
-  va_list vl;
-  obj_t *stream = make_string_output_stream();
-
-  va_start (vl, fmt);
-  (void) vcformat(stream, fmt, vl);
-  va_end (vl);
-
-  uw_throw(sym, get_string_from_stream(stream));
-  abort();
-}
-
-obj_t *uw_errorcf(const wchar_t *fmt, ...)
-{
-  va_list vl;
-  obj_t *stream = make_string_output_stream();
-
-  va_start (vl, fmt);
-  (void) vcformat(stream, fmt, vl);
-  va_end (vl);
-
-  uw_throw(error, get_string_from_stream(stream));
-  abort();
-}
-
-obj_t *type_mismatch(const wchar_t *fmt, ...)
+obj_t *type_mismatch(obj_t *fmt, ...)
 {
   va_list vl;
   obj_t *stream = make_string_output_stream();
@@ -317,21 +291,21 @@ obj_t *uw_register_subtype(obj_t *sub, obj_t *sup)
   if (sub == t) {
     if (sup == t)
       return sup;
-    uw_throwf(type_error, L"cannot define ~a as an exception subtype of ~a",
+    uw_throwf(type_error, lit("cannot define ~a as an exception subtype of ~a"),
               sub, sup, nao);
   }
 
   if (sup == nil) {
-    uw_throwf(type_error, L"cannot define ~a as an exception subtype of ~a",
+    uw_throwf(type_error, lit("cannot define ~a as an exception subtype of ~a"),
               sub, sup, nao);
   }
 
   if (uw_exception_subtype_p(sub, sup))
-    uw_throwf(type_error, L"~a is already an exception subtype of ~a",
+    uw_throwf(type_error, lit("~a is already an exception subtype of ~a"),
               sub, sup, nao);
 
   if (uw_exception_subtype_p(sup, sub))
-    uw_throwf(type_error, L"~a is already an exception supertype of ~a",
+    uw_throwf(type_error, lit("~a is already an exception supertype of ~a"),
               sub, sup, nao);
 
   /* If sup symbol not registered, then we make it
diff --git a/unwind.h b/unwind.h
index 6f7683a8..00931429 100644
--- a/unwind.h
+++ b/unwind.h
@@ -79,17 +79,15 @@ obj_t *uw_set_func(obj_t *sym, obj_t *value);
 obj_t *uw_block_return(obj_t *tag, obj_t *result);
 void uw_push_catch(uw_frame_t *, obj_t *matches);
 noreturn obj_t *uw_throw(obj_t *sym, obj_t *exception);
-noreturn obj_t *uw_throwf(obj_t *sym, const wchar_t *fmt, ...);
-noreturn obj_t *uw_errorf(const wchar_t *fmt, ...);
-noreturn obj_t *uw_throwcf(obj_t *sym, const wchar_t *fmt, ...);
-noreturn obj_t *uw_errorcf(const wchar_t *fmt, ...);
+noreturn obj_t *uw_throwf(obj_t *sym, obj_t *fmt, ...);
+noreturn obj_t *uw_errorf(obj_t *fmt, ...);
 obj_t *uw_register_subtype(obj_t *sub, obj_t *super);
 obj_t *uw_exception_subtype_p(obj_t *sub, obj_t *sup);
 void uw_continue(uw_frame_t *curr, uw_frame_t *target);
 void uw_pop_frame(uw_frame_t *);
 void uw_init(void);
 
-noreturn obj_t *type_mismatch(const wchar_t *, ...);
+noreturn obj_t *type_mismatch(obj_t *, ...);
 
 #define uw_block_begin(TAG, RESULTVAR)  \
   obj_t *RESULTVAR = nil;               \
@@ -149,9 +147,14 @@ noreturn obj_t *type_mismatch(const wchar_t *, ...);
   }
 
 #define internal_error(STR)             \
-  uw_throwcf(internal_err,              \
-             L"%s:%d %ls", __FILE__,    \
-             __LINE__, STR)
+  do {                                  \
+    extern obj_t *num(long);            \
+    uw_throwf(internal_err,             \
+              lit("~a:~a ~a"),          \
+              lit(__FILE__),            \
+              num(__LINE__), lit(STR),  \
+              nao);                     \
+  } while (0)
 
 #define type_assert(EXPR, ARGS)         \
   if (!(EXPR)) type_mismatch ARGS
@@ -164,12 +167,13 @@ noreturn obj_t *type_mismatch(const wchar_t *, ...);
 
 #define numeric_assert(EXPR)            \
   if (!(EXPR))                          \
-   uw_throwcf(numeric_err, L"%ls",      \
-              L"assertion " #EXPR       \
-              L" failed")
+   uw_throwf(numeric_err,               \
+             lit("assertion " #EXPR     \
+                 "failed"), nao)
 
 #define range_bug_unless(EXPR)          \
   if (!(EXPR))                          \
-   uw_throwcf(range_err, L"%ls",        \
-              L"assertion" #EXPR        \
-              L" failed")
+   uw_throwf(range_err,                 \
+             lit("assertion " #EXPR     \
+                 "failed"), nao)
+
diff --git a/utf8.c b/utf8.c
index 5936e43a..46b1feae 100644
--- a/utf8.c
+++ b/utf8.c
@@ -153,7 +153,7 @@ size_t utf8_to(char *dst, const wchar_t *wsrc)
 wchar_t *utf8_dup_from_uc(const unsigned char *str)
 {
   size_t nchar = utf8_from_uc(0, str);
-  wchar_t *wstr = chk_malloc(sizeof *wstr * nchar);
+  wchar_t *wstr = (wchar_t *) chk_malloc(nchar * sizeof *wstr);
   utf8_from_uc(wstr, str);
   return wstr;
 }
@@ -161,7 +161,7 @@ wchar_t *utf8_dup_from_uc(const unsigned char *str)
 wchar_t *utf8_dup_from(const char *str)
 {
   size_t nchar = utf8_from(0, str);
-  wchar_t *wstr = chk_malloc(sizeof *wstr * nchar);
+  wchar_t *wstr = (wchar_t *) chk_malloc(nchar * sizeof *wstr);
   utf8_from(wstr, str);
   return wstr;
 }
@@ -169,7 +169,7 @@ wchar_t *utf8_dup_from(const char *str)
 unsigned char *utf8_dup_to_uc(const wchar_t *wstr)
 {
   size_t nbyte = utf8_to_uc(0, wstr);
-  unsigned char *str = chk_malloc(nbyte);
+  unsigned char *str = (unsigned char *) chk_malloc(nbyte);
   utf8_to_uc(str, wstr);
   return str;
 }
@@ -177,7 +177,7 @@ unsigned char *utf8_dup_to_uc(const wchar_t *wstr)
 char *utf8_dup_to(const wchar_t *wstr)
 {
   size_t nbyte = utf8_to(0, wstr);
-  char *str = chk_malloc(nbyte);
+  char *str = (char *) chk_malloc(nbyte);
   utf8_to(str, wstr);
   return str;
 }