Index: tests/exceptions/.expect/polymorphic.txt
===================================================================
--- tests/exceptions/.expect/polymorphic.txt	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/.expect/polymorphic.txt	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -4,4 +4,4 @@
 
 -7
-0
-1
+false
+true
Index: tests/exceptions/cancel/coroutine.cfa
===================================================================
--- tests/exceptions/cancel/coroutine.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/cancel/coroutine.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Try cancelling a coroutine.
 
+#include <fstream.hfa>
 #include <coroutine.hfa>
 
@@ -13,21 +14,22 @@
 
 void main(WillCancel & wc) {
-	printf("1");
+	sout | '1';
 	cancel_stack((internal_error){&internal_vt});
-	printf("!");
+	sout | '!';
 }
 
 int main(int argc, char * argv[]) {
+	sout | nlOff;
 	WillCancel cancel;
 	try {
-		printf("0");
+		sout | '0';
 		resume(cancel);
-		printf("4");
+		sout | '4';
 	} catchResume (CoroutineCancelled(WillCancel) * error) {
-		printf("2");
+		sout | '2';
 		if ((virtual internal_error *)error->the_exception) {
-			printf("3");
+			sout | '3';
 		}
 	}
-	printf("5\n");
+	sout | '5' | nl;
 }
Index: tests/exceptions/cancel/thread.cfa
===================================================================
--- tests/exceptions/cancel/thread.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/cancel/thread.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Try cancelling a thread.
 
+#include <fstream.hfa>
 #include <thread.hfa>
 
@@ -13,23 +14,23 @@
 
 void main(WillCancel &) {
-	printf("1");
+	sout | '1';
 	cancel_stack((internal_error){&internal_vt});
-	printf("!");
+	sout | '!';
 }
 
 void explicit() {
 	try {
-		printf("0");
+		sout | '0';
 		WillCancel cancel;
-		printf("1");
+		sout | '1';
 		join(cancel);
-		printf("4");
+		sout | '4';
 	} catchResume (ThreadCancelled(WillCancel) * error) {
-		printf("2");
+		sout | '2';
 		if ((virtual internal_error *)error->the_exception) {
-			printf("3");
+			sout | '3';
 		}
 	}
-	printf("5\n");
+	sout | '5' | nl;
 }
 
@@ -37,19 +38,20 @@
 	try {
 		{
-			printf("0");
+			sout | '0';
 			WillCancel cancel;
-			printf("1");
+			sout | '1';
 		}
-		printf("4");
+		sout | '4';
 	} catchResume (ThreadCancelled(WillCancel) * error) {
-		printf("2");
+		sout | '2';
 		if ((virtual internal_error *)error->the_exception) {
-			printf("3");
+			sout | '3';
 		}
 	}
-	printf("5\n");
+	sout | '5' | nl;
 }
 
 int main(int argc, char * argv[]) {
+	sout | nlOff;
 	explicit();
 	implicit();
Index: tests/exceptions/conditional.cfa
===================================================================
--- tests/exceptions/conditional.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/conditional.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -3,4 +3,6 @@
 // I may fold this back into terminate.cfa and resume.cfa once setting
 // up the non-trivial exception is reasonable to do.
+
+#include <fstream.cfa>
 
 exception num_error {
@@ -11,5 +13,5 @@
 
 void caught_num_error(int expect, num_error * actual) {
-	printf("Caught num_error: expected=%d actual=%d.\n", expect, actual->num);
+	sout | "Caught num_error: expected=" | expect | "actual=" | actual->num | '.';
 }
 
Index: tests/exceptions/data-except.cfa
===================================================================
--- tests/exceptions/data-except.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/data-except.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,3 +1,5 @@
 // Test exceptions that add data but no functionality.
+
+#include <fstream.cfa>
 
 exception paired {
@@ -18,17 +20,17 @@
 		throw except;
 	} catch (paired * exc) {
-		printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second);
+		sout | virtual_msg(exc) | '(' | exc->first | ", " | exc->second | ')';
 		++exc->first;
 	}
 
-	printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second);
+	sout | virtual_msg(&except) | '(' | except.first | ", " | except.second | ')';
 
 	try {
 		throwResume except;
 	} catchResume (paired * exc) {
-		printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second);
+		sout | virtual_msg(exc) | '(' | exc->first | ", " | exc->second | ')';
 		++exc->first;
 	}
 
-	printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second);
+	sout | virtual_msg(&except) | '(' | except.first | ", " | except.second | ')';
 }
Index: tests/exceptions/defaults.cfa
===================================================================
--- tests/exceptions/defaults.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/defaults.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Tests for providing new default operations.
 
+#include <fstream.hfa>
 #include <string.h>
 
@@ -35,5 +36,5 @@
 		throwResume (log_message){&log_vt, "Should be printed.\n"};
 	} catchResume (log_message * this) {
-		printf("%s", this->virtual_table->msg(this));
+		sout | this->virtual_table->msg(this) | nonl;
 	}
 	// But we don't have to:
@@ -44,5 +45,5 @@
 exception jump {};
 void defaultTerminationHandler(jump &) {
-	printf("jump default handler.\n");
+	sout | "jump default handler.";
 }
 
@@ -53,5 +54,5 @@
 		throw (jump){&jump_vt};
 	} catch (jump * this) {
-		printf("jump catch handler.\n");
+		sout | "jump catch handler.";
 	}
 	throw (jump){&jump_vt};
@@ -75,5 +76,5 @@
 		throw (first){&first_vt};
 	} catch (unhandled_exception * t) {
-		printf("Catch unhandled_exception.\n");
+		sout | "Catch unhandled_exception.";
 	}
 }
@@ -84,22 +85,22 @@
 void cross_test(void) {
 	void defaultTerminationHandler(first &) {
-		printf("cross terminate default\n");
+		sout | "cross terminate default";
 		throw (second){&second_vt};
 	}
 	void defaultResumptionHandler(first &) {
-		printf("cross resume default\n");
+		sout | "cross resume default";
 		throwResume (second){&second_vt};
 	}
 	try {
-		printf("cross terminate throw\n");
+		sout | "cross terminate throw";
 		throw (first){&first_vt};
 	} catch (second *) {
-		printf("cross terminate catch\n");
+		sout | "cross terminate catch";
 	}
 	try {
-		printf("cross resume throw\n");
+		sout | "cross resume throw";
 		throwResume (first){&first_vt};
 	} catchResume (second *) {
-		printf("cross resume catch\n");
+		sout | "cross resume catch";
 	}
 }
Index: tests/exceptions/except-io.hfa
===================================================================
--- tests/exceptions/except-io.hfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/except-io.hfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -2,4 +2,7 @@
 
 // Echo when a destructor is run and an area/block is left.
+
+#include <fstream.hfa>
+
 struct loud_exit {
     const char * area;
@@ -11,5 +14,5 @@
 
 inline void ^?{}(loud_exit & this) {
-    printf("Exiting: %s\n", this.area);
+    sout | "Exiting: " | this.area;
 }
 
@@ -20,8 +23,8 @@
 inline void ?{}(loud_region & this, const char * region) {
 	this.region = region;
-	printf("Entering: %s\n", region);
+	sout | "Entering: " | region;
 }
 
 inline void ^?{}(loud_region & this) {
-	printf("Exiting: %s\n", this.region);
+	sout | "Exiting: " | this.region;
 }
Index: tests/exceptions/finally.cfa
===================================================================
--- tests/exceptions/finally.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/finally.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Finally Clause Tests
 
+#include <fstream.hfa>
 #include "except-io.hfa"
 
@@ -12,48 +13,48 @@
 	try {
 		try {
-			printf("termination throw\n");
+			sout | "termination throw";
 			throw exc;
 		} finally {
 			loud_exit a = "termination inner finally";
-			printf("finally during unwind\n");
+			sout | "finally during unwind";
 		}
 	} catch (myth * error) {
-		printf("termination catch\n");
+		sout | "termination catch";
 	} finally {
 		loud_exit a = "termination outer finally";
-		printf("finally after catch\n");
+		sout | "finally after catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	try {
 		try {
-			printf("resumption throw\n");
+			sout | "resumption throw";
 			throwResume exc;
 		} finally {
 			loud_exit a = "resumption inner finally";
-			printf("finally after resume\n");
+			sout | "finally after resume";
 		}
 	} catchResume (myth * error) {
-		printf("resumption catch\n");
+		sout | "resumption catch";
 	} finally {
 		loud_exit a = "resumption outer finally";
-		printf("finally after catch\n");
+		sout | "finally after catch";
 	}
-	printf("\n");
+	sout | "";
 
 	try {
-		printf("walking out of try\n");
+		sout | "walking out of try";
 	} finally {
 		loud_exit a = "walking finally";
-		printf("walking through finally\n");
+		sout | "walking through finally";
 	}
-	printf("\n");
+	sout | "";
 
 	try {
-		printf("jumping out of try\n");
+		sout | "jumping out of try";
 		goto endoffunction;
 	} finally {
 		loud_exit a = "jumping finally";
-		printf("jumping through finally\n");
+		sout | "jumping through finally";
 	}
 	endoffunction:
Index: tests/exceptions/interact.cfa
===================================================================
--- tests/exceptions/interact.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/interact.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Testing Interactions Between Termination and Resumption
 
+#include <fstream.hfa>
 #include "except-io.hfa"
 
@@ -14,5 +15,5 @@
 		throwResume (star){&star_vt};
 	} catch (star *) {
-		printf("caught as termination\n");
+		sout | "caught as termination";
 	}
 	// Variant of the above to check timing.
@@ -21,10 +22,10 @@
 		throwResume (star){&star_vt};
 	} catch (star *) {
-		printf("caught as termination\n");
+		sout | "caught as termination";
 	} catchResume (star *) {
-		printf("intermediate rethrow\n");
+		sout | "intermediate rethrow";
 		throwResume;
 	}
-	printf("\n");
+	sout | nl;
 
 	// Resume does not catch terminate.
@@ -33,12 +34,12 @@
 			throw (star){&star_vt};
 		} catchResume (star *) {
-			printf("resume catch on terminate\n");
+			sout | "resume catch on terminate";
 		}
 	} catchResume (star *) {
-		printf("resume catch on terminate\n");
+		sout | "resume catch on terminate";
 	} catch (star *) {
-		printf("terminate catch on terminate\n");
+		sout | "terminate catch on terminate";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Terminate does not catch resume.
@@ -47,12 +48,12 @@
 			throwResume (star){&star_vt};
 		} catch (star *) {
-			printf("terminate catch on resume\n");
+			sout | "terminate catch on resume";
 		}
 	} catch (star *) {
-		printf("terminate catch on resume\n");
+		sout | "terminate catch on resume";
 	} catchResume (star *) {
-		printf("resume catch on resume\n");
+		sout | "resume catch on resume";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Resume a termination exception.
@@ -62,14 +63,14 @@
 				throw (star){&star_vt};
 			} catchResume (star *) {
-				printf("inner resume catch (error)\n");
+				sout | "inner resume catch (error)";
 			}
 		} catch (star * error) {
-			printf("termination catch, will resume\n");
+			sout | "termination catch, will resume";
 			throwResume *error;
 		}
 	} catchResume (star *) {
-		printf("outer resume catch\n");
+		sout | "outer resume catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Terminate a resumption exception.
@@ -79,14 +80,14 @@
 				throwResume (star){&star_vt};
 			} catch (star *) {
-				printf("inner termination catch\n");
+				sout | "inner termination catch";
 			}
 		} catchResume (star * error) {
-			printf("resumption catch, will terminate\n");
+			sout | "resumption catch, will terminate";
 			throw *error;
 		}
 	} catch (star *) {
-		printf("outer terminate catch (error)\n");
+		sout | "outer terminate catch (error)";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Unwinding a resumption catch does not break the system.
@@ -95,20 +96,20 @@
 			try {
 				try {
-					printf("throwing resume moon\n");
+					sout | "throwing resume moon";
 					throwResume (moon){&moon_vt};
 				} catch (star *) {
-					printf("termination catch\n");
+					sout | "termination catch";
 				}
-				printf("throwing resume star\n");
+				sout | "throwing resume star";
 				throwResume (star){&star_vt};
 			} catchResume (star *) {
-				printf("resumption star catch\n");
+				sout | "resumption star catch";
 			}
 		} catchResume (moon *) {
-			printf("resumption moon catch, will terminate\n");
+			sout | "resumption moon catch, will terminate";
 			throw (star){&star_vt};
 		}
 	} catchResume (star *) {
-		printf("outermost catch (error)\n");
+		sout | "outermost catch (error)";
 	}
 }
