// Copyright (C) 2006-2009, 2012 Alexander Nasonov

// Copyright (C) 2012 Lorenzo Caminiti

// Distributed under the Boost Software License, Version 1.0

// (see accompanying file LICENSE_1_0.txt or a copy at

// http://www.boost.org/LICENSE_1_0.txt)

// Home at http://www.boost.org/libs/scope_exit

#ifndef FILE_boost_scope_exit_hpp_INCLUDED

#define FILE_boost_scope_exit_hpp_INCLUDED

#ifndef DOXYGEN

#include <boost/detail/workaround.hpp>

#include <boost/mpl/assert.hpp>

#include <boost/mpl/int.hpp>

#include <boost/utility/enable_if.hpp>

#include <boost/function.hpp>

#include <boost/typeof/typeof.hpp>

#include <boost/config.hpp>

#include <boost/preprocessor/cat.hpp>

#include <boost/preprocessor/control/iif.hpp>

#include <boost/preprocessor/control/expr_iif.hpp>

#include <boost/preprocessor/comparison/equal.hpp>

#include <boost/preprocessor/logical/bitor.hpp>

#include <boost/preprocessor/logical/bitand.hpp>

#include <boost/preprocessor/facilities/empty.hpp>

#include <boost/preprocessor/facilities/is_empty.hpp>

#include <boost/preprocessor/facilities/identity.hpp>

#include <boost/preprocessor/punctuation/comma_if.hpp>

#include <boost/preprocessor/punctuation/paren_if.hpp>

#include <boost/preprocessor/seq/cat.hpp>

#include <boost/preprocessor/seq/size.hpp>

#include <boost/preprocessor/seq/to_tuple.hpp>

#include <boost/preprocessor/tuple/elem.hpp>

#include <boost/preprocessor/tuple/eat.hpp>

#include <boost/preprocessor/tuple/to_list.hpp>

#include <boost/preprocessor/list/append.hpp>

#include <boost/preprocessor/list/fold_left.hpp>

#include <boost/preprocessor/list/enum.hpp>

#include <boost/preprocessor/list/adt.hpp>

#include <boost/preprocessor/list/for_each_i.hpp>

#include <boost/preprocessor/detail/is_unary.hpp>

// PRIVATE/PROTECTED //

// NOTE: AUX prefix and aux namespace mark "private" symbols that shall be used

// only within this library; DETAIL prefix and detail namespace mark "protected"

// symbols that can be used by other Boost libraries but not outside Boost.

// WARNING: BOOST_SCOPE_EXIT_AUX_GCC also used by some regression test.

#if defined(__GNUC__) && !defined(BOOST_INTEL)

#   define BOOST_SCOPE_EXIT_AUX_GCC (__GNUC__ * 100 + __GNUC_MINOR__)

#else

#   define BOOST_SCOPE_EXIT_AUX_GCC 0

#endif

#if BOOST_WORKAROUND(BOOST_SCOPE_EXIT_AUX_GCC, BOOST_TESTED_AT(413))

#   define BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 1

#else

#   define BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01 0

#endif

#if BOOST_MSVC

#   define BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 1

#else

#   define BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01 0

#endif

// MSVC has problems expanding __LINE__ so use (the non standard) __COUNTER__.

#ifdef BOOST_MSVC

#   define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __COUNTER__

#else

#   define BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER __LINE__

#endif

// Preprocessor "keyword" detection.

// These are not a local macros, do not #undefine them (these are used by the

// ..._BACK macros below).

#define this_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS (1) /* unary */

#define void_BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS (1) /* unary */

#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, checking_postfix) \

    BOOST_PP_IS_UNARY(BOOST_PP_CAT(token, checking_postfix))

#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(token) \

    BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \

            BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_THISUNDERSCORE_IS)

#define BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK(token) \

    BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_BACK_(token, \

            _BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_VOID_IS)

// Preprocessor "void-list".

// NOTE: Empty list must always be represented as void (which is also a way to

// specify no function parameter) and it can never be empty because (1)

// IS_EMPTY(&var) fails (because of the leading non alphanumeric symbol) and

// (2) some compilers (MSVC) fail to correctly pass empty macro parameters

// even if they support variadic macros. Therefore, always using void to

