source: doc/working/exception/translate.c@ cc3e4d0

/* Translation rules for exception handling code, from Cforall to C.
 *
 * Note that these are not final. Names, syntax and the exact translation
 * will be updated. The first section is the shared definitions, not generated
 * by the local translations but used by the translated code.
 *
 * Most of these exist only after translation (in C code). The first (the
 * exception type) has to exist in Cforall code so that it can be used
 * directly in Cforall. The two __throw_* functions might have wrappers in
 * Cforall, but the underlying functions should probably be C. struct
 * stack_exception_data has to exist inside of the coroutine data structures
 * and so should be compiled as they are.
 */

// Currently it is a typedef for int, but later it will be a new type.
typedef int exception;

void __throw_terminate(exception except) __attribute__((noreturn));
void __throw_resume(exception except);

void __try_terminate(void (*try_block)(),
        void (*catch_block)(int index, exception except),
        int (*match_block)(exception except));

struct __try_resume_node {
        struct __try_resume_node * next;
        bool (*try_to_handle)(exception except);
};

struct __cleanup_hook {};

// An instance of the following must be paired with every stack.
struct stack_exception_data {
        __try_resume_node * top_resume_data;
        // Other pointers may be required for re-resume.

        exception current_exception;
        int handler_index;
};


// Translations:

// Throws:
"Cforall"

throw exception_instance;

resume exception_instance;

"C"

__throw_terminate(exception_instance);

__throw_resume(exception_instance);



// Rethrows (inside matching handlers):
"Cforall"

throw;

resume;

"C"

__rethrow_terminate();

return false;


// Termination Handlers:
"Cforall"

void try_terminate() {
        try {
                insideTry();
        }
        catch (SomeException) {
                fiddleThing();
        }
        catch (OtherException err ; err.priority > 3) {
                twiddleWidget();
        }
}

"C"

void try_terminate() {
        {
                void try1() {
                        insideTry();
                }
                // index is not nessasary, but should be much faster than going over
                // all the checks in if we can find a way to pass it in.
                void catch1(exception except, int index) {
                        switch (index) {
                        case 1:
                                // if it is referenced in the handler, cast except.
                                {
                                        fiddleThing();
                                }
                                return;
                        case 2:
                                {
                                        twiddleWidget();
                                }
                                return;
                        default:
                                // Error, should never be reached.
                        }
                }
                int match1(exception except) {
                        OtherException inner_except;
                        if (dynamic_cast__SomeException(except)) {
                                return 1;
                        }
                        else if ( (inner_except = dynamic_cast__OtherException(except)) &&
                                        inner_except.priority > 3) {
                                return 2;
                        }
                        else return 0;
                }
                __try_terminate(try1, catch1, match1);
        }
}


// Resumption Handlers:
"Cforall"

void try_resume() {
        try {
                insideTry();
        }
        catch resume (SomeException) {
                fiddleThing();
        }
        catch resume (OtherException err ; err.priority > 3) {
                twiddleWidget();
        }
}

"C"

void try_resume() {
        {
                bool catch1(exception except) {
                        OtherException inner_except;
                        if (dynamic_cast__SomeException(except)) {
                                fiddleThing();
                                return true;
                        } else if (dynamic_cast__OtherException(except) &&
                                        inner_except.priority > 3) {
                                twiddleWidget();
                                return true;
                        } else {
                                return false;
                        }
                }
                struct __try_resume_node data =
                        {.next = stack.except.top_resume, .try_to_handle = catch1};
                stack.except.top_resume = &data;

                struct __cleanup_hook generated_name
                        __attribute__((cleanup(__try_resume_cleanup)));

                {
                        insideTry();
                }
        }
}


// Finally Clause:
"Cforall"

void try_finally() {
        try {
                insideTry();
        }
        finally {
                twiddleWidget();
        }
}

"C"

void try_finally() {
        {
                void finally1() {
                        twiddleWidget();
                }

                struct __cleanup_hook generated_name
                        __attribute__((cleanup(finally1)));

                {
                        insideTry();
                }
        }
}


// Combining the Above:
"Cforall"

void try_all() {
        try {
                insideTry();
        }
        catch (SomeException) {
                fiddleThing();
        }
        catch resume (OtherException) {
                twiddleWidget();
        }
        finally {
                twiddleWidget();
        }
}

"C"

void try_all() {
        {
                void try1 () {
                        insideTry();
                }
                void catch1(exception except, int index) {
                        switch (index) {
                        case 1:
                                fiddleThing();
                                break;
                        default:
                                // Error if reached.
                        }
                }
                int match1(exception except) {
                        if (dynamic_cast__SomeException(except)) {
                                return 1;
                        }
                        return 0;
                }
                bool catch2() {
                        if (dynamic_cast__OtherException(except)) {
                                twiddleWidget();
                                return true;
                        }
                        return false;
                }
                void finally1() {
                        // Finally, because of timing, also works for resume.
                        // However this might not actually be better in any way.
                        __try_resume_cleanup();

                        twiddleWidget();
                }

                struct __try_resume_node generated_name =
                        {.next = stack.except.top_resume, .try_to_handle = catch2};
                stack.except.top_resume = &data;
                struct __cleanup_hook generated_name
                        __attribute__((cleanup(finally1)));

                __try_terminate(try1, catch1, match1);
        }
}