/** exceptions.c -- by James D. Lin (last updated: 2006-02-14)
  *
  *    A set of macros to simulate exception-like handling.
  */

/** Usage:
  *
  *     USES_EXCEPTIONS();
  *
  *     TRY
  *     {
  *         ...
  *
  *         THROW(<E>);
  *
  *         ...
  *     }
  *     CATCH(int <err>)
  *     {
  *         switch (<err>)
  *         {
  *             case <E1>:
  *                 ...
  *                 break;
  *
  *             case <E2>:
  *                 ...
  *                 break;
  *
  *             ...
  *
  *             default:
  *                 ...
  *                 break;
  *         }
  *     } END_CATCH;
  *
  *
  * Notes:
  *
  *     * Exceptions are represented as ints.
  *
  *     * Unhandled exceptions won't be rethrown automatically.  It's your
  *       responsibility to rethrow if necessary.
  *
  *     * Code that uses these TRY/CATCH/THROW macros must not use the
  *       following variables:
  *         _cur_exception
  *         _old_exception_env
  *
  *     * Local, automatic variables modified within a TRY block should be
  *       declared as volatile.
  *
  *     * The JMP_BUF_COPY macro is non-portable and is dependent on the
  *       implementation of jmp_buf.
  *
  *
  * Warning:
  *
  *     Just because you can doesn't mean you should!  This is meant for
  *     demonstrative purposes only; I actually don't recommend that people
  *     use this.
  *
  *     * In general, using exceptions makes it harder to determine where
  *       failure points are.  See also:
  *
  *         <http://joelonsoftware.com/items/2003/10/13.html>
  *         <http://blogs.msdn.com/oldnewthing/archive/2004/04/22/118161.aspx>
  *
  *     * Unlike C++, C lacks the RAII idiom and therefore cannot
  *       automatically release resources as they fall out of scope.
  *
  *     * Unlike Java, C lacks a garbage collector and therefore all
  *       allocated memory must be freed explicitly.
  *
  *     * Unlike Java, these macros provide no analogue to a 'finally'
  *       clause and therefore cannot clean up arbitrary resources along
  *       multiple code paths without duplicating code.
  *
  *     Simply put, with no automatic safeguards provided by the language,
  *     any such system makes it very easy to leak memory and other
  *     resources.  C is best suited for a single-entry, single-exit (SESE)
  *     error-handling pattern; it's been that way for decades; get used to
  *     it.
  */

#include <setjmp.h>
#include <string.h>

#if DEBUG > 0
    #include <stdio.h>
#endif



/* TYPEDEFS ------------------------------------------------------------ */

typedef struct
{
    jmp_buf env;
    int err;

#if DEBUG > 0
    char* file;
    unsigned int line;
#endif
} exception_t;



/* MACROS -------------------------------------------------------------- */

/* This macro might not be portable! */
#define JMP_BUF_COPY(jbDest, jbSrc) memmove(jbDest, jbSrc, sizeof(jbDest))


/** Use if you want to use these macros.  Use this at file-scope or
  * local-scope.
  */
#define USES_EXCEPTIONS() extern exception_t _cur_exception


/* Save a copy of the current jmp_buf. */
#define TRY \
    { \
        jmp_buf _old_exception_env; \
        JMP_BUF_COPY(_old_exception_env, _cur_exception.env); \
        if ((_cur_exception.err = setjmp(_cur_exception.env)) == 0) \
        {


/* Restore the saved jmp_buf. */
#define CATCH(errDecl) \
           JMP_BUF_COPY(_cur_exception.env, _old_exception_env); \
        } \
        else \
        { \
            errDecl = _cur_exception.err; \
            JMP_BUF_COPY(_cur_exception.env, _old_exception_env);


#define END_CATCH \
        } \
    }


#if DEBUG > 0
    #define THROW(e) THROW_WITH_CONTEXT(e)
#else
    #define THROW(e) THROW_BASIC(e)
#endif


#define THROW_BASIC(e) longjmp(_cur_exception.env, e)


#define THROW_WITH_CONTEXT(e) \
    (_cur_exception.file = __FILE__, \
     _cur_exception.line = __LINE__, \
     DEBUG_PRINT_THROW_CONTEXT(e), \
     longjmp(_cur_exception.env, e))


#if DEBUG > 1
    #define DEBUG_PRINT_THROW_CONTEXT(e) \
         fprintf(stderr, \
                 "throwing %u (" __FILE__ ", %u)\n", \
                 e, __LINE__)
#else
    #define DEBUG_PRINT_THROW_CONTEXT ((void) 0)
#endif



/* GLOBALS ------------------------------------------------------------- */

exception_t _cur_exception;



/* EXAMPLE ------------------------------------------------------------- */

#include <stdio.h>
#include <stdlib.h>


static void g(int n)
{
    THROW(n);
}



static void f(int n)
{
    g(n);
}


int main(void)
{
    USES_EXCEPTIONS();

    TRY
    {
        TRY
        {
            f(1);

            printf("Not reached.\n");
        }
        CATCH(int e)
        {
            TRY
            {
                printf("Caught inner: %d\n", e);

                /* Rethrow. */
                THROW(e);
            }
            CATCH(int e)
            {
                printf("Recaught inner: %d\n", e);
            }
            END_CATCH;

            THROW(2);

        } END_CATCH;
    }
    CATCH(int e)
    {
        printf("Caught outer: %d\n", e);
    } END_CATCH;

    return EXIT_SUCCESS;
}