Ignore:
Timestamp:
Jun 16, 2017, 9:07:33 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
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:
436c0de, e1c1829, ec35498
Parents:
4aa2fb2 (diff), e1055441 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
doc/working/exception/impl
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • doc/working/exception/impl/exception.c

    r4aa2fb2 r42b0d73  
    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

    r4aa2fb2 r42b0d73  
    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

    r4aa2fb2 r42b0d73  
    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                {
    … …  
    153142
    154143// Finally Test:
    155 void farewell() {
     144void farewell(bool jump) {
    156145        {
    157146                void farewell_finally1() {
    … …  
    161150                        __attribute__((cleanup(farewell_finally1)));
    162151                {
    163                         printf("walk out of farewell\n");
    164                 }
    165         }
     152                        if (jump) {
     153                                printf("jump out of farewell\n");
     154                                goto endoffunction;
     155                        } else {
     156                                printf("walk out of farewell\n");
     157                        }
     158                }
     159        }
     160        endoffunction:
     161        printf("leaving farewell\n");
    166162}
    167163
    … …  
    260256                }
    261257                struct __try_resume_node node
    262                         __attribute__((cleanup(__try_resume_node_delete)));
     258                        __attribute__((cleanup(__try_resume_cleanup)));
    263259                __try_resume_node_new(&node, fn_handle1);
    264260                {
    … …  
    279275                }
    280276                struct __try_resume_node node
    281                         __attribute__((cleanup(__try_resume_node_delete)));
     277                        __attribute__((cleanup(__try_resume_cleanup)));
    282278                __try_resume_node_new(&node, fn_handle1);
    283279                {
    … …  
    349345                }
    350346                struct __try_resume_node node
    351                         __attribute__((cleanup(__try_resume_node_delete)));
     347                        __attribute__((cleanup(__try_resume_cleanup)));
    352348                __try_resume_node_new(&node, reresume_handle1);
    353349                {
    … …  
    361357                        }
    362358                        struct __try_resume_node node
    363                                 __attribute__((cleanup(__try_resume_node_delete)));
     359                                __attribute__((cleanup(__try_resume_cleanup)));
    364360                        __try_resume_node_new(&node, reresume_handle2);
    365361                        {
    … …  
    409405                }
    410406                struct __try_resume_node node
    411                         __attribute__((cleanup(__try_resume_node_delete)));
     407                        __attribute__((cleanup(__try_resume_cleanup)));
    412408                __try_resume_node_new(&node, foe_handle1);
    413409                {
    … …  
    456452                }
    457453                struct __try_resume_node node
    458                         __attribute__((cleanup(__try_resume_node_delete)));
     454                        __attribute__((cleanup(__try_resume_cleanup)));
    459455                __try_resume_node_new(&node, fee_handle1);
    460456                {
    … …  
    471467        foo(); printf("\n");
    472468        alpha(); printf("\n");
    473         farewell(); printf("\n");
     469        farewell(false); printf("\n");
     470        farewell(true); printf("\n");
    474471        fallback(); printf("\n");
    475472        terminate_swapped(); printf("\n");
Note: See TracChangeset for help on using the changeset viewer.