Index: tests/exceptions/defaults.cfa
===================================================================
--- tests/exceptions/defaults.cfa	(revision fd54fef231baeeb0016103bf19cc8e6d87287faf)
+++ tests/exceptions/defaults.cfa	(revision f1bce515244f5c25d2ad8d57e955e79fd202e6a7)
@@ -4,18 +4,13 @@
 #include <exception.hfa>
 
-DATA_EXCEPTION(log_message)(
+EHM_EXCEPTION(log_message)(
 	char * msg;
 );
 
-void ?{}(log_message & this, char * msg) {
-	VTABLE_INIT(this, log_message);
-	this.msg = msg;
-}
-
-const char * get_log_message(log_message * this) {
+_EHM_DEFINE_COPY(log_message, )
+const char * msg(log_message * this) {
 	return this->msg;
 }
-
-VTABLE_INSTANCE(log_message)(get_log_message);
+_EHM_VIRTUAL_TABLE(log_message, , log_vt);
 
 // Logging messages don't have to be handled.
@@ -28,34 +23,39 @@
 	// We can catch log:
 	try {
-		throwResume (log_message){"Should be printed.\n"};
+		throwResume (log_message){&log_vt, "Should be printed.\n"};
 	} catchResume (log_message * this) {
 		printf("%s", this->virtual_table->msg(this));
 	}
 	// But we don't have to:
-	throwResume (log_message){"Should not be printed.\n"};
+	throwResume (log_message){&log_vt, "Should not be printed.\n"};
 }
 
 // I don't have a good use case for doing the same with termination.
-TRIVIAL_EXCEPTION(jump);
+EHM_EXCEPTION(jump)();
 void defaultTerminationHandler(jump &) {
 	printf("jump default handler.\n");
 }
 
+EHM_VIRTUAL_TABLE(jump, jump_vt);
+
 void jump_test(void) {
 	try {
-		throw (jump){};
+		throw (jump){&jump_vt};
 	} catch (jump * this) {
 		printf("jump catch handler.\n");
 	}
-	throw (jump){};
+	throw (jump){&jump_vt};
 }
 
-TRIVIAL_EXCEPTION(first);
-TRIVIAL_EXCEPTION(unhandled_exception);
+EHM_EXCEPTION(first)();
+EHM_VIRTUAL_TABLE(first, first_vt);
+
+EHM_EXCEPTION(unhandled_exception)();
+EHM_VIRTUAL_TABLE(unhandled_exception, unhandled_vt);
 
 void unhandled_test(void) {
 	forall(T &, V & | is_exception(T, V))
 	void defaultTerminationHandler(T &) {
-		throw (unhandled_exception){};
+		throw (unhandled_exception){&unhandled_vt};
 	}
 	void defaultTerminationHandler(unhandled_exception &) {
@@ -63,5 +63,5 @@
 	}
 	try {
-		throw (first){};
+		throw (first){&first_vt};
 	} catch (unhandled_exception * t) {
 		printf("Catch unhandled_exception.\n");
@@ -69,18 +69,19 @@
 }
 
-TRIVIAL_EXCEPTION(second);
+EHM_EXCEPTION(second)();
+EHM_VIRTUAL_TABLE(second, second_vt);
 
 void cross_test(void) {
 	void defaultTerminationHandler(first &) {
 		printf("cross terminate default\n");
-		throw (second){};
+		throw (second){&second_vt};
 	}
 	void defaultResumptionHandler(first &) {
 		printf("cross resume default\n");
-		throwResume (second){};
+		throwResume (second){&second_vt};
 	}
 	try {
 		printf("cross terminate throw\n");
-		throw (first){};
+		throw (first){&first_vt};
 	} catch (second *) {
 		printf("cross terminate catch\n");
@@ -88,5 +89,5 @@
 	try {
 		printf("cross resume throw\n");
-		throwResume (first){};
+		throwResume (first){&first_vt};
 	} catchResume (second *) {
 		printf("cross resume catch\n");