ptry.h

Go to the documentation of this file.

#pragma once
 
 
 
#include <cx/meta/pblock.h>
 
typedef struct ExceptionInfo {
    int code;                   
    const char *msg;            
#if DEBUG_LEVEL >= 1
    const char *file;           
    int ln;                     
#endif
} ExceptionInfo;
 
extern _Thread_local _pblock_jmp_buf_node *_ptry_top;           // stack of jump buffers to rewind to
extern _Thread_local ExceptionInfo _ptry_exc;                   // currently active exception
extern ExceptionInfo _ptry_exc_empty;
 
typedef int (*ptUnhandledHandler)(ExceptionInfo *einfo);
 
// GCC falsely warns that _ptry_top is a dangling pointer, even though we're very careful to clean
// it up when exiting the scope that the local variable it points to is declared in.
#if defined(__GNUC__) && __GNUC__ >= 12
#define ptDisablePtrWarning _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wdangling-pointer\"")
#define ptReenableWarnings _Pragma("GCC diagnostic pop")
#else
#define ptDisablePtrWarning
#define ptReenableWarnings
#endif
 
void ptRegisterUnhandled(ptUnhandledHandler handler);
 
void ptUnregisterUnhandled(ptUnhandledHandler handler);
 
void _ptry_handle_unhandled(ExceptionInfo *einfo);
 
_meta_inline void _ptry_clear(void)
{
    _ptry_exc = _ptry_exc_empty;
}
 
_meta_inline void _ptry_push(_pblock_jmp_buf_node *node)
{
    node->next = _ptry_top;
    ptDisablePtrWarning;
    _ptry_top = node;
    ptReenableWarnings;
}
 
_meta_inline _pblock_jmp_buf_node *_ptry_pop(void)
{
    _pblock_jmp_buf_node *ret = _ptry_top;
    if (!ret)
        return ret;
 
    _ptry_top = ret->next;
    ret->next = NULL;
    return ret;
}
 
_meta_inline void _ptry_pop_until(_pblock_jmp_buf_node *node)
{
    _pblock_jmp_buf_node *last;
    // keep popping until we hit the specified node or run out of jump buffers
    do {
        last = _ptry_pop();
    } while (last && last != node);
}
 
#if DEBUG_LEVEL >= 1
_meta_inline void _ptry_throw(int code, const char *msg, const char *file, int ln)
#else
_meta_inline void _ptry_throw(int code, const char *msg)
#endif
{
    // populate the thread-local exception info as we go into exception-handling mode
    _ptry_exc.code = code;
    _ptry_exc.msg = msg;
#if DEBUG_LEVEL >= 1
    _ptry_exc.file = file;
    _ptry_exc.ln = ln;
#endif
 
    // jump to the handler block if we have one, in most cases this function stops executing here
    if (_ptry_top) _pbLongjmp(_ptry_top, -1);
 
    // otherwise call the unhandled exception handler, this will probably abort and never return
    _ptry_handle_unhandled(&_ptry_exc);
 
    // if it DOES return, terminate exception processing
    _ptry_clear();
}
 
#if DEBUG_LEVEL >= 1
#define ptThrow(code, msg) _ptry_throw(code, msg, __FILE__, __LINE__)
#else
#define ptThrow(code, msg) _ptry_throw(code, msg)
#endif
 
#if DEBUG_LEVEL >= 1
#define ptRethrow _ptry_throw(_ptry_exc.code, _ptry_exc.msg, _ptry_exc.file, _ptry_exc.ln)
#else
#define ptRethrow _ptry_throw(_ptry_exc.code, _ptry_exc.msg)
#endif
 
#define ptTry                                                                                       \
    pblock                                                                                          \
    /* phase 0 is the try, phase 1 is the catch/finally */                                          \
    for (unsigned _ptry_phase = 0; _ptry_phase < 2; ++_ptry_phase)                                  \
        /* try phase */                                                                             \
        if (!_ptry_phase)                                                                           \
            /* push the current pblock jump target to the exception handler stack */                \
            /* this will cause it to be entered through the switch label */                         \
            _blkBefore(_ptry_push(_pblock_unwind_top))                                              \
            do
 
// common setup for catch/finally
#define _ptry_after_block                                                                           \
    /* this can be reached two ways, either naturally in phase 1 of the _ptry_phase loop (this is   \
     * the 'else'), or if an exception occurs, through the case 1: label through the pblock after   \
     * longjmping into the pblock loop from a lower stack frame. The latter is the same mechanism   \
     * that PBLOCK_AFTER would use, but for try/catch it's unconditional. */                        \
    while(0); else case 1:                                                                          \
    /* critically important to protect the outer block loop variable here! */                       \
    _blkStart                                                                                       \
    /* make sure that this phase isn't executed again (if we got here via longjmp) */               \
    _blkBefore(_ptry_phase = 2)                                                                     \
    /* unwind the handler stack to one level above where we currently are */                        \
    _blkBefore(_ptry_pop_until(_pblock_unwind_top))
 
#define ptFinally                                                                                   \
    _ptry_after_block                                                                               \
    /* finally blocks end in an implicit rethrow if there is an active exception */                 \
    _blkAfter(_ptry_exc.code ? ptRethrow : nop_stmt)
 
#define ptCatch                                                                                     \
    _ptry_after_block                                                                               \
    _blkAfter(_ptry_clear())
 
#define ptCode _ptry_exc.code
 
#define ptMsg _ptry_exc.msg