// represent is more portable.

// Argument: (token1)...

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_(unused, seq) \

    BOOST_PP_TUPLE_TO_LIST(BOOST_PP_SEQ_SIZE(seq), BOOST_PP_SEQ_TO_TUPLE(seq))

// Token: void | token1

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_( \

        is_void_macro, token) \

    BOOST_PP_IIF(is_void_macro(token), \

        BOOST_PP_NIL \

    , \

        (token, BOOST_PP_NIL) \

    )

// Token: (a)(b)... | empty | void | token

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_( \

        is_void_macro, token) \

    BOOST_PP_IIF(BOOST_PP_IS_UNARY(token), /* unary paren (a)... */ \

        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_SEQ_ \

    , \

        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_VOID_ \

    )(is_void_macro, token)

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_(tokens) \

    0 /* void check always returns false */

#ifdef BOOST_NO_CXX11_VARIADIC_MACROS

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, seq) \

    BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_(is_void_macro, seq)

// Expand `void | (a)(b)...` to pp-list `NIL | (a, (b, NIL))`.

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(sign) \

    BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \

            BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, sign)

// Expand `(a)(b)...` to pp-list `(a, (b, NIL))`.

#define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(seq) \

    BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \

            BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, seq)

#else // VARIADICS

// FUTURE: Replace this with BOOST_PP_VARIADIC_SIZE when and if

// BOOST_PP_VARIAIDCS detection will match !BOOST_NO_CXX11_VARIADIC_MACROS (for

// now Boost.Preprocessor and Boost.Config disagree on detecting compiler

// variadic support while this VARIADIC_SIZE works on compilers not detected by

// PP).

#if BOOST_MSVC

#   define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \

        BOOST_PP_CAT(BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),)

#else // MSVC

#   define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_(...) \

        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)

#endif // MSVC

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_I_(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size

// Argument: token1, ...

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_(unused, ...) \

    BOOST_PP_TUPLE_TO_LIST( \

            BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \

                    __VA_ARGS__), (__VA_ARGS__))

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_(is_void_macro, ...) \

    BOOST_PP_IIF(BOOST_PP_EQUAL( \

            BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_VARIADIC_SIZE_( \

                    __VA_ARGS__), 1), \

        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_HANDLE_SEQ_ \

    , \

        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_FROM_VARIADIC_ \

    )(is_void_macro, __VA_ARGS__)

// Expand `void | (a)(b)... | a, b, ...` to pp-list `NIL | (a, (b, NIL))`.

#define BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(...) \

    BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \

            BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_VOID_BACK, __VA_ARGS__)

// Expand `(a)(b)... | a, b, ...` to pp-list `(a, (b, NIL))`.

#define BOOST_SCOPE_EXIT_AUX_PP_NON_VOID_LIST(...) \

    BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_( \

            BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST_NEVER_, __VA_ARGS__)

#endif // VARIADICS

// Steven Watanabe's trick with a modification suggested by Kim Barrett

namespace boost { namespace scope_exit { namespace detail {

// Type of a local BOOST_SCOPE_EXIT_AUX_ARGS variable.

// First use in a local scope will declare the BOOST_SCOPE_EXIT_AUX_ARGS

// variable, subsequent uses will be resolved as two comparisons

// (cmp1 with 0 and cmp2 with BOOST_SCOPE_EXIT_AUX_ARGS).

template<int Dummy = 0>

struct declared

{

    void* value;

    static int const cmp2 = 0;

    friend void operator>(int, declared const&) {}

};

struct undeclared { declared<> dummy[2]; };

template<int> struct resolve;

template<>

struct resolve<sizeof(declared<>)>

{

    static const int cmp1 = 0;

};

template<>

struct resolve<sizeof(undeclared)>

{

    template<int>

    struct cmp1

    {

        static int const cmp2 = 0;

    };

};

typedef void (*ref_tag)(int&);

typedef void (*val_tag)(int );

template<class T, class Tag> struct member;

template<class T>

struct member<T,ref_tag>

{

    T& value;

#if !BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01

    member(T& ref) : value(ref) {}

#endif

};

template<class T>

struct member<T,val_tag>

{

    T value;

#if !BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01

    member(T& val) : value(val) {}

#endif

};

template<class T> inline T& deref(T* p, ref_tag) { return *p; }

template<class T> inline T& deref(T& r, val_tag) { return  r; }

template<class T>

struct wrapper

{

    typedef T type;

};

template<class T> wrapper<T> wrap(T&);

} } } // namespace

#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::scope_exit::detail::wrapper, 1)

#define BOOST_SCOPE_EXIT_AUX_ARGS boost_scope_exit_aux_args

extern boost::scope_exit::detail::undeclared BOOST_SCOPE_EXIT_AUX_ARGS;

#define BOOST_SCOPE_EXIT_AUX_GUARD(id)   \

    BOOST_PP_CAT(boost_se_guard_, id)

#define BOOST_SCOPE_EXIT_AUX_GUARD_T(id) \

    BOOST_PP_CAT(boost_se_guard_t_, id)

#define BOOST_SCOPE_EXIT_AUX_PARAMS(id)  \

    BOOST_PP_CAT(boost_se_params_, id)

#define BOOST_SCOPE_EXIT_AUX_THIS_T(id)  \

    BOOST_PP_CAT(boost_se_this_t_,  id)

#define BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id) \

    BOOST_PP_CAT(boost_se_this_capture_t_,  id)

#define BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id) \

    BOOST_PP_CAT(boost_se_params_t_, id)

#define BOOST_SCOPE_EXIT_DETAIL_TAG(id, i) \

    BOOST_PP_SEQ_CAT( (boost_se_tag_)(i)(_)(id) )

#define BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) \

    BOOST_PP_SEQ_CAT( (boost_se_param_this_)(id) )

#define BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var) \

    BOOST_PP_SEQ_CAT( (boost_se_param_)(i)(_)(id) )

#define BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var) \

    BOOST_PP_SEQ_CAT( (boost_se_param_t_)(i)(_)(id) )

#define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(id, i, var) \

    BOOST_PP_SEQ_CAT( (boost_se_capture_t_)(i)(_)(id) )

#define BOOST_SCOPE_EXIT_AUX_WRAPPED(id, i) \

    BOOST_PP_SEQ_CAT( (boost_se_wrapped_t_)(i)(_)(id) )

#define BOOST_SCOPE_EXIT_AUX_DEREF(id, i, var) \

    ::boost::scope_exit::detail::deref(var, \

            static_cast<BOOST_SCOPE_EXIT_DETAIL_TAG(id, i)>(0))

#define BOOST_SCOPE_EXIT_AUX_MEMBER(r, id, i, var) \

    ::boost::scope_exit::detail::member< \

        BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var), \

        BOOST_SCOPE_EXIT_DETAIL_TAG(id, i) \

    > BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var);

#define BOOST_SCOPE_EXIT_AUX_ARG_DECL(r, id_ty, i, var) \

    BOOST_PP_COMMA_IF(i) \

    BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \

    BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty)):: \

            BOOST_SCOPE_EXIT_DETAIL_PARAM_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                    i, var) \

    var

#define BOOST_SCOPE_EXIT_AUX_ARG(r, id, i, var) \

    BOOST_PP_COMMA_IF(i) \

    boost_se_params_->BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var).value

#define BOOST_SCOPE_EXIT_DETAIL_TAG_DECL(r, id, i, var) \

    typedef void (*BOOST_SCOPE_EXIT_DETAIL_TAG(id, i))(int var);

// Adam Butcher's workaround to deduce `this` type on MSVC revision < 10.

// Boost.Typeof for VC71's typeid-based workaround does not work to determine

// `this` type due to error C2355 being incorrectly reported. The typical

// avoidance strategy implemented below is to make an indirect compile-time

// constant by assigning an enum and use that as type-index-- this only works

// with the sizeof() approach and not with the typeid() approach. Lorenzo

// Caminiti extended this approach to work in type-of emulation mode. This code

// is very similar (and somewhat of a duplication) of the code in

// boost/typeof/msvc/typeof_impl.hpp). However, this code cannot be integrated

// into Boost.Typeof because its final API has to be a `typedef ...` and it

// cannot be a `typeof(...)`.

