Ignore:
Timestamp:
Aug 22, 2017, 7:31:52 PM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
9aaac6e9
Parents:
fc56cdbf (diff), b3d413b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into references

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/tests/except-0.c

    rfc56cdbf r8135d4c  
    11// Draft of tests for exception handling.
     2// Outdated: The integer constant exceptions need to be replaced with virtual
     3// exceptions for the new system.
    24
    35// ERROR: exceptions do not interact with ^?{} properly.
    … …  
    57#include <stdio.h>
    68#include <stdbool.h>
     9
     10#include "except-mac.h"
     11TRIVIAL_EXCEPTION(yin)
     12TRIVIAL_EXCEPTION(yang)
     13TRIVIAL_EXCEPTION(zen)
     14
    715
    816// Local type to mark exits from scopes. (see ERROR)
    … …  
    2129
    2230
    23 // Local Exception Types and manual vtable types.
    24 //#define TRIVIAL_EXCEPTION(name) //TRIVAL_EXCEPTION(yin)
    25 struct yin;
    26 struct yin_vtable {
    27         struct exception_t_vtable const * parent;
    28         size_t size;
    29     void (*copy)(yin *this, yin * other);
    30     void (*free)(yin *this);
    31     const char (*msg)(yin *this);
    32 };
    33 struct yin {
    34         struct yin_vtable const * parent;
    35 };
    36 void yin_msg(yin) {
    37         return "in";
    38 }
    39 yin_vtable _yin_vtable_instance = {
    40         &_exception_t_vtable_instance, sizeof(yin), ?{}, ^?{}, yin_msg
    41 }
    42 
    43 
    44 void terminate(exception * except_value) {
     31// Mark throws: make sure to only pass in exception types.
     32forall(dtype T)
     33void terminate(T * except_value) {
    4534        signal_exit a = {"terminate function"};
    46         throw except_value;
     35        THROW(except_value);
    4736        printf("terminate returned\n");
    4837}
    4938
    50 void resume(exception * except_value) {
     39forall(dtype T)
     40void resume(T * except_value) {
    5141        signal_exit a = {"resume function"};
    52         throwResume except_value;
     42        THROW_RESUME(except_value);
    5343        printf("resume returned\n");
    5444}
    … …  
    5848        signal_exit a = {"bar function"};
    5949        try {
    60                 terminate(4);
    61         } catch (3) {
    62                 printf("bar caught exception 3.\n");
     50                terminate(&(zen){});
     51        } catch (yin * error) {
     52                printf("bar caught exception yin.\n");
    6353        }
    6454}
    … …  
    6858        try {
    6959                bar();
    70         } catch (4) {
    71                 printf("foo caught exception 4.\n");
    72         } catch (2) {
    73                 printf("foo caught exception 2.\n");
     60        } catch (yang * error) {
     61                printf("foo caught exception yang.\n");
     62        } catch (zen * error) {
     63                printf("foo caught exception zen.\n");
    7464        }
    7565}
    … …  
    7969        signal_exit a = {"beta function"};
    8070        try {
    81                 resume(4);
    82         } catchResume (3) {
    83                 printf("beta caught exception 3\n");
     71                zen x;
     72                resume(&x);
     73        } catchResume (yin * error) {
     74                printf("beta caught exception yin\n");
    8475        }
    8576}
    … …  
    8980        try {
    9081                beta();
    91         } catchResume (2) {
    92                 printf("alpha caught exception 2\n");
    93         } catchResume (4) {
    94                 printf("alpha caught exception 4\n");
     82        } catchResume (yang * error) {
     83                printf("alpha caught exception yang\n");
     84        } catchResume (zen * error) {
     85                printf("alpha caught exception zen\n");
    9586        }
    9687}
    … …  
    115106void fallback() {
    116107        try {
    117                 resume(2);
    118         } catch (2) {
    119                 printf("fallback caught termination 2\n");
     108                zen x;
     109                resume(&x);
     110        } catch (zen * error) {
     111                printf("fallback caught termination zen\n");
    120112        }
    121113}
    … …  
    125117        signal_exit a = {"terminate_swap"};
    126118        try {
    127                 terminate(2);
    128         } catch (2) {
    129                 terminate(3);
     119                yin x;
     120                terminate(&x);
     121        } catch (yin * error) {
     122                yang y;
     123                terminate(&y);
    130124        }
    131125}
    … …  
    135129        try {
    136130                terminate_swap();
    137         } catch (3) {
    138                 printf("terminate_swapped caught exception 3\n");
     131        } catch (yang * error) {
     132                printf("terminate_swapped caught exception yang\n");
    139133        }
    140134}
    … …  
    144138        signal_exit a = {"resume_swap"};
    145139        try {
    146                 resume(2);
    147         } catchResume (2) {
    148                 resume(3);
     140                yin x;
     141                resume(&x);
     142        } catchResume (yin * error) {
     143                yang y;
     144                resume(&y);
    149145        }
    150146}
    … …  
    153149        try {
    154150                resume_swap();
    155         } catchResume (3) {
    156                 printf("resume_swapped caught exception 3\n");
     151        } catchResume (yang * error) {
     152                printf("resume_swapped caught exception yang\n");
    157153        }
    158154}
    … …  
    162158        try {
    163159                try {
    164                         terminate(2);
    165                 } catch (2) {
    166                         printf("reterminate 2 caught and "
    167                                "will rethrow exception 2\n");
     160                        zen x;
     161                        terminate(&x);
     162                } catch (zen * error) {
     163                        printf("reterminate zen caught and "
     164                               "will rethrow exception zen\n");
    168165                        throw;
    169166                }
    170         } catch (2) {
    171                 printf("reterminate 1 caught exception 2\n");
     167        } catch (zen * error) {
     168                printf("reterminate 1 caught exception zen\n");
    172169        }
    173170}
    … …  
    177174        try {
    178175                try {
    179                         resume(2);
    180                 } catchResume (2) {
    181                         printf("reresume 2 caught and rethrows exception 2\n");
     176                        zen x;
     177                        resume(&x);
     178                } catchResume (zen * error) {
     179                        printf("reresume zen caught and rethrows exception zen\n");
    182180                        throwResume;
    183181                }
    184         } catchResume (2) {
    185                 printf("reresume 1 caught exception 2\n");
     182        } catchResume (zen * error) {
     183                printf("reresume 1 caught exception zen\n");
    186184        }
    187185}
    … …  
    191189        // terminate block, call resume
    192190        try {
    193                 resume(3);
    194         } catch (3) {
    195                 printf("fum caught exception 3\n");
     191                zen x;
     192                resume(&x);
     193        } catch (zen * error) {
     194                printf("fum caught exception zen\n");
    196195        }
    197196}
    … …  
    200199        // resume block, call terminate
    201200        try {
    202                 terminate(3);
    203         } catchResume (3) {
    204                 printf("foe caught exception 3\n");
     201                zen y;
     202                terminate(&y);
     203        } catchResume (zen * error) {
     204                printf("foe caught exception zen\n");
    205205        }
    206206}
    … …  
    210210        try {
    211211                foe();
    212         } catch (3) {
    213                 printf("fy caught exception 3\n");
     212        } catch (zen * error) {
     213                printf("fy caught exception zen\n");
    214214                fum();
    215215        }
    … …  
    220220        try {
    221221                fy();
    222         } catchResume (3) {
    223                 printf("fee caught exception 3\n");
     222        } catchResume (zen * error) {
     223                printf("fee caught exception zen\n");
    224224        }
    225225}
    … …  
    240240        reresume(); printf("\n");
    241241        fee(); printf("\n");
     242
    242243        // Uncaught termination test.
    243         terminate(7);
    244 }
     244        printf("Throw uncaught.\n");
     245        yang z;
     246        terminate(&z);
     247}
Note: See TracChangeset for help on using the changeset viewer.