Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/detail')
8 files changed, 20 insertions, 20 deletions
diff --git a/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp b/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp index fb46576..b7e5c30 100644 --- a/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/as_expr.hpp @@ -1,55 +1,55 @@ /////////////////////////////////////////////////////////////////////////////// /// \file as_expr.hpp /// Contains definition of the as_expr\<\> and as_child\<\> helper class /// templates used to implement proto::domain's as_expr\<\> and as_child\<\> /// member templates. // // Copyright 2010 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 #define BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { //////////////////////////////////////////////////////////////////////////////////////////////// template<typename Generator> struct base_generator { typedef Generator type; }; template<typename Generator> struct base_generator<use_basic_expr<Generator> > { typedef Generator type; }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator, bool WantsBasicExpr> struct as_expr; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T, typename Generator> struct as_expr<T, Generator, false> { typedef typename term_traits<T &>::value_type value_type; typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type; typedef typename Generator::template result<Generator(expr_type)>::type result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { @@ -148,40 +148,40 @@ namespace boost { namespace proto { namespace detail { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; //////////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_child<T, proto::default_generator, true> { #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) typedef typename term_traits<T &>::reference reference; #else typedef T &reference; #endif typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type; BOOST_FORCEINLINE result_type operator()(T &t) const { return result_type::make(t); } }; }}} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp b/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp index 8ff9091..df4dacb 100644 --- a/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/as_lvalue.hpp @@ -1,43 +1,43 @@ /////////////////////////////////////////////////////////////////////////////// /// \file as_lvalue.hpp /// Contains definition the as_lvalue() functions. // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 #define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007 #include <boost/proto/proto_fwd.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T> BOOST_FORCEINLINE T &as_lvalue(T &t) { return t; } template<typename T> BOOST_FORCEINLINE T const &as_lvalue(T const &t) { return t; } } }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/detail/decltype.hpp b/3rdParty/Boost/src/boost/proto/detail/decltype.hpp index 629ef99..5882071 100644 --- a/3rdParty/Boost/src/boost/proto/detail/decltype.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/decltype.hpp @@ -4,78 +4,78 @@ // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 #define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/get_pointer.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/mpl/identity.hpp> #include <boost/type_traits/is_class.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/type_traits/is_function.hpp> #include <boost/type_traits/is_member_object_pointer.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/typeof/typeof.hpp> #include <boost/utility/addressof.hpp> #include <boost/utility/result_of.hpp> #include <boost/utility/enable_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/any.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif // We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug: // https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong -#if !defined(BOOST_NO_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) +#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700)) # define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE; #else # define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \ BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \ static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\ struct NESTED \ : boost::mpl::if_c< \ 1 == BOOST_PP_CAT(sz, NESTED) \ , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type & \ , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \ > \ {}; # define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \ BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \ typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE; #endif namespace boost { namespace proto { namespace detail { //////////////////////////////////////////////////////////////////////////////////////////// template<typename T> struct as_mutable { typedef T &type; }; template<typename T> struct as_mutable<T &> { typedef T &type; }; template<typename T> @@ -414,40 +414,40 @@ namespace boost { namespace proto //BOOST_MPL_ASSERT((is_same<bar const, result_of_fixup<bar const &>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(*)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(* const &)()>::type>)); //BOOST_MPL_ASSERT((is_same<void(*)(), result_of_fixup<void(&)()>::type>)); template<typename T, typename PMF> struct memfun { typedef typename uncvref<PMF>::type pmf_type; typedef typename class_member_traits<pmf_type>::class_type V; typedef typename class_member_traits<pmf_type>::result_type result_type; memfun(T t, pmf_type p) : obj(t) , pmf(p) {} result_type operator()() const { BOOST_PROTO_USE_GET_POINTER(); return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(); } // Other overloads generated by the preprocessor #include <boost/proto/detail/memfun_funop.hpp> private: T obj; pmf_type pmf; }; } // namespace detail }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp b/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp index 630304f..0d4f3a5 100644 --- a/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/deduce_domain.hpp @@ -12,143 +12,143 @@ // also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who // offered alternate solutions to this tricky programming problem. #ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 #define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010 #include <boost/config.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/mpl/assert.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN # define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>)) #endif namespace boost { namespace proto { namespace detail { template<typename Domain> struct domain_ : domain_<typename Domain::proto_super_domain> { typedef Domain type; typedef domain_<typename Domain::proto_super_domain> base; - #ifdef BOOST_NO_DECLTYPE + #ifdef BOOST_NO_CXX11_DECLTYPE using base::deduce98; static int const index = base::index + 1; static typename sized_type<index>::type deduce98(domain_<Domain>*); #else using base::deduce0x; static Domain deduce0x(domain_<Domain>*); #endif }; template<> struct domain_<not_a_domain> { typedef not_a_domain type; - #ifdef BOOST_NO_DECLTYPE + #ifdef BOOST_NO_CXX11_DECLTYPE static int const index = 1; static sized_type<1>::type deduce98(void*); #else static not_a_domain deduce0x(void*); #endif }; template<> struct domain_<default_domain> : domain_<not_a_domain> {}; template<> struct domain_<basic_default_domain> : domain_<not_a_domain> {}; sized_type<1>::type default_test(void*, void*); sized_type<2>::type default_test(domain_<default_domain>*, void*); sized_type<2>::type default_test(domain_<basic_default_domain>*, void*); sized_type<3>::type default_test(void*, domain_<default_domain>*); sized_type<3>::type default_test(void*, domain_<basic_default_domain>*); sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*); sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*); sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*); sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*); - #ifdef BOOST_NO_DECLTYPE + #ifdef BOOST_NO_CXX11_DECLTYPE template<int N, typename Domain> struct nth_domain : nth_domain<N - 1, typename Domain::base> {}; template<typename Domain> struct nth_domain<0, Domain> : Domain {}; #endif template<typename D0> struct common_domain1 { typedef D0 type; }; template<typename E0> struct deduce_domain1 : domain_of<E0> {}; template< typename D0 , typename D1 , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0)) > struct common_domain2 { - #ifdef BOOST_NO_DECLTYPE + #ifdef BOOST_NO_CXX11_DECLTYPE static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0)); typedef typename nth_domain<index, domain_<D0> >::type type; #else typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type; #endif }; template<typename D0, typename D1> struct common_domain2<D0, D1, 2> { typedef D1 type; }; template<typename D0, typename D1> struct common_domain2<D0, D1, 3> { typedef D0 type; }; template<typename D0> struct common_domain2<D0, default_domain, 4> { typedef D0 type; }; template<typename D0> struct common_domain2<D0, basic_default_domain, 4> { typedef D0 type; }; template<typename D1> struct common_domain2<default_domain, D1, 4> { typedef D1 type; diff --git a/3rdParty/Boost/src/boost/proto/detail/expr.hpp b/3rdParty/Boost/src/boost/proto/detail/expr.hpp index 3f3291b..8ceedd8 100644 --- a/3rdParty/Boost/src/boost/proto/detail/expr.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/expr.hpp @@ -1,112 +1,112 @@ #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) - #ifndef BOOST_NO_VARIADIC_TEMPLATES + #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES #include <boost/proto/detail/preprocessed/expr_variadic.hpp> #else #include <boost/proto/detail/preprocessed/expr.hpp> #endif #elif !defined(BOOST_PP_IS_ITERATING) /// INTERNAL ONLY /// #define BOOST_PROTO_CHILD(Z, N, DATA) \ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N); \ BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N); \ /**< INTERNAL ONLY */ /// INTERNAL ONLY /// #define BOOST_PROTO_VOID(Z, N, DATA) \ typedef void BOOST_PP_CAT(proto_child, N); \ /**< INTERNAL ONLY */ // Generate variadic versions of expr #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr_variadic.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file expr_variadic.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif // The expr<> specializations are actually defined here. #define BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 0, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() // Generate non-variadic versions of expr #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) - #define BOOST_NO_VARIADIC_TEMPLATES + #define BOOST_NO_CXX11_VARIADIC_TEMPLATES #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr.hpp") /////////////////////////////////////////////////////////////////////////////// /// \file expr.hpp /// Contains definition of expr\<\> class template. // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #pragma wave option(preserve: 1) // The expr<> specializations are actually defined here. #define BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #undef BOOST_PROTO_DEFINE_TERMINAL #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>)) #include BOOST_PP_ITERATE() #pragma wave option(output: null) - #undef BOOST_NO_VARIADIC_TEMPLATES + #undef BOOST_NO_CXX11_VARIADIC_TEMPLATES #endif #undef BOOST_PROTO_CHILD #undef BOOST_PROTO_VOID #else #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION()) /// \brief Representation of a node in an expression tree. /// /// \c proto::expr\<\> is a node in an expression template tree. It /// is a container for its child sub-trees. It also serves as /// the terminal nodes of the tree. /// /// \c Tag is type that represents the operation encoded by /// this expression. It is typically one of the structs /// in the \c boost::proto::tag namespace, but it doesn't /// have to be. /// /// \c Args is a type list representing the type of the children /// of this expression. It is an instantiation of one /// of \c proto::list1\<\>, \c proto::list2\<\>, etc. The /// child types must all themselves be either \c expr\<\> /// or <tt>proto::expr\<\>&</tt>. If \c Args is an /// instantiation of \c proto::term\<\> then this /// \c expr\<\> type represents a terminal expression; /// the parameter to the \c proto::term\<\> template /// represents the terminal's value type. /// /// \c Arity is an integral constant representing the number of child /// nodes this node contains. If \c Arity is 0, then this /// node is a terminal. /// /// \c proto::expr\<\> is a valid Fusion random-access sequence, where @@ -366,109 +366,109 @@ proto::tag::subscript , list2<expr &, typename result_of::as_child<A>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } /// \overload /// template<typename A> BOOST_FORCEINLINE proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > const operator [](A const &a) { proto::expr< proto::tag::subscript , list2<expr &, typename result_of::as_child<A const>::type> , 2 > that = {*this, proto::as_child(a)}; return that; } #endif /// Encodes the return type of \c expr\<\>::operator(), for use with \c boost::result_of\<\> /// template<typename Sig> struct result { typedef typename result_of::funop<Sig, expr, default_domain>::type const type; }; - #ifndef BOOST_NO_VARIADIC_TEMPLATES + #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES /// \overload /// template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr const(A const &...) , expr , default_domain >::type const operator ()(A const &... a) const { return result_of::funop< expr const(A const &...) , expr , default_domain >::call(*this, a...); } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// template<typename ...A> BOOST_FORCEINLINE typename result_of::funop< expr(A const &...) , expr , default_domain >::type const operator ()(A const &... a) { return result_of::funop< expr(A const &...) , expr , default_domain >::call(*this, a...); } #endif - #else // BOOST_NO_VARIADIC_TEMPLATES + #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES /// Function call /// /// \return A new \c expr\<\> node representing the function invocation of \c (*this)(). BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr const &>, 1> const operator ()() const { proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this}; return that; } #ifdef BOOST_PROTO_DEFINE_TERMINAL /// \overload /// BOOST_FORCEINLINE proto::expr<proto::tag::function, list1<expr &>, 1> const operator ()() { proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this}; return that; } #endif #define BOOST_PP_ITERATION_PARAMS_2 \ (3, (1, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/expr_funop.hpp>)) #include BOOST_PP_ITERATE() #endif }; #undef ARG_COUNT #endif diff --git a/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp b/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp index bb157c5..d722641 100644 --- a/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/extends_funop.hpp @@ -1,38 +1,38 @@ #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) - #ifndef BOOST_NO_VARIADIC_TEMPLATES + #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES BOOST_PROTO_EXTENDS_FUNCTION_() BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) #else #include <boost/proto/detail/preprocessed/extends_funop.hpp> #endif #else #define BOOST_PP_LOCAL_MACRO(N) \ BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT) #pragma wave option(preserve: 1) #endif BOOST_PROTO_EXTENDS_FUNCTION_() #define BOOST_PP_LOCAL_LIMITS \ (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) #include BOOST_PP_LOCAL_ITERATE() diff --git a/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp b/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp index 229a0f9..1791a1b 100644 --- a/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/extends_funop_const.hpp @@ -1,38 +1,38 @@ #if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES) - #ifndef BOOST_NO_VARIADIC_TEMPLATES + #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES BOOST_PROTO_EXTENDS_FUNCTION_() BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) #else #include <boost/proto/detail/preprocessed/extends_funop_const.hpp> #endif #else #define BOOST_PP_LOCAL_MACRO(N) \ BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \ /**/ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop_const.hpp") #endif /////////////////////////////////////////////////////////////////////////////// /// \file extends_funop_const.hpp /// Definitions for extends\<\>::operator() // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) #pragma wave option(preserve: 1) #endif BOOST_PROTO_EXTENDS_FUNCTION_() #define BOOST_PP_LOCAL_LIMITS \ (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)) #include BOOST_PP_LOCAL_ITERATE() #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) diff --git a/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp b/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp index 6004b83..7ca3446 100644 --- a/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp +++ b/3rdParty/Boost/src/boost/proto/detail/ignore_unused.hpp @@ -1,34 +1,34 @@ /////////////////////////////////////////////////////////////////////////////// /// \file ignore_unused.hpp /// Definintion of ignore_unused, a dummy function for suppressing compiler /// warnings // // Copyright 2008 Eric Niebler. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 #define BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008 #include <boost/config.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T> BOOST_FORCEINLINE void ignore_unused(T const &) {} } }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif |