Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/ControlStruct/ExceptTranslate.cc	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -10,5 +10,5 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Jun 29 15:18:00 2017
+// Last Modified On : Fri Jun 30 13:30:00 2017
 // Update Count     : 1
 //
@@ -22,5 +22,5 @@
 #include "SynTree/Attribute.h"
 
-namespace ControlFlow {
+namespace ControlStruct {
 
 	// This (large) section could probably be moved out of the class
@@ -29,6 +29,6 @@
 	// Type(Qualifiers &, false, std::list<Attribute *> &)
 
-	// void (*function)()
-	static FunctionType void_func_t(Type::Qualifiers(), false);
+	// void (*function)();
+	static FunctionType try_func_t(Type::Qualifiers(), false);
 	// void (*function)(int, exception);
 	static FunctionType catch_func_t(Type::Qualifiers(), false);
@@ -37,4 +37,6 @@
 	// bool (*function)(exception);
 	static FunctionType handle_func_t(Type::Qualifiers(), false);
+	// void (*function)(__attribute__((unused)) void *);
+	static FunctionType finally_func_t(Type::Qualifiers(), false);
 
 	static void init_func_types() {
@@ -48,7 +50,7 @@
 			LinkageSpec::Cforall,
 			/*bitfieldWidth*/ NULL,
-			new BasicType(emptyQualifiers, BasicType::UnsignedInt),
+			new BasicType( emptyQualifiers, BasicType::SignedInt ),
 			/*init*/ NULL
-		);
+			);
 		ObjectDecl exception_obj(
 			"__exception_inst",
@@ -56,7 +58,10 @@
 			LinkageSpec::Cforall,
 			/*bitfieldWidth*/ NULL,
-			new BasicType(emptyQualifiers, BasicType::UnsignedInt),
+			new PointerType(
+				emptyQualifiers,
+				new BasicType( emptyQualifiers, BasicType::SignedInt )
+				),
 			/*init*/ NULL
-		);
+			);
 		ObjectDecl bool_obj(
 			"__ret_bool",
@@ -66,12 +71,27 @@
 			new BasicType(emptyQualifiers, BasicType::Bool),
 			/*init*/ NULL
-		);
-
-		catch_func_t.get_parameters().push_back(index_obj.clone());
-		catch_func_t.get_parameters().push_back(exception_obj.clone());
-		match_func_t.get_returnVals().push_back(index_obj.clone());
-		match_func_t.get_parameters().push_back(exception_obj.clone());
-		handle_func_t.get_returnVals().push_back(bool_obj.clone());
-		handle_func_t.get_parameters().push_back(exception_obj.clone());
+			);
+		ObjectDecl voidptr_obj(
+			"__hook",
+			Type::StorageClasses(),
+			LinkageSpec::Cforall,
+			NULL,
+			new PointerType(
+				emptyQualifiers,
+				new VoidType(
+					emptyQualifiers
+					),
+				std::list<Attribute *>{new Attribute("unused")}
+				),
+			NULL
+			);
+
+		catch_func_t.get_parameters().push_back( index_obj.clone() );
+		catch_func_t.get_parameters().push_back( exception_obj.clone() );
+		match_func_t.get_returnVals().push_back( index_obj.clone() );
+		match_func_t.get_parameters().push_back( exception_obj.clone() );
+		handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+		handle_func_t.get_parameters().push_back( exception_obj.clone() );
+		finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
 
 		init_complete = true;
@@ -114,13 +134,28 @@
 	// ThrowStmt Mutation Helpers
 
-	Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
-		// __throw_terminate( EXPR );
-		UntypedExpr * call = new UntypedExpr( new NameExpr(
-			"__cfaehm__throw_termination" ) );
-		call->get_args().push_back( throwStmt->get_expr() );
-		Statement * result = new ExprStmt( throwStmt->get_labels(), call );
+	Statement * create_given_throw(
+			const char * throwFunc, ThrowStmt * throwStmt ) {
+		// { int NAME = EXPR; throwFunc( &NAME ); }
+		CompoundStmt * result = new CompoundStmt( noLabels );
+		ObjectDecl * local = new ObjectDecl(
+			"__local_exception_copy",
+			Type::StorageClasses(),
+			LinkageSpec::Cforall,
+			NULL,
+			new BasicType( emptyQualifiers, BasicType::SignedInt ),
+			new SingleInit( throwStmt->get_expr() )
+			);
+		appendDeclStmt( result, local );
+		UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+		call->get_args().push_back( new AddressExpr( nameOf( local ) ) );
+		result->push_back( new ExprStmt( throwStmt->get_labels(), call ) );
 		throwStmt->set_expr( nullptr );
 		delete throwStmt;
 		return result;
+	}
+
+	Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
+		// { int NAME = EXPR; __throw_terminate( &NAME ); }
+		return create_given_throw( "__cfaehm__throw_termination", throwStmt );
 	}
 	Statement * create_terminate_rethrow( ThrowStmt *throwStmt ) {
@@ -136,11 +171,5 @@
 	Statement * create_resume_throw( ThrowStmt *throwStmt ) {
 		// __throw_resume( EXPR );
-		UntypedExpr * call = new UntypedExpr( new NameExpr(
-			"__cfaehm__throw_resumption" ) );
-		call->get_args().push_back( throwStmt->get_expr() );
-		Statement * result = new ExprStmt( throwStmt->get_labels(), call );
-		throwStmt->set_expr( nullptr );
-		delete throwStmt;
-		return result;
+		return create_given_throw( "__cfaehm__throw_resumption", throwStmt );
 	}
 	Statement * create_resume_rethrow( ThrowStmt *throwStmt ) {
@@ -164,5 +193,5 @@
 
 		return new FunctionDecl( "try", Type::StorageClasses(),
-			LinkageSpec::Cforall, void_func_t.clone(), body );
+			LinkageSpec::Cforall, try_func_t.clone(), body );
 	}
 
@@ -235,5 +264,11 @@
 			std::list<Expression *> args;
 			args.push_back( number );
-			args.push_back( nameOf( except_obj ) );
+
+			std::list<Expression *> rhs_args;
+			rhs_args.push_back( nameOf( except_obj ) );
+			Expression * rhs = new UntypedExpr(
+				new NameExpr( "*?" ), rhs_args );
+			args.push_back( rhs );
+
 			cond = new UntypedExpr( new NameExpr( "?==?" /*???*/), args );
 		}
@@ -276,4 +311,7 @@
 			*it = nullptr;
 		}
+
+		body->push_back( new ReturnStmt( noLabels, new ConstantExpr(
+			Constant::from_int( 0 ) ) ) );
 
 		return new FunctionDecl("match", Type::StorageClasses(),
@@ -364,5 +402,5 @@
 		UntypedExpr *setup = new UntypedExpr( new NameExpr(
 			"__cfaehm__try_resume_setup" ) );
-		setup->get_args().push_back( nameOf( obj ) );
+		setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
 		setup->get_args().push_back( nameOf( resume_handler ) );
 
@@ -381,5 +419,5 @@
 
 		return new FunctionDecl("finally", Type::StorageClasses(),
-			LinkageSpec::Cforall, void_func_t.clone(), body);
+			LinkageSpec::Cforall, finally_func_t.clone(), body);
 	}
 
Index: src/ControlStruct/ExceptTranslate.h
===================================================================
--- src/ControlStruct/ExceptTranslate.h	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/ControlStruct/ExceptTranslate.h	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -10,6 +10,6 @@
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Jun 29 15:18:00 2017
-// Update Count     : 1
+// Last Modified On : Fri Jun 30 10:20:00 2017
+// Update Count     : 2
 //
 
@@ -20,5 +20,5 @@
 #include "SynTree/SynTree.h"
 
-namespace ControlFlow {
+namespace ControlStruct {
 	void translateEHM( std::list< Declaration *> & translationUnit );
 	/* Converts exception handling structures into their underlying C code.
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/Parser/parser.yy	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -9,7 +9,7 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep  1 20:22:55 2001
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 28 22:11:22 2017
-// Update Count     : 2414
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 30 15:38:00 2017
+// Update Count     : 2415
 //
 
@@ -104,4 +104,5 @@
 	std::string * str;
 	bool flag;
+	CatchStmt::Kind catch_kind;
 }
 
@@ -192,4 +193,5 @@
 %type<sn> switch_clause_list_opt		switch_clause_list			choose_clause_list_opt		choose_clause_list
 %type<sn> /* handler_list */			handler_clause				finally_clause
+%type<catch_kind> handler_key
 
 // declarations
@@ -958,17 +960,20 @@
 handler_clause:
 	// TEMPORARY, TEST EXCEPTIONS
-	CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
-		{ $$ = new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
-	| handler_clause CATCH '(' push push INTEGERconstant pop ')' compound_statement pop
-		{ $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
-
-	| CATCH '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = new StatementNode( build_catch( CatchStmt::Terminate, $5, nullptr, $8 ) ); }
-	| handler_clause CATCH '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Terminate, $6, nullptr, $9 ) ) ); }
-	| CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = new StatementNode( build_catch( CatchStmt::Resume, $5, nullptr, $8 ) ); }
-	| handler_clause CATCHRESUME '(' push push exception_declaration pop ')' compound_statement pop
-		{ $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( CatchStmt::Resume, $6, nullptr, $9 ) ) ); }
+	handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+		{ $$ = new StatementNode( build_catch( $1, nullptr, new ExpressionNode( build_constantInteger( *$5 ) ), $8 ) ); }
+	| handler_clause handler_key '(' push push INTEGERconstant pop ')' compound_statement pop
+		{ $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, nullptr, new ExpressionNode( build_constantInteger( *$6 ) ), $9 ) ) ); }
+
+	| handler_key '(' push push exception_declaration pop ')' compound_statement pop
+		{ $$ = new StatementNode( build_catch( $1, $5, nullptr, $8 ) ); }
+	| handler_clause handler_key '(' push push exception_declaration pop ')' compound_statement pop
+		{ $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, nullptr, $9 ) ) ); }
+	;
+
+handler_key:
+	CATCH
+		{ $$ = CatchStmt::Terminate; }
+	| CATCHRESUME
+		{ $$ = CatchStmt::Resume; }
 	;
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/ResolvExpr/Resolver.cc	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -70,4 +70,5 @@
 		virtual void visit( BranchStmt *branchStmt ) override;
 		virtual void visit( ReturnStmt *returnStmt ) override;
+		virtual void visit( ThrowStmt *throwStmt ) override;
 
 		virtual void visit( SingleInit *singleInit ) override;
@@ -366,4 +367,12 @@
 	}
 
+	void Resolver::visit( ThrowStmt *throwStmt ) {
+		if ( throwStmt->get_expr() ) {
+			Expression * wrapped = new CastExpr( throwStmt->get_expr(), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+			Expression * newExpr = findSingleExpression( wrapped, *this );
+			throwStmt->set_expr( newExpr );
+		}
+	}
+
 	template< typename T >
 	bool isCharType( T t ) {
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/SymTab/Indexer.cc	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -652,5 +652,5 @@
 			for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
 				// check for C decls with the same name, skipping those with a compatible type (by mangleName)
-				if ( decl->second->get_linkage() == LinkageSpec::C && decl->first != mangleName ) return true;
+				if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first != mangleName ) return true;
 			}
 		}
@@ -669,5 +669,5 @@
 				// check for C decls with the same name, skipping
 				// those with an incompatible type (by mangleName)
-				if ( decl->second->get_linkage() == LinkageSpec::C && decl->first == mangleName ) return true;
+				if ( ! LinkageSpec::isMangled( decl->second->get_linkage() ) && decl->first == mangleName ) return true;
 			}
 		}
@@ -724,5 +724,5 @@
 			// new definition shadows the autogenerated one, even at the same scope
 			return false;
-		} else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
+		} else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
 			// typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
 			// we should ignore outermost pointer qualifiers, except _Atomic?
@@ -765,5 +765,5 @@
 
 		// this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-		if ( decl->get_linkage() == LinkageSpec::C ) {
+		if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) {
 			// NOTE this is broken in Richard's original code in such a way that it never triggers (it
 			// doesn't check decls that have the same manglename, and all C-linkage decls are defined to
Index: src/libcfa/Makefile.am
===================================================================
--- src/libcfa/Makefile.am	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/libcfa/Makefile.am	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -50,5 +50,5 @@
 
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c}
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} exception.c
 
 # not all platforms support concurrency, add option do disable it
Index: src/libcfa/Makefile.in
===================================================================
--- src/libcfa/Makefile.in	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/libcfa/Makefile.in	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -102,5 +102,5 @@
 	containers/pair.c containers/result.c containers/vector.c \
 	concurrency/coroutine.c concurrency/thread.c \
-	concurrency/kernel.c concurrency/monitor.c \
+	concurrency/kernel.c concurrency/monitor.c exception.c \
 	concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
 	concurrency/invoke.c concurrency/preemption.c
@@ -126,5 +126,5 @@
 	libcfa_d_a-interpose.$(OBJEXT) \
 	libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
-	$(am__objects_3)
+	libcfa_d_a-exception.$(OBJEXT) $(am__objects_3)
 am_libcfa_d_a_OBJECTS = $(am__objects_4)
 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
@@ -136,5 +136,5 @@
 	containers/pair.c containers/result.c containers/vector.c \
 	concurrency/coroutine.c concurrency/thread.c \
-	concurrency/kernel.c concurrency/monitor.c \
+	concurrency/kernel.c concurrency/monitor.c exception.c \
 	concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
 	concurrency/invoke.c concurrency/preemption.c
@@ -158,5 +158,5 @@
 	libcfa_a-interpose.$(OBJEXT) \
 	libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
-	$(am__objects_7)
+	libcfa_a-exception.$(OBJEXT) $(am__objects_7)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -328,5 +328,5 @@
 libobjs = ${headers:=.o}
 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
-	$(am__append_4)
+	exception.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
 libcfa_a_CFLAGS = -nodebug -O2
