Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/proto | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/proto')
24 files changed, 57 insertions, 57 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 diff --git a/3rdParty/Boost/src/boost/proto/domain.hpp b/3rdParty/Boost/src/boost/proto/domain.hpp index 44bc45d..33dabeb 100644 --- a/3rdParty/Boost/src/boost/proto/domain.hpp +++ b/3rdParty/Boost/src/boost/proto/domain.hpp @@ -1,56 +1,56 @@ /////////////////////////////////////////////////////////////////////////////// /// \file domain.hpp /// Contains definition of domain\<\> class template and helpers for /// defining domains with a generator and a grammar for controlling /// operator overloading. // // 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_DOMAIN_HPP_EAN_02_13_2007 #define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007 #include <boost/ref.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/detail/as_expr.hpp> #include <boost/proto/detail/deduce_domain.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 { struct not_a_generator {}; struct not_a_grammar {}; struct not_a_domain {}; } namespace domainns_ { /// \brief For use in defining domain tags to be used /// with \c proto::extends\<\>. A \e Domain associates /// an expression type with a \e Generator, and optionally /// a \e Grammar. /// /// The Generator determines how new expressions in the /// domain are constructed. Typically, a generator wraps /// all new expressions in a wrapper that imparts /// domain-specific behaviors to expressions within its /// domain. (See \c proto::extends\<\>.) /// /// The Grammar determines whether a given expression is /// valid within the domain, and automatically disables /// any operator overloads which would cause an invalid @@ -298,40 +298,40 @@ namespace boost { namespace proto typedef typename domain_of<T>::type type; }; /// INTERNAL ONLY /// template<typename T> struct domain_of<boost::reference_wrapper<T> const, void> { typedef typename domain_of<T>::type type; }; /// A metafunction that returns \c mpl::true_ /// if the type \c SubDomain is a sub-domain of /// \c SuperDomain; \c mpl::false_ otherwise. template<typename SubDomain, typename SuperDomain> struct is_sub_domain_of : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain> {}; /// INTERNAL ONLY /// template<typename SuperDomain> struct is_sub_domain_of<proto::no_super_domain, SuperDomain> : mpl::false_ {}; /// INTERNAL ONLY /// template<typename SuperDomain> struct is_sub_domain_of<SuperDomain, SuperDomain> : mpl::true_ {}; }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/expr.hpp b/3rdParty/Boost/src/boost/proto/expr.hpp index e75ee16..1bd6498 100644 --- a/3rdParty/Boost/src/boost/proto/expr.hpp +++ b/3rdParty/Boost/src/boost/proto/expr.hpp @@ -1,64 +1,64 @@ /////////////////////////////////////////////////////////////////////////////// /// \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) #ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 #define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/selection/max.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/repetition/enum_trailing.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/utility/addressof.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/traits.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4510) // default constructor could not be generated # pragma warning(disable : 4512) // assignment operator could not be generated # pragma warning(disable : 4610) // user defined constructor required # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { struct not_a_valid_type { private: not_a_valid_type() {} }; template<typename Tag, typename Arg> struct address_of_hack { typedef not_a_valid_type type; }; template<typename Expr> struct address_of_hack<proto::tag::address_of, Expr &> { typedef Expr *type; }; template<typename T, typename Expr, typename Arg0> BOOST_FORCEINLINE Expr make_terminal(T &t, Expr *, proto::term<Arg0> *) { @@ -124,40 +124,40 @@ namespace boost { namespace proto struct funop; #include <boost/proto/detail/funop.hpp> } namespace exprns_ { // This is where the basic_expr specializations are // actually defined: #include <boost/proto/detail/basic_expr.hpp> // This is where the expr specialization are // actually defined: #include <boost/proto/detail/expr.hpp> } /// \brief Lets you inherit the interface of an expression /// while hiding from Proto the fact that the type is a Proto /// expression. template<typename Expr> struct unexpr : Expr { BOOST_PROTO_UNEXPR() BOOST_FORCEINLINE explicit unexpr(Expr const &e) : Expr(e) {} using Expr::operator =; }; }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005 diff --git a/3rdParty/Boost/src/boost/proto/extends.hpp b/3rdParty/Boost/src/boost/proto/extends.hpp index 47dca11..1fb0429 100644 --- a/3rdParty/Boost/src/boost/proto/extends.hpp +++ b/3rdParty/Boost/src/boost/proto/extends.hpp @@ -2,71 +2,71 @@ /// \file extends.hpp /// Macros and a base class for defining end-user expression types // // 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_EXTENDS_HPP_EAN_11_1_2006 #define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006 #include <cstddef> // for offsetof #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/facilities/empty.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/preprocessor/control/if.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/utility/addressof.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/expr.hpp> #include <boost/proto/args.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/detail/remove_typename.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 { #ifdef __GNUC__ /// INTERNAL ONLY /// # define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x)) /// INTERNAL ONLY /// # define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this))) #else /// INTERNAL ONLY /// # define BOOST_PROTO_OFFSETOF offsetof #endif /// INTERNAL ONLY /// #define BOOST_PROTO_CONST() const /// INTERNAL ONLY /// #define BOOST_PROTO_TYPENAME() typename /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> /// INTERNAL ONLY /// #define BOOST_PROTO_TEMPLATE_NO_(Z, N) @@ -361,71 +361,71 @@ namespace boost { namespace proto #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_SUBSCRIPT() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \ BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_FUNCTION_() \ template<typename Sig> \ struct result \ { \ typedef \ typename BOOST_PROTO_RESULT_OF< \ proto_generator( \ typename boost::proto::result_of::funop< \ Sig \ , proto_derived_expr \ , proto_domain \ >::type \ ) \ >::type const \ type; \ }; \ /**/ - #ifndef BOOST_NO_VARIADIC_TEMPLATES + #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION() \ 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 #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PP_REPEAT_FROM_TO( \ 0 \ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ , BOOST_PROTO_DEFINE_FUN_OP_CONST \ , ~ \ ) \ /**/ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \ BOOST_PROTO_EXTENDS_FUNCTION_() \ BOOST_PP_REPEAT_FROM_TO( \ 0 \ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \ , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \ , ~ \ ) \ /**/ @@ -608,40 +608,40 @@ namespace boost { namespace proto static expr<tag::terminal, term<Fun>, 0> const that = {Fun()}; return that; } }; /// INTERNAL ONLY /// #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \ boost::proto::exprns_::virtual_member< \ proto_derived_expr \ , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \ , DOMAIN \ > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \ /**/ /// \brief For declaring virtual data members in an extension class. /// #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \ union \ { \ char proto_member_union_start_; \ BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \ }; \ /**/ /// \brief For declaring virtual data members in an extension class. /// #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \ BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \ /**/ } }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/generate.hpp b/3rdParty/Boost/src/boost/proto/generate.hpp index 92a47c4..4762741 100644 --- a/3rdParty/Boost/src/boost/proto/generate.hpp +++ b/3rdParty/Boost/src/boost/proto/generate.hpp @@ -1,62 +1,62 @@ /////////////////////////////////////////////////////////////////////////////// /// \file generate.hpp /// Contains definition of generate\<\> class template, which end users can /// specialize for generating domain-specific expression wrappers. // // 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_GENERATE_HPP_EAN_02_13_2007 #define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 #include <boost/config.hpp> #include <boost/version.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/mpl/bool.hpp> #include <boost/utility/enable_if.hpp> #include <boost/utility/result_of.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 Expr> struct by_value_generator_; template<typename Tag, typename Arg> struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> > { typedef proto::expr< Tag , term<typename detail::term_traits<Arg>::value_type> , 0 > type; BOOST_FORCEINLINE static type const call(proto::expr<Tag, term<Arg>, 0> const &e) { type that = {e.child0}; return that; } }; template<typename Tag, typename Arg> struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> > { typedef @@ -431,40 +431,40 @@ namespace boost }; template<typename Expr> struct result_of<proto::basic_default_generator(Expr)> { typedef Expr type; }; #if BOOST_VERSION >= 104400 template<typename Expr> struct tr1_result_of<proto::default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::basic_default_domain(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::default_generator(Expr)> { typedef Expr type; }; template<typename Expr> struct tr1_result_of<proto::basic_default_generator(Expr)> { typedef Expr type; }; #endif } -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007 diff --git a/3rdParty/Boost/src/boost/proto/make_expr.hpp b/3rdParty/Boost/src/boost/proto/make_expr.hpp index 08ef2f5..720c1bd 100644 --- a/3rdParty/Boost/src/boost/proto/make_expr.hpp +++ b/3rdParty/Boost/src/boost/proto/make_expr.hpp @@ -13,71 +13,71 @@ #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/ref.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/generate.hpp> #include <boost/fusion/include/at_c.hpp> #include <boost/fusion/include/begin.hpp> #include <boost/fusion/include/next.hpp> #include <boost/fusion/include/value_of.hpp> #include <boost/fusion/include/size.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/detail/deprecated.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable : 4180) // qualifier applied to function type has no meaning; ignored # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { /// INTERNAL ONLY /// #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA) \ typename boost::proto::detail::protoify< \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ >::result_type \ /**/ /// INTERNAL ONLY /// #define BOOST_PROTO_AS_CHILD(Z, N, DATA) \ boost::proto::detail::protoify< \ BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 0, DATA), N) \ , BOOST_PP_TUPLE_ELEM(3, 2, DATA) \ >()(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3, 1, DATA), N)) \ /**/ namespace detail { template<typename T, typename Domain> struct protoify : Domain::template as_expr<T> {}; template<typename T, typename Domain> struct protoify<T &, Domain> : Domain::template as_child<T> @@ -470,40 +470,40 @@ namespace boost { namespace proto , fusion::result_of::size<Sequence>::type::value >::call(sequence); } /// \overload /// template<typename Tag, typename Domain, typename Sequence2> BOOST_FORCEINLINE typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const unpack_expr(Sequence2 const &sequence2) { return proto::detail::unpack_expr_< Tag , Domain , Sequence2 const , fusion::result_of::size<Sequence2>::type::value >::call(sequence2); } /// INTERNAL ONLY /// template<typename Tag, typename Domain> struct is_callable<functional::make_expr<Tag, Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Tag, typename Domain> struct is_callable<functional::unpack_expr<Tag, Domain> > : mpl::true_ {}; }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005 diff --git a/3rdParty/Boost/src/boost/proto/matches.hpp b/3rdParty/Boost/src/boost/proto/matches.hpp index 38ff962..09bb4b9 100644 --- a/3rdParty/Boost/src/boost/proto/matches.hpp +++ b/3rdParty/Boost/src/boost/proto/matches.hpp @@ -11,71 +11,71 @@ #define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_shifted.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_shifted_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/config.hpp> #include <boost/mpl/logical.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/utility/enable_if.hpp> #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) #include <boost/type_traits/is_array.hpp> #endif #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/type_traits/is_reference.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/when.hpp> #include <boost/proto/transform/impl.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable:4305) // 'specialization' : truncation from 'const int' to 'bool' #endif #define BOOST_PROTO_LOGICAL_typename_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, typename G) #define BOOST_PROTO_LOGICAL_G BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_LOGICAL_ARITY, G) namespace boost { namespace proto { namespace detail { template<typename Expr, typename BasicExpr, typename Grammar> struct matches_; template<bool B, typename Pred> struct and_2; template<typename And, typename Expr, typename State, typename Data> struct _and_impl; template<typename T, typename U> struct array_matches : mpl::false_ {}; template<typename T, std::size_t M> struct array_matches<T[M], T *> : mpl::true_ {}; template<typename T, std::size_t M> struct array_matches<T[M], T const *> : mpl::true_ {}; @@ -908,40 +908,40 @@ namespace boost { namespace proto {}; /// INTERNAL ONLY /// template<typename Grammar> struct is_callable<not_<Grammar> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename If, typename Then, typename Else> struct is_callable<if_<If, Then, Else> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Grammar> struct is_callable<vararg<Grammar> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Cases, typename Transform> struct is_callable<switch_<Cases, Transform> > : mpl::true_ {}; }} #undef BOOST_PROTO_LOGICAL_typename_G #undef BOOST_PROTO_LOGICAL_G -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/operators.hpp b/3rdParty/Boost/src/boost/proto/operators.hpp index 1f2bad8..7d4195c 100644 --- a/3rdParty/Boost/src/boost/proto/operators.hpp +++ b/3rdParty/Boost/src/boost/proto/operators.hpp @@ -1,59 +1,59 @@ /////////////////////////////////////////////////////////////////////////////// /// \file operators.hpp /// Contains all the overloaded operators that make it possible to build /// Proto expression trees. // // 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_OPERATORS_HPP_EAN_04_01_2005 #define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005 #include <boost/config.hpp> #include <boost/preprocessor/punctuation/comma.hpp> #include <boost/mpl/logical.hpp> #include <boost/utility/enable_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/tags.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/matches.hpp> #include <boost/proto/generate.hpp> #include <boost/proto/make_expr.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 MakeExpr, typename Grammar> struct lazy_matches : proto::matches<typename MakeExpr::type, Grammar> {}; template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Arg> struct enable_unary : boost::lazy_enable_if_c< boost::mpl::and_< Trait , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Arg>, Grammar> >::value , result_of::make_expr<Tag, Domain, Arg> > {}; template<typename Domain, typename Trait, typename Tag, typename Arg> struct enable_unary<Domain, proto::_, Trait, Tag, Arg &> : boost::lazy_enable_if_c< Trait::value , result_of::make_expr<Tag, Domain, Arg &> > {}; template<typename Trait, typename Tag, typename Arg> struct enable_unary<deduce_domain, not_a_grammar, Trait, Tag, Arg &> : enable_unary< @@ -69,71 +69,71 @@ namespace boost { namespace proto struct enable_binary : boost::lazy_enable_if_c< boost::mpl::and_< Trait , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Left, Right>, Grammar> >::value , result_of::make_expr<Tag, Domain, Left, Right> > {}; template<typename Domain, typename Trait, typename Tag, typename Left, typename Right> struct enable_binary<Domain, proto::_, Trait, Tag, Left &, Right &> : boost::lazy_enable_if_c< Trait::value , result_of::make_expr<Tag, Domain, Left &, Right &> > {}; template<typename Trait, typename Tag, typename Left, typename Right> struct enable_binary<deduce_domain, not_a_grammar, Trait, Tag, Left &, Right &> : enable_binary< typename deduce_domain2<Left, Right>::type , typename deduce_domain2<Left, Right>::type::proto_grammar , Trait , Tag , Left & , Right & > {}; } // detail #define BOOST_PROTO_UNARY_OP_IS_POSTFIX_0 #define BOOST_PROTO_UNARY_OP_IS_POSTFIX_1 , int -#ifdef BOOST_NO_RVALUE_REFERENCES +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST) \ template<typename Arg> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_unary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ , TAG \ , Arg & \ >::type const \ operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg &>()(arg); \ } \ \ template<typename Arg> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_unary< \ DOMAIN \ , DOMAIN::proto_grammar \ , BOOST_PROTO_APPLY_UNARY_(TRAIT, Arg) \ , TAG \ , Arg const & \ >::type const \ operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST) \ { \ return boost::proto::detail::make_expr_<TAG, DOMAIN, Arg const &>()(arg); \ } \ /**/ #define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN) \ template<typename Left, typename Right> \ BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE \ typename boost::proto::detail::enable_binary< \ @@ -293,86 +293,86 @@ namespace boost { namespace proto { // This defines all of Proto's built-in free operator overloads BOOST_PROTO_DEFINE_OPERATORS(is_extension, deduce_domain) // if_else, for the non-overloadable ternary conditional operator ?: template<typename A0, typename A1, typename A2> BOOST_FORCEINLINE typename result_of::make_expr< tag::if_else_ , deduce_domain , A0 const & , A1 const & , A2 const & >::type const if_else(A0 const &a0, A1 const &a1, A2 const &a2) { return proto::detail::make_expr_< tag::if_else_ , deduce_domain , A0 const & , A1 const & , A2 const & >()(a0, a1, a2); } } using exprns_::if_else; #undef BOOST_PROTO_APPLY_UNARY_ #undef BOOST_PROTO_APPLY_BINARY_ // Redefine BOOST_PROTO_APPLY_UNARY_ and BOOST_PROTO_APPLY_BINARY_ so that end users // can use BOOST_PROTO_DEFINE_OPERATORS to define Proto operator overloads that work // with their own terminal types. -#ifdef BOOST_NO_RVALUE_REFERENCES +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ boost::mpl::and_< \ TRAIT<ARG> \ , boost::mpl::not_<boost::proto::is_extension<ARG> > \ > \ /**/ #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ boost::mpl::and_< \ boost::mpl::or_<TRAIT<LEFT>, TRAIT<RIGHT> > \ , boost::mpl::not_< \ boost::mpl::or_< \ boost::proto::is_extension<LEFT> \ , boost::proto::is_extension<RIGHT> \ > \ > \ > \ /**/ #else #define BOOST_PROTO_APPLY_UNARY_(TRAIT, ARG) \ boost::mpl::and_< \ TRAIT<BOOST_PROTO_UNCVREF(ARG) > \ , boost::mpl::not_<boost::proto::is_extension<ARG> > \ > \ /**/ #define BOOST_PROTO_APPLY_BINARY_(TRAIT, LEFT, RIGHT) \ boost::mpl::and_< \ boost::mpl::or_<TRAIT<BOOST_PROTO_UNCVREF(LEFT) >, TRAIT<BOOST_PROTO_UNCVREF(RIGHT) > > \ , boost::mpl::not_< \ boost::mpl::or_< \ boost::proto::is_extension<LEFT> \ , boost::proto::is_extension<RIGHT> \ > \ > \ > \ /**/ #endif }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/proto_fwd.hpp b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp index 5547e77..a1a2598 100644 --- a/3rdParty/Boost/src/boost/proto/proto_fwd.hpp +++ b/3rdParty/Boost/src/boost/proto/proto_fwd.hpp @@ -61,101 +61,101 @@ # define BOOST_PROTO_BROKEN_CONST_OVERLOADS # endif #endif #ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # if BOOST_WORKAROUND(__GNUC__, == 3) \ || BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310)) # define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # endif #endif #ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS # include <boost/utility/enable_if.hpp> # include <boost/type_traits/is_const.hpp> # define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\ , typename boost::disable_if_c<boost::is_const<T>::value, boost::proto::detail::undefined>::type * = 0 #else # define BOOST_PROTO_DISABLE_IF_IS_CONST(T) #endif #ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS # include <boost/utility/enable_if.hpp> # include <boost/type_traits/is_function.hpp> # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\ , typename boost::disable_if_c<boost::is_function<T>::value, boost::proto::detail::undefined>::type * = 0 #else # define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T) #endif #ifndef BOOST_PROTO_BROKEN_PTS # if BOOST_WORKAROUND(BOOST_MSVC, <= 1400) # define BOOST_PROTO_BROKEN_PTS # endif #endif -#ifdef BOOST_NO_DECLTYPE_N3276 +#ifdef BOOST_NO_CXX11_DECLTYPE_N3276 # // Proto can only use the decltype-based result_of if N3276 has been # // implemented by the compiler. # // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf # ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF # define BOOST_PROTO_USE_NORMAL_RESULT_OF # endif #endif // Unless compiler support is there, use tr1_result_of instead of // result_of to avoid the problems addressed by N3276. #ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF # define BOOST_PROTO_RESULT_OF boost::result_of #else # define BOOST_PROTO_RESULT_OF boost::tr1_result_of #endif // If we're using the decltype-based result_of, we need to be a bit // stricter about the return types of some functions. #if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF) # define BOOST_PROTO_STRICT_RESULT_OF # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X #else # define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y #endif #ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING # define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING #endif -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified # define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined #else # define BOOST_PROTO_DISABLE_MSVC_C4522 # define BOOST_PROTO_DISABLE_MSVC_C4714 #endif namespace boost { namespace proto { namespace detail { typedef char yes_type; typedef char (&no_type)[2]; template<int N> struct sized_type { typedef char (&type)[N]; }; struct dont_care; struct undefined; // leave this undefined struct not_a_valid_type; struct private_type_ { private_type_ operator ,(int) const; }; template<typename T> struct uncvref { typedef T type; }; diff --git a/3rdParty/Boost/src/boost/proto/traits.hpp b/3rdParty/Boost/src/boost/proto/traits.hpp index cf9f091..f1a83fc 100644 --- a/3rdParty/Boost/src/boost/proto/traits.hpp +++ b/3rdParty/Boost/src/boost/proto/traits.hpp @@ -1,70 +1,70 @@ /////////////////////////////////////////////////////////////////////////////// /// \file traits.hpp /// Contains definitions for child\<\>, child_c\<\>, left\<\>, /// right\<\>, tag_of\<\>, and the helper functions child(), child_c(), /// value(), left() and right(). // // 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_ARG_TRAITS_HPP_EAN_04_01_2005 #define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/static_assert.hpp> #include <boost/mpl/bool.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/type_traits/is_pod.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/domain.hpp> #include <boost/proto/transform/pass_through.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 ) # pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored # endif # pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined #endif namespace boost { namespace proto { namespace detail { template<typename T, typename Void = void> struct if_vararg {}; template<typename T> struct if_vararg<T, typename T::proto_is_vararg_> : T {}; template<typename T, typename Void = void> struct is_callable2_ : mpl::false_ {}; template<typename T> struct is_callable2_<T, typename T::proto_is_callable_> : mpl::true_ {}; template<typename T BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = boost::proto::detail::template_arity<T>::value)> struct is_callable_ : is_callable2_<T> {}; @@ -1105,71 +1105,71 @@ namespace boost { namespace proto { return expr2.proto_base().child0; } /// \brief Return the Nth child of the specified Proto expression. /// /// Return the Nth child of the specified Proto expression. The child /// is returned by reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre <tt>N \< Expr::proto_arity::value</tt> /// \throw nothrow /// \return A reference to the Nth child template<long N, typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr &, N>::type child_c(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return result_of::child_c<Expr &, N>::call(e); } /// \overload /// template<long N, typename Expr> BOOST_FORCEINLINE typename result_of::child_c<Expr const &, N>::type child_c(Expr const &e) { return result_of::child_c<Expr const &, N>::call(e); } /// \brief Return the value stored within the specified Proto /// terminal expression. /// - /// Return the the value stored within the specified Proto + /// Return the value stored within the specified Proto /// terminal expression. The value is returned by /// reference. /// /// \param expr The Proto terminal expression. /// \pre <tt>N::value == 0</tt> /// \throw nothrow /// \return A reference to the terminal's value template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr &>::type value(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr)) { return e.proto_base().child0; } /// \overload /// template<typename Expr> BOOST_FORCEINLINE typename result_of::value<Expr const &>::type value(Expr const &e) { return e.proto_base().child0; } /// \brief Return the left child of the specified binary Proto /// expression. /// /// Return the left child of the specified binary Proto expression. The /// child is returned by reference. /// /// \param expr The Proto expression. /// \pre <tt>is_expr\<Expr\>::value</tt> is \c true. /// \pre <tt>2 == Expr::proto_arity::value</tt> /// \throw nothrow @@ -1219,40 +1219,40 @@ namespace boost { namespace proto right(Expr const &e) { return e.proto_base().child1; } /// INTERNAL ONLY /// template<typename Domain> struct is_callable<functional::as_expr<Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename Domain> struct is_callable<functional::as_child<Domain> > : mpl::true_ {}; /// INTERNAL ONLY /// template<long N> struct is_callable<functional::child_c<N> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename N> struct is_callable<functional::child<N> > : mpl::true_ {}; }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/call.hpp b/3rdParty/Boost/src/boost/proto/transform/call.hpp index 7d87c90..1e05011 100644 --- a/3rdParty/Boost/src/boost/proto/transform/call.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/call.hpp @@ -1,47 +1,47 @@ /////////////////////////////////////////////////////////////////////////////// /// \file call.hpp /// Contains definition of the call<> transform. // // 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_CALL_HPP_EAN_11_02_2007 #define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007 -#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 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_binary_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/ref.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/as_lvalue.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/transform/detail/pack.hpp> namespace boost { namespace proto { /// \brief Wrap \c PrimitiveTransform so that <tt>when\<\></tt> knows /// it is callable. Requires that the parameter is actually a /// PrimitiveTransform. /// /// This form of <tt>call\<\></tt> is useful for annotating an /// arbitrary PrimitiveTransform as callable when using it with /// <tt>when\<\></tt>. Consider the following transform, which /// is parameterized with another transform. /// /// \code /// template<typename Grammar> /// struct Foo @@ -362,40 +362,40 @@ namespace boost { namespace proto { return typename Fun::template impl<a0, a1, a2>()( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) , typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ); } }; /// Let \c x be <tt>when\<_, A0\>()(e, s, d)</tt>. /// Let \c y be <tt>when\<_, A1\>()(e, s, d)</tt>. /// Let \c z be <tt>when\<_, A2\>()(e, s, d)</tt>. /// Return <tt>Fun()(x, y, z)</tt>. /// /// \param e The current expression /// \param s The current state /// \param d An arbitrary data template<typename Expr, typename State, typename Data> struct impl : impl2<Expr, State, Data, detail::is_transform_<Fun>::value> {}; }; #include <boost/proto/transform/detail/call.hpp> /// INTERNAL ONLY /// template<typename Fun> struct is_callable<call<Fun> > : mpl::true_ {}; }} // namespace boost::proto -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp b/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp index 863e7a0..20a8ce3 100644 --- a/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/detail/pack.hpp @@ -1,97 +1,97 @@ /////////////////////////////////////////////////////////////////////////////// /// \file pack.hpp /// Contains helpers for pseudo-pack expansion. // // Copyright 2012 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_DETAIL_PACK_HPP_EAN_2012_07_11 #define BOOST_PROTO_TRANSFORM_DETAIL_PACK_HPP_EAN_2012_07_11 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/preprocessor/arithmetic/dec.hpp> #include <boost/preprocessor/arithmetic/sub.hpp> #include <boost/preprocessor/punctuation/comma_if.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat.hpp> #include <boost/preprocessor/iteration/local.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/assert.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/proto/proto_fwd.hpp> -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(push) # pragma warning(disable: 4348) // redefinition of default parameter #endif namespace boost { namespace proto { namespace detail { template<typename Fun> struct msvc_fun_workaround; template<typename Tfx, typename T> struct expand_pattern_helper { typedef T type; typedef mpl::false_ applied; }; template<typename Tfx, typename Fun> struct expand_pattern_helper<Tfx, Fun *> : expand_pattern_helper<Tfx, Fun> {}; template<typename Tfx, typename T> struct expand_pattern_helper<Tfx, pack(T)> { // BUGBUG fix me. See comment in transform/detail/call.hpp BOOST_MPL_ASSERT_MSG( (is_same<T, _>::value) , PACK_EXPANSIONS_OF_EXPRESSIONS_OTHER_THAN_THE_CURRENT_NOT_YET_SUPPORTED , (T) ); typedef Tfx type(T); typedef mpl::true_ applied; }; template<typename Tfx> struct expand_pattern_helper<Tfx, pack(_)> { typedef Tfx type; typedef mpl::true_ applied; }; #include <boost/proto/transform/detail/expand_pack.hpp> template<long Arity, typename Fun, typename Cont> struct expand_pattern; template<typename Fun, typename Cont> struct expand_pattern<0, Fun, Cont> : Cont::template cat<typename expand_pattern_helper<proto::_value, Fun>::type> { BOOST_MPL_ASSERT_MSG( (expand_pattern_helper<proto::_value, Fun>::applied::value) , NO_PACK_EXPRESSION_FOUND_IN_PACK_EXPANSION , (Fun) ); }; #include <boost/proto/transform/detail/pack_impl.hpp> } }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp index ace2c21..b541a15 100644 --- a/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/fold_tree.hpp @@ -37,126 +37,126 @@ namespace boost { namespace proto template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data, typename Expr::proto_tag> { typedef mpl::true_ result_type; }; }; template<typename Tag, typename Fun> struct fold_tree_ : if_<has_tag<Tag>, fold<_, _state, fold_tree_<Tag, Fun> >, Fun> {}; template<typename Tag, typename Fun> struct reverse_fold_tree_ : if_<has_tag<Tag>, reverse_fold<_, _state, reverse_fold_tree_<Tag, Fun> >, Fun> {}; } /// \brief A PrimitiveTransform that recursively applies the /// <tt>fold\<\></tt> transform to sub-trees that all share a common /// tag type. /// /// <tt>fold_tree\<\></tt> is useful for flattening trees into lists; /// for example, you might use <tt>fold_tree\<\></tt> to flatten an /// expression tree like <tt>a | b | c</tt> into a Fusion list like /// <tt>cons(c, cons(b, cons(a)))</tt>. /// /// <tt>fold_tree\<\></tt> is easily understood in terms of a /// <tt>recurse_if_\<\></tt> helper, defined as follows: /// /// \code /// template<typename Tag, typename Fun> /// struct recurse_if_ /// : if_< - /// // If the current node has type type "Tag" ... + /// // If the current node has type "Tag" ... /// is_same<tag_of<_>, Tag>() /// // ... recurse, otherwise ... /// , fold<_, _state, recurse_if_<Tag, Fun> > /// // ... apply the Fun transform. /// , Fun /// > /// {}; /// \endcode /// /// With <tt>recurse_if_\<\></tt> as defined above, /// <tt>fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is /// equivalent to /// <tt>fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> /// It has the effect of folding a tree front-to-back, recursing into /// child nodes that share a tag type with the parent node. template<typename Sequence, typename State0, typename Fun> struct fold_tree : transform<fold_tree<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : fold< Sequence , State0 , detail::fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : fold< Sequence , State0 , detail::fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr &, State, Data> {}; }; /// \brief A PrimitiveTransform that recursively applies the /// <tt>reverse_fold\<\></tt> transform to sub-trees that all share /// a common tag type. /// /// <tt>reverse_fold_tree\<\></tt> is useful for flattening trees into /// lists; for example, you might use <tt>reverse_fold_tree\<\></tt> to /// flatten an expression tree like <tt>a | b | c</tt> into a Fusion list /// like <tt>cons(a, cons(b, cons(c)))</tt>. /// /// <tt>reverse_fold_tree\<\></tt> is easily understood in terms of a /// <tt>recurse_if_\<\></tt> helper, defined as follows: /// /// \code /// template<typename Tag, typename Fun> /// struct recurse_if_ /// : if_< - /// // If the current node has type type "Tag" ... + /// // If the current node has type "Tag" ... /// is_same<tag_of<_>, Tag>() /// // ... recurse, otherwise ... /// , reverse_fold<_, _state, recurse_if_<Tag, Fun> > /// // ... apply the Fun transform. /// , Fun /// > /// {}; /// \endcode /// /// With <tt>recurse_if_\<\></tt> as defined above, /// <tt>reverse_fold_tree\<Sequence, State0, Fun\>()(e, s, d)</tt> is /// equivalent to /// <tt>reverse_fold<Sequence, State0, recurse_if_<Expr::proto_tag, Fun> >()(e, s, d).</tt> /// It has the effect of folding a tree back-to-front, recursing into /// child nodes that share a tag type with the parent node. template<typename Sequence, typename State0, typename Fun> struct reverse_fold_tree : transform<reverse_fold_tree<Sequence, State0, Fun> > { template<typename Expr, typename State, typename Data> struct impl : reverse_fold< Sequence , State0 , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr, State, Data> {}; template<typename Expr, typename State, typename Data> struct impl<Expr &, State, Data> : reverse_fold< Sequence , State0 , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun> >::template impl<Expr &, State, Data> diff --git a/3rdParty/Boost/src/boost/proto/transform/impl.hpp b/3rdParty/Boost/src/boost/proto/transform/impl.hpp index 5cd538b..5490086 100644 --- a/3rdParty/Boost/src/boost/proto/transform/impl.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/impl.hpp @@ -1,113 +1,113 @@ /////////////////////////////////////////////////////////////////////////////// /// \file impl.hpp /// Contains definition of transform<> and transform_impl<> helpers. // // 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_IMPL_HPP_EAN_04_03_2008 #define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 #include <boost/config.hpp> #include <boost/mpl/bool.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/detail/any.hpp> #include <boost/proto/detail/static_const.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 envns_ { //////////////////////////////////////////////////////////////////////////////////////////// struct key_not_found {}; //////////////////////////////////////////////////////////////////////////////////////////// // empty_env struct empty_env { typedef void proto_environment_; template<typename OtherTag, typename OtherValue = key_not_found> struct lookup { typedef OtherValue type; typedef typename add_reference<typename add_const<OtherValue>::type>::type const_reference; }; key_not_found operator[](detail::any) const { return key_not_found(); } template<typename T> T const &at(detail::any, T const &t) const { return t; } }; } //////////////////////////////////////////////////////////////////////////////////////////// // is_env template<typename T, typename Void> struct is_env : mpl::false_ {}; template<typename T> struct is_env<T, typename T::proto_environment_> : mpl::true_ {}; template<typename T> struct is_env<T &, void> : is_env<T> {}; -#ifdef BOOST_NO_RVALUE_REFERENCES +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES /// INTERNAL ONLY /// #define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ BOOST_PROTO_CALLABLE() \ typedef X proto_is_transform_; \ typedef PrimitiveTransform transform_type; \ \ template<typename Sig> \ struct result \ { \ typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ }; \ \ template<typename Expr> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \ operator ()(Expr &e) const \ { \ boost::proto::empty_state s = 0; \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, s, d); \ } \ \ template<typename Expr> \ BOOST_FORCEINLINE \ typename boost::proto::detail::apply_transform<transform_type(Expr const &)>::result_type \ operator ()(Expr const &e) const \ { \ boost::proto::empty_state s = 0; \ boost::proto::empty_env d; \ return boost::proto::detail::apply_transform<transform_type(Expr const &)>()(e, s, d); \ } \ \ template<typename Expr, typename State> \ @@ -313,40 +313,40 @@ namespace boost { namespace proto template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State, Data &> { typedef Expr expr; typedef Expr &expr_param; typedef State const state; typedef State const &state_param; typedef Data data; typedef Data &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr, State &, Data &> { typedef Expr const expr; typedef Expr const &expr_param; typedef State state; typedef State &state_param; typedef Data data; typedef Data &data_param; }; template<typename Expr, typename State, typename Data> struct transform_impl<Expr &, State &, Data &> { typedef Expr expr; typedef Expr &expr_param; typedef State state; typedef State &state_param; typedef Data data; typedef Data &data_param; }; }} // namespace boost::proto -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/make.hpp b/3rdParty/Boost/src/boost/proto/transform/make.hpp index 140ca1d..5652543 100644 --- a/3rdParty/Boost/src/boost/proto/transform/make.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/make.hpp @@ -1,71 +1,71 @@ /////////////////////////////////////////////////////////////////////////////// /// \file make.hpp /// Contains definition of the make<> transform. // // 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_MAKE_HPP_EAN_12_02_2007 #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007 #include <boost/detail/workaround.hpp> #include <boost/preprocessor/repetition/enum.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/enum_params_with_a_default.hpp> #include <boost/preprocessor/repetition/repeat_from_to.hpp> #include <boost/preprocessor/facilities/intercept.hpp> #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/preprocessor/selection/max.hpp> #include <boost/preprocessor/arithmetic/inc.hpp> #include <boost/mpl/and.hpp> #include <boost/mpl/aux_/has_type.hpp> #include <boost/proto/detail/template_arity.hpp> #include <boost/utility/result_of.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/args.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/detail/pack.hpp> #include <boost/proto/detail/as_lvalue.hpp> #include <boost/proto/detail/ignore_unused.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> struct is_applyable : mpl::and_<is_callable<T>, is_transform<T> > {}; template<typename T, bool HasType = mpl::aux::has_type<T>::value> struct nested_type { typedef typename T::type type; }; template<typename T> struct nested_type<T, false> { typedef T type; }; template<typename T, bool Applied> struct nested_type_if { typedef T type; static bool const applied = false; }; template<typename T> struct nested_type_if<T, true> : nested_type<T> @@ -245,40 +245,40 @@ namespace boost { namespace proto , typename impl::state_param , typename impl::data_param ) const { return result_type(); } }; }; /// INTERNAL ONLY template<typename Fun> struct make<detail::msvc_fun_workaround<Fun> > : make<Fun> {}; // Other specializations generated by the preprocessor. #include <boost/proto/transform/detail/make.hpp> #include <boost/proto/transform/detail/make_gcc_workaround.hpp> /// INTERNAL ONLY /// template<typename Object> struct is_callable<make<Object> > : mpl::true_ {}; /// INTERNAL ONLY /// template<typename PrimitiveTransform> struct is_callable<protect<PrimitiveTransform> > : mpl::true_ {}; }} -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp index 9c43008..bdd152e 100644 --- a/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/pass_through.hpp @@ -1,62 +1,62 @@ /////////////////////////////////////////////////////////////////////////////// /// \file pass_through.hpp /// /// Definition of the pass_through transform, which is the default transform /// of all of the expression generator metafunctions such as unary_plus<>, plus<> /// and nary_expr<>. // // 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_PASS_THROUGH_HPP_EAN_12_26_2006 #define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/args.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/ignore_unused.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 Grammar , typename Domain , typename Expr , typename State , typename Data , long Arity = arity_of<Expr>::value > struct pass_through_impl {}; #include <boost/proto/transform/detail/pass_through_impl.hpp> template<typename Grammar, typename Domain, typename Expr, typename State, typename Data> struct pass_through_impl<Grammar, Domain, Expr, State, Data, 0> : transform_impl<Expr, State, Data> { typedef Expr result_type; /// \param e An expression /// \return \c e /// \throw nothrow BOOST_FORCEINLINE BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename pass_through_impl::expr_param) operator()( typename pass_through_impl::expr_param e , typename pass_through_impl::state_param @@ -106,40 +106,40 @@ namespace boost { namespace proto /// For example, consider the following transform that promotes all /// \c float terminals in an expression to \c double. /// /// \code /// // This transform finds all float terminals in an expression and promotes /// // them to doubles. /// struct Promote /// : or_< /// when<terminal<float>, terminal<double>::type(_value) > /// // terminal<>'s default transform is a no-op: /// , terminal<_> /// // nary_expr<> has a pass_through<> transform: /// , nary_expr<_, vararg<Promote> > /// > /// {}; /// \endcode template<typename Grammar, typename Domain /* = deduce_domain*/> struct pass_through : transform<pass_through<Grammar, Domain> > { template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<Grammar, Domain, Expr, State, Data> {}; }; /// INTERNAL ONLY /// template<typename Grammar, typename Domain> struct is_callable<pass_through<Grammar, Domain> > : mpl::true_ {}; }} // namespace boost::proto -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif diff --git a/3rdParty/Boost/src/boost/proto/transform/when.hpp b/3rdParty/Boost/src/boost/proto/transform/when.hpp index d1defb8..78ffa9e 100644 --- a/3rdParty/Boost/src/boost/proto/transform/when.hpp +++ b/3rdParty/Boost/src/boost/proto/transform/when.hpp @@ -1,62 +1,62 @@ /////////////////////////////////////////////////////////////////////////////// /// \file when.hpp /// Definition of when transform. // // 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_WHEN_HPP_EAN_10_29_2007 #define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007 #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/repetition/enum_params.hpp> #include <boost/preprocessor/repetition/enum_trailing_params.hpp> #include <boost/preprocessor/iteration/iterate.hpp> #include <boost/mpl/at.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/map.hpp> #include <boost/mpl/eval_if.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/traits.hpp> #include <boost/proto/transform/call.hpp> #include <boost/proto/transform/make.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/transform/env.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 Grammar, typename R, typename Fun> struct when_impl : transform<when<Grammar, Fun> > { typedef Grammar first; typedef Fun second; typedef typename Grammar::proto_grammar proto_grammar; // Note: do not evaluate is_callable<R> in this scope. // R may be an incomplete type at this point. template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { // OK to evaluate is_callable<R> here. R should be compete by now. typedef typename mpl::if_c< is_callable<R>::value , proto::call<Fun> // "R" is a function to call , proto::make<Fun> // "R" is an object to construct >::type which; typedef typename which::template impl<Expr, State, Data>::result_type result_type; /// Evaluate <tt>R(A0,A1,...)</tt> as a transform either with /// <tt>call\<\></tt> or with <tt>make\<\></tt> depending on @@ -228,40 +228,40 @@ namespace boost { namespace proto /// proto::when<int_terminal, print(proto::_value)> /// , proto::when<char_terminal, print(proto::_value)> /// > /// {}; /// /// proto::literal<int> i(1); /// proto::literal<char> c('a'); /// my_transforms trx; /// /// // Evaluate "i+c" using my_grammar with the specified transforms: /// my_grammar()(i + c, 0, trx); /// \endcode template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)> struct external_transforms { typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type; template<typename Rule> struct when : proto::when<_, typename mpl::at<map_type, Rule>::type> {}; }; // Other specializations of proto::when are generated by the preprocessor... #include <boost/proto/transform/detail/when.hpp> /// INTERNAL ONLY /// template<typename Grammar, typename Transform> struct is_callable<when<Grammar, Transform> > : mpl::true_ {}; }} // namespace boost::proto -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma warning(pop) #endif #endif |