Index: tests/exceptions/.expect/resume-threads.txt =================================================================== --- tests/exceptions/.expect/resume-threads.txt (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/.expect/resume-threads.txt (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -6,7 +6,4 @@ catch-all - -throwing child exception -inner parent match caught yin as yin Index: tests/exceptions/.expect/resume.txt =================================================================== --- tests/exceptions/.expect/resume.txt (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/.expect/resume.txt (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -6,7 +6,4 @@ catch-all - -throwing child exception -inner parent match caught yin as yin Index: tests/exceptions/.expect/terminate-threads.txt =================================================================== --- tests/exceptions/.expect/terminate-threads.txt (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/.expect/terminate-threads.txt (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -5,7 +5,4 @@ catch-all - -throwing child exception -inner parent match caught yin as yin Index: tests/exceptions/.expect/terminate.txt =================================================================== --- tests/exceptions/.expect/terminate.txt (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/.expect/terminate.txt (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -5,7 +5,4 @@ catch-all - -throwing child exception -inner parent match caught yin as yin Index: tests/exceptions/cancel/coroutine.cfa =================================================================== --- tests/exceptions/cancel/coroutine.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/cancel/coroutine.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,5 +4,6 @@ #include -TRIVIAL_EXCEPTION(internal_error); +EHM_EXCEPTION(internal_error)(); +EHM_VIRTUAL_TABLE(internal_error, internal_vt); coroutine WillCancel {}; @@ -14,5 +15,5 @@ void main(WillCancel & wc) { printf("1"); - cancel_stack((internal_error){}); + cancel_stack((internal_error){&internal_vt}); printf("!"); } @@ -24,5 +25,5 @@ resume(cancel); printf("4"); - } catchResume (CoroutineCancelled(WillCancel) * error) { + } catchResume (SomeCoroutineCancelled * error) { printf("2"); if ((virtual internal_error *)error->the_exception) { Index: tests/exceptions/cancel/thread.cfa =================================================================== --- tests/exceptions/cancel/thread.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/cancel/thread.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,5 +4,6 @@ #include -TRIVIAL_EXCEPTION(internal_error); +EHM_EXCEPTION(internal_error)(); +EHM_VIRTUAL_TABLE(internal_error, internal_vt); thread WillCancel {}; @@ -14,5 +15,5 @@ void main(WillCancel &) { printf("1"); - cancel_stack((internal_error){}); + cancel_stack((internal_error){&internal_vt}); printf("!"); } @@ -25,5 +26,5 @@ join(cancel); printf("4"); - } catchResume (ThreadCancelled(WillCancel) * error) { + } catchResume (SomeThreadCancelled * error) { printf("2"); if ((virtual internal_error *)error->the_exception) { @@ -42,5 +43,5 @@ } printf("4"); - } catchResume (ThreadCancelled(WillCancel) * error) { + } catchResume (SomeThreadCancelled * error) { printf("2"); if ((virtual internal_error *)error->the_exception) { Index: tests/exceptions/conditional.cfa =================================================================== --- tests/exceptions/conditional.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/conditional.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -6,44 +6,9 @@ #include -VTABLE_DECLARATION(num_error)( - int (*code)(num_error *this); +EHM_EXCEPTION(num_error)( + int num; ); -struct num_error { - VTABLE_FIELD(num_error); - char * msg; - int num; -}; - -const char * num_error_msg(num_error * this) { - if ( ! this->msg ) { - static const char * base = "Num Error with code: X"; - this->msg = (char *)malloc(22); - for (int i = 0 ; (this->msg[i] = base[i]) ; ++i); - } - this->msg[21] = '0' + this->num; - return this->msg; -} -void ?{}(num_error & this, int num) { - VTABLE_INIT(this, num_error); - this.msg = 0; - this.num = num; -} -void ?{}(num_error & this, num_error & other) { - this.virtual_table = other.virtual_table; - this.msg = 0; - this.num = other.num; -} -void ^?{}(num_error & this) { - if( this.msg ) free( this.msg ); -} -int num_error_code( num_error * this ) { - return this->num; -} - -VTABLE_INSTANCE(num_error)( - num_error_msg, - num_error_code, -); +EHM_VIRTUAL_TABLE(num_error, num_error_vt); void caught_num_error(int expect, num_error * actual) { @@ -52,11 +17,11 @@ int main(int argc, char * argv[]) { - num_error exc = 2; + num_error exc = {&num_error_vt, 2}; try { throw exc; - } catch (num_error * error ; 3 == error->virtual_table->code( error )) { + } catch (num_error * error ; 3 == error->num ) { caught_num_error(3, error); - } catch (num_error * error ; 2 == error->virtual_table->code( error )) { + } catch (num_error * error ; 2 == error->num ) { caught_num_error(2, error); } @@ -64,7 +29,7 @@ try { throwResume exc; - } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) { + } catchResume (num_error * error ; 3 == error->num ) { caught_num_error(3, error); - } catchResume (num_error * error ; 2 == error->virtual_table->code( error )) { + } catchResume (num_error * error ; 2 == error->num ) { caught_num_error(2, error); } Index: tests/exceptions/data-except.cfa =================================================================== --- tests/exceptions/data-except.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/data-except.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -3,44 +3,34 @@ #include -DATA_EXCEPTION(paired)( +EHM_EXCEPTION(paired)( int first; int second; ); -void ?{}(paired & this, int first, int second) { - VTABLE_INIT(this, paired); - this.first = first; - this.second = second; -} +EHM_VIRTUAL_TABLE(paired, paired_vt); -const char * paired_msg(paired * this) { - return "paired"; -} - -VTABLE_INSTANCE(paired)(paired_msg); - -void throwPaired(int first, int second) { - paired exc = {first, second}; +const char * virtual_msg(paired * this) { + return this->virtual_table->msg(this); } int main(int argc, char * argv[]) { - paired except = {3, 13}; + paired except = {&paired_vt, 3, 13}; try { throw except; } catch (paired * exc) { - printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second); ++exc->first; } - printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); + printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second); try { throwResume except; } catchResume (paired * exc) { - printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second); ++exc->first; } - printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); + printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second); } Index: tests/exceptions/defaults.cfa =================================================================== --- tests/exceptions/defaults.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/defaults.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,18 +4,13 @@ #include -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"); Index: tests/exceptions/finally.cfa =================================================================== --- tests/exceptions/finally.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/finally.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,8 +4,10 @@ #include "except-io.hfa" -TRIVIAL_EXCEPTION(myth); +EHM_EXCEPTION(myth)(); + +EHM_VIRTUAL_TABLE(myth, myth_vt); int main(int argc, char * argv[]) { - myth exc; + myth exc = {&myth_vt}; try { Index: tests/exceptions/interact.cfa =================================================================== --- tests/exceptions/interact.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/interact.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,11 +4,14 @@ #include "except-io.hfa" -TRIVIAL_EXCEPTION(star); -TRIVIAL_EXCEPTION(moon); +EHM_EXCEPTION(star)(); +EHM_EXCEPTION(moon)(); + +EHM_VIRTUAL_TABLE(star, star_vt); +EHM_VIRTUAL_TABLE(moon, moon_vt); int main(int argc, char * argv[]) { // Resume falls back to terminate. try { - throwResume (star){}; + throwResume (star){&star_vt}; } catch (star *) { printf("caught as termination\n"); @@ -17,5 +20,5 @@ try { loud_region a = "try block with resume throw"; - throwResume (star){}; + throwResume (star){&star_vt}; } catch (star *) { printf("caught as termination\n"); @@ -29,5 +32,5 @@ try { try { - throw (star){}; + throw (star){&star_vt}; } catchResume (star *) { printf("resume catch on terminate\n"); @@ -43,5 +46,5 @@ try { try { - throwResume (star){}; + throwResume (star){&star_vt}; } catch (star *) { printf("terminate catch on resume\n"); @@ -58,5 +61,5 @@ try { try { - throw (star){}; + throw (star){&star_vt}; } catchResume (star *) { printf("inner resume catch (error)\n"); @@ -75,5 +78,5 @@ try { try { - throwResume (star){}; + throwResume (star){&star_vt}; } catch (star *) { printf("inner termination catch\n"); @@ -94,10 +97,10 @@ try { printf("throwing resume moon\n"); - throwResume (moon){}; + throwResume (moon){&moon_vt}; } catch (star *) { printf("termination catch\n"); } printf("throwing resume star\n"); - throwResume (star){}; + throwResume (star){&star_vt}; } catchResume (star *) { printf("resumption star catch\n"); @@ -105,5 +108,5 @@ } catchResume (moon *) { printf("resumption moon catch, will terminate\n"); - throw (star){}; + throw (star){&star_vt}; } } catchResume (star *) { Index: tests/exceptions/polymorphic.cfa =================================================================== --- tests/exceptions/polymorphic.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/polymorphic.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -3,15 +3,15 @@ #include -FORALL_TRIVIAL_EXCEPTION(proxy, (T), (T)); -FORALL_TRIVIAL_INSTANCE(proxy, (U), (U)) +EHM_FORALL_EXCEPTION(proxy, (T&), (T))(); -const char * msg(proxy(int) * this) { return "proxy(int)"; } -const char * msg(proxy(char) * this) { return "proxy(char)"; } -POLY_VTABLE_INSTANCE(proxy, int)(msg); -POLY_VTABLE_INSTANCE(proxy, char)(msg); +EHM_FORALL_VIRTUAL_TABLE(proxy, (int), proxy_int); +EHM_FORALL_VIRTUAL_TABLE(proxy, (char), proxy_char); void proxy_test(void) { + proxy(int) an_int = {&proxy_int}; + proxy(char) a_char = {&proxy_char}; + try { - throw (proxy(int)){}; + throw an_int; } catch (proxy(int) *) { printf("terminate catch\n"); @@ -19,5 +19,5 @@ try { - throwResume (proxy(char)){}; + throwResume a_char; } catchResume (proxy(char) *) { printf("resume catch\n"); @@ -25,5 +25,5 @@ try { - throw (proxy(char)){}; + throw a_char; } catch (proxy(int) *) { printf("caught proxy(int)\n"); @@ -33,21 +33,15 @@ } -FORALL_DATA_EXCEPTION(cell, (T), (T))( +EHM_FORALL_EXCEPTION(cell, (T), (T))( T data; ); -FORALL_DATA_INSTANCE(cell, (T), (T)) - -const char * msg(cell(int) * this) { return "cell(int)"; } -const char * msg(cell(char) * this) { return "cell(char)"; } -const char * msg(cell(bool) * this) { return "cell(bool)"; } -POLY_VTABLE_INSTANCE(cell, int)(msg); -POLY_VTABLE_INSTANCE(cell, char)(msg); -POLY_VTABLE_INSTANCE(cell, bool)(msg); +EHM_FORALL_VIRTUAL_TABLE(cell, (int), int_cell); +EHM_FORALL_VIRTUAL_TABLE(cell, (char), char_cell); +EHM_FORALL_VIRTUAL_TABLE(cell, (bool), bool_cell); void cell_test(void) { try { - cell(int) except; - except.data = -7; + cell(int) except = {&int_cell, -7}; throw except; } catch (cell(int) * error) { @@ -56,6 +50,5 @@ try { - cell(bool) ball; - ball.data = false; + cell(bool) ball = {&bool_cell, false}; throwResume ball; printf("%i\n", ball.data); Index: tests/exceptions/resume.cfa =================================================================== --- tests/exceptions/resume.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/resume.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,17 +4,24 @@ #include "except-io.hfa" -TRIVIAL_EXCEPTION(yin); -TRIVIAL_EXCEPTION(yang); -TRIVIAL_EXCEPTION(zen); -TRIVIAL_EXCEPTION(moment_of, zen); +EHM_EXCEPTION(yin)(); +EHM_EXCEPTION(yang)(); +EHM_EXCEPTION(zen)(); + +EHM_VIRTUAL_TABLE(yin, yin_vt); +EHM_VIRTUAL_TABLE(yang, yang_vt); +EHM_VIRTUAL_TABLE(zen, zen_vt); void in_void(void); int main(int argc, char * argv[]) { + yin a_yin = {&yin_vt}; + yang a_yang = {&yang_vt}; + zen a_zen = {&zen_vt}; + // The simple throw catchResume test. try { loud_exit a = "simple try clause"; printf("simple throw\n"); - throwResume (zen){}; + throwResume a_zen; printf("end of try clause\n"); } catchResume (zen * error) { @@ -26,18 +33,7 @@ // Throw catch-all test. try { - throwResume (zen){}; + throwResume a_zen; } catchResume (exception_t * error) { printf("catch-all\n"); - } - printf("\n"); - - // Catch a parent of the given exception. - try { - printf("throwing child exception\n"); - throwResume (moment_of){}; - } catchResume (zen *) { - printf("inner parent match\n"); - } catchResume (moment_of *) { - printf("outer exact match\n"); } printf("\n"); @@ -46,5 +42,5 @@ try { try { - throwResume (yin){}; + throwResume a_yin; } catchResume (zen *) { printf("caught yin as zen\n"); @@ -62,5 +58,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - throwResume (zen){}; + throwResume a_zen; } catchResume (zen *) { loud_exit a = "rethrowing catch clause"; @@ -77,8 +73,8 @@ try { try { - throwResume (yin){}; + throwResume a_yin; } catchResume (yin *) { printf("caught yin, will throw yang\n"); - throwResume (yang){}; + throwResume a_yang; } catchResume (yang *) { printf("caught exception from same try\n"); @@ -93,10 +89,10 @@ try { printf("throwing first exception\n"); - throwResume (yin){}; + throwResume a_yin; } catchResume (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - throwResume (yang){}; + throwResume a_yang; } catchResume (yang *) { printf("caught second exception\n"); @@ -114,10 +110,10 @@ try { try { - throwResume (zen){}; - throwResume (zen){}; + throwResume a_zen; + throwResume a_zen; } catchResume (zen *) { printf("inner catch\n"); } - throwResume (zen){}; + throwResume a_zen; } catchResume (zen *) { printf("outer catch\n"); @@ -130,8 +126,9 @@ // Do a throw and rethrow in a void function. void in_void(void) { + zen a_zen = {&zen_vt}; try { try { printf("throw\n"); - throwResume (zen){}; + throwResume a_zen; } catchResume (zen *) { printf("rethrow\n"); Index: tests/exceptions/terminate.cfa =================================================================== --- tests/exceptions/terminate.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/terminate.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -4,17 +4,24 @@ #include "except-io.hfa" -TRIVIAL_EXCEPTION(yin); -TRIVIAL_EXCEPTION(yang); -TRIVIAL_EXCEPTION(zen); -TRIVIAL_EXCEPTION(moment_of, zen); +EHM_EXCEPTION(yin)(); +EHM_EXCEPTION(yang)(); +EHM_EXCEPTION(zen)(); + +EHM_VIRTUAL_TABLE(yin, yin_vt); +EHM_VIRTUAL_TABLE(yang, yang_vt); +EHM_VIRTUAL_TABLE(zen, zen_vt); void in_void(void); int main(int argc, char * argv[]) { + yin a_yin = {&yin_vt}; + yang a_yang = {&yang_vt}; + zen a_zen = {&zen_vt}; + // The simple throw catch test. try { loud_exit a = "simple try clause"; printf("simple throw\n"); - throw (zen){}; + throw a_zen; printf("end of try clause\n"); } catch (zen * error) { @@ -26,18 +33,7 @@ // Throw catch-all test. try { - throw (zen){}; + throw a_zen; } catch (exception_t * error) { printf("catch-all\n"); - } - printf("\n"); - - // Catch a parent of the given exception. - try { - printf("throwing child exception\n"); - throw (moment_of){}; - } catch (zen *) { - printf("inner parent match\n"); - } catch (moment_of *) { - printf("outer exact match\n"); } printf("\n"); @@ -46,5 +42,5 @@ try { try { - throw (yin){}; + throw a_yin; } catch (zen *) { printf("caught yin as zen\n"); @@ -62,5 +58,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - throw (zen){}; + throw a_zen; } catch (zen *) { loud_exit a = "rethrowing catch clause"; @@ -77,8 +73,8 @@ try { try { - throw (yin){}; + throw a_yin; } catch (yin *) { printf("caught yin, will throw yang\n"); - throw (yang){}; + throw a_yang; } catch (yang *) { printf("caught exception from same try\n"); @@ -93,10 +89,10 @@ try { printf("throwing first exception\n"); - throw (yin){}; + throw a_yin; } catch (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - throw (yang){}; + throw a_yang; } catch (yang *) { printf("caught second exception\n"); @@ -114,10 +110,10 @@ try { try { - throw (zen){}; - throw (zen){}; + throw a_zen; + throw a_zen; } catch (zen *) { printf("inner catch\n"); } - throw (zen){}; + throw a_zen; } catch (zen *) { printf("outer catch\n"); @@ -130,8 +126,9 @@ // Do a throw and rethrow in a void function. void in_void(void) { + zen a_zen = {&zen_vt}; try { try { printf("throw\n"); - throw (zen){}; + throw a_zen; } catch (zen *) { printf("rethrow\n"); Index: tests/exceptions/trash.cfa =================================================================== --- tests/exceptions/trash.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/trash.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -3,14 +3,17 @@ #include -TRIVIAL_EXCEPTION(yin); -TRIVIAL_EXCEPTION(yang); +EHM_EXCEPTION(yin)(); +EHM_EXCEPTION(yang)(); + +EHM_VIRTUAL_TABLE(yin, yin_vt); +EHM_VIRTUAL_TABLE(yang, yang_vt); int main(int argc, char * argv[]) { try { try { - throw (yin){}; + throw (yin){&yin_vt}; } finally { try { - throw (yang){}; + throw (yang){&yang_vt}; } catch (yin *) { printf("inner yin\n"); Index: tests/exceptions/type-check.cfa =================================================================== --- tests/exceptions/type-check.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/type-check.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -3,5 +3,5 @@ #include -TRIVIAL_EXCEPTION(truth); +EHM_EXCEPTION(truth)(); int main(int argc, char * argv[]) { Index: tests/exceptions/virtual-cast.cfa =================================================================== --- tests/exceptions/virtual-cast.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/virtual-cast.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -12,6 +12,18 @@ #include + + +// Hand defined alpha virtual type: +struct __cfatid_struct_alpha { + __cfa__parent_vtable const * parent; +}; + +__attribute__(( section(".gnu.linkonce.__cfatid_alpha") )) +struct __cfatid_struct_alpha __cfatid_alpha = { + (__cfa__parent_vtable *)0, +}; + struct alpha_vtable { - alpha_vtable const * const parent; + struct __cfatid_struct_alpha const * const __cfavir_typeid; char (*code)(void); }; @@ -27,6 +39,16 @@ +// Hand defined beta virtual type: +struct __cfatid_struct_beta { + __cfatid_struct_alpha const * parent; +}; + +__attribute__(( section(".gnu.linkonce.__cfatid_beta") )) +struct __cfatid_struct_beta __cfatid_beta = { + &__cfatid_alpha, +}; + struct beta_vtable { - alpha_vtable const * const parent; + struct __cfatid_struct_beta const * const __cfavir_typeid; char (*code)(void); }; @@ -42,6 +64,16 @@ +// Hand defined gamma virtual type: +struct __cfatid_struct_gamma { + __cfatid_struct_beta const * parent; +}; + +__attribute__(( section(".gnu.linkonce.__cfatid_gamma") )) +struct __cfatid_struct_gamma __cfatid_gamma = { + &__cfatid_beta, +}; + struct gamma_vtable { - beta_vtable const * const parent; + struct __cfatid_struct_gamma const * const __cfavir_typeid; char (*code)(void); }; @@ -57,7 +89,7 @@ extern "C" { - alpha_vtable _alpha_vtable_instance = { 0, ret_a }; - beta_vtable _beta_vtable_instance = { &_alpha_vtable_instance, ret_b }; - gamma_vtable _gamma_vtable_instance = { &_beta_vtable_instance, ret_g }; + alpha_vtable _alpha_vtable_instance = { &__cfatid_alpha, ret_a }; + beta_vtable _beta_vtable_instance = { &__cfatid_beta, ret_b }; + gamma_vtable _gamma_vtable_instance = { &__cfatid_gamma, ret_g }; } Index: tests/exceptions/virtual-poly.cfa =================================================================== --- tests/exceptions/virtual-poly.cfa (revision fd54fef231baeeb0016103bf19cc8e6d87287faf) +++ tests/exceptions/virtual-poly.cfa (revision a33c11376e88fecef869e2f63e32b80f9410edc8) @@ -8,6 +8,16 @@ #include + +struct __cfatid_struct_mono_base { + __cfa__parent_vtable const * parent; +}; + +__attribute__(( section(".gnu.linkonce.__cfatid_mono_base") )) +struct __cfatid_struct_mono_base __cfatid_mono_base = { + (__cfa__parent_vtable *)0, +}; + struct mono_base_vtable { - mono_base_vtable const * const parent; + __cfatid_struct_mono_base const * const __cfavir_typeid; }; @@ -17,6 +27,11 @@ forall(T) +struct __cfatid_struct_mono_child { + __cfatid_struct_mono_base const * parent; +}; + +forall(T) struct mono_child_vtable { - mono_base_vtable const * const parent; + __cfatid_struct_mono_child(T) const * const __cfavir_typeid; }; @@ -26,7 +41,10 @@ }; -mono_base_vtable _mono_base_vtable_instance @= { 0 }; +__cfatid_struct_mono_child(int) __cfatid_mono_child @= { + &__cfatid_mono_base, +}; + mono_child_vtable(int) _mono_child_vtable_instance @= { - &_mono_base_vtable_instance + &__cfatid_mono_child, }; @@ -37,7 +55,13 @@ } + +forall(U) +struct __cfatid_struct_poly_base { + __cfa__parent_vtable const * parent; +}; + forall(U) struct poly_base_vtable { - poly_base_vtable(U) const * const parent; + __cfatid_struct_poly_base(U) const * const __cfavir_typeid; }; @@ -48,6 +72,11 @@ forall(V) +struct __cfatid_struct_poly_child { + __cfatid_struct_poly_base(V) const * parent; +}; + +forall(V) struct poly_child_vtable { - poly_base_vtable(V) const * const parent; + __cfatid_struct_poly_child(V) const * const __cfavir_typeid; }; @@ -57,14 +86,13 @@ }; -poly_base_vtable(int) _poly_base_vtable_instance @= { 0 }; +__cfatid_struct_poly_base(int) __cfatid_poly_base @= { + (__cfa__parent_vtable *)0, +}; +__cfatid_struct_poly_child(int) __cfatid_poly_child = { + &__cfatid_poly_base, +}; poly_child_vtable(int) _poly_child_vtable_instance @= { - &_poly_base_vtable_instance + &__cfatid_poly_child, }; -/* Resolver bug keeps me from adding these. -poly_base_vtable(char) _poly_base_vtable_instance @= { 0 }; -poly_child_vtable(char) _poly_child_vtable_instance @= { - &_poly_base_vtable_instance -}; -*/ void poly_poly_test() { @@ -77,4 +105,4 @@ mono_poly_test(); poly_poly_test(); - printf( "done\n" ); // non-empty .expect file + printf( "done\n" ); }