Index: libcfa/src/exception.c
===================================================================
--- libcfa/src/exception.c	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ libcfa/src/exception.c	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -10,6 +10,6 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 14 12:01:00 2020
-// Update Count     : 18
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 19
 //
 
@@ -80,5 +80,5 @@
 }
 
-void __cfaehm_throw_resume(exception_t * except) {
+void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
 	struct exception_context_t * context = this_exception_context();
 
@@ -96,9 +96,7 @@
 	}
 
+	// No handler found, fall back to the default operation.
 	__cfadbg_print_safe(exception, "Unhandled exception\n");
-
-	// Fall back to termination:
-	__cfaehm_throw_terminate(except);
-	// TODO: Default handler for resumption.
+	defaultHandler(except);
 }
 
@@ -240,5 +238,5 @@
 
 // The exception that is being thrown must already be stored.
-static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
+static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) {
 	if ( ! this_exception_context()->current_exception ) {
 		printf("UNWIND ERROR missing exception in begin unwind\n");
@@ -257,9 +255,8 @@
 
 	// No handler found, go to the default operation.
-	// Currently this will always be a cancellation.
 	if ( ret == _URC_END_OF_STACK ) {
 		__cfadbg_print_safe(exception, "Uncaught exception %p\n", &this_exception_storage);
 
-		__cfaehm_cancel_stack(this_exception_context()->current_exception);
+		defaultHandler( this_exception_context()->current_exception );
 	}
 
@@ -269,9 +266,15 @@
 }
 
-void __cfaehm_throw_terminate( exception_t * val ) {
+void __cfaehm_throw_terminate( exception_t * val, void (*defaultHandler)(exception_t *) ) {
 	__cfadbg_print_safe(exception, "Throwing termination exception\n");
 
 	__cfaehm_allocate_exception( val );
-	__cfaehm_begin_unwind();
+	__cfaehm_begin_unwind( defaultHandler );
+}
+
+static __attribute__((noreturn)) void __cfaehm_rethrow_adapter( exception_t * except ) {
+	// TODO: Print some error message.
+	(void)except;
+	abort();
 }
 
@@ -279,5 +282,6 @@
 	__cfadbg_print_safe(exception, "Rethrowing termination exception\n");
 
-	__cfaehm_begin_unwind();
+	__cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
+	abort();
 }
 
Index: libcfa/src/exception.h
===================================================================
--- libcfa/src/exception.h	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ libcfa/src/exception.h	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -10,6 +10,6 @@
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 10:16:00 2020
-// Update Count     : 9
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 10
 //
 
@@ -41,7 +41,7 @@
 
 // Used in throw statement translation.
-void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
+void __cfaehm_throw_terminate(exception_t * except, void (*)(exception_t *));
 void __cfaehm_rethrow_terminate() __attribute__((noreturn));
-void __cfaehm_throw_resume(exception_t * except);
+void __cfaehm_throw_resume(exception_t * except, void (*)(exception_t *));
 
 // Function catches termination exceptions.
@@ -72,3 +72,54 @@
 #ifdef __cforall
 }
+
+// Not all the built-ins can be expressed in C. These can't be
+// implemented in the .c file either so they all have to be inline.
+
+trait is_exception(dtype T) {
+	/* The first field must be a pointer to a virtual table.
+	 * That virtual table must be a decendent of the base exception virtual tab$
+	 */
+	void mark_exception(T *);
+	// This is never used and should be a no-op.
+};
+
+trait is_termination_exception(dtype T | is_exception(T)) {
+	void defaultTerminationHandler(T &);
+};
+
+trait is_resumption_exception(dtype T | is_exception(T)) {
+	void defaultResumptionHandler(T &);
+};
+
+forall(dtype T | is_termination_exception(T))
+static inline void $throw(T & except) {
+	__cfaehm_throw_terminate(
+		(exception_t *)&except,
+		(void(*)(exception_t *))defaultTerminationHandler
+	);
+}
+
+forall(dtype T | is_resumption_exception(T))
+static inline void $throwResume(T & except) {
+	__cfaehm_throw_resume(
+		(exception_t *)&except,
+		(void(*)(exception_t *))defaultResumptionHandler
+	);
+}
+
+forall(dtype T | is_exception(T))
+static inline void cancel_stack(T & except) __attribute__((noreturn)) {
+	__cfaehm_cancel_stack( (exception_t *)&except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultTerminationHandler(T & except) {
+	return cancel_stack( except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultResumptionHandler(T & except) {
+	throw except;
+}
+
 #endif
Index: libcfa/src/exception.hfa
===================================================================
--- libcfa/src/exception.hfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ libcfa/src/exception.hfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -10,18 +10,7 @@
 // Created On       : Thu Apr  7 10:25:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 13 15:42:00 2020
-// Update Count     : 1
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 2
 //
-
-trait is_exception(dtype T) {
-	// The trait system can't describe the actual constrants.
-	// Unused, should always be a no-op.
-	void mark_exception(T *);
-};
-
-forall(dtype T | is_exception(T))
-inline void cancel_stack(T & except) __attribute__((noreturn)) {
-	__cfaehm_cancel_stack( (exception_t *)&except );
-}
 
 // Everything below this line should be considered a patch while the exception
Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ src/ControlStruct/ExceptTranslate.cc	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 11:58:00 2020
-// Update Count     : 13
+// Last Modified On : Tue May 19 16:46:00 2020
+// Update Count     : 14
 //
 
@@ -64,5 +64,123 @@
 	}
 
-	class ExceptionMutatorCore : public WithGuards {
+	class ThrowMutatorCore : public WithGuards {
+		ObjectDecl * terminate_handler_except;
+		enum Context { NoHandler, TerHandler, ResHandler } cur_context;
+
+		// The helper functions for code/syntree generation.
+		Statement * create_either_throw(
+			ThrowStmt * throwStmt, const char * throwFunc );
+		Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+		Statement * create_resume_rethrow( ThrowStmt * throwStmt );
+
+	public:
+		ThrowMutatorCore() :
+			terminate_handler_except( nullptr ),
+			cur_context( NoHandler )
+		{}
+
+		void premutate( CatchStmt *catchStmt );
+		Statement * postmutate( ThrowStmt *throwStmt );
+	};
+
+	// ThrowStmt Mutation Helpers
+
+	Statement * ThrowMutatorCore::create_either_throw(
+			ThrowStmt * throwStmt, const char * throwFunc ) {
+		// `throwFunc`( `throwStmt->get_name()` );
+		UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+		call->get_args().push_back( throwStmt->get_expr() );
+		throwStmt->set_expr( nullptr );
+		delete throwStmt;
+		return new ExprStmt( call );
+	}
+
+	Statement * ThrowMutatorCore::create_terminate_rethrow(
+			ThrowStmt *throwStmt ) {
+		// { `terminate_handler_except` = 0p; __rethrow_terminate(); }
+		assert( nullptr == throwStmt->get_expr() );
+		assert( terminate_handler_except );
+
+		CompoundStmt * result = new CompoundStmt();
+		result->labels =  throwStmt->labels;
+		result->push_back( new ExprStmt( UntypedExpr::createAssign(
+			nameOf( terminate_handler_except ),
+			new ConstantExpr( Constant::null(
+				//new PointerType(
+				//	noQualifiers,
+					terminate_handler_except->get_type()->clone()
+				//	)
+				) )
+			) ) );
+		result->push_back( new ExprStmt(
+			new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
+			) );
+		delete throwStmt;
+		return result;
+	}
+
+	Statement * ThrowMutatorCore::create_resume_rethrow(
+			ThrowStmt *throwStmt ) {
+		// return false;
+		Statement * result = new ReturnStmt(
+			new ConstantExpr( Constant::from_bool( false ) )
+			);
+		result->labels = throwStmt->labels;
+		delete throwStmt;
+		return result;
+	}
+
+	// Visiting/Mutating Functions
+
+	void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
+		// Validate the statement's form.
+		ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+		// Also checking the type would be nice.
+		if ( decl ) {
+			// Pass.
+		} else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+			SemanticError(catchStmt->location, "catch must have exception type");
+		} else {
+			SemanticError(catchStmt->location, "catchResume must have exception type");
+		}
+
+		// Track the handler context.
+		GuardValue( cur_context );
+		if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+			cur_context = TerHandler;
+
+			GuardValue( terminate_handler_except );
+			terminate_handler_except = decl;
+		} else {
+			cur_context = ResHandler;
+		}
+	}
+
+	Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+		// Ignoring throwStmt->get_target() for now.
+		if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+			if ( throwStmt->get_expr() ) {
+				return create_either_throw( throwStmt, "$throw" );
+			} else if ( TerHandler == cur_context ) {
+				return create_terminate_rethrow( throwStmt );
+			} else {
+				abort("Invalid throw in %s at %i\n",
+					throwStmt->location.filename.c_str(),
+					throwStmt->location.first_line);
+			}
+		} else {
+			if ( throwStmt->get_expr() ) {
+				return create_either_throw( throwStmt, "$throwResume" );
+			} else if ( ResHandler == cur_context ) {
+				return create_resume_rethrow( throwStmt );
+			} else {
+				abort("Invalid throwResume in %s at %i\n",
+					throwStmt->location.filename.c_str(),
+					throwStmt->location.first_line);
+			}
+		}
+	}
+
+	class TryMutatorCore : public WithGuards {
 		enum Context { NoHandler, TerHandler, ResHandler };
 
@@ -82,10 +200,4 @@
 
 		// The many helper functions for code/syntree generation.
-		Statement * create_given_throw(
-			const char * throwFunc, ThrowStmt * throwStmt );
-		Statement * create_terminate_throw( ThrowStmt * throwStmt );
-		Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
-		Statement * create_resume_throw( ThrowStmt * throwStmt );
-		Statement * create_resume_rethrow( ThrowStmt * throwStmt );
 		CompoundStmt * take_try_block( TryStmt * tryStmt );
 		FunctionDecl * create_try_wrapper( CompoundStmt * body );
@@ -121,5 +233,5 @@
 
 	public:
-		ExceptionMutatorCore() :
+		TryMutatorCore() :
 			cur_context( NoHandler ),
 			handler_except_decl( nullptr ),
@@ -138,5 +250,5 @@
 	};
 
