pblock.h

Go to the documentation of this file.

#pragma once
 
 
 
#include <cx/meta/block.h>
#include <cx/utils/macros/unused.h>
#include <setjmp.h>
 
enum _pblock_unwind_const {
    _pblock_unwind_top = 0
};
 
typedef struct _pblock_jmp_buf_node _pblock_jmp_buf_node;
typedef struct _pblock_jmp_buf_node {
    _pblock_jmp_buf_node *next;  
    jmp_buf buf;                 
    volatile int target;         
} _pblock_jmp_buf_node;
 
typedef _pblock_jmp_buf_node _pblock_jmp_buf[1];
#define BLOCK_JMPBUF_INIT {[0] = {.target = 0}}
 
_meta_inline /*noreturn*/ void _pbLongjmp(_pblock_jmp_buf_node *node, int val)
{
    node->target = val;
    longjmp(node->buf, 1);
}
 
#define pblock                                                                                                  \
    _blkStart                                                                                                   \
    _inhibitReturn                                                                                              \
    /* set to true during the unwinding process */                                                              \
    _blkDef(volatile bool _pblock_unwind = false)                                                               \
    _blkFull(/* BEFORE */ volatile int _pblock_target = 0, true,                                                \
        /* After we exit the block through whatever means, if we are unwinding, try to unwind the next level.   \
         * Since this loop is above the one that defines _pblock_unwind_top, the jump buffer here points to the \
         * one set by the block that encloses this one and we'll jump back into it, giving it the ability to    \
         * run any PBLOCK_AFTER cleanup and continue the chain.                                                 \
         * In the outermost block, _pblock_unwind_top will instead be 0 from the global enum, and pblockUnwind  \
         * will do nothing.                                                                                     \
         * If _pblock_target reaches 0, this will also exit the loop and continue execution as normal. */       \
        /* AFTER */ (_pblock_unwind ?                                                                           \
            pblockUnwind(_pblock_target <= 0 ? _pblock_target : _pblock_target - 1) : nop_stmt))                \
    /* allocate a jump buffer on the stack for this level of recursion */                                       \
    _blkDef(_pblock_jmp_buf _pblock_unwind_top = tokeval(BLOCK_JMPBUF_INIT))                                    \
    /* set the longjump target to be within the inntermost loop and coerce the return value to 1 or 0 */        \
    switch(setjmp(_pblock_unwind_top[0].buf))                                                                   \
        /* case 2 doesn't actually exist, it serves as a place to hang an if-else construct so we can define    \
           two case labels here instead of only one - case 0 for the user block to execute, and a default       \
           case label that acts as a fallback for case 1 not being defined, which can happen if the user does   \
           not include a PBLOCK_AFTER label. */                                                                 \
        case 2: if (0) {                                                                                        \
            default:                                                                                            \
                /* if there isn't a PBLOCK_AFTER but we got here as a longjmp target, we need to take care of   \
                 * setting up the variable for unwinding, otherwise the AFTER blocks will fail to jump to the   \
                 * next target in the chain and we'll stop unwinding early. */                                  \
                _pblock_target = _pblock_unwind_top[0].target;                                                  \
                _pblock_unwind = !!_pblock_target;                                                              \
        } else                                                                                                  \
        /* This is the case for when we get here the first time, right after calling setjmp. The user-provided  \
         * block slots in directly after this label. */                                                         \
        case 0:
 
 
_meta_inline void _pblockUnwind(void *top, int cond)
{
    if (cond && top) _pbLongjmp(top, cond);
}
 
#define pblockUnwind(num) _pblockUnwind((void*)_pblock_unwind_top, (num))
 
#define PBLOCK_AFTER                                                                                            \
    if (0) {                                                                                                    \
        /* Even though this case 1 label is placed into the user-defined block, it technically exists within    \
         * the switch statement at the end of the pblock macro.                                                 \
         * When the user provides a PBLOCK_AFTER target, it defines this case 1 which overrides the default     \
         * case label (the one that's hidden in the if(0) after the case 2:) and comes here instead. */         \
        case 1:                                                                                                 \
            _pblock_target = _pblock_unwind_top[0].target;                                                      \
            _pblock_unwind = !!_pblock_target;                                                                  \
            /* Execution falls through to the statement below. */                                               \
    }                                                                                                           \
    /* This odd looking construct exists to swallow the ':' after the fake PBLOCK_AFTER label. */               \
    switch(0) case 0