source: doc/working/exception/translate.c @ 7ab24fef

/* Translation rules for exception handling code, from Cforall to C.
 *
 * Reminder: This is not final. Besides names and things it is also going very
 * much for correctness and simplisity over efficiency.
 *
 * 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;

// Will have to be availibe to user. Consider new name. Requires tagged types.
forall(dtype parent | tagged(parent), dtype child | tagged(child))
parent *dynamic_cast(child *);

void __throw_terminate(exception except) __attribute__((noreturn));
void __rethrow_terminate() __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);
};

void __try_resume_cleanup(struct __try_resume_node * node);

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) {
                        {
                                if (dynamic_cast__SomeException(except)) {
                                        return 1;
                                }
                        }
                        {
                                OtherException err;
                                if ( (err = dynamic_cast__OtherException(except)) &&
                                                err.priority > 3) {
                                        return 2;
                                }
                        }
                        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 handle1(exception except) {
                        {
                                if (dynamic_cast__SomeException(except)) {
                                        fiddleThing();
                                        return true;
                                }
                        }
                        {
                                OtherException err;
                                if ( ( err = dynamic_cast__OtherException(except) ) &&
                                                err.priority > 3) {
                                        twiddleWidget();
                                        return true;
                                }
                        }
                        return false;
                }
                struct __try_resume_node data =
                        {.next = stack.except.top_resume, .try_to_handle = handle1};
                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();
                }
        }
}


// Resume + Finally:
"Cforall"

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

"C"

void try_resume_finally() {
        {
                void finally1() {
                        twiddleWidget();
                }
                bool handle1(exception except) {
                        {
                                if (dynamic_cast__SomeException(except)) {
                                        fiddleThing();
                                        return true;
                                }
                        }
                        return false;
                }
                struct __cleanup_hook generated_name
                        __attribute__((cleanup(finally1)));

                struct __try_resume_node data =
                        {.next = stack.except.top_resume, .try_to_handle = handle1};
                stack.except.top_resume = &data;

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


// Terminate + Resume + Finally:
"Cforall"

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

"C"

void try_all() {
        {
                bool handle1() {
                        {
                                if (dynamic_cast__OtherException(except)) {
                                        twiddleWidget();
                                        return true;
                                }
                        }
                        return false;
                }
                void try1 () {
                        struct __try_resume_node generated_name =
                                {.next = stack.except.top_resume, .try_to_handle = handle1}
                                __attribute__((cleanup(__try_resume_cleanup)));
                        stack.except.top_resume = &data;

                        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;
                }
                void finally1() {

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

                __try_terminate(try1, catch1, match1);
        }
}