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