block.h

Go to the documentation of this file.

#pragma once
 
 
 
// Block wrapping using complex for statements
// Inspired by P99 preprocessor macros, modified (in some cases heavily)
// to fit with CX design philosophy.
// https://gustedt.gitlabpages.inria.fr/p99/p99-html/
 
#include <cx/platform/base.h>
#include <cx/stype/stype.h>
#include <cx/utils/macros/tokens.h>
 
// -------------------- Compile-Time Feature Inhibition --------------------
 
 
#define _inhibit_name(name) _inhibit_##name
 
#define inhibitDeclare(name) enum { _inhibit_name(name) = 0 }
 
#if (!defined(_MSC_VER) || _MSC_VER > 1930) && !defined(__cplusplus)
#define inhibitCheck(name)                                       \
    switch (tokstring(_inhibit_name(name))[_inhibit_name(name)]) \
    default:
#else
#define inhibitCheck(name)
#endif
 
#define _inhibitDisallow(name) \
    _blkCond(const int* const _inhibit_name(name) = 0, !_inhibit_name(name))
 
#define inhibitDisallow(name) _blkStart _inhibitDisallow(name)
 
#define _inhibitAllow(name) _blkCond(const int _inhibit_name(name) = 0, !_inhibit_name(name))
 
#define inhibitAllow(name) _blkStart _inhibitAllow(name)
 
 
// The "RETURN" feature is used internally for correctness checks
 
// If this is being compiled in debug/dev mode, redefine "return" to check it for correctness
#if DEBUG_LEVEL >= 1 && !defined(_PREFAST_)
inhibitDeclare(RETURN);
#define _inhibitReturn _inhibitDisallow(RETURN)
#define _allowReturn   _inhibitAllow(RETURN)
#define return         inhibitCheck(RETURN) return
#else
#define _inhibitReturn _blkStart
#define _allowReturn   _blkStart
#endif
 
// -------------------- Block Wrapping Macros --------------------
 
#define _BLK_VAR _block_done
 
// Internal building blocks (no pun intended)
 
#define _blkDef(before)        for (tokeval(before); _BLK_VAR; _BLK_VAR = 0)
#define _blkCond(before, cond) for (tokeval(before); (cond) && _BLK_VAR; _BLK_VAR = 0)
#define _blkFull(before, cond, ...) \
    for (tokeval(before); (cond) && _BLK_VAR; (__VA_ARGS__), _BLK_VAR = 0)
 
// _blkStart should be the first token used when building a structure that uses blocks.
// It declares the marker variable that is used to ensure the various for loop abuse only executes
// once.
#define _blkStart                    _blkDef(bool _BLK_VAR = 1)
#define _blkBefore(...)              for (tokeval(__VA_ARGS__); _BLK_VAR; _BLK_VAR = 0)
#define _blkBeforeAfter(before, ...) _inhibitReturn _blkFull(tokeval(before), true, __VA_ARGS__)
#define _blkAfter(...)               _blkBeforeAfter(, (__VA_ARGS__))
// _blkEnd is used as an inner loop around a user-provided block to swallow 'break' so it
// doesn't interrupt control flow.
#define _blkEnd                      _blkBefore()
 
// Special helper for declaring a scoped variable that can refer to a variable in the outer scope
// with the same name. It does this by using a temporary variable with a different name.
#define _blkDefRecursive(type, name, ...)                            \
    _blkDef(type tokcat2(_block_decl_, name) = tokeval(__VA_ARGS__)) \
        _blkCond(type name = tokcat2(_block_decl_, name), ((void)name, true))
 
#define blkWrap(before, ...) _blkStart _blkBeforeAfter(tokeval(before), __VA_ARGS__) _blkEnd