-	void ExceptionMutatorCore::init_func_types() {
+	void TryMutatorCore::init_func_types() {
 		assert( except_decl );
 
@@ -196,66 +308,7 @@
 	}
 
-	// ThrowStmt Mutation Helpers
-
-	Statement * ExceptionMutatorCore::create_given_throw(
-			const char * throwFunc, ThrowStmt * throwStmt ) {
-		// `throwFunc`( `throwStmt->get_name` );
-		UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
-		call->get_args().push_back( throwStmt->get_expr() );
-		throwStmt->set_expr( nullptr );
-		delete throwStmt;
-		return new ExprStmt( call );
-	}
-
-	Statement * ExceptionMutatorCore::create_terminate_throw(
-			ThrowStmt *throwStmt ) {
-		// __throw_terminate( `throwStmt->get_name()` ); }
-		return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
-	}
-
-	Statement * ExceptionMutatorCore::create_terminate_rethrow(
-			ThrowStmt *throwStmt ) {
-		// { `handler_except_decl` = NULL; __rethrow_terminate(); }
-		assert( nullptr == throwStmt->get_expr() );
-		assert( handler_except_decl );
-
-		CompoundStmt * result = new CompoundStmt();
-		result->labels =  throwStmt->labels;
-		result->push_back( new ExprStmt( UntypedExpr::createAssign(
-			nameOf( handler_except_decl ),
-			new ConstantExpr( Constant::null(
-				new PointerType(
-					noQualifiers,
-					handler_except_decl->get_type()->clone()
-					)
-				) )
-			) ) );
-		result->push_back( new ExprStmt(
-			new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
-			) );
-		delete throwStmt;
-		return result;
-	}
-
-	Statement * ExceptionMutatorCore::create_resume_throw(
-			ThrowStmt *throwStmt ) {
-		// __throw_resume( `throwStmt->get_name` );
-		return create_given_throw( "__cfaehm_throw_resume", throwStmt );
-	}
-
-	Statement * ExceptionMutatorCore::create_resume_rethrow(
-			ThrowStmt *throwStmt ) {
-		// return false;
-		Statement * result = new ReturnStmt(
-			new ConstantExpr( Constant::from_bool( false ) )
-			);
-		result->labels = throwStmt->labels;
-		delete throwStmt;
-		return result;
-	}
-
 	// TryStmt Mutation Helpers
 
-	CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+	CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
 		CompoundStmt * block = tryStmt->get_block();
 		tryStmt->set_block( nullptr );
@@ -263,5 +316,5 @@
 	}
 
