Changeset ecfd758 for tests/exceptions/defaults.cfa

Timestamp:

Apr 9, 2021, 2:11:43 PM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b91bfde

Parents:

e07b589

Message:

Major exception update, seperating type-ids from virtual tables. The major interface changes are done. There is a regression of ?Cancelled(T) to Some?Cancelled. There is some bits of code for the new verion of the ?Cancelled(T) interface already there. Not connected yet but I just reached the limit of what I wanted to do in one commit and then spent over a day cleaning up, so it will replace Some?Cancelled in a future commit.

File:

• tests/exceptions/defaults.cfa (modified) (5 diffs)

tests/exceptions/defaults.cfa

@@ -4 +4 @@
 #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 +23 @@
         // 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 +63 @@
         }
         try {
-                throw (first){};
+                throw (first){&first_vt};
         } catch (unhandled_exception * t) {
                 printf("Catch unhandled_exception.\n");
@@ -69 +69 @@
 }
 
-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 +89 @@
         try {
                 printf("cross resume throw\n");
-                throwResume (first){};
+                throwResume (first){&first_vt};
         } catchResume (second *) {
                 printf("cross resume catch\n");