cleanup.h

Go to the documentation of this file.

 
#ifndef ZEPHYR_INCLUDE_CLEANUP_H_
#define ZEPHYR_INCLUDE_CLEANUP_H_
 
#include <zephyr/toolchain.h>
 
#if defined(CONFIG_SCOPE_CLEANUP_HELPERS) || defined(__DOXYGEN__)
 
#define SCOPE_VAR_DEFINE(_name, _type, _exit_fn, _init_fn, ...)                                    \
        static inline void __maybe_unused cleanup_##_name##_exit(_type *p)                         \
        {                                                                                          \
                _type _T = *p;                                                                     \
                _exit_fn;                                                                          \
        }                                                                                          \
        static inline _type __maybe_unused cleanup_##_name##_init(__VA_ARGS__)                     \
        {                                                                                          \
                _type t = _init_fn;                                                                \
                return t;                                                                          \
        }                                                                                          \
        typedef _type cleanup_##_name##_t
 
#define SCOPE_GUARD_DEFINE(_name, _type, _lock, _unlock)                                           \
        SCOPE_VAR_DEFINE(                                                                          \
                guard_##_name, _type, if (_T != NULL) { _unlock; }, ({                             \
                        _lock;                                                                     \
                        _T;                                                                        \
                }),                                                                                \
                _type _T)
 
#define SCOPE_COND_GUARD_DEFINE(_name, _type, _try_lock, _unlock)                                  \
        SCOPE_VAR_DEFINE(guard_##_name, _type, if (_T != NULL) { _unlock; },                       \
                         ((_try_lock) ? _T : NULL), _type _T)
 
#define Z_SCOPE_DEFER_DEFINE_VOID(_func)                                                           \
        SCOPE_VAR_DEFINE(defer_##_func, void *, (void)_T; (void)_func(), NULL, void)
 
#define Z_DEFER_CTX_ARG(idx, t) t arg##idx;
#define Z_DEFER_FUNC_ARG(idx, t) t arg##idx
#define Z_DEFER_INIT_ARG(idx, _) .arg##idx = arg##idx
#define Z_DEFER_EXIT_ARG(idx, _) _T.arg##idx
#define Z_COMMA ,
 
#define Z_SCOPE_DEFER_DEFINE_N(_func, ...)                                                         \
        struct defer_##_func##_ctx {                                                               \
                FOR_EACH_IDX(Z_DEFER_CTX_ARG, (), __VA_ARGS__)                                     \
        };                                                                                         \
        SCOPE_VAR_DEFINE(defer_##_func, struct defer_##_func##_ctx,                                \
                     (void)_func(FOR_EACH_IDX(Z_DEFER_EXIT_ARG, (Z_COMMA), __VA_ARGS__)),          \
                     {FOR_EACH_IDX(Z_DEFER_INIT_ARG, (Z_COMMA), __VA_ARGS__)},                     \
                     FOR_EACH_IDX(Z_DEFER_FUNC_ARG, (Z_COMMA), __VA_ARGS__))
 
#define SCOPE_DEFER_DEFINE(_func, ...)                                                             \
        COND_CODE_0(NUM_VA_ARGS(__VA_ARGS__),                                                      \
                    (Z_SCOPE_DEFER_DEFINE_VOID(_func)),                                            \
                    (Z_SCOPE_DEFER_DEFINE_N(_func, __VA_ARGS__)))
 
#define Z_UNIQUE_ID(_prefix) _CONCAT(_CONCAT(Z_UNIQUE_ID_, _prefix), __COUNTER__)
 
/*
 * Block-scope wrapper for @ref scoped_guard. A single-iteration nested for-loop ties the
 * lifetime of the guard variable (_g) - and thus its cleanup/release - to the brace body
 * that follows. The body is guarded on _g != NULL so that a conditional guard whose
 * acquisition fails skips the body instead of running it without the lock held.
 * For an unconditional guard _g is always non-NULL.
 */
#define Z_SCOPED_GUARD(_name, _g, _done, ...)                                                      \
        for (int _done = 0; _done == 0; _done = 1)                                                 \
                for (scope_var(guard_##_name, _g)(__VA_ARGS__); _done == 0 && _g != NULL;          \
                     _done = 1)
 
/*
 * Block-scope wrapper for @ref scoped_cond_guard. Like Z_SCOPED_GUARD but the guard
 * variable is named (_g) so the body can be guarded on whether the lock was acquired:
 * when acquisition fails _g is NULL, _fail runs and the body is skipped.
 */
#define Z_SCOPED_COND_GUARD(_name, _g, _done, _fail, ...)                                          \
        for (int _done = 0; _done == 0; _done = 1)                                                 \
                for (scope_var(guard_##_name, _g)(__VA_ARGS__); _done == 0; _done = 1)             \
                        if (_g == NULL) {                                                          \
                                _fail;                                                             \
                        } else
 
#define scope_var(_name, _var)                                                                     \
        cleanup_##_name##_t _var __cleanup(cleanup_##_name##_exit) = cleanup_##_name##_init
 
#define scope_var_init(_name, _var, _init_expr)                                                    \
        cleanup_##_name##_t _var __cleanup(cleanup_##_name##_exit) = (_init_expr)
 
#define scope_guard(_name) scope_var(guard_##_name, Z_UNIQUE_ID(guard))
 
#define scoped_guard(_name, ...)                                                                   \
        Z_SCOPED_GUARD(_name, Z_UNIQUE_ID(scoped_g), Z_UNIQUE_ID(scoped_done), __VA_ARGS__)
 
#define scoped_cond_guard(_name, _fail, ...)                                                       \
        Z_SCOPED_COND_GUARD(_name, Z_UNIQUE_ID(scoped_g), Z_UNIQUE_ID(scoped_done), _fail,         \
                            __VA_ARGS__)
 
#define scope_defer(_name) scope_var(defer_##_name, Z_UNIQUE_ID(defer))
 
#endif /* defined(CONFIG_SCOPE_CLEANUP_HELPERS) || defined(__DOXYGEN__) */
 
#endif /* ZEPHYR_INCLUDE_CLEANUP_H_ */