-	FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+	FunctionDecl * TryMutatorCore::create_try_wrapper(
 			CompoundStmt *body ) {
 
@@ -270,5 +323,5 @@
 	}
 
-	FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+	FunctionDecl * TryMutatorCore::create_terminate_catch(
 			CatchList &handlers ) {
 		std::list<CaseStmt *> handler_wrappers;
@@ -350,5 +403,5 @@
 	// Create a single check from a moddified handler.
 	// except_obj is referenced, modded_handler will be freed.
-	CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+	CompoundStmt * TryMutatorCore::create_single_matcher(
 			DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
 		// {
@@ -388,5 +441,5 @@
 	}
 
-	FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+	FunctionDecl * TryMutatorCore::create_terminate_match(
 			CatchList &handlers ) {
 		// int match(exception * except) {
@@ -425,5 +478,5 @@
 	}
 
-	CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+	CompoundStmt * TryMutatorCore::create_terminate_caller(
 			FunctionDecl * try_wrapper,
 			FunctionDecl * terminate_catch,
@@ -443,5 +496,5 @@
 	}
 
-	FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+	FunctionDecl * TryMutatorCore::create_resume_handler(
 			CatchList &handlers ) {
 		// bool handle(exception * except) {
@@ -480,5 +533,5 @@
 	}
 
-	CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+	CompoundStmt * TryMutatorCore::create_resume_wrapper(
 			Statement * wraps,
 			FunctionDecl * resume_handler ) {
@@ -524,5 +577,5 @@
 	}
 
-	FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+	FunctionDecl * TryMutatorCore::create_finally_wrapper(
 			TryStmt * tryStmt ) {
 		// void finally() { <finally code> }
@@ -537,8 +590,8 @@
 	}
 
-	ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+	ObjectDecl * TryMutatorCore::create_finally_hook(
 			FunctionDecl * finally_wrapper ) {
 		// struct __cfaehm_cleanup_hook __finally_hook
-		//   	__attribute__((cleanup( finally_wrapper )));
+		//   	__attribute__((cleanup( `finally_wrapper` )));
 
 		// Make Cleanup Attribute.
@@ -565,8 +618,7 @@
 
 	// Visiting/Mutating Functions
-	void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
+	void TryMutatorCore::premutate( CatchStmt *catchStmt ) {
 		// Validate the Statement's form.
-		ObjectDecl * decl =
-			dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+		ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
 		if ( decl && true /* check decl->get_type() */ ) {
 			// Pass.
@@ -589,5 +641,5 @@
 	}
 
-	void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+	void TryMutatorCore::premutate( StructDecl *structDecl ) {
 		if ( !structDecl->has_body() ) {
 			// Skip children?
@@ -604,35 +656,12 @@
 			hook_decl = structDecl;
 		}
-		// Later we might get the exception type as well.
-	}
-
-	Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
-		assert( except_decl );
-
-		// Ignoring throwStmt->get_target() for now.
-		if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
-			if ( throwStmt->get_expr() ) {
-				return create_terminate_throw( throwStmt );
-			} else if ( TerHandler == cur_context ) {
-				return create_terminate_rethrow( throwStmt );
-			} else {
-				abort("Invalid throw in %s at %i\n",
-					throwStmt->location.filename.c_str(),
-					throwStmt->location.first_line);
-			}
-		} else {
-			if ( throwStmt->get_expr() ) {
-				return create_resume_throw( throwStmt );
-			} else if ( ResHandler == cur_context ) {
-				return create_resume_rethrow( throwStmt );
-			} else {
-				abort("Invalid throwResume in %s at %i\n",
-					throwStmt->location.filename.c_str(),
-					throwStmt->location.first_line);
-			}
-		}
-	}
-
-	Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+	}
+
+	Statement * TryMutatorCore::postmutate( ThrowStmt * ) {
+		// All throws should be removed by this point.
+		assert( false );
+	}
+
+	Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
 		assert( except_decl );
 		assert( node_decl );
