cleanup.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	__cleanup(fn)   __attribute__((cleanup(fn)))
#define	CLASS(name, var)   name##_t var __cleanup(name##_destructor) = name##_constructor
#define	DEFINE_FREE(_name, _type, _free)    static __always_inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }
#define	__free(_name)   __cleanup(__free_##_name)
#define	no_free_ptr(p)    ({ __auto_type __ptr = (p); (p) = NULL; __ptr; })
#define	return_ptr(p)   return no_free_ptr(p)
#define	DCL_CAT2(a, b)   a##b
#define	DCL_CAT(a, b)   DCL_CAT2(a, b)
#define	DCL_UID(base)   DCL_CAT(base, __COUNTER__)
#define	DCL_LOCK_GUARD_TYPES(name, type, release)
#define	DCL_LOCK_GUARD(name, type, acquire, release)
#define	DCL_LOCK_GUARD_COND(name, type, acquire, release)
#define	DEFINE_GUARD(_name, _type, _lock, _unlock)
#define	DEFINE_LOCK_GUARD_1(_name, _type, _lock, _unlock, ...)
#define	DECLARE_LOCK_GUARD_1_ATTRS(_name, _lock, _unlock)
#define	WITH_LOCK_GUARD_1_ATTRS(_name, _T)
#define	DEFINE_LOCK_GUARD_0(_name, _lock, _unlock, ...)
#define	guard(name)
#define	scoped_guard(name, args...)
#define	scoped_cond_guard(name, fail, args...)

Macro Definition Documentation

__cleanup

#define __cleanup

(

fn

)

__attribute__((cleanup(fn)))

__free

#define __free

(

_name

)

__cleanup(__free_##_name)

CLASS

#define CLASS	(		name,
			var
	)		name##_t var __cleanup(name##_destructor) = name##_constructor

DCL_CAT

#define DCL_CAT	(		a,
			b
	)		DCL_CAT2(a, b)

DCL_CAT2

#define DCL_CAT2	(		a,
			b
	)		a##b

DCL_LOCK_GUARD

#define DCL_LOCK_GUARD	(		name,
			type,
			acquire,
			release
	)

Value:

    DCL_LOCK_GUARD_TYPES(name, type, release)           \
    static inline dclg_##name dclg_##name##_ctor(type* p)       \
    {                               \
        dclg_##name g;                      \
        type* _T = p;                       \
        (void)_T;                       \
        acquire;                        \
        g.lock = p;                     \
        return g;                       \
    }

DCL_LOCK_GUARD_COND

#define DCL_LOCK_GUARD_COND	(		name,
			type,
			acquire,
			release
	)

Value:

    DCL_LOCK_GUARD_TYPES(name, type, release)           \
    static inline dclg_##name dclg_##name##_ctor(type* p)       \
    {                               \
        dclg_##name g;                      \
        type* _T = p;                       \
        int _r = (acquire);                 \
        (void)_T;                       \
        g.lock = (_r == 0) ? p : 0;             \
        return g;                       \
    }

DCL_LOCK_GUARD_TYPES

#define DCL_LOCK_GUARD_TYPES	(		name,
			type,
			release
	)

Value:

    typedef struct { type* lock; } dclg_##name;         \
    static inline void dclg_##name##_release(dclg_##name* g)    \
    {                               \
        type* _T = g->lock;                 \
        if (_T) { release; }                    \
    }

DCL_UID

#define DCL_UID

(

base

)

DCL_CAT(base, __COUNTER__)

DECLARE_LOCK_GUARD_1_ATTRS

#define DECLARE_LOCK_GUARD_1_ATTRS	(		_name,
			_lock,
			_unlock
	)

Value:

    static inline dclg_##_name dclg_##_name##_ctor(dcllt_##_name *_T) _lock;\
    static __always_inline void dclg_##_name##_unlock_ctx(dclg_##_name **_T)\
        _unlock { }

DEFINE_FREE

#define DEFINE_FREE	(		_name,
			_type,
			_free
	)		static __always_inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }

DEFINE_GUARD

#define DEFINE_GUARD	(		_name,
			_type,
			_lock,
			_unlock
	)

Value:

    typedef struct { _type lock; } dclg_##_name;            \
    static inline void dclg_##_name##_release(dclg_##_name* g)  \
    {                               \
        _type _T = g->lock;                 \
        if (_T) { _unlock; }                    \
    }                               \
    static inline dclg_##_name dclg_##_name##_ctor(_type p)     \
    {                               \
        dclg_##_name g;                     \
        _type _T = p;                       \
        (void)_T;                       \
        _lock;                          \
        g.lock = p;                     \
        return g;                       \
    }

DEFINE_LOCK_GUARD_0

#define DEFINE_LOCK_GUARD_0	(		_name,
			_lock,
			_unlock,
			...
	)

Value:

    typedef struct { void *lock; __VA_ARGS__; } dclg_##_name;   \
    static inline void dclg_##_name##_release(dclg_##_name* _T) \
    {                               \
        if (_T->lock) { _unlock; }              \
    }                               \
    static inline dclg_##_name dclg_##_name##_ctor(void)        \
    {                               \
        dclg_##_name _t = { .lock = (void*)1 };         \
        dclg_##_name* _T = &_t;                 \
        (void)_T;                       \
        _lock;                          \
        return _t;                      \
    }

DEFINE_LOCK_GUARD_1

#define DEFINE_LOCK_GUARD_1	(		_name,
			_type,
			_lock,
			_unlock,
			...
	)

Value:

    typedef struct { _type* lock; __VA_ARGS__; } dclg_##_name;  \
    typedef _type dcllt_##_name;                    \
    static inline void dclg_##_name##_release(dclg_##_name* _T) \
    {                               \
        if (_T->lock) { _unlock; }              \
    }                               \
    static inline dclg_##_name dclg_##_name##_ctor(_type* p)        \
    {                               \
        dclg_##_name g = { .lock = p };             \
        dclg_##_name* _T = &g;                  \
        (void)_T;                       \
        _lock;                          \
        return g;                       \
    }

guard

#define guard

(

name

)

Value:

    dclg_##name DCL_UID(dclg_##name)                \
        __cleanup(dclg_##name##_release) = dclg_##name##_ctor

no_free_ptr

#define no_free_ptr

(

p

)

({ __auto_type __ptr = (p); (p) = NULL; __ptr; })

return_ptr

#define return_ptr

(

p

)

return no_free_ptr(p)

scoped_cond_guard

#define scoped_cond_guard	(		name,
			fail,
			args...
	)

Value:

    for (dclg_##name _dclg __cleanup(dclg_##name##_release)     \
            = dclg_##name##_ctor(args), *_dclg_done = 0;    \
         !_dclg_done; _dclg_done = (void*)1)                \
        if (_dclg.lock == 0) { fail; } else

scoped_guard

#define scoped_guard	(		name,
			args...
	)

Value:

    for (dclg_##name _dclg __cleanup(dclg_##name##_release)     \
            = dclg_##name##_ctor(args), *_dclg_done = 0;    \
         !_dclg_done; _dclg_done = (void*)1)

WITH_LOCK_GUARD_1_ATTRS

#define WITH_LOCK_GUARD_1_ATTRS	(		_name,
			_T
	)

Value:

    dclg_##_name##_ctor(_T),                    \
    *DCL_UID(unlock) __cleanup(dclg_##_name##_unlock_ctx) =     \
        (void *)(unsigned long)(_T)