#if BOOST_SCOPE_EXIT_AUX_TYPEOF_THIS_MSVC_WORKAROUND_01

#include <boost/config.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/mpl/int.hpp>

#include <boost/type_traits/is_function.hpp>

#include <boost/utility/enable_if.hpp>

#if defined(BOOST_MSVC)

#   include <typeinfo>

#endif

namespace boost { namespace scope_exit { namespace aux {

        namespace msvc_typeof_this {

// compile-time constant code

#if defined(BOOST_MSVC) && defined(_MSC_EXTENSIONS)

template<int N> struct the_counter;

template<typename T,int N = 5 /* for similarity */>

struct encode_counter {

    __if_exists(the_counter<N + 256>) {

        BOOST_STATIC_CONSTANT(unsigned,

            count=(encode_counter<T,N + 257>::count));

    }

    __if_not_exists(the_counter<N + 256>) {

        __if_exists(the_counter<N + 64>) {

            BOOST_STATIC_CONSTANT(unsigned,

                    count=(encode_counter<T,N + 65>::count));

        }

        __if_not_exists(the_counter<N + 64>) {

            __if_exists(the_counter<N + 16>) {

                BOOST_STATIC_CONSTANT(unsigned,

                        count=(encode_counter<T,N + 17>::count));

            }

            __if_not_exists(the_counter<N + 16>) {

                __if_exists(the_counter<N + 4>) {

                    BOOST_STATIC_CONSTANT(unsigned,

                            count=(encode_counter<T,N + 5>::count));

                }

                __if_not_exists(the_counter<N + 4>) {

                    __if_exists(the_counter<N>) {

                        BOOST_STATIC_CONSTANT(unsigned,

                                count=(encode_counter<T,N + 1>::count));

                    }

                    __if_not_exists(the_counter<N>) {

                        BOOST_STATIC_CONSTANT(unsigned,count=N);

                        typedef the_counter<N> type;

                    }

                }

            }

        }

    }

};

#else // compile-time constant code

template<int N> struct encode_counter : encode_counter<N - 1> {};

template<> struct encode_counter<0> {};

#endif // compile-time constant code

#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) // type-of code

struct msvc_extract_type_default_param {};

template<typename ID, typename T = msvc_extract_type_default_param>

struct msvc_extract_type;

template<typename ID>

struct msvc_extract_type<ID, msvc_extract_type_default_param> {

    template<bool>

    struct id2type_impl;

    typedef id2type_impl<true> id2type;

};

template<typename ID, typename T>

struct msvc_extract_type

        : msvc_extract_type<ID, msvc_extract_type_default_param> {

    template<>

    struct id2type_impl<true> { // VC8.0 specific bug-feature.

        typedef T type;

    };

    template<bool>

    struct id2type_impl;

    typedef id2type_impl<true> id2type;

};

template<typename T, typename ID>

struct msvc_register_type : msvc_extract_type<ID, T> {};

#else // type-of code

template<typename ID>

struct msvc_extract_type {

    struct id2type;

};

template<typename T, typename ID>

struct msvc_register_type : msvc_extract_type<ID> {

    typedef msvc_extract_type<ID> base_type;

    struct base_type::id2type { // This uses nice VC6.5 and VC7.1 bug-features.

        typedef T type;

    };

};

#endif // typeof code

template<int Id>

struct msvc_typeid_wrapper {

    typedef typename msvc_extract_type<boost::mpl::int_<Id>

            >::id2type id2type;

    typedef typename id2type::type type;

};

template<>

struct msvc_typeid_wrapper<4> {

    typedef msvc_typeid_wrapper<4> type;

};

template<typename T>

struct encode_type {

    BOOST_STATIC_CONSTANT(unsigned, value = encode_counter<T>::count);

    typedef typename msvc_register_type

            boost::mpl::int_<value> >::id2type type;

    BOOST_STATIC_CONSTANT(unsigned, next = value + 1);

};

template<class T>

struct sizer {

    typedef char(*type)[encode_type<T>::value];

};

template<typename T>

typename boost::disable_if<

      typename boost::is_function<T>::type

    , typename sizer<T>::type

>::type encode_start(T const&);

template<typename T>

typename boost::enable_if<

      typename boost::is_function<T>::type

    , typename sizer<T>::type

>::type encode_start(T&);

template<typename Organizer, typename T>

msvc_register_type<T, Organizer> typeof_register_type(const T&,

        Organizer* = 0);

} } } } // namespace

#define BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) \

    BOOST_PP_CAT(boost_se_thistype_index_, id)

#define BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, new_type) \

    /* unfortunately, we need to go via this enum which causes this to be */ \

    /* a typedef construct and not a typeof (so this code cannot be */ \

    /* integrated into Boost.Typeof) */ \

    enum { \

        BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) = sizeof( \

            *::boost::scope_exit::aux::msvc_typeof_this::encode_start(this)) \

    }; \

    typedef \

        ty ::boost::scope_exit::aux::msvc_typeof_this::msvc_typeid_wrapper< \

            BOOST_SCOPE_EXIT_AUX_TYPEDEF_TYPEOF_THIS_INDEX_(id) \

        >::type \

        new_type \

    ;

#else // TYPEOF_THIS_MSVC_WORKAROUND

#define BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, new_type) \

    typedef /* trailing `EMPTY()` handles empty `ty` */ \

        BOOST_PP_IIF(BOOST_PP_IS_EMPTY(ty BOOST_PP_EMPTY()), \

            BOOST_TYPEOF \

        , \

            BOOST_TYPEOF_TPL \

        )(this) \

        new_type \

    ;

#endif // TYPEOF_THIS_MSVC_WORKAROUND

#if BOOST_SCOPE_EXIT_AUX_TPL_GCC_WORKAROUND_01

#define BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, captures, has_this) \

    /* expand to nothing */

#define BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT(r, id, i, var) \

    BOOST_PP_COMMA_IF(i) { BOOST_SCOPE_EXIT_AUX_DEREF(id, i, var) }

#define BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, captures, has_this) \

    BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(has_this, \

            BOOST_PP_LIST_IS_CONS(captures)), \

        = { \

    ) \

    BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT, id, captures) \

    BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS(captures), \

            has_this)) \

    BOOST_PP_EXPR_IIF(has_this, this) /* no extra {...} needed here */ \

    BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(has_this, \

            BOOST_PP_LIST_IS_CONS(captures)), \

        } /* trailing `;` will be added by the caller */ \

    )

#else // TPL_GCC_WORKAROUND

#define BOOST_SCOPE_EXIT_AUX_CTOR_ARG(r, id, i, var) \

    BOOST_PP_COMMA_IF(i) \

    BOOST_SCOPE_EXIT_DETAIL_PARAM_T(id, i, var) & BOOST_PP_CAT(a, i)

#define BOOST_SCOPE_EXIT_AUX_MEMBER_INIT(r, id, i, var) \

    BOOST_PP_COMMA_IF(i) \

    BOOST_SCOPE_EXIT_DETAIL_PARAM(id, i, var) ( BOOST_PP_CAT(a, i) )

#define BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id) \

    BOOST_PP_CAT(boost_se_this_arg_, id)

#define BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS(id, ty, comma01) \

    BOOST_PP_COMMA_IF(comma01) \

    ty BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)::BOOST_SCOPE_EXIT_AUX_THIS_T(id) \

            BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id) /* ptr so no & */

#define BOOST_SCOPE_EXIT_AUX_MEMBER_THIS_INIT(id, comma01) \

    BOOST_PP_COMMA_IF(comma01) \

    BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id)( \

            BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS_NAME(id))

#define BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, captures, has_this) \

    BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)( \

        BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_CTOR_ARG, id, captures) \

        BOOST_PP_IIF(has_this, \

            BOOST_SCOPE_EXIT_AUX_CTOR_ARG_THIS \

        , \

            BOOST_PP_TUPLE_EAT(3) \

        )(id, ty, BOOST_PP_LIST_IS_CONS(captures)) \

    ) \

        BOOST_PP_EXPR_IIF(BOOST_PP_BITOR(BOOST_PP_LIST_IS_CONS(captures), \

                has_this), \

            : \

        ) \

        BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_MEMBER_INIT, id, \

                captures) \

        BOOST_PP_IIF(has_this, \

            BOOST_SCOPE_EXIT_AUX_MEMBER_THIS_INIT \

        , \

            BOOST_PP_TUPLE_EAT(2) \

        )(id, BOOST_PP_LIST_IS_CONS(captures)) \

    {}

#define BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT(r, id, i, var) \

    BOOST_PP_COMMA_IF(i) BOOST_SCOPE_EXIT_AUX_DEREF(id,i,var)

#define BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, captures, has_this) \

    BOOST_PP_LPAREN_IF(BOOST_PP_BITOR(has_this, \

            BOOST_PP_LIST_IS_CONS(captures))) \

    BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_INIT, id, captures) \

    BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS(captures), \

            has_this)) \

    BOOST_PP_EXPR_IIF(has_this, this) \

    BOOST_PP_RPAREN_IF(BOOST_PP_BITOR(has_this, \

            BOOST_PP_LIST_IS_CONS(captures)))

#endif // TPL_GCC_WORKAROUND

#if defined(BOOST_TYPEOF_EMULATION)

#define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \

    struct BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i) \

        /* no need to use TYPEOF_TPL here because it's within inheritance */ \

        : BOOST_TYPEOF(::boost::scope_exit::detail::wrap( \

                BOOST_SCOPE_EXIT_AUX_DEREF(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                        i, var))) \

    {}; \

    typedef BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \

        BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i)::type\

        BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                i, var) \

    ;

#elif defined(BOOST_INTEL)

#define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \

    typedef \

        /* no TYPEOF_TPL here because uses TYPEOF_KEYWORD directly */ \

        BOOST_TYPEOF_KEYWORD(BOOST_SCOPE_EXIT_AUX_DEREF( \

                BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i, var)) \

        BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                i, var) \

    ;

#else

#define BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL(r, id_ty, i, var) \

    typedef \

        /* no need to use TYPEOF_TPL here because it's a typedef */ \

        BOOST_TYPEOF(::boost::scope_exit::detail::wrap( \

                BOOST_SCOPE_EXIT_AUX_DEREF(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                        i, var))) \

        BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i) \

    ; \

    typedef BOOST_PP_TUPLE_ELEM(2, 1, id_ty) \

        BOOST_SCOPE_EXIT_AUX_WRAPPED(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), i)::type\

        BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                i, var) \

    ;

#endif

#define BOOST_SCOPE_EXIT_DETAIL_PARAM_DECL(r, id_ty, i, var) \

    typedef \

        BOOST_SCOPE_EXIT_DETAIL_CAPTURE_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                i, var) \

        BOOST_SCOPE_EXIT_DETAIL_PARAM_T(BOOST_PP_TUPLE_ELEM(2, 0, id_ty), \

                i, var) \

    ;

// Traits.

#define BOOST_SCOPE_EXIT_AUX_TRAITS_OP_CAPTURE(d, captures, this01, capture) \

    (BOOST_PP_LIST_APPEND(captures, (capture, BOOST_PP_NIL)), this01)

#define BOOST_SCOPE_EXIT_AUX_TRAITS_OP_THIS(d, captures, this01, this_) \

    (captures, 1 /* has this (note, no error if multiple this_) */)

#define BOOST_SCOPE_EXIT_AUX_TRAITS_OP(d, captures_this, capture) \

    BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_PP_KEYWORD_IS_THISUNDERSCORE_BACK(\

            capture), \

        BOOST_SCOPE_EXIT_AUX_TRAITS_OP_THIS \

    , \

        BOOST_SCOPE_EXIT_AUX_TRAITS_OP_CAPTURE \

    )(d, BOOST_PP_TUPLE_ELEM(2, 0, captures_this), \

            BOOST_PP_TUPLE_ELEM(2, 1, captures_this), capture)

// ref_val: & | =

#define BOOST_SCOPE_EXIT_AUX_TRAITS_ALL_OP(ref_val, traits) \

    ( \

        BOOST_PP_LIST_APPEND((ref_val, BOOST_PP_NIL), \

                BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

    , \

        BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits) \

    )

#define BOOST_SCOPE_EXIT_AUX_TRAITS(captures) \

    BOOST_PP_LIST_FOLD_LEFT(BOOST_SCOPE_EXIT_AUX_TRAITS_OP, \

            (BOOST_PP_NIL, 0), captures)