Index: tests/exceptions/polymorphic.cfa
===================================================================
--- tests/exceptions/polymorphic.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/polymorphic.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,3 +1,5 @@
 // Testing polymophic exception types.
+
+#include <fstream.hfa>
 
 forall(T &) exception proxy {};
@@ -13,5 +15,5 @@
 		throw an_int;
 	} catch (proxy(int) *) {
-		printf("terminate catch\n");
+		sout | "terminate catch";
 	}
 
@@ -19,5 +21,5 @@
 		throwResume a_char;
 	} catchResume (proxy(char) *) {
-		printf("resume catch\n");
+		sout | "resume catch";
 	}
 
@@ -25,7 +27,7 @@
 		throw a_char;
 	} catch (proxy(int) *) {
-		printf("caught proxy(int)\n");
+		sout | "caught proxy(int)";
 	} catch (proxy(char) *) {
-		printf("caught proxy(char)\n");
+		sout | "caught proxy(char)";
 	}
 }
@@ -44,5 +46,5 @@
 		throw except;
 	} catch (cell(int) * error) {
-		printf("%d\n", error->data);
+		sout | error->data;
 	}
 
@@ -50,7 +52,7 @@
 		cell(bool) ball = {&bool_cell, false};
 		throwResume ball;
-		printf("%i\n", ball.data);
+		sout | ball.data;
 	} catchResume (cell(bool) * error) {
-		printf("%i\n", error->data);
+		sout | error->data;
 		error->data = true;
 	}
@@ -59,5 +61,5 @@
 int main(int argc, char * argv[]) {
 	proxy_test();
-	printf("\n");
+	sout | nl;
 	cell_test();
 }
Index: tests/exceptions/resume.cfa
===================================================================
--- tests/exceptions/resume.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/resume.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Resumption Exception Tests
 
+#include <fstream.hfa>
 #include "except-io.hfa"
 