@@ -514,4 +514,5 @@
 
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-exception.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-fstream.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-interpose.Po@am__quote@
@@ -524,4 +525,5 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-exception.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-fstream.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-interpose.Po@am__quote@
@@ -850,4 +852,11 @@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_d_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
 
+libcfa_d_a-exception.obj: exception.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-exception.Tpo -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-exception.Tpo $(DEPDIR)/libcfa_d_a-exception.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='exception.c' object='libcfa_d_a-exception.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+
 concurrency/libcfa_d_a-alarm.o: concurrency/alarm.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT concurrency/libcfa_d_a-alarm.o -MD -MP -MF concurrency/$(DEPDIR)/libcfa_d_a-alarm.Tpo -c -o concurrency/libcfa_d_a-alarm.o `test -f 'concurrency/alarm.c' || echo '$(srcdir)/'`concurrency/alarm.c
@@ -1143,4 +1152,11 @@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-monitor.obj `if test -f 'concurrency/monitor.c'; then $(CYGPATH_W) 'concurrency/monitor.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/monitor.c'; fi`
+
+libcfa_a-exception.obj: exception.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-exception.obj -MD -MP -MF $(DEPDIR)/libcfa_a-exception.Tpo -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-exception.Tpo $(DEPDIR)/libcfa_a-exception.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='exception.c' object='libcfa_a-exception.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-exception.obj `if test -f 'exception.c'; then $(CYGPATH_W) 'exception.c'; else $(CYGPATH_W) '$(srcdir)/exception.c'; fi`
 
 concurrency/libcfa_a-alarm.o: concurrency/alarm.c
Index: src/libcfa/exception.c
===================================================================
--- src/libcfa/exception.c	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/libcfa/exception.c	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -44,16 +44,16 @@
 // RESUMPTION ================================================================
 