#define BOOST_SCOPE_EXIT_AUX_TRAITS_ALL(captures) \

    BOOST_SCOPE_EXIT_AUX_TRAITS_ALL_OP(BOOST_PP_LIST_FIRST(captures), \

            BOOST_SCOPE_EXIT_AUX_TRAITS(BOOST_PP_LIST_REST(captures)))

#define BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits) \

    BOOST_PP_TUPLE_ELEM(2, 0, traits)

#define BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits) \

    BOOST_PP_TUPLE_ELEM(2, 1, traits)

#ifndef BOOST_NO_CXX11_LAMBDAS

namespace boost { namespace scope_exit { namespace aux {

template<typename This = void>

struct guard { // With object `this_` (for backward compatibility).

    explicit guard(This _this) : this_(_this) {}

    ~guard() { if(f_) f_(this_); }

    template<typename Lambda>

    void operator=(Lambda f) { f_ = f; }

private:

    This this_;

    boost::function<void (This)> f_;

};

template<>

struct guard<void> { // Without object `this_` (could capture `this` directly).

    ~guard() { if(f_) f_(); }

    template<typename Lambda>

    void operator=(Lambda f) { f_ = f; }

private:

    boost::function<void (void)> f_;

};

} } } // namespace

#define BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id) \

    BOOST_PP_CAT(boost_se_lambda_params_, id)

#define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id) \

    BOOST_PP_CAT(boost_se_lambda_this_t_, id)

#define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id) \

    BOOST_PP_CAT(boost_se_lambda_this_capture_t_, id)

#define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE(id, ty) \

    ty BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id):: \

            BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id)

// Precondition: HAS_THIS(traits).

#define BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPEDEFS(id, ty, traits) \

    BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS(id, ty, \

            BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id)) \

    /* capture type for workaround GCC internal error (even on later C++11) */ \

    struct BOOST_SCOPE_EXIT_AUX_LAMBDA_PARAMS(id) { \

        typedef BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_CAPTURE_TYPE(id) \

                BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_PARAM_TYPE(id); \

    };

#define BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, ty, traits) \

    BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

        /* no need for TYPEDEF THIS MSVC workaround on C++11 */ \

        BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPEDEFS \

    , \

        BOOST_PP_TUPLE_EAT(3) \

    )(id, ty, traits) \

    ::boost::scope_exit::aux::guard< \

        BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

            BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE \

        , \

            BOOST_PP_TUPLE_EAT(2) \

        )(id, ty) \

    > BOOST_SCOPE_EXIT_AUX_GUARD(id) \

        BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

            (this) \

        ) \

    ; \

    BOOST_SCOPE_EXIT_AUX_GUARD(id) = [ \

        BOOST_PP_LIST_ENUM(BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

    ]( \

        BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

            BOOST_SCOPE_EXIT_AUX_LAMBDA_THIS_TYPE \

        , \

            BOOST_PP_TUPLE_EAT(2) \

        )(id, ty) \

        BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), this_) \

    ) mutable /* can change value captures (as with SCOPE_EXIT) */ -> void

#endif // Lambdas.

#if defined(BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS) && \

        !defined(BOOST_NO_CXX11_LAMBDAS) // Use lambda for SCOPE_EXIT (not just _ALL).

#define BOOST_SCOPE_EXIT_AUX_IMPL(id, ty, traits) \

    BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, ty, traits)

#else // Not using lambdas.

// ty: EMPTY() | typename