@@ -21,12 +22,12 @@
 	try {
 		loud_exit a = "simple try clause";
-		printf("simple throw\n");
+		sout | "simple throw";
 		throwResume a_zen;
-		printf("end of try clause\n");
+		sout | "end of try clause";
 	} catchResume (zen * error) {
 		loud_exit a = "simple catch clause";
-		printf("simple catch\n");
+		sout | "simple catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw catch-all test.
@@ -34,7 +35,7 @@
 		throwResume a_zen;
 	} catchResume (exception_t * error) {
-		printf("catch-all\n");
+		sout | "catch-all";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Don't catch if handler does not match exception.
@@ -43,12 +44,12 @@
 			throwResume a_yin;
 		} catchResume (zen *) {
-			printf("caught yin as zen\n");
+			sout | "caught yin as zen";
 		}
 	} catchResume (yang *) {
-		printf("caught yin as yang\n");
+		sout | "caught yin as yang";
 	} catchResume (yin *) {
-		printf("caught yin as yin\n");
+		sout | "caught yin as yin";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Test rethrowing an exception.
@@ -56,16 +57,16 @@
 		try {
 			loud_exit a = "rethrow inner try";
-			printf("rethrow inner try\n");
+			sout | "rethrow inner try";
 			throwResume a_zen;
 		} catchResume (zen *) {
 			loud_exit a = "rethrowing catch clause";
-			printf("caught throw, will rethrow\n");
+			sout | "caught throw, will rethrow";
 			throwResume;
 		}
 	} catchResume (zen *) {
 		loud_exit a = "rethrow catch clause";
-		printf("caught rethrow\n");
+		sout | "caught rethrow";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw a different exception in a catch.
@@ -74,35 +75,35 @@
 			throwResume a_yin;
 		} catchResume (yin *) {
-			printf("caught yin, will throw yang\n");
+			sout | "caught yin, will throw yang";
 			throwResume a_yang;
 		} catchResume (yang *) {
-			printf("caught exception from same try\n");
+			sout | "caught exception from same try";
 		}
 	} catchResume (yang *) {
-		printf("caught yang\n");
+		sout | "caught yang";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Another throw in the catch does not interfere.
 	try {
 		try {
-			printf("throwing first exception\n");
+			sout | "throwing first exception";
 			throwResume a_yin;
 		} catchResume (yin *) {
-			printf("caught first exception\n");
+			sout | "caught first exception";
 			try {
-				printf("throwing second exception\n");
+				sout | "throwing second exception";
 				throwResume a_yang;
 			} catchResume (yang *) {
-				printf("caught second exception\n");
+				sout | "caught second exception";
 			}
 			throwResume;
 		}
 	} catchResume (yin *) {
-		printf("recaught first exception\n");
+		sout | "recaught first exception";
 	} catchResume (yang *) {
-		printf("caught second exception (bad location)\n");
+		sout | "caught second exception (bad location)";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Check successive operations.
@@ -112,11 +113,11 @@
 			throwResume a_zen;
 		} catchResume (zen *) {
-			printf("inner catch\n");
+			sout | "inner catch";
 		}
 		throwResume a_zen;
 	} catchResume (zen *) {
-		printf("outer catch\n");
+		sout | "outer catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	in_void();
@@ -128,12 +129,12 @@
 	try {
 		try {
-			printf("throw\n");
+			sout | "throw";
 			throwResume a_zen;
 		} catchResume (zen *) {
-			printf("rethrow\n");
+			sout | "rethrow";
 			throwResume;
 		}
 	} catchResume (zen *) {
-		printf("handle\n");
+		sout | "handle";
 	}
 }
Index: tests/exceptions/terminate.cfa
===================================================================
--- tests/exceptions/terminate.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/terminate.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,4 +1,5 @@
 // Termination Exception Tests
 
+#include <fstream.hfa>
 #include "except-io.hfa"
 
