Changeset c529a24


Ignore:
Timestamp:
Jun 16, 2017, 4:36:00 PM (4 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
365d553c
Parents:
0892b1b
Message:

Updates to exception handling and translation.

Location:
doc/working/exception
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • doc/working/exception/impl/exception.c

    r0892b1b rc529a24  
    4444        __throw_terminate(except);
    4545        // TODO: Default handler for resumption.
     46}
     47
     48/* QUESTION: Could interupts interact with exception handling?
     49Ex. could an context switch stop execution, and we get an exception when we
     50come back? Is so resumption has to go:
     51+ create node (init next and handler)
     52+ prepare cleanup (add a cleanup hook with the ..._cleaup function)
     53  also the cleanup has to be the next node, not just a pop from the list.
     54+ push node on the list (change the existing node)
     55Which if an exception can come from anywhere, might just be required to ensure
     56the list is valid.
     57
     58void __try_resume_setup(struct __try_resume_node * node,
     59                        bool (*handler)(exception except) {
     60        node->next = shared_stack.top_resume;
     61        node->try_to_handle = handler;
     62        shared_stack.top_resume = node;
     63}*/
     64
     65// We have a single cleanup function
     66void __try_resume_cleanup(struct __try_resume_node * node) {
     67        shared_stack.top_resume = node->next;
    4668}
    4769
  • doc/working/exception/impl/exception.h

    r0892b1b rc529a24  
    66
    77
    8 // These might be given simpler names and made public.
    98void __throw_terminate(exception except) __attribute__((noreturn));
    109void __rethrow_terminate(void) __attribute__((noreturn));
     
    2019};
    2120
     21void __try_resume_cleanup(struct __try_resume_node * node);
     22
    2223struct __cleanup_hook {};
    2324
     
    2728 * and threads means that... well I'm going to get it working ignoring those
    2829 * first, then get it working with concurrency.
     30 * Eventually there should be some global name that just gets you the right
     31 * data block.
    2932 */
    3033struct shared_stack_t {
    31         //struct lock lock;
    3234        struct __try_resume_node * top_resume;
    3335        struct __try_resume_node * current_resume;
  • doc/working/exception/impl/test-main.c

    r0892b1b rc529a24  
    66#include <stdbool.h>
    77
    8 // Translation Helpers:
    9 #define CLEANUP(function) \
    10         struct __cleanup_hook __hidden_hook __attribute__((cleanup(function)))
    11 
    12 #define SET_UP_RESUME_NODE(handler_function) \
    13         struct __try_resume_node node \
    14                 __attribute__((cleanup(__try_resume_node_delete))); \
    15         __try_resume_node_new(&node, handler_function)
    16 
     8// Helps with manual translation. It may or may not get folded into the
     9// header, that depends on how it interacts with concurancy.
    1710void __try_resume_node_new(struct __try_resume_node * node,
    1811        _Bool (*handler)(exception except)) {
     
    2013    shared_stack.top_resume = node;
    2114    node->try_to_handle = handler;
    22 }
    23 
    24 void __try_resume_node_delete(struct __try_resume_node * node) {
    25     shared_stack.top_resume = node->next;
    2615}
    2716
     
    122111                }
    123112                struct __try_resume_node node
    124                         __attribute__((cleanup(__try_resume_node_delete)));
     113                        __attribute__((cleanup(__try_resume_cleanup)));
    125114                __try_resume_node_new(&node, beta_handle1);
    126115                {
     
    144133                }
    145134                struct __try_resume_node node
    146                         __attribute__((cleanup(__try_resume_node_delete)));
     135                        __attribute__((cleanup(__try_resume_cleanup)));
    147136                __try_resume_node_new(&node, alpha_handle1);
    148137                {
     
    260249                }
    261250                struct __try_resume_node node
    262                         __attribute__((cleanup(__try_resume_node_delete)));
     251                        __attribute__((cleanup(__try_resume_cleanup)));
    263252                __try_resume_node_new(&node, fn_handle1);
    264253                {
     
    279268                }
    280269                struct __try_resume_node node
    281                         __attribute__((cleanup(__try_resume_node_delete)));
     270                        __attribute__((cleanup(__try_resume_cleanup)));
    282271                __try_resume_node_new(&node, fn_handle1);
    283272                {
     
    349338                }
    350339                struct __try_resume_node node
    351                         __attribute__((cleanup(__try_resume_node_delete)));
     340                        __attribute__((cleanup(__try_resume_cleanup)));
    352341                __try_resume_node_new(&node, reresume_handle1);
    353342                {
     
    361350                        }
    362351                        struct __try_resume_node node
    363                                 __attribute__((cleanup(__try_resume_node_delete)));
     352                                __attribute__((cleanup(__try_resume_cleanup)));
    364353                        __try_resume_node_new(&node, reresume_handle2);
    365354                        {
     
    409398                }
    410399                struct __try_resume_node node
    411                         __attribute__((cleanup(__try_resume_node_delete)));
     400                        __attribute__((cleanup(__try_resume_cleanup)));
    412401                __try_resume_node_new(&node, foe_handle1);
    413402                {
     
    456445                }
    457446                struct __try_resume_node node
    458                         __attribute__((cleanup(__try_resume_node_delete)));
     447                        __attribute__((cleanup(__try_resume_cleanup)));
    459448                __try_resume_node_new(&node, fee_handle1);
    460449                {
  • doc/working/exception/translate.c

    r0892b1b rc529a24  
    1717
    1818void __throw_terminate(exception except) __attribute__((noreturn));
     19void __rethrow_terminate() __attribute__((noreturn));
    1920void __throw_resume(exception except);
    2021
     
    2728        bool (*try_to_handle)(exception except);
    2829};
     30
     31void __try_resume_cleanup(struct __try_resume_node * node);
    2932
    3033struct __cleanup_hook {};
     
    147150void try_resume() {
    148151        {
    149                 bool catch1(exception except) {
     152                bool handle1(exception except) {
    150153                        OtherException inner_except;
    151154                        if (dynamic_cast__SomeException(except)) {
     
    161164                }
    162165                struct __try_resume_node data =
    163                         {.next = stack.except.top_resume, .try_to_handle = catch1};
     166                        {.next = stack.except.top_resume, .try_to_handle = handle1};
    164167                stack.except.top_resume = &data;
    165168
     
    204207
    205208
    206 // Combining the Above:
     209// Resume + Finally:
     210"Cforall"
     211
     212void try_resume_finally() {
     213        try {
     214                insideTry();
     215        }
     216        catch resume (SomeException) {
     217                fiddleThing();
     218        }
     219        finally {
     220                twiddleWidget();
     221        }
     222}
     223
     224"C"
     225
     226void try_resume_finally() {
     227        {
     228                void finally1() {
     229                        twiddleWidget();
     230                }
     231                bool handle1(exception except) {
     232                        if (dynamic_cast__SomeException(except)) {
     233                                fiddleThing();
     234                                return true;
     235                        } else {
     236                                return false;
     237                        }
     238                }
     239                struct __cleanup_hook generated_name
     240                        __attribute__((cleanup(finally1)));
     241
     242                struct __try_resume_node data =
     243                        {.next = stack.except.top_resume, .try_to_handle = handle1};
     244                stack.except.top_resume = &data;
     245
     246                struct __cleanup_hook generated_name
     247                        __attribute__((cleanup(__try_resume_cleanup)));
     248        }
     249}
     250
     251
     252// Terminate + Resume + Finally:
    207253"Cforall"
    208254
     
    226272void try_all() {
    227273        {
     274                bool handle1() {
     275                        if (dynamic_cast__OtherException(except)) {
     276                                twiddleWidget();
     277                                return true;
     278                        }
     279                        return false;
     280                }
    228281                void try1 () {
     282                        struct __try_resume_node generated_name =
     283                                {.next = stack.except.top_resume, .try_to_handle = handle1}
     284                                __attribute__((cleanup(__try_resume_cleanup)));
     285                        stack.except.top_resume = &data;
     286
    229287                        insideTry();
    230288                }
     
    244302                        return 0;
    245303                }
    246                 bool catch2() {
    247                         if (dynamic_cast__OtherException(except)) {
    248                                 twiddleWidget();
    249                                 return true;
    250                         }
    251                         return false;
    252                 }
    253304                void finally1() {
    254                         // Finally, because of timing, also works for resume.
    255                         // However this might not actually be better in any way.
    256                         __try_resume_cleanup();
    257305
    258306                        twiddleWidget();
    259307                }
    260 
    261                 struct __try_resume_node generated_name =
    262                         {.next = stack.except.top_resume, .try_to_handle = catch2};
    263                 stack.except.top_resume = &data;
    264308                struct __cleanup_hook generated_name
    265309                        __attribute__((cleanup(finally1)));
Note: See TracChangeset for help on using the changeset viewer.