-void __cfaehm__throw_resume(exception except) {
-
-	// DEBUG
-	printf("Throwing resumption exception %d\n", except);
-
-	struct __try_resume_node * original_head = shared_stack.current_resume;
-	struct __try_resume_node * current =
+void __cfaehm__throw_resumption(exception * except) {
+
+	// DEBUG
+	printf("Throwing resumption exception %d\n", *except);
+
+	struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
+	struct __cfaehm__try_resume_node * current =
 		(original_head) ? original_head->next : shared_stack.top_resume;
 
 	for ( ; current ; current = current->next) {
 		shared_stack.current_resume = current;
-		if (current->try_to_handle(except)) {
+		if (current->handler(except)) {
 			shared_stack.current_resume = original_head;
 			return;
@@ -61,9 +61,9 @@
 	}
 
-	printf("Unhandled exception %d\n", except);
+	printf("Unhandled exception %d\n", *except);
 	shared_stack.current_resume = original_head;
 
 	// Fall back to termination:
-	__cfaehm__throw_terminate(except);
+	__cfaehm__throw_termination(except);
 	// TODO: Default handler for resumption.
 }
@@ -73,12 +73,12 @@
  * after the node is built but before it is made the top node.
  */
-void __try_resume_setup(struct __try_resume_node * node,
-                        bool (*handler)(exception except)) {
+void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
+                        int (*handler)(exception * except)) {
 	node->next = shared_stack.top_resume;
-	node->try_to_handle = handler;
+	node->handler = handler;
 	shared_stack.top_resume = node;
 }
 
-void __try_resume_cleanup(struct __try_resume_node * node) {
+void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
 	shared_stack.top_resume = node->next;
 }
@@ -111,10 +111,10 @@
 }
 
-void __cfaehm__throw_terminate( int val ) {
+void __cfaehm__throw_termination( exception * val ) {
 	// Store the current exception
-	shared_stack.current_exception = val;
-
-	// DEBUG
-	printf("Throwing termination exception %d\n", val);
+	shared_stack.current_exception = *val;
+
+	// DEBUG
+	printf("Throwing termination exception %d\n", *val);
 
 	// Call stdlibc to raise the exception
@@ -147,9 +147,9 @@
 
 // Nesting this the other way would probably be faster.
-void __cfaehm__rethrow_terminate(void) {
+void __cfaehm__rethrow_termination(void) {
 	// DEBUG
 	printf("Rethrowing termination exception\n");
 
-	__cfaehm__throw_terminate(shared_stack.current_exception);
+	__cfaehm__throw_termination(&shared_stack.current_exception);
 }
 
@@ -322,7 +322,7 @@
 // for details
 __attribute__((noinline))
-void __try_terminate(void (*try_block)(),
-		void (*catch_block)(int index, exception except),
-		__attribute__((unused)) int (*match_block)(exception except)) {
+void __cfaehm__try_terminate(void (*try_block)(),
+		void (*catch_block)(int index, exception * except),
+		__attribute__((unused)) int (*match_block)(exception * except)) {
 	//! volatile int xy = 0;
 	//! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
@@ -364,5 +364,5 @@
 	// Exception handler
 	catch_block(shared_stack.current_handler_index,
-	            shared_stack.current_exception);
+	            &shared_stack.current_exception);
 }
 
@@ -384,11 +384,11 @@
 	// Body uses language specific data and therefore could be modified arbitrarily
 	".LLSDACSBCFA2:\n"						// BODY start
-	"	.uleb128 .TRYSTART-__try_terminate\n"		// Handled area start  (relative to start of function)
+	"	.uleb128 .TRYSTART-__cfaehm__try_terminate\n"		// Handled area start  (relative to start of function)
 	"	.uleb128 .TRYEND-.TRYSTART\n"				// Handled area length
-	"	.uleb128 .CATCH-__try_terminate\n"				// Hanlder landing pad adress  (relative to start of function)
+	"	.uleb128 .CATCH-__cfaehm__try_terminate\n"				// Hanlder landing pad adress  (relative to start of function)
 	"	.uleb128 1\n"						// Action code, gcc seems to use always 0
 	".LLSDACSECFA2:\n"						// BODY end
 	"	.text\n"							// TABLE footer
-	"	.size	__try_terminate, .-__try_terminate\n"
+	"	.size	__cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
 	"	.ident	\"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //	"	.section	.note.GNU-stack,\"x\",@progbits\n"
Index: src/libcfa/exception.h
===================================================================
--- src/libcfa/exception.h	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/libcfa/exception.h	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -38,13 +38,13 @@
 // Data structure creates a list of resume handlers.
 struct __cfaehm__try_resume_node {
-    __cfaehm__try_resume_node * next;
+    struct __cfaehm__try_resume_node * next;
     int (*handler)(exception * except);
 };
 
 void __cfaehm__try_resume_setup(
-    __cfaehm__try_resume_node * node,
+    struct __cfaehm__try_resume_node * node,
     int (*handler)(exception * except));
 void __cfaehm__try_resume_cleanup(
-    __cfaehm__try_resume_node * node);
+    struct __cfaehm__try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.
Index: src/libcfa/lsda.h
===================================================================
--- src/libcfa/lsda.h	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
+++ src/libcfa/lsda.h	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -0,0 +1,262 @@
+//This code was stolen from gcc to read exception tables
+
+
+/* If using C++, references to abort have to be qualified with std::.  */
+#if __cplusplus
+#define __gxx_abort std::abort
+#else
+#define __gxx_abort abort
+#endif
+
+/* Pointer encodings, from dwarf2.h.  */
+#define DW_EH_PE_absptr         0x00
+#define DW_EH_PE_omit           0xff
+
+#define DW_EH_PE_uleb128        0x01
+#define DW_EH_PE_udata2         0x02
+#define DW_EH_PE_udata4         0x03
+#define DW_EH_PE_udata8         0x04
+#define DW_EH_PE_sleb128        0x09
+#define DW_EH_PE_sdata2         0x0A
+#define DW_EH_PE_sdata4         0x0B
+#define DW_EH_PE_sdata8         0x0C
+#define DW_EH_PE_signed         0x08
+
+#define DW_EH_PE_pcrel          0x10
+#define DW_EH_PE_textrel        0x20
+#define DW_EH_PE_datarel        0x30
+#define DW_EH_PE_funcrel        0x40
+#define DW_EH_PE_aligned        0x50
+
+#define DW_EH_PE_indirect	0x80
+
+
+
+int handler_found = 0;
+
+/* Given an encoding, return the number of bytes the format occupies.
+This is only defined for fixed-size encodings, and so does not
+include leb128.  */
+static unsigned int size_of_encoded_value (unsigned char encoding) __attribute__ ((unused));
+
+static unsigned int size_of_encoded_value (unsigned char encoding)
+{
+	if (encoding == DW_EH_PE_omit) return 0;
+
+	switch (encoding & 0x07) {
+		case DW_EH_PE_absptr: return sizeof (void *);
+		case DW_EH_PE_udata2: return 2;
+		case DW_EH_PE_udata4: return 4;
+		case DW_EH_PE_udata8: return 8;
+	}
+	__gxx_abort ();
+}
+
+/* Given an encoding and an _Unwind_Context, return the base to which
+the encoding is relative.  This base may then be passed to
+read_encoded_value_with_base for use when the _Unwind_Context is
+not available.  */
+static _Unwind_Ptr base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context)
+{
+	if (encoding == DW_EH_PE_omit) return 0;
+
+	switch (encoding & 0x70) {
+		case DW_EH_PE_absptr:
+		case DW_EH_PE_pcrel:
+		case DW_EH_PE_aligned:
+			return 0;
+		case DW_EH_PE_textrel:
+			return _Unwind_GetTextRelBase (context);
+		case DW_EH_PE_datarel:
+			return _Unwind_GetDataRelBase (context);
+		case DW_EH_PE_funcrel:
+			return _Unwind_GetRegionStart (context);
+	}
+	__gxx_abort ();
+}
+
+/* Read an unsigned leb128 value from P, store the value in VAL, return
+P incremented past the value.  We assume that a word is large enough to
+hold any value so encoded; if it is smaller than a pointer on some target,
+pointers should not be leb128 encoded on that target.  */
+static const unsigned char * read_uleb128 (const unsigned char *p, _uleb128_t *val)
+{
+	unsigned int shift = 0;
+	unsigned char byte;
+	_uleb128_t result;
+
+	result = 0;
+	do
+	{
+		byte = *p++;
+		result |= ((_uleb128_t)byte & 0x7f) << shift;
+		shift += 7;
+	}
+	while (byte & 0x80);
+
+	*val = result;
+	return p;
+}
+
+/* Similar, but read a signed leb128 value.  */
+static const unsigned char * read_sleb128 (const unsigned char *p, _sleb128_t *val)
+{
+	unsigned int shift = 0;
+	unsigned char byte;
+	_uleb128_t result;
+
+	result = 0;
+	do
+	{
+		byte = *p++;
+		result |= ((_uleb128_t)byte & 0x7f) << shift;
+		shift += 7;
+	}
+	while (byte & 0x80);
+
+	/* Sign-extend a negative value.  */
+	if (shift < 8 * sizeof(result) && (byte & 0x40) != 0) result |= -(((_uleb128_t)1L) << shift);
+
+	*val = (_sleb128_t) result;
+	return p;
+}
+
+/* Load an encoded value from memory at P.  The value is returned in VAL;
+The function returns P incremented past the value.  BASE is as given
+by base_of_encoded_value for this encoding in the appropriate context.  */
+
+static const unsigned char * read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base, const unsigned char *p, _Unwind_Ptr *val)
+{
+	union unaligned
+	{
+		void *ptr;
+		unsigned u2 __attribute__ ((mode (HI)));
+		unsigned u4 __attribute__ ((mode (SI)));
+		unsigned u8 __attribute__ ((mode (DI)));
+		signed s2 __attribute__ ((mode (HI)));
+		signed s4 __attribute__ ((mode (SI)));
+		signed s8 __attribute__ ((mode (DI)));
+	} __attribute__((__packed__));
+
+	const union unaligned *u = (const union unaligned *) p;
+	_Unwind_Internal_Ptr result;
+
+	if (encoding == DW_EH_PE_aligned)
+	{
+		_Unwind_Internal_Ptr a = (_Unwind_Internal_Ptr) p;
+		a = (a + sizeof (void *) - 1) & - sizeof(void *);
+		result = *(_Unwind_Internal_Ptr *) a;
+		p = (const unsigned char *) (_Unwind_Internal_Ptr) (a + sizeof (void *));
+	}
+	else
+	{
+		switch (encoding & 0x0f)
+		{
+			case DW_EH_PE_absptr:
+				result = (_Unwind_Internal_Ptr) u->ptr;
+				p += sizeof (void *);
+				break;
+			case DW_EH_PE_uleb128:
+			{
+				_uleb128_t tmp;
+				p = read_uleb128 (p, &tmp);
+				result = (_Unwind_Internal_Ptr) tmp;
+			}
+			break;
+
+			case DW_EH_PE_sleb128:
+			{
+				_sleb128_t tmp;
+				p = read_sleb128 (p, &tmp);
+				result = (_Unwind_Internal_Ptr) tmp;
+			}
+			break;
+
+			case DW_EH_PE_udata2:
+				result = u->u2;
+				p += 2;
+				break;
+			case DW_EH_PE_udata4:
+				result = u->u4;
+				p += 4;
+				break;
+			case DW_EH_PE_udata8:
+				result = u->u8;
+				p += 8;
+				break;
+			case DW_EH_PE_sdata2:
+				result = u->s2;
+				p += 2;
+				break;
+			case DW_EH_PE_sdata4:
+				result = u->s4;
+				p += 4;
+				break;
+			case DW_EH_PE_sdata8:
+				result = u->s8;
+				p += 8;
+				break;
+			default:
+				__gxx_abort();
+		}
+
+		if (result != 0)
+		{
+			result += ((encoding & 0x70) == DW_EH_PE_pcrel ? (_Unwind_Internal_Ptr) u : base);
+			
+			if (encoding & DW_EH_PE_indirect) result = *(_Unwind_Internal_Ptr *) result;
+		}
+	}
+
+	*val = result;
+	return p;
+}
+
+/* Like read_encoded_value_with_base, but get the base from the context
+rather than providing it directly.  */
+static inline const unsigned char * read_encoded_value (struct _Unwind_Context *context, unsigned char encoding, const unsigned char *p, _Unwind_Ptr *val)
+{
+	return read_encoded_value_with_base (encoding, base_of_encoded_value (encoding, context), p, val);
+}
+
+typedef struct
+{
+	_Unwind_Ptr Start;
+	_Unwind_Ptr LPStart;
+	_Unwind_Ptr ttype_base;
+	const unsigned char *TType;
+	const unsigned char *action_table;
+	unsigned char ttype_encoding;
+	unsigned char call_site_encoding;
+} lsda_header_info;
+
+static const unsigned char * parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p, lsda_header_info *info)
+{
+	_uleb128_t tmp;
+	unsigned char lpstart_encoding;
+
+	info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
+
+	/* Find @LPStart, the base to which landing pad offsets are relative.  */
+	lpstart_encoding = *p++;
+	if (lpstart_encoding != DW_EH_PE_omit) p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
+
+	else info->LPStart = info->Start;
+
+	/* Find @TType, the base of the handler and exception spec type data.  */
+	info->ttype_encoding = *p++;
+	if (info->ttype_encoding != DW_EH_PE_omit)
+	{
+		p = read_uleb128 (p, &tmp);
+		info->TType = p + tmp;
+	}
+	else info->TType = 0;
+
+	/* The encoding and length of the call-site table; the action table
+	immediately follows.  */
+	info->call_site_encoding = *p++;
+	p = read_uleb128 (p, &tmp);
+	info->action_table = p + tmp;
+
+	return p;
+}
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/main.cc	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -39,4 +39,5 @@
 #include "CodeTools/TrackLoc.h"
 #include "ControlStruct/Mutate.h"
+#include "ControlStruct/ExceptTranslate.h"
 #include "SymTab/Validate.h"
 #include "ResolvExpr/AlternativePrinter.h"
@@ -290,4 +291,7 @@
 		Tuples::expandUniqueExpr( translationUnit );
 
+		OPTPRINT( "translateEHM" );
+		ControlStruct::translateEHM( translationUnit );
+
 		OPTPRINT( "convertSpecializations" ) // needs to happen before tuple types are expanded
 		GenPoly::convertSpecializations( translationUnit );
Index: src/prelude/Makefile.am
===================================================================
--- src/prelude/Makefile.am	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/prelude/Makefile.am	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -23,4 +23,6 @@
 noinst_DATA = ../libcfa/libcfa-prelude.c
 
+CC = ${abs_top_srcdir}/src/driver/cfa
+
 $(DEPDIR) :
 	mkdir $(DEPDIR)
@@ -45,6 +47,6 @@
 
 # create forward declarations for cfa builtins
-builtins.cf : builtins.c
-	${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+builtins.cf : builtins.c ${CC}
+	${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
 	${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 
Index: src/prelude/Makefile.in
===================================================================
--- src/prelude/Makefile.in	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ src/prelude/Makefile.in	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -95,5 +95,5 @@
 AWK = @AWK@
 BACKEND_CC = @BACKEND_CC@
-CC = @CC@
+CC = ${abs_top_srcdir}/src/driver/cfa
 CCAS = @CCAS@
 CCASDEPMODE = @CCASDEPMODE@
@@ -444,6 +444,6 @@
 
 # create forward declarations for cfa builtins
-builtins.cf : builtins.c
-	${AM_V_GEN}@BACKEND_CC@ -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+builtins.cf : builtins.c ${CC}
+	${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
 	${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
 
Index: src/tests/except-0.c
===================================================================
--- src/tests/except-0.c	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
+++ src/tests/except-0.c	(revision 307a732f5fa4b97b19f405fc215fcd76f473e3a1)
@@ -0,0 +1,219 @@
+// Draft of tests for exception handling.
+
+#include <stdio.h>
+#include <stdbool.h>
+
+struct signal_exit {
+	const char * area;
+};
+
+void ?{}(signal_exit * this, const char * area) {
+	this->area = area;
+}
+
+void ^?{}(signal_exit * this) {
+	printf("Exiting: %s\n", this->area);
+//	sout | "Exiting:" | this->area | endl;
+}
+
+void terminate(int except_value) {
+	signal_exit a = {"terminate function"};
+	throw except_value;
+	printf("terminate returned\n");
+}
+
+void resume(int except_value) {
+	signal_exit a = {"resume function"};
+	throwResume except_value;
+	printf("resume returned\n");
+}
+
+// Termination Test: Two handlers: no catch, catch
+void bar() {
+	signal_exit a = {"bar function"};
+	try {
+		terminate(4);
+	} catch (3) {
+		printf("bar caught exception 3.\n");
+	}
+}
+
+void foo() {
+	signal_exit a = {"foo function"};
+	try {
+		bar();
+	} catch (4) {
+		printf("foo caught exception 4.\n");
+	} catch (2) {
+		printf("foo caught exception 2.\n");
+	}
+}
+
+// Resumption Two Handler Test: no catch, catch.
+void beta() {
+	signal_exit a = {"beta function"};
+	try {
+		resume(4);
+	} catchResume (3) {
+		printf("beta caught exception 3\n");
+	}
+}
+
+void alpha() {
+	signal_exit a = {"alpha function"};
+	try {
+		beta();
+	} catchResume (2) {
+		printf("alpha caught exception 2\n");
+	} catchResume (4) {
+		printf("alpha caught exception 4\n");
+	}
+}
+
+// Finally Test:
+void farewell(bool jump) {
+	try {
+		if (jump) {
+			printf("jump out of farewell\n");
+			goto endoffunction;
+		} else {
+			printf("walk out of farewell\n");
+		}
+	} finally {
+		printf("See you next time\n");
+	}
+	endoffunction:
+	printf("leaving farewell\n");
+}
+
+// Resume-to-Terminate Test:
+void fallback() {
+	try {
+		resume(2);
+	} catch (2) {
+		printf("fallback caught termination 2\n");
+	}
+}
+
+// Terminate Throw New Exception:
+void terminate_swap() {
+	signal_exit a = {"terminate_swap"};
+	try {
+		terminate(2);
+	} catch (2) {
+		terminate(3);
+	}
+}
+
+void terminate_swapped() {
+	signal_exit a = {"terminate_swapped"};
+	try {
+		terminate_swap();
+	} catch (3) {
+		printf("terminate_swapped caught exception 3\n");
+	}
+}
+
+// Resume Throw New Exception:
+void resume_swap() {
+	signal_exit a = {"terminate_swap"};
+	try {
+		resume(2);
+	} catchResume (2) {
+		resume(3);
+	}
+}
+
+void resume_swapped() {
+	try {
+		resume_swap();
+	} catchResume (3) {
+		printf("resume_swapped caught exception 3\n");
+	}
+}
+
+// Terminate Rethrow:
+void reterminate() {
+	try {
+		try {
+			terminate(2);
+		} catch (2) {
+			printf("reterminate 2 caught and "
+			       "will rethrow exception 2\n");
+			throw;
+		}
+	} catch (2) {
+		printf("reterminate 1 caught exception 2\n");
+	}
+}
+
+// Resume Rethrow:
+void reresume() {
+	try {
+		try {
+			resume(2);
+		} catchResume (2) {
+			printf("reresume 2 caught and rethrows exception 2\n");
+			throwResume;
+		}
+	} catchResume (2) {
+		printf("reresume 1 caught exception 2\n");
+	}
+}
+
+// Terminate-Resume interaction:
+void fum() {
+	// terminate block, call resume
+	try {
+		resume(3);
+	} catch (3) {
+		printf("fum caught exception 3\n");
+	}
+}
+
+void foe() {
+	// resume block, call terminate
+	try {
+		terminate(3);
+	} catchResume (3) {
+		printf("foe caught exception 3\n");
+	}
+}
+
+void fy() {
+	// terminate block calls fum, call foe
+	try {
+		foe();
+	} catch (3) {
+		printf("fy caught exception 3\n");
+		fum();
+	}
+}
+
+void fee() {
+	// resume block, call fy
+	try {
+		fy();
+	} catchResume (3) {
+		printf("fee caught exception 3\n");
+	}
+}
+
+
+// main: choose which tests to run
+int main(int argc, char * argv[]) {
+	signal_exit a = {"main function"};
+
+	foo(); printf("\n");
+	alpha(); printf("\n");
+	farewell(false); printf("\n");
+	farewell(true); printf("\n");
+	fallback(); printf("\n");
+	terminate_swapped(); printf("\n");
+	resume_swapped(); printf("\n");
+	reterminate(); printf("\n");
+	reresume(); printf("\n");
+	fee(); printf("\n");
+	// Uncaught termination test.
+	terminate(7);
+}
Index: src/tests/exception.c
===================================================================
--- src/tests/exception.c	(revision 86f384bba584191182741295324fe1ca6656b380)
+++ 	(revision )
@@ -1,31 +1,0 @@
-//Testing esceptions syntax
-int fred() {
-    int x;
-    throw 3;
-    throw x = 5;
-
-    try {
-    } catch( int i ) {}
-
-    try {
-	x/4;
-    } catch( int ) {
-    } catch( float x ) {
-    } catch( struct { int i; } ) {
-    } catch( struct { int i; } x ) {
-    } catch( struct { int i; } *x ) {
-
-// Cforall extensions
-
-    } catch( * struct { int i; } ) {
-    } catch( * struct { int i; } x ) {
-    } catch( ... ) {
-    } finally {
-    } // try
-}
-
-//Dummy main
-int main(int argc, char const *argv[])
-{
-	return 0;
-}