@@ -21,12 +22,12 @@
 	try {
 		loud_exit a = "simple try clause";
-		printf("simple throw\n");
+		sout | "simple throw";
 		throw a_zen;
-		printf("end of try clause\n");
+		sout | "end of try clause";
 	} catch (zen * error) {
 		loud_exit a = "simple catch clause";
-		printf("simple catch\n");
+		sout | "simple catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw catch-all test.
@@ -34,7 +35,7 @@
 		throw a_zen;
 	} catch (exception_t * error) {
-		printf("catch-all\n");
+		sout | "catch-all";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Don't catch if handler does not match exception.
@@ -43,12 +44,12 @@
 			throw a_yin;
 		} catch (zen *) {
-			printf("caught yin as zen\n");
+			sout | "caught yin as zen";
 		}
 	} catch (yang *) {
-		printf("caught yin as yang\n");
+		sout | "caught yin as yang";
 	} catch (yin *) {
-		printf("caught yin as yin\n");
+		sout | "caught yin as yin";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Test rethrowing an exception.
@@ -56,16 +57,16 @@
 		try {
 			loud_exit a = "rethrow inner try";
-			printf("rethrow inner try\n");
+			sout | "rethrow inner try";
 			throw a_zen;
 		} catch (zen *) {
 			loud_exit a = "rethrowing catch clause";
-			printf("caught throw, will rethrow\n");
+			sout | "caught throw, will rethrow";
 			throw;
 		}
 	} catch (zen *) {
 		loud_exit a = "rethrow catch clause";
-		printf("caught rethrow\n");
+		sout | "caught rethrow";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Throw a different exception in a catch.
@@ -74,35 +75,35 @@
 			throw a_yin;
 		} catch (yin *) {
-			printf("caught yin, will throw yang\n");
+			sout | "caught yin, will throw yang";
 			throw a_yang;
 		} catch (yang *) {
-			printf("caught exception from same try\n");
+			sout | "caught exception from same try";
 		}
 	} catch (yang *) {
-		printf("caught yang\n");
+		sout | "caught yang";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Another throw in the catch does not interfere.
 	try {
 		try {
-			printf("throwing first exception\n");
+			sout | "throwing first exception";
 			throw a_yin;
 		} catch (yin *) {
-			printf("caught first exception\n");
+			sout | "caught first exception";
 			try {
-				printf("throwing second exception\n");
+				sout | "throwing second exception";
 				throw a_yang;
 			} catch (yang *) {
-				printf("caught second exception\n");
+				sout | "caught second exception";
 			}
 			throw;
 		}
 	} catch (yin *) {
-		printf("recaught first exception\n");
+		sout | "recaught first exception";
 	} catch (yang *) {
-		printf("caught second exception (bad location)\n");
+		sout | "caught second exception (bad location)";
 	}
-	printf("\n");
+	sout | nl;
 
 	// Check successive operations.
@@ -112,11 +113,11 @@
 			throw a_zen;
 		} catch (zen *) {
-			printf("inner catch\n");
+			sout | "inner catch";
 		}
 		throw a_zen;
 	} catch (zen *) {
-		printf("outer catch\n");
+		sout | "outer catch";
 	}
-	printf("\n");
+	sout | nl;
 
 	in_void();
@@ -128,12 +129,12 @@
 	try {
 		try {
-			printf("throw\n");
+			sout | "throw";
 			throw a_zen;
 		} catch (zen *) {
-			printf("rethrow\n");
+			sout | "rethrow";
 			throw;
 		}
 	} catch (zen *) {
-		printf("handle\n");
+		sout | "handle";
 	}
 }
Index: tests/exceptions/trash.cfa
===================================================================
--- tests/exceptions/trash.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/trash.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -1,3 +1,5 @@
 // Make sure throw-catch during unwind does not trash internal data.
+
+#include <fstream.hfa>
 
 exception yin {};
@@ -15,13 +17,13 @@
 				throw (yang){&yang_vt};
 			} catch (yin *) {
-				printf("inner yin\n");
+				sout | "inner yin";
 			} catch (yang *) {
-				printf("inner yang\n");
+				sout | "inner yang";
 			}
 		}
 	} catch (yin *) {
-		printf("outer yin\n");
+		sout | "outer yin";
 	} catch (yang *) {
-		printf("outer yang\n");
+		sout | "outer yang";
 	}
 }
Index: tests/exceptions/virtual-cast.cfa
===================================================================
--- tests/exceptions/virtual-cast.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/virtual-cast.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -9,8 +9,7 @@
  */
 
+#include <fstream.hfa>
 #include <stdlib.hfa>
 #include <assert.h>
-
-
 
 // Hand defined alpha virtual type:
@@ -106,4 +105,4 @@
 	free(tri);
 	free(top);
-	printf( "done\n" );				// non-empty .expect file
+	sout | "done";										// non-empty .expect file
 }
Index: tests/exceptions/virtual-poly.cfa
===================================================================
--- tests/exceptions/virtual-poly.cfa	(revision da0edec766476f9bd235acd685e746ea25b1bf5d)
+++ tests/exceptions/virtual-poly.cfa	(revision 3bf9d101e125e952f9abb0271db2208c769320f8)
@@ -6,4 +6,5 @@
  */
 
+#include <fstream.hfa>
 #include <assert.h>
 
@@ -105,4 +106,4 @@
 	mono_poly_test();
 	poly_poly_test();
-	printf( "done\n" );
+	sout | "done";
 }