@@ -688,7 +717,12 @@
 	}
 
-	void translateEHM( std::list< Declaration *> & translationUnit ) {
-		PassVisitor<ExceptionMutatorCore> translator;
+	void translateThrows( std::list< Declaration *> & translationUnit ) {
+		PassVisitor<ThrowMutatorCore> translator;
 		mutateAll( translationUnit, translator );
 	}
+
+	void translateTries( std::list< Declaration *> & translationUnit ) {
+		PassVisitor<TryMutatorCore> translator;
+		mutateAll( translationUnit, translator );
+	}
 }
Index: src/ControlStruct/ExceptTranslate.h
===================================================================
--- src/ControlStruct/ExceptTranslate.h	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ src/ControlStruct/ExceptTranslate.h	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -9,7 +9,7 @@
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:19:23 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus May 19 11:47:00 2020
+// Update Count     : 5
 //
 
@@ -21,7 +21,14 @@
 
 namespace ControlStruct {
-	void translateEHM( std::list< Declaration *> & translationUnit );
-	// Converts exception handling structures into their underlying C code.  Translation does use the exception
-	// handling header, make sure it is visible wherever translation occurs.
+	void translateThrows( std::list< Declaration *> & translationUnit );
+	/* Replaces all throw & throwResume statements with function calls.
+	 * These still need to be resolved, so call this before the reslover.
+	 */
+
+	void translateTries( std::list< Declaration *> & translationUnit );
+	/* Replaces all try blocks (and their many clauses) with function definitions and calls.
+	 * This uses the exception built-ins to produce typed output and should take place after
+	 * the resolver.
+	 */
 }
 
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ src/main.cc	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -9,7 +9,7 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:33:50 2020
-// Update Count     : 633
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 19 12:03:00 2020
+// Update Count     : 634
 //
 
@@ -312,4 +312,5 @@
 		} // if
 
+		PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
 		PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
 		PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
@@ -354,5 +355,5 @@
 		PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
-		PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+		PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 
 		PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
