source: doc/working/exception/impl/resume-main.c@ 6cff9f3

#include <stdio.h>
#include <stdbool.h>

// Proof of concept for resumption exception handling.
// Names, checks promises and so on all would have to be improved.

struct resume_group;

// Stackwise information (global for single stack)
struct code_stack_data {
        struct resume_group * top_resume;
        struct resume_group * current_resume;
} stack = {NULL, NULL};

// private exception header begin ============================================

struct resume_group {
        struct resume_group * next;
        bool (*try_to_handle)(int);
};

void __resume_group_dtor(struct resume_group * this) {
        stack.top_resume = this->next;
}

void __cfa_eh__throw_resume(int except) {
        struct resume_group * original_head = stack.current_resume;
        struct resume_group * current =
                (original_head) ? original_head->next : stack.top_resume;

        for ( ; current ; current = current->next) {
                stack.current_resume = current;
                if (current->try_to_handle(except)) {
                        stack.current_resume = original_head;
                        return;
                }
        }

        printf("Unhandled exception %d\n", except);
}

// private exception header end ==============================================

// Set up of unwind checker type.
struct type_raii_t {
        char * msg;
};

void dtor( struct type_raii_t * this ) {
        printf("%s\n", this->msg);
}

#define raii_t __attribute__((cleanup(dtor))) struct type_raii_t

void bar() {
        raii_t a = { "Bar dtor" };

        __cfa_eh__throw_resume( 3 );
}

void foo() {
        raii_t a = { "Foo dtor" };

        {
                bool foo_catch_resume(int exception_id) {
                        if (exception_id == 3) {
                                printf("Exception caught\n");
                                return true;
                        }
                        return false;
                }
                struct resume_group __attribute__((cleanup(__resume_group_dtor)))
                        foo_try_resume = {stack.top_resume, foo_catch_resume};
                stack.top_resume = &foo_try_resume;
                {
                        raii_t b = { "Foo try dtor" };

                        bar();

                        printf("Called bar successfully\n");
                }
        }
        printf( "Foo exited normally\n" );
}

// Not in main.cfa
void foe() {
        raii_t a = { "Foe dtor" };

        printf("Foe throws\n");
        __cfa_eh__throw_resume( 4 );

        printf("Foe exits normally\n");
}

void fy() {
        raii_t a = { "Fy dtor" };

        {
                bool fy_catch_resume(int exception_id) {
                        if (4 == exception_id) {
                                printf("Rethrow in fy\n");
                                __cfa_eh__throw_resume(exception_id);
                                return true;
                        }
                        return false;
                }
                struct resume_group __attribute__((cleanup(__resume_group_dtor)))
                        fy_try_resume = {stack.top_resume, fy_catch_resume};
                stack.top_resume = &fy_try_resume;
                {
                        raii_t b = { "Fy try dtor" };
                        foe();
                }
        }

        printf("Fy exits normally\n");
}

void fee() {
        raii_t a = { "Fee dtor" };

        {
                bool fee_catch_resume(int exception_id) {
                        if (4 == exception_id) {
                                printf("fee caught exception\n");
                                return true;
                        }
                        return false;
                }
                struct resume_group __attribute__((cleanup(__resume_group_dtor)))
                        fee_try_resume = {stack.top_resume, fee_catch_resume};
                stack.top_resume = &fee_try_resume;
                {
                        raii_t b = { "Fee try dtor" };
                        fy();
                }
        }

        printf("Fee exits normally\n");
}
// End not in main.cfa

int main() {
        raii_t a = { "Main dtor" };

        foo();

        fee();

        printf("End of program reached\n");
}