defer.h

Go to the documentation of this file.

 
#ifndef __DEFER__H
#define __DEFER__H
 
#include <stddef.h>
 
#ifdef _WIN32
#define ATTR_UNUSED
#else
#define ATTR_UNUSED __attribute__((__unused__))
#endif
 
// Macro helpers
#define _DEFER_CONCAT_IMPL(a, b) a##b
#define _DEFER_CONCAT(a, b)      _DEFER_CONCAT_IMPL(a, b)
 
//******************************************************************************
//*                                                                            *
//*                           C++ IMPLEMENTATION                               *
//*                                                                            *
//******************************************************************************
 
#ifdef __cplusplus
 
#include <utility>
 
// 1. The RAII Holder that runs the lambda on destruction
template <typename F>
struct Deferrer {
    F f;
    Deferrer(F&& func) : f(std::forward<F>(func)) {}
    ~Deferrer() { f(); }
    Deferrer(const Deferrer&) = delete;
    Deferrer& operator=(const Deferrer&) = delete;
};
 
// 2. A dummy helper tag to trigger operator overloading
struct DeferHelper {};
 
// 3. Operator+ overload to capture the lambda
// This allows the syntax: DeferHelper() + [&](){ ... }
template <typename F>
Deferrer<F> operator+(DeferHelper, F&& f) {
    return Deferrer<F>(std::forward<F>(f));
}
 
// 4. The Macro
// Expands to: auto _var_N = DeferHelper() + [&]() { user_code };
#define defer auto _DEFER_CONCAT(__defer_var_, __COUNTER__) = DeferHelper() + [&]()
 
//******************************************************************************
//*                                                                            *
//*                      C IMPLEMENTATION - GCC                                *
//*                                                                            *
//******************************************************************************
 
#elif defined(__GNUC__) && !defined(__clang__)
#define __DEFER(N)  __DEFER_(N)
#define __DEFER_(N) __DEFER__(_DEFER_CONCAT(__defer_fn_, N), _DEFER_CONCAT(__defer_var_, N))
 
#define __DEFER__(F, V)                    \
    auto void F(int*);                     \
    [[gnu::cleanup(F)]] ATTR_UNUSED int V; \
    auto void F(int* _unused ATTR_UNUSED)
 
#define defer __DEFER(__COUNTER__)
 
//******************************************************************************
//*                                                                            *
//*                      C IMPLEMENTATION - CLANG                              *
//*                                                                            *
//******************************************************************************
 
#elif defined(__clang__)
 
#include <Block.h>
 
typedef void (^defer_block)(void);
 
static inline void __defer_cleanup(defer_block* ptr) {
    if (ptr && *ptr) {
        (*ptr)();
    }
}
 
// Macro helpers
#define _DEFER_CONCAT_IMPL(a, b) a##b
#define _DEFER_CONCAT(a, b)      _DEFER_CONCAT_IMPL(a, b)
 
#define defer \
    __attribute__((cleanup(__defer_cleanup))) ATTR_UNUSED defer_block _DEFER_CONCAT(__defer_var_, __COUNTER__) = ^
 
//******************************************************************************
//*                                                                            *
//*                      C IMPLEMENTATION - MSVC                               *
//*                                                                            *
//******************************************************************************
 
#elif defined(_MSC_VER)
 
#elif defined(_MSC_VER)
 
// Uses SEH __try/__finally
// Expands to: __try { } __finally { user_code }
#define defer \
    __try {   \
    } __finally
 
#else
#error "Unsupported compiler"
#endif
 
#endif  // __DEFER__H