Index: tests/exceptions/conditional.cfa
===================================================================
--- tests/exceptions/conditional.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/conditional.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -56,5 +56,5 @@
 
 	try {
-		throw &exc;
+		throw exc;
 	} catch (num_error * error ; 3 == error->virtual_table->code( error )) {
 		caught_num_error(3, error);
@@ -64,5 +64,5 @@
 
 	try {
-		throwResume &exc;
+		throwResume exc;
 	} catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
 		caught_num_error(3, error);
Index: tests/exceptions/data-except.cfa
===================================================================
--- tests/exceptions/data-except.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/data-except.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -28,5 +28,5 @@
 
 	try {
-		throw &except;
+		throw except;
 	} catch (paired * exc) {
 		printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
@@ -37,5 +37,5 @@
 
 	try {
-		throwResume &except;
+		throwResume except;
 	} catchResume (paired * exc) {
 		printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
Index: tests/exceptions/finally.cfa
===================================================================
--- tests/exceptions/finally.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/finally.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -12,5 +12,5 @@
 		try {
 			printf("termination throw\n");
-			throw &exc;
+			throw exc;
 		} finally {
 			loud_exit a = "termination inner finally";
@@ -28,5 +28,5 @@
 		try {
 			printf("resumption throw\n");
-			throwResume &exc;
+			throwResume exc;
 		} finally {
 			loud_exit a = "resumption inner finally";
Index: tests/exceptions/interact.cfa
===================================================================
--- tests/exceptions/interact.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/interact.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -10,5 +10,5 @@
 	// Resume falls back to terminate.
 	try {
-		throwResume &(star){};
+		throwResume (star){};
 	} catch (star *) {
 		printf("caught as termination\n");
@@ -17,5 +17,5 @@
 	try {
 		loud_region a = "try block with resume throw";
-		throwResume &(star){};
+		throwResume (star){};
 	} catch (star *) {
 		printf("caught as termination\n");
@@ -29,5 +29,5 @@
 	try {
 		try {
-			throw &(star){};
+			throw (star){};
 		} catchResume (star *) {
 			printf("resume catch on terminate\n");
@@ -43,5 +43,5 @@
 	try {
 		try {
-			throwResume &(star){};
+			throwResume (star){};
 		} catch (star *) {
 			printf("terminate catch on resume\n");
@@ -58,5 +58,5 @@
 		try {
 			try {
-				throw &(star){};
+				throw (star){};
 			} catchResume (star *) {
 				printf("inner resume catch (error)\n");
@@ -64,5 +64,5 @@
 		} catch (star * error) {
 			printf("termination catch, will resume\n");
-			throwResume error;
+			throwResume *error;
 		}
 	} catchResume (star *) {
@@ -75,5 +75,5 @@
 		try {
 			try {
-				throwResume &(star){};
+				throwResume (star){};
 			} catch (star *) {
 				printf("inner termination catch\n");
@@ -81,5 +81,5 @@
 		} catchResume (star * error) {
 			printf("resumption catch, will terminate\n");
-			throw error;
+			throw *error;
 		}
 	} catch (star *) {
@@ -94,10 +94,10 @@
 				try {
 					printf("throwing resume moon\n");
-					throwResume &(moon){};
+					throwResume (moon){};
 				} catch (star *) {
 					printf("termination catch\n");
 				}
 				printf("throwing resume star\n");
-				throwResume &(star){};
+				throwResume (star){};
 			} catchResume (star *) {
 				printf("resumption star catch\n");
@@ -105,5 +105,5 @@
 		} catchResume (moon *) {
 			printf("resumption moon catch, will terminate\n");
-			throw &(star){};
+			throw (star){};
 		}
 	} catchResume (star *) {
Index: tests/exceptions/resume.cfa
===================================================================
--- tests/exceptions/resume.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/resume.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -14,5 +14,5 @@
 		loud_exit a = "simple try clause";
 		printf("simple throw\n");
-		throwResume &(zen){};
+		throwResume (zen){};
 		printf("end of try clause\n");
 	} catchResume (zen * error) {
@@ -24,5 +24,5 @@
 	// Throw catch-all test.
 	try {
-		throwResume &(zen){};
+		throwResume (zen){};
 	} catchResume (exception_t * error) {
 		printf("catch-all\n");
@@ -33,5 +33,5 @@
 	try {
 		printf("throwing child exception\n");
-		throwResume &(moment_of){};
+		throwResume (moment_of){};
 	} catchResume (zen *) {
 		printf("inner parent match\n");
@@ -44,5 +44,5 @@
 	try {
 		try {
-			throwResume &(yin){};
+			throwResume (yin){};
 		} catchResume (zen *) {
 			printf("caught yin as zen\n");
@@ -60,5 +60,5 @@
 			loud_exit a = "rethrow inner try";
 			printf("rethrow inner try\n");
-			throwResume &(zen){};
+			throwResume (zen){};
 		} catchResume (zen *) {
 			loud_exit a = "rethrowing catch clause";
@@ -75,8 +75,8 @@
 	try {
 		try {
-			throwResume &(yin){};
+			throwResume (yin){};
 		} catchResume (yin *) {
 			printf("caught yin, will throw yang\n");
-			throwResume &(yang){};
+			throwResume (yang){};
 		} catchResume (yang *) {
 			printf("caught exception from same try\n");
@@ -91,10 +91,10 @@
 		try {
 			printf("throwing first exception\n");
-			throwResume &(yin){};
+			throwResume (yin){};
 		} catchResume (yin *) {
 			printf("caught first exception\n");
 			try {
 				printf("throwing second exception\n");
-				throwResume &(yang){};
+				throwResume (yang){};
 			} catchResume (yang *) {
 				printf("caught second exception\n");
@@ -112,10 +112,10 @@
 	try {
 		try {
-			throwResume &(zen){};
-			throwResume &(zen){};
+			throwResume (zen){};
+			throwResume (zen){};
 		} catchResume (zen *) {
 			printf("inner catch\n");
 		}
-		throwResume &(zen){};
+		throwResume (zen){};
 	} catchResume (zen *) {
 		printf("outer catch\n");
Index: tests/exceptions/terminate.cfa
===================================================================
--- tests/exceptions/terminate.cfa	(revision 7d6e01d4da997a6b00da903140b2ca630de5d766)
+++ tests/exceptions/terminate.cfa	(revision 046a8903d149ffd7aa25c33fdf767b8e68ffaaca)
@@ -14,5 +14,5 @@
 		loud_exit a = "simple try clause";
 		printf("simple throw\n");
-		throw &(zen){};
+		throw (zen){};
 		printf("end of try clause\n");
 	} catch (zen * error) {
@@ -24,5 +24,5 @@
 	// Throw catch-all test.
 	try {
-		throw &(zen){};
+		throw (zen){};
 	} catch (exception_t * error) {
 		printf("catch-all\n");
@@ -33,5 +33,5 @@
 	try {
 		printf("throwing child exception\n");
-		throw &(moment_of){};
+		throw (moment_of){};
 	} catch (zen *) {
 		printf("inner parent match\n");
@@ -44,5 +44,5 @@
 	try {
 		try {
-			throw &(yin){};
+			throw (yin){};
 		} catch (zen *) {
 			printf("caught yin as zen\n");
@@ -60,5 +60,5 @@
 			loud_exit a = "rethrow inner try";
 			printf("rethrow inner try\n");
-			throw &(zen){};
+			throw (zen){};
 		} catch (zen *) {
 			loud_exit a = "rethrowing catch clause";
@@ -75,8 +75,8 @@
 	try {
 		try {
-			throw &(yin){};
+			throw (yin){};
 		} catch (yin *) {
 			printf("caught yin, will throw yang\n");
-			throw &(yang){};
+			throw (yang){};
 		} catch (yang *) {
 			printf("caught exception from same try\n");
@@ -91,10 +91,10 @@
 		try {
 			printf("throwing first exception\n");
-			throw &(yin){};
+			throw (yin){};
 		} catch (yin *) {
 			printf("caught first exception\n");
 			try {
 				printf("throwing second exception\n");
-				throw &(yang){};
+				throw (yang){};
 			} catch (yang *) {
 				printf("caught second exception\n");
@@ -112,10 +112,10 @@
 	try {
 		try {
-			throw &(zen){};
-			throw &(zen){};
+			throw (zen){};
+			throw (zen){};
 		} catch (zen *) {
 			printf("inner catch\n");
 		}
-		throw &(zen){};
+		throw (zen){};
 	} catch (zen *) {
 		printf("outer catch\n");