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 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__)


#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 scope_defer(_name) scope_var(defer_##_name, Z_UNIQUE_ID(defer))

 
#endif /* defined(CONFIG_SCOPE_CLEANUP_HELPERS) || defined(__DOXYGEN__) */
 
#endif /* ZEPHYR_INCLUDE_CLEANUP_H_ */