#define BOOST_SCOPE_EXIT_AUX_IMPL(id, ty, traits) \

    BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_TAG_DECL, id, \

            BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

    BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_CAPTURE_DECL, (id, ty), \

            BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

    BOOST_PP_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

        BOOST_SCOPE_EXIT_DETAIL_TYPEDEF_TYPEOF_THIS \

    , \

        BOOST_PP_TUPLE_EAT(3) \

    )(id, ty, BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id)) \

    struct BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id) { \

        /* interim capture types to workaround internal errors on old GCC */ \

        BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_DETAIL_PARAM_DECL, (id, ty), \

                BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

        BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

            typedef BOOST_SCOPE_EXIT_AUX_THIS_CAPTURE_T(id) \

                    BOOST_SCOPE_EXIT_AUX_THIS_T(id) ; \

        ) \

        BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_MEMBER, id, \

                BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

        BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

            BOOST_SCOPE_EXIT_AUX_THIS_T(id) \

                    BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) ; \

        ) \

        BOOST_SCOPE_EXIT_AUX_PARAMS_T_CTOR(id, ty, \

                BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits), \

                BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits)) \

    } BOOST_SCOPE_EXIT_AUX_PARAMS(id) \

        BOOST_SCOPE_EXIT_AUX_PARAMS_INIT(id, \

                BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits), \

                BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits)) \

    ; \

    ::boost::scope_exit::detail::declared< \

        ::boost::scope_exit::detail::resolve< \

            sizeof(BOOST_SCOPE_EXIT_AUX_ARGS) \

        >::cmp1<0>::cmp2 \

    > BOOST_SCOPE_EXIT_AUX_ARGS; \

    BOOST_SCOPE_EXIT_AUX_ARGS.value = &BOOST_SCOPE_EXIT_AUX_PARAMS(id); \

    struct BOOST_SCOPE_EXIT_AUX_GUARD_T(id) { \

        BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)* boost_se_params_; \

        BOOST_SCOPE_EXIT_AUX_GUARD_T(id) (void* boost_se_params) \

            : boost_se_params_( \

                    (BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id)*)boost_se_params) \

        {} \

        ~BOOST_SCOPE_EXIT_AUX_GUARD_T(id)() { \

            boost_se_body( \

                BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_ARG, id, \

                        BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

                BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS( \

                        BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)), \

                        BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits))) \

                BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS( \

                        traits), \

                    boost_se_params_->BOOST_SCOPE_EXIT_DETAIL_PARAM_THIS(id) \

                ) \

            ); \

        } \

        static void boost_se_body( \

            BOOST_PP_LIST_FOR_EACH_I(BOOST_SCOPE_EXIT_AUX_ARG_DECL, (id, ty), \

                    BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)) \

            BOOST_PP_COMMA_IF(BOOST_PP_BITAND(BOOST_PP_LIST_IS_CONS( \

                    BOOST_SCOPE_EXIT_AUX_TRAITS_CAPTURES(traits)), \

                    BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits))) \

            BOOST_PP_EXPR_IIF(BOOST_SCOPE_EXIT_AUX_TRAITS_HAS_THIS(traits), \

                ty BOOST_SCOPE_EXIT_DETAIL_PARAMS_T(id):: \

                        BOOST_SCOPE_EXIT_AUX_THIS_T(id) this_ \

            ) \

        )

#endif // Using lambdas.

// PUBLIC //

#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) // No variadic macros (sequences only).

#   define BOOST_SCOPE_EXIT_ID(id, void_or_seq) \

        BOOST_SCOPE_EXIT_AUX_IMPL(id, BOOST_PP_EMPTY(), \

                BOOST_SCOPE_EXIT_AUX_TRAITS( \

                        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq)))

#   define BOOST_SCOPE_EXIT_ID_TPL(id, void_or_seq) \

        BOOST_SCOPE_EXIT_AUX_IMPL(id, typename, \

                BOOST_SCOPE_EXIT_AUX_TRAITS( \

                        BOOST_SCOPE_EXIT_AUX_PP_VOID_LIST(void_or_seq)))

#   define BOOST_SCOPE_EXIT(void_or_seq) \

        BOOST_SCOPE_EXIT_ID(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \

                void_or_seq)

#   define BOOST_SCOPE_EXIT_TPL(void_or_seq) \

        BOOST_SCOPE_EXIT_ID_TPL(BOOST_SCOPE_EXIT_AUX_PP_LINE_COUNTER, \

                void_or_seq)

#   if !defined(BOOST_NO_CXX11_LAMBDAS)

#       define BOOST_SCOPE_EXIT_ALL_ID(id, seq) \

            BOOST_SCOPE_EXIT_AUX_IMPL_LAMBDA(id, \

                    /* C++11 allows to use typename outside templates so */ \

                    /* always typename here and no need for ..._ALL_TPL */ \

                    /* (if a C++11 compiler does not implement this use of */ \