Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home')
106 files changed, 350 insertions, 5690 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp index b25b25f..96b2dd7 100644 --- a/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp +++ b/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp @@ -151,169 +151,6 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN return s.parse(scan); } -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - - /////////////////////////////////////////////////////////////////////// - // - // from spirit 1.1 (copyright (c) 2001 Bruce Florman) - // various workarounds to support longest and shortest directives - // - /////////////////////////////////////////////////////////////////////// - template <typename T> - struct is_alternative - { - // Determine at compile time (without partial specialization) - // whether a given type is an instance of the alternative<A,B> - - static T t(); - template <typename A, typename B> - static char test_(alternative<A, B> const&); // no implementation - static int test_(...); // no implementation - enum { r = sizeof(char) == sizeof(test_(t())) }; - typedef mpl::bool_<r> value; - }; - - template <typename T> struct select_to_longest; - - template <typename T> - struct to_longest_alternative - { - typedef typename select_to_longest<T>::result_t result_t; - typedef typename select_to_longest<T>::plain_t plain_t; - typedef typename select_to_longest<T>::choose_t choose_t; - static result_t convert(T const& a); - }; - - template <typename T> - struct to_longest_generic - { - typedef T const& result_t; - typedef T plain_t; - typedef mpl::false_ choose_t; - }; - - template <typename T> - inline T const& - to_longest_convert(T const& a, mpl::false_) - { return a; } - - template <typename T> - struct to_longest_recursive - { - typedef typename to_longest_alternative< - typename T::left_t>::plain_t a_t; - typedef typename to_longest_alternative< - typename T::right_t>::plain_t b_t; - - typedef longest_alternative<a_t, b_t> result_t; - - typedef result_t plain_t; - typedef mpl::true_ choose_t; - }; - - template <typename A, typename B> - inline typename to_longest_alternative<alternative<A, B> >::result_t - to_longest_convert(alternative<A, B> const& alt, mpl::true_) - { - typedef typename to_longest_alternative< - alternative<A, B> >::result_t result_t; - return result_t( - to_longest_alternative<A>::convert(alt.left()), - to_longest_alternative<B>::convert(alt.right())); - } - - template <typename T> - inline typename to_longest_alternative<T>::result_t - to_longest_alternative<T>::convert(T const& a) - { - return to_longest_convert( - a, to_longest_alternative<T>::choose_t()); - } - - template <typename T> - struct select_to_longest - { - typedef typename mpl::if_< - is_alternative<T> // IF - , to_longest_recursive<T> // THEN - , to_longest_generic<T> // ELSE - >::type type; - - typedef typename select_to_longest::type::result_t result_t; - typedef typename select_to_longest::type::plain_t plain_t; - typedef typename select_to_longest::type::choose_t choose_t; - }; - - template <typename T> struct select_to_shortest; - - template <typename T> - struct to_shortest_alternative - { - typedef typename select_to_shortest<T>::result_t result_t; - typedef typename select_to_shortest<T>::plain_t plain_t; - typedef typename select_to_shortest<T>::choose_t choose_t; - static result_t convert(T const& a); - }; - - template <typename T> - struct to_shortest_generic - { - typedef T const& result_t; - typedef T plain_t; - typedef mpl::false_ choose_t; - }; - - template <typename T> - inline T const& - to_shortest_convert(T const& a, mpl::false_) { return a; } - - template <typename T> - struct to_shortest_recursive - { - typedef typename to_shortest_alternative< - typename T::left_t>::plain_t a_t; - typedef typename to_shortest_alternative< - typename T::right_t>::plain_t b_t; - - typedef shortest_alternative<a_t, b_t> result_t; - - typedef result_t plain_t; - typedef mpl::true_ choose_t; - }; - - template <typename A, typename B> - inline typename to_shortest_alternative<alternative<A, B> >::result_t - to_shortest_convert(alternative<A, B> const& alt, mpl::true_) - { - typedef typename to_shortest_alternative< - alternative<A, B> >::result_t result_t; - return result_t( - to_shortest_alternative<A>::convert(alt.left()), - to_shortest_alternative<B>::convert(alt.right())); - } - - template <typename T> - inline typename to_shortest_alternative<T>::result_t - to_shortest_alternative<T>::convert(T const& a) - { - return to_shortest_convert( - a, to_shortest_alternative<T>::choose_t()); - } - - template <typename T> - struct select_to_shortest - { - typedef typename mpl::if_< - is_alternative<T> // IF - , to_shortest_recursive<T> // THEN - , to_shortest_generic<T> // ELSE - >::type type; - - typedef typename select_to_shortest::type::result_t result_t; - typedef typename select_to_shortest::type::plain_t plain_t; - typedef typename select_to_shortest::type::choose_t choose_t; - }; -#else template <typename T> struct to_longest_alternative { @@ -363,7 +200,6 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN to_shortest_alternative<B>::convert(alt.right())); } }; -#endif } BOOST_SPIRIT_CLASSIC_NAMESPACE_END diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/core/non_terminal/rule.hpp b/3rdParty/Boost/src/boost/spirit/home/classic/core/non_terminal/rule.hpp index e905689..1d4336b 100644 --- a/3rdParty/Boost/src/boost/spirit/home/classic/core/non_terminal/rule.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/classic/core/non_terminal/rule.hpp @@ -15,7 +15,7 @@ // Spirit predefined maximum number of simultaneously usable different // scanner types. // -// This limit defines the maximum number of of possible different scanner +// This limit defines the maximum number of possible different scanner // types for which a specific rule<> may be used. If this isn't defined, a // rule<> may be used with one scanner type only (multiple scanner support // is disabled). diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/core/primitives/impl/primitives.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/core/primitives/impl/primitives.ipp index 152e5b1..8a52251 100644 --- a/3rdParty/Boost/src/boost/spirit/home/classic/core/primitives/impl/primitives.ipp +++ b/3rdParty/Boost/src/boost/spirit/home/classic/core/primitives/impl/primitives.ipp @@ -10,21 +10,12 @@ #if !defined(BOOST_SPIRIT_PRIMITIVES_IPP) #define BOOST_SPIRIT_PRIMITIVES_IPP -// This should eventually go to a config file. -#if defined(__GNUC__) && (__GNUC__ < 3) && !defined(_STLPORT_VERSION) -# ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# define BOOST_SPIRIT_NO_CHAR_TRAITS -# endif -#endif - #include <cctype> #if !defined(BOOST_NO_CWCTYPE) #include <cwctype> #endif -#ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# include <string> // char_traits -#endif +#include <string> // char_traits #if defined(BOOST_MSVC) # pragma warning (push) @@ -79,80 +70,6 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN // /////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_SPIRIT_NO_CHAR_TRAITS -# define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE std -#else - - template <typename CharT> - struct char_traits - { - typedef CharT int_type; - typedef CharT char_type; - }; - - template<> - struct char_traits<char> - { - typedef int int_type; - typedef char char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast<char_type>(c); - } - - static int - to_int_type(char c) - { - return static_cast<unsigned char>(c); - } - }; - - template<> - struct char_traits<unsigned char> - { - typedef int int_type; - typedef unsigned char char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast<char_type>(c); - } - - static int - to_int_type(unsigned char c) - { - return c; - } - }; - -# define BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE impl -# ifndef BOOST_NO_CWCTYPE - - template<> - struct char_traits<wchar_t> - { - typedef wint_t int_type; - typedef wchar_t char_type; - - static char_type - to_char_type(int_type c) - { - return static_cast<char_type>(c); - } - - static wint_t - to_int_type(wchar_t c) - { - return c; - } - }; - -# endif -#endif // BOOST_SPIRIT_NO_CHAR_TRAITS - // Use char_traits for char and wchar_t only, as these are the only // specializations provided in the standard. Other types are on their // own. @@ -182,19 +99,16 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN struct char_type_char_traits_helper { typedef CharT char_type; - typedef typename BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits<CharT>::int_type int_type; + typedef typename std::char_traits<CharT>::int_type int_type; static int_type to_int_type(CharT c) { - return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits<CharT>::to_int_type(c); + return std::char_traits<CharT>::to_int_type(c); } static char_type to_char_type(int_type i) { - return BOOST_SPIRIT_CHAR_TRAITS_NAMESPACE - ::char_traits<CharT>::to_char_type(i); + return std::char_traits<CharT>::to_char_type(i); } }; diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp index 3017035..6e2130b 100644 --- a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp +++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset.ipp @@ -71,38 +71,6 @@ namespace utility { namespace impl { } } - ////////////////////////////////// - -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - - template <typename CharT, typename FakeT> - void chset_negated_set(boost::shared_ptr<basic_chset<CharT> > &ptr, chlit<CharT> const &ch, - FakeT) - { - if(ch.ch != (std::numeric_limits<CharT>::min)()) { - ptr->set((std::numeric_limits<CharT>::min)(), ch.ch - 1); - } - if(ch.ch != (std::numeric_limits<CharT>::max)()) { - ptr->set(ch.ch + 1, (std::numeric_limits<CharT>::max)()); - } - } - - template <typename CharT, typename FakeT> - void chset_negated_set(boost::shared_ptr<basic_chset<CharT> > &ptr, - spirit::range<CharT> const &rng, FakeT) - { - if(rng.first != (std::numeric_limits<CharT>::min)()) { - ptr->set((std::numeric_limits<CharT>::min)(), rng.first - 1); - } - if(rng.last != (std::numeric_limits<CharT>::max)()) { - ptr->set(rng.last + 1, (std::numeric_limits<CharT>::max)()); - } - } - -#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -////////////////////////////////// - }} // namespace utility::impl template <typename CharT> @@ -142,8 +110,6 @@ inline chset<CharT>::chset(range<CharT> const& arg_) : ptr(new basic_chset<CharT>()) { ptr->set(arg_.first, arg_.last); } -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_) : ptr(new basic_chset<CharT>()) @@ -158,8 +124,6 @@ inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_) set(arg_); } -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline chset<CharT>::~chset() {} @@ -218,8 +182,6 @@ chset<CharT>::operator=(range<CharT> const& rhs) return *this; } -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline chset<CharT>& chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs) @@ -238,8 +200,6 @@ chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs) return *this; } -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline void chset<CharT>::set(range<CharT> const& arg_) @@ -248,8 +208,6 @@ chset<CharT>::set(range<CharT> const& arg_) ptr->set(arg_.first, arg_.last); } -#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline void chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_) @@ -278,8 +236,6 @@ chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_) } } -#endif // !BOOST_WORKAROUND(BOOST_MSVC, < 1300) - template <typename CharT> inline void chset<CharT>::clear(range<CharT> const& arg_) diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp index 4319c9b..842a679 100644 --- a/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp +++ b/3rdParty/Boost/src/boost/spirit/home/classic/utility/impl/chset_operators.ipp @@ -285,78 +285,6 @@ operator^(chlit<CharT> const& a, chset<CharT> const& b) return chset<CharT>(a.ch) ^ b; } -#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) - -/////////////////////////////////////////////////////////////////////////////// -// -// negated_char_parser <--> chset free operators implementation -// -/////////////////////////////////////////////////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator|(chset<CharT> const& a, negated_char_parser<ParserT> const& b) -{ - return a | chset<CharT>(b); -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator&(chset<CharT> const& a, negated_char_parser<ParserT> const& b) -{ - return a & chset<CharT>(b); -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator-(chset<CharT> const& a, negated_char_parser<ParserT> const& b) -{ - return a - chset<CharT>(b); -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator^(chset<CharT> const& a, negated_char_parser<ParserT> const& b) -{ - return a ^ chset<CharT>(b); -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator|(negated_char_parser<ParserT> const& a, chset<CharT> const& b) -{ - return chset<CharT>(a) | b; -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator&(negated_char_parser<ParserT> const& a, chset<CharT> const& b) -{ - return chset<CharT>(a) & b; -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator-(negated_char_parser<ParserT> const& a, chset<CharT> const& b) -{ - return chset<CharT>(a) - b; -} - -////////////////////////////////// -template <typename CharT, typename ParserT> -inline chset<CharT> -operator^(negated_char_parser<ParserT> const& a, chset<CharT> const& b) -{ - return chset<CharT>(a) ^ b; -} - -#else // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - /////////////////////////////////////////////////////////////////////////////// // // negated_char_parser<range> <--> chset free operators implementation @@ -493,8 +421,6 @@ operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b) return chset<CharT>(a) ^ b; } -#endif // BOOST_WORKAROUND(BOOST_MSVC, < 1300) - /////////////////////////////////////////////////////////////////////////////// // // anychar_parser <--> chset free operators diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp index edfee0b..fbac3c1 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/argument.hpp @@ -110,12 +110,6 @@ namespace boost { namespace spirit { namespace lex state_setter(Actor const& actor) : actor_(actor) {} - // see explanation for this constructor at the end of this file -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - state_setter(phoenix::actor<state_getter>, Actor const& actor) - : actor_(actor) {} -#endif - Actor actor_; }; @@ -190,12 +184,6 @@ namespace boost { namespace spirit { namespace lex value_setter(Actor const& actor) : actor_(actor) {} -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - // see explanation for this constructor at the end of this file - value_setter(phoenix::actor<value_getter>, Actor const& actor) - : actor_(actor) {} -#endif - Actor actor_; }; @@ -281,81 +269,6 @@ namespace boost { namespace spirit { namespace lex #endif }}} -/////////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 -namespace boost { namespace phoenix -{ - /////////////////////////////////////////////////////////////////////////// - // The specialization of as_actor_base<> below is needed to convert all - // occurrences of _state in places where it's used as a rvalue into the - // proper Phoenix actor (spirit::state_getter) accessing the lexer state. - template<> - struct as_actor_base<actor<spirit::lex::state_context> > - { - typedef spirit::lex::state_getter type; - - static spirit::lex::state_getter - convert(actor<spirit::lex::state_context>) - { - return spirit::lex::state_getter(); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // The specialization of as_composite<> below is needed to convert all - // assignments to _state (places where it's used as a lvalue) into the - // proper Phoenix actor (spirit::state_setter) allowing to change the - // lexer state. - template <typename RHS> - struct as_composite<assign_eval, actor<spirit::lex::state_context>, RHS> - { - // For an assignment to _state (a spirit::state_context actor), this - // specialization makes Phoenix's compose() function construct a - // spirit::state_setter actor from 1. the LHS, a spirit::state_getter - // actor (due to the specialization of as_actor_base<> above), - // and 2. the RHS actor. - // This is why spirit::state_setter needs a constructor which takes - // a dummy spirit::state_getter as its first argument in addition - // to its real, second argument (the RHS actor). - typedef spirit::lex::state_setter<typename as_actor<RHS>::type> type; - }; - - /////////////////////////////////////////////////////////////////////////// - // The specialization of as_actor_base<> below is needed to convert all - // occurrences of _val in places where it's used as a rvalue into the - // proper Phoenix actor (spirit::value_getter) accessing the token value. - template<> - struct as_actor_base<actor<spirit::lex::value_context> > - { - typedef spirit::lex::value_getter type; - - static spirit::lex::value_getter - convert(actor<spirit::lex::value_context>) - { - return spirit::lex::value_getter(); - } - }; - - /////////////////////////////////////////////////////////////////////////// - // The specialization of as_composite<> below is needed to convert all - // assignments to _val (places where it's used as a lvalue) into the - // proper Phoenix actor (spirit::value_setter) allowing to change the - // token value. - template <typename RHS> - struct as_composite<assign_eval, actor<spirit::lex::value_context>, RHS> - { - // For an assignment to _val (a spirit::value_context actor), this - // specialization makes Phoenix's compose() function construct a - // spirit::value_setter actor from 1. the LHS, a spirit::value_getter - // actor (due to the specialization of as_actor_base<> above), - // and 2. the RHS actor. - // This is why spirit::value_setter needs a constructor which takes - // a dummy spirit::value_getter as its first argument in addition - // to its real, second argument (the RHS actor). - typedef spirit::lex::value_setter<typename as_actor<RHS>::type> type; - }; -}} -#endif #undef SPIRIT_DECLARE_ARG #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp index da24503..7989b01 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/argument_phoenix.hpp @@ -82,7 +82,6 @@ namespace boost { namespace spirit { namespace lex }}} /////////////////////////////////////////////////////////////////////////////// -#ifdef BOOST_SPIRIT_USE_PHOENIX_V3 BOOST_PHOENIX_DEFINE_EXPRESSION( (boost)(spirit)(lex)(value_setter) @@ -246,6 +245,4 @@ namespace boost { namespace phoenix {}; }} -#endif // BOOST_SPIRIT_USE_PHOENIX_V3 - #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp index 93412ce..e733533 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexer.hpp @@ -285,7 +285,7 @@ namespace boost { namespace spirit { namespace lex lexer_def_& operator= (lexer_def_ const&); }; -#if defined(BOOST_NO_RVALUE_REFERENCES) +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) // allow to assign a token definition expression template <typename LexerDef, typename Expr> inline lexer_def_<LexerDef>& diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp index 207b374..dfad49b 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/functor_data.hpp @@ -300,7 +300,7 @@ namespace boost { namespace spirit { namespace lex { namespace lexertl data (IterData const& data_, Iterator& first, Iterator const& last) : base_type(data_, first, last) , actions_(data_.actions_), hold_() - , value_(iterator_range<Iterator>(first, last)) + , value_(iterator_range<Iterator>(last, last)) , has_value_(false), has_hold_(false) {} // invoke attached semantic actions, if defined diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp index f2793ba..1b05720 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/iterator.hpp @@ -10,6 +10,7 @@ #pragma once #endif +#include <boost/spirit/home/support/multi_pass_wrapper.hpp> #if defined(BOOST_SPIRIT_DEBUG) #include <boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp> #else @@ -115,7 +116,34 @@ namespace boost { namespace spirit { namespace lex { namespace lexertl : 0; } }; +}} -}}}} +namespace traits +{ + template <typename Functor> + struct is_multi_pass<spirit::lex::lexertl::iterator<Functor> > + : mpl::true_ {}; + + template <typename Functor> + void clear_queue(spirit::lex::lexertl::iterator<Functor> & mp + , BOOST_SCOPED_ENUM(traits::clear_mode) mode) + { + mp.clear_queue(mode); + } + + template <typename Functor> + void inhibit_clear_queue(spirit::lex::lexertl::iterator<Functor>& mp, bool flag) + { + mp.inhibit_clear_queue(flag); + } + + template <typename Functor> + bool inhibit_clear_queue(spirit::lex::lexertl::iterator<Functor>& mp) + { + return mp.inhibit_clear_queue(); + } +} + +}} #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp index 90961af..9f4bdb3 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/lexertl/token.hpp @@ -35,9 +35,7 @@ #include <boost/mpl/or.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/range/iterator_range.hpp> -#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) #include <boost/static_assert.hpp> -#endif #if defined(BOOST_SPIRIT_DEBUG) #include <iosfwd> @@ -330,14 +328,12 @@ namespace boost { namespace spirit { namespace lex { namespace lexertl struct token : token<Iterator, lex::omit, HasState, Idtype> { private: // precondition assertions -#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) BOOST_STATIC_ASSERT((mpl::is_sequence<AttributeTypes>::value || is_same<AttributeTypes, lex::omit>::value)); -#endif typedef token<Iterator, lex::omit, HasState, Idtype> base_type; protected: - // If no additional token value types are given, the the token will + // If no additional token value types are given, the token will // hold the plain pair of iterators pointing to the matched range // in the underlying input sequence. Otherwise the token value is // stored as a variant and will again hold the pair of iterators but diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp index f3987c6..8467560 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions.hpp @@ -47,11 +47,11 @@ namespace boost { namespace spirit { namespace lex template <typename Env> struct result { - typedef typename - remove_const< + typedef typename remove_reference< + typename remove_const< typename mpl::at_c<typename Env::args_type, 4>::type >::type - context_type; + >::type context_type; typedef typename context_type::base_iterator_type type; }; diff --git a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp index 613a4a4..3c7572d 100644 --- a/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/lex/lexer/support_functions_expression.hpp @@ -21,37 +21,6 @@ namespace boost { namespace spirit { namespace lex }}} /////////////////////////////////////////////////////////////////////////////// -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - -namespace boost { namespace spirit { namespace lex -{ - namespace expression - { - template <typename Eval> - struct less - { - typedef phoenix::actor<lex::less_type<Eval> > type; - - static type make(Eval const & eval) - { - return lex::less_type<Eval>(eval); - } - }; - - template <typename IdType, typename State> - struct lookahead - { - typedef phoenix::actor<lex::lookahead_type<IdType, State> > type; - - static type make(IdType const & id_type, State const & state) - { - return lex::lookahead_type<IdType, State>(id_type, state); - } - }; - } -}}} - -#else // BOOST_SPIRIT_USE_PHOENIX_V3 BOOST_PHOENIX_DEFINE_EXPRESSION( (boost)(spirit)(lex)(less) @@ -130,6 +99,4 @@ namespace boost { namespace phoenix {}; }} -#endif // BOOST_SPIRIT_USE_PHOENIX_V3 - #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp deleted file mode 100644 index 5a90d44..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind.hpp +++ /dev/null @@ -1,16 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_BIND_HPP -#define PHOENIX_BIND_HPP - -#include <boost/spirit/home/phoenix/version.hpp> -#include <boost/spirit/home/phoenix/bind/bind_function.hpp> -#include <boost/spirit/home/phoenix/bind/bind_function_object.hpp> -#include <boost/spirit/home/phoenix/bind/bind_member_function.hpp> -#include <boost/spirit/home/phoenix/bind/bind_member_variable.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp deleted file mode 100644 index 9121fdc..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function.hpp +++ /dev/null @@ -1,58 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_BIND_BIND_FUNCTION_HPP -#define PHOENIX_BIND_BIND_FUNCTION_HPP - -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp> -#include <boost/spirit/home/phoenix/bind/detail/function_ptr.hpp> - -namespace boost { namespace phoenix -{ - template <typename RT> - inline actor< - typename as_composite< - detail::function_eval<0> - , detail::function_ptr<0, RT, RT(*)()> - >::type> - bind(RT(*f)()) - { - typedef detail::function_ptr<0, RT, RT(*)()> fp_type; - return compose<detail::function_eval<0> >(fp_type(f)); - } - - template <typename RT, typename T0, typename A0> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::function_ptr<1, RT, RT(*)(T0)> - , A0 - >::type> - bind(RT(*f)(T0), A0 const& _0) - { - typedef detail::function_ptr<1, RT, RT(*)(T0)> fp_type; - return compose<detail::function_eval<1> >(fp_type(f), _0); - } - - template <typename RT, typename T0, typename T1, typename A0, typename A1> - inline actor< - typename as_composite< - detail::function_eval<2> - , detail::function_ptr<2, RT, RT(*)(T0, T1)> - , A0, A1 - >::type> - bind(RT(*f)(T0, T1), A0 const& _0, A1 const& _1) - { - typedef detail::function_ptr<2, RT, RT(*)(T0, T1)> fp_type; - return compose<detail::function_eval<2> >(fp_type(f), _0, _1); - } - - // Bring in the rest of the function binders - #include <boost/spirit/home/phoenix/bind/detail/bind_function.hpp> -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp deleted file mode 100644 index 752ae31..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_function_object.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP -#define PHOENIX_BIND_BIND_FUNCTION_OBJECT_HPP - -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp> - -namespace boost { namespace phoenix -{ - template <typename F> - inline actor<typename as_composite<detail::function_eval<0>, F>::type> - bind(F const& f) - { - return compose<detail::function_eval<0> >(f); - } - - template <typename F, typename A0> - inline actor<typename as_composite<detail::function_eval<1>, F, A0>::type> - bind(F const& f, A0 const& _0) - { - return compose<detail::function_eval<1> >(f, _0); - } - - template <typename F, typename A0, typename A1> - inline actor<typename as_composite<detail::function_eval<2>, F, A0, A1>::type> - bind(F const& f, A0 const& _0, A1 const& _1) - { - return compose<detail::function_eval<2> >(f, _0, _1); - } - - // Bring in the rest of the function object binders - #include <boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp> -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp deleted file mode 100644 index 9d31a38..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_function.hpp +++ /dev/null @@ -1,77 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP -#define PHOENIX_BIND_BIND_MEMBER_FUNCTION_HPP - -#include <boost/spirit/home/phoenix/core/reference.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp> -#include <boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp> - -namespace boost { namespace phoenix -{ - template <typename RT, typename ClassT, typename ClassA> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_function_ptr<0, RT, RT(ClassT::*)()> - , ClassA - >::type> - bind(RT(ClassT::*f)(), ClassA const& obj) - { - typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type; - return compose<detail::function_eval<1> >(fp_type(f), obj); - } - - template <typename RT, typename ClassT, typename ClassA> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_function_ptr<0, RT, RT(ClassT::*)() const> - , ClassA - >::type> - bind(RT(ClassT::*f)() const, ClassA const& obj) - { - typedef detail::member_function_ptr<0, RT, RT(ClassT::*)() const> fp_type; - return compose<detail::function_eval<1> >(fp_type(f), obj); - } - - template <typename RT, typename ClassT> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_function_ptr<0, RT, RT(ClassT::*)()> - , actor<reference<ClassT> > - >::type> - bind(RT(ClassT::*f)(), ClassT& obj) - { - typedef detail::member_function_ptr<0, RT, RT(ClassT::*)()> fp_type; - return compose<detail::function_eval<1> >( - fp_type(f) - , actor<reference<ClassT> >(reference<ClassT>(obj))); - } - - template <typename RT, typename ClassT> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_function_ptr<0, RT, RT(ClassT::*)() const> - , actor<reference<ClassT> > - >::type> - bind(RT(ClassT::*f)() const, ClassT& obj) - { - typedef detail::member_function_ptr<0, RT, RT(ClassT::*)() const> fp_type; - return compose<detail::function_eval<1> >( - fp_type(f) - , actor<reference<ClassT> >(reference<ClassT>(obj))); - } - - // Bring in the rest of the function binders - #include <boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp> -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp deleted file mode 100644 index 3d11351..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/bind_member_variable.hpp +++ /dev/null @@ -1,105 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP -#define PHOENIX_BIND_BIND_MEMBER_VARIABLE_HPP - -#include <boost/mpl/if.hpp> -#include <boost/type_traits/is_const.hpp> -#include <boost/type_traits/remove_pointer.hpp> -#include <boost/type_traits/remove_reference.hpp> - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/reference.hpp> -#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp> -#include <boost/mpl/if.hpp> -#include <boost/type_traits/is_const.hpp> -#include <boost/type_traits/remove_pointer.hpp> -#include <boost/type_traits/remove_reference.hpp> - -namespace boost { namespace phoenix -{ - namespace detail - { - template <typename RT, typename MP> - struct member_variable - { - template <typename Class> - struct result - { - typedef typename boost::mpl::if_< - boost::is_const< - typename boost::remove_pointer< - typename boost::remove_reference<Class>::type - >::type - > - , const RT& - , RT& - >::type type; - }; - - member_variable(MP mp) - : mp(mp) {} - - template <typename Class> - RT& operator()(Class& obj) const - { - return obj.*mp; - } - - template <typename Class> - RT& operator()(Class* obj) const - { - return obj->*mp; - } - - template <typename Class> - RT const& operator()(Class const& obj) const - { - return obj.*mp; - } - - template <typename Class> - RT const& operator()(Class const* obj) const - { - return obj->*mp; - } - - MP mp; - }; - } - - template <typename RT, typename ClassT, typename ClassA> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_variable<RT, RT ClassT::*> - , ClassA - >::type> - bind(RT ClassT::*mp, ClassA const& obj) - { - typedef detail::member_variable<RT, RT ClassT::*> mp_type; - return compose<detail::function_eval<1> >(mp_type(mp), obj); - } - - template <typename RT, typename ClassT> - inline actor< - typename as_composite< - detail::function_eval<1> - , detail::member_variable<RT, RT ClassT::*> - , actor<reference<ClassT> > - >::type> - bind(RT ClassT::*mp, ClassT& obj) - { - typedef detail::member_variable<RT, RT ClassT::*> mp_type; - return compose<detail::function_eval<1> >( - mp_type(mp) - , actor<reference<ClassT> >(reference<ClassT>(obj))); - } -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp deleted file mode 100644 index 8d6340d..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_BIND_DETAIL_BIND_FUNCTION_HPP) -#define PHOENIX_BIND_DETAIL_BIND_FUNCTION_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/dec.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT), \ - "boost/spirit/home/phoenix/bind/detail/bind_function.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <typename RT - , BOOST_PP_ENUM_PARAMS(N, typename T) - , BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor< - typename as_composite< - detail::function_eval<N> - , detail::function_ptr<N, RT, RT(*)(BOOST_PP_ENUM_PARAMS(N, T))> - , BOOST_PP_ENUM_PARAMS(N, A) - >::type> - bind(RT(*f)(BOOST_PP_ENUM_PARAMS(N, T)) - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - typedef detail::function_ptr< - N, RT, RT(*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type; - return compose<detail::function_eval<N> >( - fp_type(f), BOOST_PP_ENUM_PARAMS(N, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp deleted file mode 100644 index 4e4984d..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp +++ /dev/null @@ -1,43 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_BIND_DETAIL_BIND_FUNCTION_OBJECT_HPP) -#define PHOENIX_BIND_DETAIL_BIND_FUNCTION_OBJECT_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/dec.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT), \ - "boost/spirit/home/phoenix/bind/detail/bind_function_object.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor<typename as_composite<detail::function_eval<N>, F - , BOOST_PP_ENUM_PARAMS(N, A)>::type> - bind(F const& f, BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - return compose<detail::function_eval<N> >(f, BOOST_PP_ENUM_PARAMS(N, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp deleted file mode 100644 index 315f56f..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp +++ /dev/null @@ -1,132 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_BIND_DETAIL_BIND_MEMBER_FUNCTION_HPP) -#define PHOENIX_BIND_DETAIL_BIND_MEMBER_FUNCTION_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/dec.hpp> -#include <boost/preprocessor/inc.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT)), \ - "boost/spirit/home/phoenix/bind/detail/bind_member_function.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <typename RT - , typename ClassT - , BOOST_PP_ENUM_PARAMS(N, typename T) - , typename ClassA - , BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor< - typename as_composite< - detail::function_eval<BOOST_PP_INC(N)> - , detail::member_function_ptr<N, - RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> - , ClassA, BOOST_PP_ENUM_PARAMS(N, A) - >::type> - bind( - RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) - , ClassA const& obj - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - typedef detail::member_function_ptr< - N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type; - return compose<detail::function_eval<BOOST_PP_INC(N)> >( - fp_type(f), obj, BOOST_PP_ENUM_PARAMS(N, _)); - } - - template <typename RT - , typename ClassT - , BOOST_PP_ENUM_PARAMS(N, typename T) - , typename ClassA - , BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor< - typename as_composite< - detail::function_eval<BOOST_PP_INC(N)> - , detail::member_function_ptr<N, - RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> - , ClassA, BOOST_PP_ENUM_PARAMS(N, A) - >::type> - bind( - RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) const - , ClassA const& obj - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - typedef detail::member_function_ptr< - N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> fp_type; - return compose<detail::function_eval<BOOST_PP_INC(N)> >( - fp_type(f), obj, BOOST_PP_ENUM_PARAMS(N, _)); - } - - template <typename RT - , typename ClassT - , BOOST_PP_ENUM_PARAMS(N, typename T) - , BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor< - typename as_composite< - detail::function_eval<BOOST_PP_INC(N)> - , detail::member_function_ptr<N, - RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> - , actor<reference<ClassT> > - , BOOST_PP_ENUM_PARAMS(N, A) - >::type> - bind( - RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) - , ClassT& obj - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - typedef detail::member_function_ptr< - N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T))> fp_type; - return compose<detail::function_eval<BOOST_PP_INC(N)> >( - fp_type(f) - , actor<reference<ClassT> >(reference<ClassT>(obj)) - , BOOST_PP_ENUM_PARAMS(N, _)); - } - - template <typename RT - , typename ClassT - , BOOST_PP_ENUM_PARAMS(N, typename T) - , BOOST_PP_ENUM_PARAMS(N, typename A)> - inline actor< - typename as_composite< - detail::function_eval<BOOST_PP_INC(N)> - , detail::member_function_ptr<N, - RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> - , actor<reference<ClassT> > - , BOOST_PP_ENUM_PARAMS(N, A) - >::type> - bind( - RT(ClassT::*f)(BOOST_PP_ENUM_PARAMS(N, T)) const - , ClassT& obj - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) - { - typedef detail::member_function_ptr< - N, RT, RT(ClassT::*)(BOOST_PP_ENUM_PARAMS(N, T)) const> fp_type; - return compose<detail::function_eval<BOOST_PP_INC(N)> >( - fp_type(f) - , actor<reference<ClassT> >(reference<ClassT>(obj)) - , BOOST_PP_ENUM_PARAMS(N, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp deleted file mode 100644 index a2352cd..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/function_ptr.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP) -#define PHOENIX_BIND_DETAIL_FUNCTION_PTR_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/dec.hpp> - -namespace boost { namespace phoenix { namespace detail -{ - template <int N> - struct function_ptr_impl - { - template <typename RT, typename FP> - struct impl; - }; - - template <int N, typename RT, typename FP> - struct function_ptr : function_ptr_impl<N>::template impl<RT, FP> - { - typedef typename function_ptr_impl<N>::template impl<RT, FP> base; - function_ptr(FP fp) - : base(fp) {} - }; - - template <> - struct function_ptr_impl<0> - { - template <typename RT, typename FP> - struct impl - { - typedef RT result_type; - - impl(FP fp) - : fp(fp) {} - - RT operator()() const - { - return fp(); - } - - FP fp; - }; - }; - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, PHOENIX_COMPOSITE_LIMIT, \ - "boost/spirit/home/phoenix/bind/detail/function_ptr.hpp")) -#include BOOST_PP_ITERATE() - -}}} // namespace boost::phoenix::detail - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <> - struct function_ptr_impl<N> - { - template <typename RT, typename FP> - struct impl - { - template <BOOST_PP_ENUM_PARAMS(N, typename T)> - struct result - { - typedef RT type; - }; - - impl(FP fp) - : fp(fp) {} - - template <BOOST_PP_ENUM_PARAMS(N, typename A)> - RT operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const - { - return fp(BOOST_PP_ENUM_PARAMS(N, _)); - } - - FP fp; - }; - }; - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp deleted file mode 100644 index 2c11510..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp +++ /dev/null @@ -1,119 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP) -#define PHOENIX_BIND_DETAIL_MEMBER_FUNCTION_PTR_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/dec.hpp> -#include <boost/utility/addressof.hpp> - -namespace boost { namespace phoenix { namespace detail -{ - template <int N> - struct member_function_ptr_impl - { - template <typename RT, typename FP> - struct impl; - }; - - template <int N, typename RT, typename FP> - struct member_function_ptr - : member_function_ptr_impl<N>::template impl<RT, FP> - { - typedef typename member_function_ptr_impl<N>:: - template impl<RT, FP> base; - member_function_ptr(FP fp) - : base(fp) {} - }; - - template <> - struct member_function_ptr_impl<0> - { - template <typename RT, typename FP> - struct impl - { - template <typename Class> - struct result - { - typedef RT type; - }; - - impl(FP fp) - : fp(fp) {} - - template <typename Class> - RT operator()(Class& obj) const - { - return (obj.*fp)(); - } - - template <typename Class> - RT operator()(Class* obj) const - { - return (obj->*fp)(); - } - - FP fp; - }; - }; - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, PHOENIX_COMPOSITE_LIMIT, \ - "boost/spirit/home/phoenix/bind/detail/member_function_ptr.hpp")) -#include BOOST_PP_ITERATE() - -}}} // namespace boost::phoenix::detail - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <> - struct member_function_ptr_impl<N> - { - template <typename RT, typename FP> - struct impl - { - template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename T)> - struct result - { - typedef RT type; - }; - - impl(FP fp) - : fp(fp) {} - - template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename A)> - RT operator()(Class& obj, BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const - { - return (obj.*fp)(BOOST_PP_ENUM_PARAMS(N, _)); - } - - template <typename Class, BOOST_PP_ENUM_PARAMS(N, typename A)> - RT operator()(Class* obj, BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) const - { - return (obj->*fp)(BOOST_PP_ENUM_PARAMS(N, _)); - } - - FP fp; - }; - }; - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp deleted file mode 100644 index 7dfefb3..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core.hpp +++ /dev/null @@ -1,23 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_HPP -#define PHOENIX_CORE_HPP - -#include <boost/spirit/home/phoenix/version.hpp> -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/core/basic_environment.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/spirit/home/phoenix/core/as_actor.hpp> -#include <boost/spirit/home/phoenix/core/is_actor.hpp> -#include <boost/spirit/home/phoenix/core/argument.hpp> -#include <boost/spirit/home/phoenix/core/value.hpp> -#include <boost/spirit/home/phoenix/core/reference.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/nothing.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp deleted file mode 100644 index 6ff48e9..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/actor.hpp +++ /dev/null @@ -1,194 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_ACTOR_HPP -#define PHOENIX_CORE_ACTOR_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> - -#if !defined(BOOST_RESULT_OF_NUM_ARGS) -# define BOOST_RESULT_OF_NUM_ARGS PHOENIX_ACTOR_LIMIT -#elif (BOOST_RESULT_OF_NUM_ARGS < PHOENIX_ACTOR_LIMIT) -# error "BOOST_RESULT_OF_NUM_ARGS < PHOENIX_ACTOR_LIMIT" -#endif - -#include <boost/spirit/home/phoenix/core/basic_environment.hpp> -#include <boost/mpl/min.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/add_const.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/utility/result_of.hpp> - -namespace boost { namespace phoenix -{ - // phoenix::void_ is the same as fusion::void_ - typedef fusion::void_ void_; - - namespace detail - { - // Forward declarations. These will come in when we get to the - // operator module, yet, the actor's assignment operator and index - // operator are required to be members. - - template <typename T0, typename T1> - struct make_assign_composite; - - template <typename T0, typename T1> - struct make_index_composite; - - template <typename BaseT0, typename BaseT1> - struct comma_result; - - // error no arguments supplied - struct error_expecting_arguments - { - template <typename T> - error_expecting_arguments(T const&) {} - }; - } - - template <typename Eval, typename Env> - struct eval_result - { - typedef typename Eval::template result<Env>::type type; - }; - -#if defined(BOOST_MSVC) -# pragma warning(push) -# pragma warning(disable: 4522) // multiple assignment operators specified warning -#endif - - template <typename Eval> - struct actor : Eval - { - typedef actor<Eval> self_type; - typedef Eval eval_type; - - template <class Sig> struct result {}; - - actor() - : Eval() {} - - actor(Eval const& base) - : Eval(base) {} - - template <typename T0> - explicit actor(T0 const& _0) - : Eval(_0) {} - - template <typename T0, typename T1> - actor(T0 const& _0, T1 const& _1) - : Eval(_0, _1) {} - - typedef typename - mpl::eval_if< - typename Eval::no_nullary // avoid calling eval_result when this is true - , mpl::identity<detail::error_expecting_arguments> - , eval_result<eval_type, basic_environment<> > - >::type - nullary_result; - - actor& operator=(actor const& rhs) - { - Eval::operator=(rhs); - return *this; - } - - actor& operator=(actor& rhs) - { - Eval::operator=(rhs); - return *this; - } - - nullary_result - operator()() const - { - return eval_type::eval(basic_environment<>()); - } - - template <class F, class A0> - struct result<F(A0)> - : eval_result< - eval_type - , basic_environment< - typename remove_reference<A0>::type - > - > - {}; - - template <typename T0> - typename result<actor(T0&)>::type - operator()(T0& _0) const - { - return eval_type::eval(basic_environment<T0>(_0)); - } - - template <class F, class A0, class A1> - struct result<F(A0,A1)> - : eval_result< - eval_type - , basic_environment< - typename remove_reference<A0>::type - , typename remove_reference<A1>::type - > - > - {}; - - template <typename T0, typename T1> - typename result<actor(T0&,T1&)>::type - operator()(T0& _0, T1& _1) const - { - return eval_type::eval(basic_environment<T0, T1>(_0, _1)); - } - - template <typename T1> - typename detail::make_assign_composite<self_type, T1>::type - operator=(T1 const& a1) const; - - template <typename T1> - typename detail::make_index_composite<self_type, T1>::type - operator[](T1 const& a1) const; - - // Bring in the rest of the constructors and function call operators - #include <boost/spirit/home/phoenix/core/detail/actor.hpp> - }; - -#if defined(BOOST_MSVC) -# pragma warning(pop) -#endif - - // Forward declaration: The intent to overload the comma must be - // stated early on to avoid the subtle problem that arises when - // the header file where the comma operator overload is defined, - // is not included by the client and the client attempts to use - // the comma anyway. - - namespace detail - { - template <typename BaseT0, typename BaseT1> - struct comma_result; - } - - template <typename BaseT0, typename BaseT1> - typename detail::comma_result<BaseT0, BaseT1>::type - operator,(actor<BaseT0> const& a0, actor<BaseT1> const& a1); -}} - -namespace boost -{ - template <typename Eval> - struct result_of<phoenix::actor<Eval>()> - { - typedef typename phoenix::actor<Eval>::nullary_result type; - }; - - template <typename Eval> - struct result_of<phoenix::actor<Eval> const()> - : result_of<phoenix::actor<Eval>()> - {}; -} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp deleted file mode 100644 index 1679cb2..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/argument.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_ARGUMENT_HPP -#define PHOENIX_CORE_ARGUMENT_HPP - -#include <boost/preprocessor/repetition/repeat_from_to.hpp> -#include <boost/preprocessor/inc.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/fusion/include/at.hpp> -#include <boost/mpl/if.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/mpl/less.hpp> -#include <boost/mpl/bool.hpp> -#include <boost/mpl/int.hpp> -#include <boost/mpl/at.hpp> -#include <boost/mpl/size.hpp> -#include <boost/type_traits/add_reference.hpp> - -#define PHOENIX_DECLARE_ARG(z, n, data) \ - typedef actor<argument<n> > \ - BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(n)), _type); \ - actor<argument<n> > const \ - BOOST_PP_CAT(arg, BOOST_PP_INC(n)) = argument<n>(); \ - typedef actor<argument<n> > \ - BOOST_PP_CAT(BOOST_PP_CAT(_, BOOST_PP_INC(n)), _type); \ - actor<argument<n> > const \ - BOOST_PP_CAT(_, BOOST_PP_INC(n)) = argument<n>(); - -namespace boost { namespace phoenix -{ - namespace detail - { - template <typename Arg> - struct error_argument_not_found {}; - inline void test_invalid_argument(int) {} - } - - template <int N> - struct argument - { - typedef mpl::true_ no_nullary; - - template <typename Env> - struct result - { - typedef typename - fusion::result_of::at<typename Env::tie_type, mpl::int_<N> >::type - type; - }; - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename - mpl::if_< - mpl::less<mpl::int_<N>, mpl::size<typename Env::args_type> > - , int - , detail::error_argument_not_found<argument<N> > - >::type - check_out_of_bounds; - - detail::test_invalid_argument(check_out_of_bounds()); - return fusion::at_c<N>(env.args()); - } - }; - - namespace arg_names - { - // Phoenix style names - typedef actor<argument<0> > arg1_type; - actor<argument<0> > const arg1 = argument<0>(); - typedef actor<argument<1> > arg2_type; - actor<argument<1> > const arg2 = argument<1>(); - typedef actor<argument<2> > arg3_type; - actor<argument<2> > const arg3 = argument<2>(); - - // BLL style names - typedef actor<argument<0> > _1_type; - actor<argument<0> > const _1 = argument<0>(); - typedef actor<argument<1> > _2_type; - actor<argument<1> > const _2 = argument<1>(); - typedef actor<argument<2> > _3_type; - actor<argument<2> > const _3 = argument<2>(); - - // Bring in the rest or the Phoenix style arguments (arg4 .. argN+1) - // and BLL style arguments (_4 .. _N+1), using PP - BOOST_PP_REPEAT_FROM_TO( - 3, PHOENIX_ARG_LIMIT, PHOENIX_DECLARE_ARG, _) - } -}} - -#undef PHOENIX_DECLARE_ARG -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp deleted file mode 100644 index 36f0aac..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/as_actor.hpp +++ /dev/null @@ -1,62 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_AS_ACTOR_HPP -#define PHOENIX_CORE_AS_ACTOR_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> - -namespace boost { namespace phoenix -{ - template <typename T> - struct as_actor_base; // defined in value.hpp - - template <typename Base> - struct as_actor_base<actor<Base> > - { - typedef Base type; - - static Base const& - convert(actor<Base> const& x) - { - return x; - } - }; - - template <> - struct as_actor_base<fusion::void_> - { - typedef fusion::void_ type; - struct error_attempting_to_convert_void_type_to_an_actor {}; - - static void - convert(error_attempting_to_convert_void_type_to_an_actor); - }; - - template <> - struct as_actor_base<void> - { - typedef void type; - struct error_attempting_to_convert_void_type_to_an_actor {}; - - static void - convert(error_attempting_to_convert_void_type_to_an_actor); - }; - - template <typename T> - struct as_actor - { - typedef actor<typename as_actor_base<T>::type> type; - - static type - convert(T const& x) - { - return as_actor_base<T>::convert(x); - } - }; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp deleted file mode 100644 index 5ef8223..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/basic_environment.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_BASIC_ENVIRONMENT_HPP -#define PHOENIX_CORE_BASIC_ENVIRONMENT_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/mpl/remove.hpp> -#include <boost/mpl/transform.hpp> -#include <boost/preprocessor/cat.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> -#include <boost/type_traits/add_reference.hpp> -#include <boost/fusion/include/as_vector.hpp> -#include <boost/fusion/include/mpl.hpp> - -namespace boost { namespace phoenix -{ - template < - BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( - PHOENIX_ARG_LIMIT, typename T, fusion::void_)> - class basic_environment - { - typedef - mpl::BOOST_PP_CAT(vector, PHOENIX_ARG_LIMIT)< - BOOST_PP_ENUM_PARAMS(PHOENIX_ARG_LIMIT, T)> - args_with_void_type; - - public: - - // args_type: the list of types in an mpl::sequence - typedef typename - mpl::remove<args_with_void_type, fusion::void_>::type - args_type; - - // tie_type: a fusion::tuple of references - typedef typename - fusion::result_of::as_vector< - typename mpl::transform< - args_type, boost::add_reference<mpl::_1> - >::type - >::type - tie_type; - - basic_environment() - : args_() {} - - template <typename U0> - explicit basic_environment(U0& _0) - : args_(_0) {} - - template <typename U0, typename U1> - basic_environment(U0& _0, U1& _1) - : args_(_0, _1) {} - - // Bring in the rest of the constructors - #include <boost/spirit/home/phoenix/core/detail/basic_environment.hpp> - - tie_type const& - args() const - { - return args_; - } - - tie_type& - args() - { - return args_; - } - - private: - - tie_type args_; - }; -}} - -#endif - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp deleted file mode 100644 index d536113..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/compose.hpp +++ /dev/null @@ -1,118 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_COMPOSE_HPP -#define PHOENIX_CORE_COMPOSE_HPP - -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/preprocessor/repetition/enum.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/value.hpp> -#include <boost/spirit/home/phoenix/core/as_actor.hpp> - -#define PHOENIX_AS_ACTOR(z, n, data) \ - typename mpl::eval_if< \ - is_same<BOOST_PP_CAT(T, n), fusion::void_> \ - , mpl::identity<fusion::void_> \ - , as_actor_base<BOOST_PP_CAT(T, n)> \ - >::type - -namespace boost { namespace phoenix -{ - -/////////////////////////////////////////////////////////////////////////////// -// -// as_composite<EvalPolicy, T0,... TN> metafunction -// -// Create a composite given an EvalPolicy and types T0..TN. -// The types are converted to an actor through the as_actor -// metafunction (see as_actor.hpp). -// -/////////////////////////////////////////////////////////////////////////////// - template < - typename EvalPolicy - , BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( - PHOENIX_COMPOSITE_LIMIT, typename T, fusion::void_)> - struct as_composite - { - typedef composite< - EvalPolicy - , fusion::vector< - BOOST_PP_ENUM(PHOENIX_COMPOSITE_LIMIT, PHOENIX_AS_ACTOR, _)> - > - type; - }; - -/////////////////////////////////////////////////////////////////////////////// -// -// compose functions -// -// Usage: -// -// compose<EvalPolicy>(_0, _1,... _N) -// -// Returns a composite given an EvalPolicy and arguments _0.._N. -// The arguments are converted to an actor through the as_actor -// metafunction (see as_actor.hpp). -// -/////////////////////////////////////////////////////////////////////////////// - template <typename EvalPolicy> - inline actor<typename as_composite<EvalPolicy>::type> - compose() - { - return actor<typename as_composite<EvalPolicy>::type>(); - } - - template <typename EvalPolicy, typename T0> - inline actor<typename as_composite<EvalPolicy, T0>::type> - compose(T0 const& _0) - { - return actor<typename as_composite<EvalPolicy, T0>::type>( - as_actor<T0>::convert(_0) - ); - } - - template <typename EvalPolicy, typename T0, typename T1> - inline actor<typename as_composite<EvalPolicy, T0, T1>::type> - compose(T0 const& _0, T1 const& _1) - { - return actor<typename as_composite<EvalPolicy, T0, T1>::type>( - as_actor<T0>::convert(_0) - , as_actor<T1>::convert(_1) - ); - } - - // Bring in the the rest of the compose overloads - #include <boost/spirit/home/phoenix/core/detail/compose.hpp> - -/////////////////////////////////////////////////////////////////////////////// -// -// re_curry<EvalPolicy, T0,...TN> -// -// returns the result of re currying T0..TN using EvalPolicy. -// -/////////////////////////////////////////////////////////////////////////////// - template < - typename EvalPolicy - , BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( - PHOENIX_COMPOSITE_LIMIT, typename T, fusion::void_)> - struct re_curry - { - typedef actor< - typename as_composite< - EvalPolicy - , BOOST_PP_ENUM_PARAMS(PHOENIX_COMPOSITE_LIMIT, T)>::type - > - type; - }; -}} - -#undef PHOENIX_AS_ACTOR -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp deleted file mode 100644 index 283bdc2..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/composite.hpp +++ /dev/null @@ -1,96 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_COMPOSITE_HPP -#define PHOENIX_CORE_COMPOSITE_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/spirit/home/phoenix/core/is_actor.hpp> -#include <boost/fusion/include/vector.hpp> -#include <boost/fusion/include/at.hpp> -#include <boost/fusion/include/size.hpp> -#include <boost/fusion/include/mpl.hpp> -#include <boost/mpl/fold.hpp> -#include <boost/mpl/bool.hpp> -#include <boost/mpl/or.hpp> - -namespace boost { namespace phoenix -{ - namespace detail - { - template <int N> - struct composite_eval; - - struct compute_no_nullary - { - template <typename State, typename T> - struct apply - { - typedef typename - mpl::or_<typename T::no_nullary, State>::type - type; - }; - }; - } - - template <typename EvalPolicy, typename EvalTuple> - struct composite : EvalTuple - { - typedef EvalTuple base_type; - typedef composite<EvalPolicy, EvalTuple> self_type; - typedef EvalPolicy eval_policy_type; - - typedef typename - mpl::fold< - EvalTuple - , mpl::false_ - , detail::compute_no_nullary - >::type - no_nullary; - - template <typename Env> - struct result - { - typedef - typename detail::composite_eval< - fusion::result_of::size<base_type>::value>:: - template result<self_type, Env>::type - type; - }; - - composite() - : base_type() {} - - composite(base_type const& base) - : base_type(base) {} - - template <typename U0> - composite(U0& _0) - : base_type(_0) {} - - template <typename U0, typename U1> - composite(U0& _0, U1& _1) - : base_type(_0, _1) {} - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename result<Env>::type return_type; - return detail:: - composite_eval<fusion::result_of::size<base_type>::value>::template - call<return_type>(*this, env); - } - - // Bring in the rest of the constructors - #include <boost/spirit/home/phoenix/core/detail/composite.hpp> - }; - - // Bring in the detail::composite_eval<0..N> definitions - #include <boost/spirit/home/phoenix/core/detail/composite_eval.hpp> -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp deleted file mode 100644 index 66666c5..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/actor.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_CORE_DETAIL_ACTOR_HPP -#define PHOENIX_CORE_DETAIL_ACTOR_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/facilities/intercept.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, PHOENIX_ACTOR_LIMIT, \ - "boost/spirit/home/phoenix/core/detail/actor.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <BOOST_PP_ENUM_PARAMS(N, typename T)> - actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _)) - : Eval(BOOST_PP_ENUM_PARAMS(N, _)) {} - - template <typename F, BOOST_PP_ENUM_PARAMS(N, typename A)> - struct result<F(BOOST_PP_ENUM_PARAMS(N, A))> - : eval_result< - eval_type - , basic_environment< - BOOST_PP_ENUM_BINARY_PARAMS( - N - , typename remove_reference<A - , >::type BOOST_PP_INTERCEPT - ) - > - > - {}; - - template <BOOST_PP_ENUM_PARAMS(N, typename T)> - typename result< - actor(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & BOOST_PP_INTERCEPT)) - >::type - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _)) const - { - return eval_type::eval( - basic_environment<BOOST_PP_ENUM_PARAMS(N, T)>( - BOOST_PP_ENUM_PARAMS(N, _)) - ); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp deleted file mode 100644 index 986ecf2..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/basic_environment.hpp +++ /dev/null @@ -1,38 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP -#define PHOENIX_CORE_DETAIL_BASIC_ENVIRONMENT_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, PHOENIX_ARG_LIMIT, \ - "boost/spirit/home/phoenix/core/detail/basic_environment.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <BOOST_PP_ENUM_PARAMS(N, typename U)> - basic_environment(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _)) - : args_(BOOST_PP_ENUM_PARAMS(N, _)) {} - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp deleted file mode 100644 index 945a3d3..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/compose.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP -#define PHOENIX_CORE_DETAIL_COMPOSE_DETAIL_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum.hpp> - -#define PHOENIX_AS_ACTOR_CONVERT(z, n, data) \ - as_actor<BOOST_PP_CAT(T, n)>::convert(BOOST_PP_CAT(_, n)) - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, PHOENIX_COMPOSITE_LIMIT, \ - "boost/spirit/home/phoenix/core/detail/compose.hpp")) -#include BOOST_PP_ITERATE() - -#undef PHOENIX_AS_ACTOR_CONVERT -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <typename EvalPolicy, BOOST_PP_ENUM_PARAMS(N, typename T)> - inline actor< - typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type> - compose(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _)) - { - return actor< - typename as_composite<EvalPolicy, BOOST_PP_ENUM_PARAMS(N, T)>::type>( - BOOST_PP_ENUM(N, PHOENIX_AS_ACTOR_CONVERT, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp deleted file mode 100644 index 6970f7c..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite.hpp +++ /dev/null @@ -1,36 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_HPP -#define PHOENIX_CORE_DETAIL_COMPOSITE_HPP - -#include <boost/preprocessor/iterate.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, PHOENIX_COMPOSITE_LIMIT, \ - "boost/spirit/home/phoenix/core/detail/composite.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <BOOST_PP_ENUM_PARAMS(N, typename U)> - composite(BOOST_PP_ENUM_BINARY_PARAMS(N, U, & _)) - : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {} - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp deleted file mode 100644 index 14f12af..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/composite_eval.hpp +++ /dev/null @@ -1,106 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP -#define PHOENIX_CORE_DETAIL_COMPOSITE_EVAL_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> - - namespace detail - { - template <int N> - struct composite_eval; - - template <> - struct composite_eval<0> - { - template <typename Composite, typename Env> - struct result - { - typedef typename Composite::eval_policy_type:: - template result<Env>::type - type; - }; - - template <typename RT, typename Composite, typename Env> - static RT - call(Composite const& /*composite*/, Env const& env) - { - typedef typename Composite::eval_policy_type eval_policy_type; - return eval_policy_type::template eval<RT>(env); - } - }; - - template <typename Actor, typename Env> - struct eval_is_actor - : is_actor<typename Actor::template result<Env>::type> {}; - - template <typename Actor, typename Env> - struct eval_is_void - : is_same<typename Actor::template result<Env>::type, fusion::void_> {}; - } - -#define PHOENIX_GET_ACTOR_TYPE(z, n, data) \ - typedef \ - typename fusion::result_of::value_at_c<Composite, n>::type \ - BOOST_PP_CAT(actor, n); - -#define PHOENIX_GET_ACTOR(z, n, data) \ - fusion::at_c<n>(composite) - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, PHOENIX_COMPOSITE_LIMIT, \ - "boost/spirit/home/phoenix/core/detail/composite_eval.hpp")) -#include BOOST_PP_ITERATE() - -#undef PHOENIX_GET_ACTOR -#undef PHOENIX_GET_ACTOR_TYPE -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - namespace detail - { - template <> - struct composite_eval<N> - { - template <typename Composite, typename Env> - struct result - { - BOOST_PP_REPEAT(N, PHOENIX_GET_ACTOR_TYPE, _) - - typedef typename - Composite::eval_policy_type::template result< - Env, BOOST_PP_ENUM_PARAMS(N, actor) - >::type - type; - }; - - template <typename RT, typename Composite, typename Env> - static RT - call(Composite const& composite, Env const& env) - { - typedef typename Composite::eval_policy_type eval_policy_type; - return eval_policy_type::template eval<RT>( - env, BOOST_PP_ENUM(N, PHOENIX_GET_ACTOR, _)); - } - }; - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp deleted file mode 100644 index 711b32c..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/detail/function_eval.hpp +++ /dev/null @@ -1,142 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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(BOOST_PP_IS_ITERATING) -#if !defined(PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP) -#define PHOENIX_CORE_DETAIL_FUNCTION_EVAL_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/enum.hpp> -#include <boost/preprocessor/repeat.hpp> -#include <boost/preprocessor/dec.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/find.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/type_traits/remove_reference.hpp> - -// we assume that mpl::vectorN, where N = PHOENIX_COMPOSITE_LIMIT -// is included already. - -namespace boost { namespace phoenix { namespace detail -{ - template <int N> - struct function_eval; - - template <> - struct function_eval<0> - { - template <typename Env, typename F> - struct result - { - typedef typename - remove_reference< - typename F::template result<Env>::type - >::type - fn; - typedef typename fn::result_type type; - }; - - template <typename RT, typename Env, typename F> - static RT - eval(Env const& env, F const& f) - { - return f.eval(env)(); - } - }; - - template <typename T> - T& help_rvalue_deduction(T& x) - { - return x; - } - - template <typename T> - T const& help_rvalue_deduction(T const& x) - { - return x; - } - -// When we call f(_0, _1...) we remove the reference when deducing f's -// return type. $$$ Explain why $$$ - -#define PHOENIX_GET_ARG(z, n, data) \ - typedef typename \ - remove_reference< \ - typename BOOST_PP_CAT(A, n)::template result<Env>::type \ - >::type \ - BOOST_PP_CAT(a, n); - -#define PHOENIX_EVAL_ARG(z, n, data) \ - help_rvalue_deduction(BOOST_PP_CAT(_, n).eval(env)) - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT), \ - "boost/spirit/home/phoenix/core/detail/function_eval.hpp")) -#include BOOST_PP_ITERATE() - -}}} // namespace boost::phoenix::detail - -#undef PHOENIX_GET_ARG -#undef PHOENIX_EVAL_ARG -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <> - struct function_eval<N> - { - template <typename Env, typename F - , BOOST_PP_ENUM_PARAMS(N, typename A)> - struct result - { - typedef typename - remove_reference< - typename F::template result<Env>::type - >::type - fn; - BOOST_PP_REPEAT(N, PHOENIX_GET_ARG, _) - - typedef BOOST_PP_CAT(mpl::vector, N) - <BOOST_PP_ENUM_PARAMS(N, a)> - args; - - typedef typename - fn::template result<BOOST_PP_ENUM_PARAMS(N, a)> - function_apply; - - typedef typename - mpl::eval_if< - is_same< - typename mpl::find<args, fusion::void_>::type - , typename mpl::end<args>::type> - , function_apply - , mpl::identity<fusion::void_> - >::type - type; - }; - - template <typename RT, typename Env, typename F - , BOOST_PP_ENUM_PARAMS(N, typename A)> - static RT - eval(Env const& env, F const& f - , BOOST_PP_ENUM_BINARY_PARAMS(N, A, & _)) - { - return f.eval(env)(BOOST_PP_ENUM(N, PHOENIX_EVAL_ARG, _)); - } - }; - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp deleted file mode 100644 index ba0e77c..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/is_actor.hpp +++ /dev/null @@ -1,29 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_IS_ACTOR_HPP -#define PHOENIX_CORE_IS_ACTOR_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/mpl/bool.hpp> - -namespace boost { namespace phoenix -{ -/////////////////////////////////////////////////////////////////////////////// -// -// is_actor<T> -// -// Tests if T is an actor. Evaluates to mpl::true_ or mpl::false_ -// -/////////////////////////////////////////////////////////////////////////////// - template <typename T> - struct is_actor : mpl::false_ {}; - - template <typename Base> - struct is_actor<actor<Base> > : mpl::true_ {}; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp deleted file mode 100644 index 50c7573..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/limits.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_LIMITS_HPP -#define PHOENIX_CORE_LIMITS_HPP - -#include <boost/preprocessor/dec.hpp> - -#if !defined(PHOENIX_LIMIT) -# define PHOENIX_LIMIT 10 -#elif (PHOENIX_LIMIT < 5) -# error "PHOENIX_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_ARG_LIMIT) -# define PHOENIX_ARG_LIMIT PHOENIX_LIMIT -#elif (PHOENIX_ARG_LIMIT < 5) -# error "PHOENIX_ARG_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_ACTOR_LIMIT) -# define PHOENIX_ACTOR_LIMIT PHOENIX_LIMIT -#elif (PHOENIX_ACTOR_LIMIT > PHOENIX_ARG_LIMIT) -# error "PHOENIX_ACTOR_LIMIT > PHOENIX_ARG_LIMIT" -#elif (PHOENIX_ACTOR_LIMIT < 3) -# error "PHOENIX_ACTOR_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_COMPOSITE_LIMIT) -# define PHOENIX_COMPOSITE_LIMIT PHOENIX_LIMIT -#elif (PHOENIX_COMPOSITE_LIMIT < 5) -# error "PHOENIX_COMPOSITE_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_MEMBER_LIMIT) -# define PHOENIX_MEMBER_LIMIT BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT)) -#elif (PHOENIX_MEMBER_LIMIT > PHOENIX_COMPOSITE_LIMIT) -# error "PHOENIX_MEMBER_LIMIT > PHOENIX_COMPOSITE_LIMIT" -#elif (PHOENIX_MEMBER_LIMIT < 3) -# error "PHOENIX_MEMBER_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_CATCH_LIMIT) -# define PHOENIX_CATCH_LIMIT BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT) -#elif (PHOENIX_CATCH_LIMIT < 1) -# error "PHOENIX_CATCH_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_DYNAMIC_LIMIT) -# define PHOENIX_DYNAMIC_LIMIT PHOENIX_LIMIT -#elif (PHOENIX_DYNAMIC_LIMIT < 1) -# error "PHOENIX_DYNAMIC_LIMIT is set too low" -#endif - -#if !defined(PHOENIX_LOCAL_LIMIT) -# define PHOENIX_LOCAL_LIMIT PHOENIX_LIMIT -#elif (PHOENIX_LOCAL_LIMIT < 3) -# error "PHOENIX_LOCAL_LIMIT is set too low" -#endif - - -#if !defined(FUSION_MAX_VECTOR_SIZE) -# define FUSION_MAX_VECTOR_SIZE PHOENIX_LIMIT -#elif (FUSION_MAX_VECTOR_SIZE < PHOENIX_LIMIT) -# error "FUSION_MAX_VECTOR_SIZE < PHOENIX_LIMIT" -#endif - -// this include will bring in mpl::vectorN and -// fusion::vectorN where N is PHOENIX_LIMIT -#include <boost/fusion/include/vector.hpp> - -// for some reason, this must be included now to make -// detail/type_deduction.hpp compile. $$$ TODO: Investigate further $$$ -#include <boost/mpl/vector/vector20.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp deleted file mode 100644 index 029fbbf..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/nothing.hpp +++ /dev/null @@ -1,42 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_NOTHING_HPP -#define PHOENIX_CORE_NOTHING_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/mpl/bool.hpp> - -namespace boost { namespace phoenix -{ -/////////////////////////////////////////////////////////////////////////////// -// -// null_actor -// -// A actor that does nothing (a "bum", if you will :-). -// -/////////////////////////////////////////////////////////////////////////////// - struct null_actor - { - typedef mpl::false_ no_nullary; - - template <typename Env> - struct result - { - typedef void type; - }; - - template <typename Env> - void - eval(Env const&) const - { - } - }; - - actor<null_actor> const nothing = null_actor(); -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp deleted file mode 100644 index 2e1f588..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/reference.hpp +++ /dev/null @@ -1,80 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_REFERENCE_HPP -#define PHOENIX_CORE_REFERENCE_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/static_assert.hpp> -#include <boost/type_traits/is_reference.hpp> -#include <boost/mpl/bool.hpp> - -namespace boost { namespace phoenix -{ - template <typename T> - struct reference - { - // $$$ TODO: a better (user friendly) static assert - BOOST_STATIC_ASSERT( - mpl::not_<is_reference<T> >::value != 0); - - typedef mpl::false_ no_nullary; - - template <typename Env> - struct result - { - typedef T& type; - }; - - reference(T& arg) - : ref(arg) {} - - template <typename Env> - T& eval(Env const&) const - { - return ref; - } - - T& ref; - - private: - // silence MSVC warning C4512: assignment operator could not be generated - reference& operator= (reference const&); - }; - - template <typename T> - inline actor<reference<T> > const - ref(T& v) - { - return reference<T>(v); - } - - template <typename T> - inline actor<reference<T const> > const - cref(T const& v) - { - return reference<T const>(v); - } - - namespace detail - { - struct error_attempting_to_convert_an_actor_to_a_reference {}; - } - - template <typename Base> - void - ref(actor<Base> const& v - , detail::error_attempting_to_convert_an_actor_to_a_reference - = detail::error_attempting_to_convert_an_actor_to_a_reference()); - - template <typename Base> - void - cref(actor<Base> const& v - , detail::error_attempting_to_convert_an_actor_to_a_reference - = detail::error_attempting_to_convert_an_actor_to_a_reference()); -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp deleted file mode 100644 index a275a7d..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/core/value.hpp +++ /dev/null @@ -1,158 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_CORE_VALUE_HPP -#define PHOENIX_CORE_VALUE_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/spirit/home/phoenix/core/as_actor.hpp> -#include <boost/static_assert.hpp> - -#include <boost/type_traits/is_reference.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/type_traits/add_const.hpp> -#include <boost/type_traits/add_reference.hpp> -#include <boost/type_traits/remove_pointer.hpp> -#include <boost/type_traits/is_function.hpp> - -#include <boost/mpl/bool.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/identity.hpp> - -namespace boost { namespace phoenix -{ - namespace meta - { - template<typename T> - struct const_ref - : add_reference<typename add_const<T>::type> - {}; - - template<typename T> - struct argument_type - : mpl::eval_if< - is_function<typename remove_pointer<T>::type>, - mpl::identity<T>, - const_ref<T> > - { - typedef T type; - }; - } - - template <typename T> - struct value - { - BOOST_STATIC_ASSERT( - mpl::not_<is_reference<T> >::value != 0); - - typedef mpl::false_ no_nullary; - - template <typename Env> - struct result - { - typedef T type; - }; - - value() - : val() {} - - value(T const& arg) - : val(arg) {} - - template <typename Env> - T const& - eval(Env const&) const - { - return val; - } - - T val; - }; - - template <typename Actor> - struct actor_value - { - typedef typename Actor::no_nullary no_nullary; - - template <typename Env> - struct result - { - typedef typename - remove_reference< - typename eval_result<Actor, Env>::type - >::type - type; - }; - - actor_value(Actor const& actor) - : actor(actor) {} - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - return actor.eval(env); - } - - Actor actor; - }; - - template <typename T> - inline typename as_actor<T>::type - val(T const& v) - { - return as_actor<T>::convert(v); - } - - template <typename Derived> - inline actor<actor_value<Derived> > - val(actor<Derived> const& actor) - { - return actor_value<Derived>(actor); - } - - template <typename T> - struct as_actor_base - { - typedef value<T> type; - - static value<T> - convert(typename meta::argument_type<T>::type x) - { - return value<T>(x); - } - }; - - // Sometimes it is necessary to auto-convert references to - // a value<T>. This happens when we are re-currying. This - // cannot happen through the standard public actor interfaces. - template <typename T> - struct as_actor_base<T&> - { - typedef value<T> type; - - static value<T> - convert(T& x) - { - return value<T>(x); - } - }; - - template <typename T, int N> - struct as_actor_base<T[N]> - { - typedef value<T const*> type; - - static value<T const*> - convert(T const x[N]) - { - return value<T const*>(x); - } - }; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp deleted file mode 100644 index ad1fdb4..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 Joel de Guzman - - 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 PHOENIX_DETAIL_LOCAL_REFERENCE_HPP -#define PHOENIX_DETAIL_LOCAL_REFERENCE_HPP - -#include <boost/utility/addressof.hpp> - -namespace boost { namespace phoenix { namespace detail -{ - template <typename T> - struct local_reference - { - typedef T type; - - explicit local_reference(T& t): t_(boost::addressof(t)) {} - operator T& () const { return *t_; } - local_reference& operator=(T const& x) { *t_ = x; return *this; } - local_reference const& operator=(T const& x) const { *t_ = x; return *this; } - T& get() const { return *t_; } - T* get_pointer() const { return t_; } - - private: - - T* t_; - }; - - template <typename T> - struct unwrap_local_reference - { - typedef T type; // T should be a reference - }; - - template <typename T> - struct unwrap_local_reference<local_reference<T> > - { - typedef T type; // unwrap the reference; T is a value - }; -}}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp deleted file mode 100644 index b99ea1e..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp +++ /dev/null @@ -1,497 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_DETAIL_TYPE_DEDUCTION_HPP -#define PHOENIX_DETAIL_TYPE_DEDUCTION_HPP - -/*============================================================================= - - Return Type Deduction - [JDG Sept. 15, 2003] - - Before C++ adopts the typeof, there is currently no way to deduce the - result type of an expression such as x + y. This deficiency is a major - problem with template metaprogramming; for example, when writing - forwarding functions that attempt to capture the essence of an - expression inside a function. Consider the std::plus<T>: - - template <typename T> - struct plus : public binary_function<T, T, T> - { - T operator()(T const& x, T const& y) const - { - return x + y; - } - }; - - What's wrong with this? Well, this functor does not accurately capture - the behavior of the plus operator. 1) It does not handle the case where - x and y are of different types (e.g. x is short and y is int). 2) It - assumes that the arguments and return type are the same (i.e. when - adding a short and an int, the return type ought to be an int). Due to - these shortcomings, std::plus<T>(x, y) is a poor substitute for x + y. - - The case where x is short and y is int does not really expose the - problem. We can simply use std::plus<int> and be happy that the - operands x and y will simply be converted to an int. The problem - becomes evident when an operand is a user defined type such as bigint. - Here, the conversion to bigint is simply not acceptable. Even if the - unnecessary conversion is tolerable, in generic code, it is not always - possible to choose the right T type that can accomodate both x and y - operands. - - To truly model the plus operator, what we need is a polymorphic functor - that can take arbitrary x and y operands. Here's a rough schematic: - - struct plus - { - template <typename X, typename Y> - unspecified-type - operator()(X const& x, Y const& y) const - { - return x + y; - } - }; - - Now, we can handle the case where X and Y are arbitrary types. We've - solved the first problem. To solve the second problem, we need some - form of return type deduction mechanism. If we had the typeof, it would - be something like: - - template <typename X, typename Y> - typeof(X() + Y()) - operator()(X const& x, Y const& y) const - { - return x + y; - } - - Without the typeof facility, it is only possible to wrap an expression - such as x + y in a function or functor if we are given a hint that - tells us what the actual result type of such an expression is. Such a - hint can be in the form of a metaprogram, that, given the types of the - arguments, will return the result type. Example: - - template <typename X, typename Y> - struct result_of_plus - { - typedef unspecified-type type; - }; - - Given a result_of_plus metaprogram, we can complete our polymorphic - plus functor: - - struct plus - { - template <typename X, typename Y> - typename result_of_plus<X, Y>::type - operator()(X const& x, Y const& y) const - { - return x + y; - } - }; - - The process is not automatic. We have to specialize the metaprogram for - specific argument types. Examples: - - template <> - struct result_of_plus<short, int> - { - typedef int type; - }; - - template <typename T> - struct result_of_plus<std::complex<T>, std::complex<T> > - { - typedef std::complex<T> type; - }; - - To make it easier for the user, specializations are provided for common - types such as primitive c++ types (e.g. int, char, double, etc.), and - standard types (e.g. std::complex, iostream, std containers and - iterators). - - To further improve the ease of use, for user defined classes, we can - supply a few more basic specializations through metaprogramming using - heuristics based on canonical operator rules (Such heuristics can be - found in the LL and Phoenix, for example). For example, it is rather - common that the result of x += y is X& or the result of x || y is a - bool. The client is out of luck if her classes do not follow the - canonical rules. She'll then have to supply her own specialization. - - The type deduction mechanism demostrated below approaches the problem - not through specialization and heuristics, but through a limited form - of typeof mechanism. The code does not use heuristics, hence, no - guessing games. The code takes advantage of the fact that, in general, - the result type of an expression is related to one its arguments' type. - For example, x + y, where x has type int and y has type double, has the - result type double (the second operand type). Another example, x[y] - where x is a vector<T> and y is a std::size_t, has the result type - vector<T>::reference (the vector<T>'s reference type type). - - The limited form of type deduction presented can detect common - relations if the result of a binary or unary operation, given arguments - x and y with types X and Y (respectively), is X, Y, X&, Y&, X*, Y*, X - const*, Y const*, bool, int, unsigned, double, container and iterator - elements (e.g the T, where X is: T[N], T*, vector<T>, map<T>, - vector<T>::iterator). More arguments/return type relationships can be - established if needed. - - A set of overloaded test(T) functions capture these argument related - types. Each test(T) function returns a distinct type that can be used - to determine the exact type of an expression. - - Consider: - - template <typename X, typename Y> - x_value_type - test(X const&); - - template <typename X, typename Y> - y_value_type - test(Y const&); - - Given an expression x + y, where x is int and y is double, the call to: - - test<int, double>(x + y) - - will return a y_value_type. - - Now, if we rig x_value_type and y_value_type such that both have unique - sizes, we can use sizeof(test<X, Y>(x + y)) to determine if the result - type is either X or Y. - - For example, if: - - sizeof(test<X, Y>(x + y)) == sizeof(y_value_type) - - then, we know for sure that the result of x + y has type Y. - - The same basic scheme can be used to detect more argument-dependent - return types where the sizeof the test(T) return type is used to index - through a boost::mpl vector which holds each of the corresponding - result types. - -==============================================================================*/ -#include <boost/mpl/vector/vector20.hpp> -#include <boost/mpl/at.hpp> -#include <boost/mpl/not.hpp> -#include <boost/mpl/or.hpp> -#include <boost/mpl/and.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/type_traits/add_reference.hpp> -#include <boost/type_traits/remove_cv.hpp> -#include <boost/type_traits/is_const.hpp> -#include <boost/type_traits/is_reference.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/type_traits/is_array.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/utility/enable_if.hpp> -#include <boost/static_assert.hpp> -#include <boost/preprocessor/cat.hpp> -#include <boost/spirit/home/phoenix/detail/local_reference.hpp> - -namespace boost -{ - struct error_cant_deduce_type {}; -} - -namespace boost { namespace type_deduction_detail -{ - typedef char(&bool_value_type)[1]; - typedef char(&int_value_type)[2]; - typedef char(&uint_value_type)[3]; - typedef char(&double_value_type)[4]; - - typedef char(&bool_reference_type)[5]; - typedef char(&int_reference_type)[6]; - typedef char(&uint_reference_type)[7]; - typedef char(&double_reference_type)[8]; - - typedef char(&x_value_type)[9]; - typedef char(&x_reference_type)[10]; - typedef char(&x_const_pointer_type)[11]; - typedef char(&x_pointer_type)[12]; - - typedef char(&y_value_type)[13]; - typedef char(&y_reference_type)[14]; - typedef char(&y_const_pointer_type)[15]; - typedef char(&y_pointer_type)[16]; - - typedef char(&container_reference_type)[17]; - typedef char(&container_const_reference_type)[18]; - typedef char(&container_mapped_type)[19]; - - typedef char(&cant_deduce_type)[20]; - - template <typename T, typename Plain = typename remove_cv<T>::type> - struct is_basic - : mpl::or_< - is_same<Plain, bool> - , is_same<Plain, int> - , is_same<Plain, unsigned> - , is_same<Plain, double> - > {}; - - template <typename C> - struct reference_type - { - typedef typename C::reference type; - }; - - template <typename T> - struct reference_type<T const> - : reference_type<T> {}; - - template <typename T, std::size_t N> - struct reference_type<T[N]> - { - typedef T& type; - }; - - template <typename T> - struct reference_type<T*> - { - typedef T& type; - }; - - template <typename T> - struct reference_type<T* const> - { - typedef T const& type; - }; - - template <typename C> - struct const_reference_type - { - typedef typename C::const_reference type; - }; - - template <typename C> - struct mapped_type - { - typedef typename C::mapped_type type; - }; - - struct asymmetric; - - template <typename X, typename Y> - cant_deduce_type - test(...); // The black hole !!! - - template <typename X, typename Y> - bool_value_type - test(bool const&); - - template <typename X, typename Y> - int_value_type - test(int const&); - - template <typename X, typename Y> - uint_value_type - test(unsigned const&); - - template <typename X, typename Y> - double_value_type - test(double const&); - - template <typename X, typename Y> - bool_reference_type - test(bool&); - - template <typename X, typename Y> - int_reference_type - test(int&); - - template <typename X, typename Y> - uint_reference_type - test(unsigned&); - - template <typename X, typename Y> - double_reference_type - test(double&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_<is_basic<X>, is_const<X> > - , x_value_type - >::type - test(X const&); - - template <typename X, typename Y> - typename disable_if< - is_basic<X> - , x_reference_type - >::type - test(X&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<X> - , is_const<X> - > - , x_const_pointer_type - >::type - test(X const*); - - template <typename X, typename Y> - x_pointer_type - test(X*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<Y> - , is_same<Y, asymmetric> - , is_const<Y> - , is_same<X, Y> - > - , y_value_type - >::type - test(Y const&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<Y> - , is_same<Y, asymmetric> - , is_same<X, Y> - > - , y_reference_type - >::type - test(Y&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_same<Y, asymmetric> - , is_const<Y> - , is_same<X, Y> - > - , y_const_pointer_type - >::type - test(Y const*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_same<Y, asymmetric> - , is_same<X, Y> - > - , y_pointer_type - >::type - test(Y*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<typename X::value_type> - , is_same<typename add_reference<X>::type, typename X::reference> - > - , container_reference_type - >::type - test(typename X::reference); - - template <typename X, typename Y, typename Z> - typename enable_if< - mpl::and_< - mpl::or_<is_array<X>, is_pointer<X> > - , mpl::not_<is_basic<Z> > - , mpl::not_<is_same<X, Z> > - > - , container_reference_type - >::type - test(Z&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<typename X::value_type> - , is_same<typename add_reference<X>::type, typename X::const_reference> - > - , container_const_reference_type - >::type - test(typename X::const_reference); - - template <typename X, typename Y> - typename disable_if< - is_basic<typename X::mapped_type> - , container_mapped_type - >::type - test(typename X::mapped_type); - - template <typename X, typename Y> - struct base_result_of - { - typedef typename phoenix::detail::unwrap_local_reference<X>::type x_type_; - typedef typename phoenix::detail::unwrap_local_reference<Y>::type y_type_; - typedef typename remove_reference<x_type_>::type x_type; - typedef typename remove_reference<y_type_>::type y_type; - - typedef mpl::vector20< - mpl::identity<bool> - , mpl::identity<int> - , mpl::identity<unsigned> - , mpl::identity<double> - , mpl::identity<bool&> - , mpl::identity<int&> - , mpl::identity<unsigned&> - , mpl::identity<double&> - , mpl::identity<x_type> - , mpl::identity<x_type&> - , mpl::identity<x_type const*> - , mpl::identity<x_type*> - , mpl::identity<y_type> - , mpl::identity<y_type&> - , mpl::identity<y_type const*> - , mpl::identity<y_type*> - , reference_type<x_type> - , const_reference_type<x_type> - , mapped_type<x_type> - , mpl::identity<error_cant_deduce_type> - > - types; - }; - -}} // namespace boost::type_deduction_detail - -#define BOOST_RESULT_OF_COMMON(expr, name, Y, SYMMETRY) \ - struct name \ - { \ - typedef type_deduction_detail::base_result_of<X, Y> base_type; \ - static typename base_type::x_type x; \ - static typename base_type::y_type y; \ - \ - BOOST_STATIC_CONSTANT(int, \ - size = sizeof( \ - type_deduction_detail::test< \ - typename base_type::x_type \ - , SYMMETRY \ - >(expr) \ - )); \ - \ - BOOST_STATIC_CONSTANT(int, index = (size / sizeof(char)) - 1); \ - \ - typedef typename mpl::at_c< \ - typename base_type::types, index>::type id; \ - typedef typename id::type type; \ - }; - -#define BOOST_UNARY_RESULT_OF(expr, name) \ - template <typename X> \ - BOOST_RESULT_OF_COMMON(expr, name, \ - type_deduction_detail::asymmetric, type_deduction_detail::asymmetric) - -#define BOOST_BINARY_RESULT_OF(expr, name) \ - template <typename X, typename Y> \ - BOOST_RESULT_OF_COMMON(expr, name, Y, typename base_type::y_type) - -#define BOOST_ASYMMETRIC_BINARY_RESULT_OF(expr, name) \ - template <typename X, typename Y> \ - BOOST_RESULT_OF_COMMON(expr, name, Y, type_deduction_detail::asymmetric) - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp deleted file mode 100644 index 5309d9a..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/function.hpp +++ /dev/null @@ -1,13 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_FUNCTION_HPP -#define PHOENIX_FUNCTION_HPP - -#include <boost/spirit/home/phoenix/version.hpp> -#include <boost/spirit/home/phoenix/function/function.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp deleted file mode 100644 index 622f118..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/detail/function_call.hpp +++ /dev/null @@ -1,42 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_FUNCTION_DETAIL_FUNCTION_CALL_HPP -#define PHOENIX_FUNCTION_DETAIL_FUNCTION_CALL_HPP - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, BOOST_PP_DEC(PHOENIX_COMPOSITE_LIMIT), \ - "boost/spirit/home/phoenix/function/detail/function_call.hpp")) -#include BOOST_PP_ITERATE() - -#endif - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template <BOOST_PP_ENUM_PARAMS(N, typename A)> - actor<typename as_composite<detail::function_eval<N>, F - , BOOST_PP_ENUM_PARAMS(N, A)>::type> - operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& _)) const - { - return compose<detail::function_eval<N> >(f, BOOST_PP_ENUM_PARAMS(N, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp deleted file mode 100644 index 1cf4701..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/function/function.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_FUNCTION_FUNCTION_HPP -#define PHOENIX_FUNCTION_FUNCTION_HPP - -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/detail/function_eval.hpp> - -namespace boost { namespace phoenix -{ - template <typename F> - struct function - { - function() : f() {} - function(F const& f) : f(f) {} - - actor<typename as_composite<detail::function_eval<0>, F>::type> - operator()() const - { - return compose<detail::function_eval<0> >(f); - } - - template <typename A0> - actor<typename as_composite<detail::function_eval<1>, F, A0>::type> - operator()(A0 const& _0) const - { - return compose<detail::function_eval<1> >(f, _0); - } - - template <typename A0, typename A1> - actor<typename as_composite<detail::function_eval<2>, F, A0, A1>::type> - operator()(A0 const& _0, A1 const& _1) const - { - return compose<detail::function_eval<2> >(f, _0, _1); - } - - // Bring in the rest of the function call operators - #include <boost/spirit/home/phoenix/function/detail/function_call.hpp> - - F f; - }; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp deleted file mode 100644 index 2d8ee6c..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator.hpp +++ /dev/null @@ -1,20 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_HPP -#define PHOENIX_OPERATOR_HPP - -#include <boost/spirit/home/phoenix/version.hpp> -#include <boost/spirit/home/phoenix/operator/arithmetic.hpp> -#include <boost/spirit/home/phoenix/operator/bitwise.hpp> -#include <boost/spirit/home/phoenix/operator/comparison.hpp> -#include <boost/spirit/home/phoenix/operator/if_else.hpp> -#include <boost/spirit/home/phoenix/operator/logical.hpp> -#include <boost/spirit/home/phoenix/operator/self.hpp> -#include <boost/spirit/home/phoenix/operator/io.hpp> -#include <boost/spirit/home/phoenix/operator/member.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp deleted file mode 100644 index e51b23e..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/arithmetic.hpp +++ /dev/null @@ -1,115 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_ARITHMETIC_HPP -#define PHOENIX_OPERATOR_ARITHMETIC_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> - -namespace boost { namespace phoenix -{ - struct negate_eval; - struct posit_eval; - struct pre_increment_eval; - struct pre_decrement_eval; - struct post_increment_eval; - struct post_decrement_eval; - - struct plus_assign_eval; - struct minus_assign_eval; - struct multiplies_assign_eval; - struct divides_assign_eval; - struct modulus_assign_eval; - - struct plus_eval; - struct minus_eval; - struct multiplies_eval; - struct divides_eval; - struct modulus_eval; - - BOOST_UNARY_RESULT_OF(-x, result_of_negate) - BOOST_UNARY_RESULT_OF(+x, result_of_posit) - BOOST_UNARY_RESULT_OF(++x, result_of_pre_increment) - BOOST_UNARY_RESULT_OF(--x, result_of_pre_decrement) - BOOST_UNARY_RESULT_OF(x++, result_of_post_increment) - BOOST_UNARY_RESULT_OF(x--, result_of_post_decrement) - - BOOST_BINARY_RESULT_OF(x += y, result_of_plus_assign) - BOOST_BINARY_RESULT_OF(x -= y, result_of_minus_assign) - BOOST_BINARY_RESULT_OF(x *= y, result_of_multiplies_assign) - BOOST_BINARY_RESULT_OF(x /= y, result_of_divides_assign) - BOOST_BINARY_RESULT_OF(x %= y, result_of_modulus_assign) - - BOOST_BINARY_RESULT_OF(x + y, result_of_plus) - BOOST_BINARY_RESULT_OF(x - y, result_of_minus) - BOOST_BINARY_RESULT_OF(x * y, result_of_multiplies) - BOOST_BINARY_RESULT_OF(x / y, result_of_divides) - BOOST_BINARY_RESULT_OF(x % y, result_of_modulus) - -#define x a0.eval(env) -#define y a1.eval(env) - - PHOENIX_UNARY_EVAL(negate_eval, result_of_negate, -x) - PHOENIX_UNARY_EVAL(posit_eval, result_of_posit, +x) - PHOENIX_UNARY_EVAL(pre_increment_eval, result_of_pre_increment, ++x) - PHOENIX_UNARY_EVAL(pre_decrement_eval, result_of_pre_decrement, --x) - PHOENIX_UNARY_EVAL(post_increment_eval, result_of_post_increment, x++) - PHOENIX_UNARY_EVAL(post_decrement_eval, result_of_post_decrement, x--) - - PHOENIX_BINARY_EVAL(plus_assign_eval, result_of_plus_assign, x += y) - PHOENIX_BINARY_EVAL(minus_assign_eval, result_of_minus_assign, x -= y) - PHOENIX_BINARY_EVAL(multiplies_assign_eval, result_of_multiplies_assign, x *= y) - PHOENIX_BINARY_EVAL(divides_assign_eval, result_of_divides_assign, x /= y) - PHOENIX_BINARY_EVAL(modulus_assign_eval, result_of_modulus_assign, x %= y) - - PHOENIX_BINARY_EVAL(plus_eval, result_of_plus, x + y) - PHOENIX_BINARY_EVAL(minus_eval, result_of_minus, x - y) - PHOENIX_BINARY_EVAL(multiplies_eval, result_of_multiplies, x * y) - PHOENIX_BINARY_EVAL(divides_eval, result_of_divides, x / y) - PHOENIX_BINARY_EVAL(modulus_eval, result_of_modulus, x % y) - - PHOENIX_UNARY_COMPOSE(negate_eval, -) - PHOENIX_UNARY_COMPOSE(posit_eval, +) - PHOENIX_UNARY_COMPOSE(pre_increment_eval, ++) - PHOENIX_UNARY_COMPOSE(pre_decrement_eval, --) - - template <typename T0> - inline actor<typename as_composite<post_increment_eval, actor<T0> >::type> - operator++(actor<T0> const& a0, int) // special case - { - return compose<post_increment_eval>(a0); - } - - template <typename T0> - inline actor<typename as_composite<post_decrement_eval, actor<T0> >::type> - operator--(actor<T0> const& a0, int) // special case - { - return compose<post_decrement_eval>(a0); - } - - PHOENIX_BINARY_COMPOSE(plus_assign_eval, +=) - PHOENIX_BINARY_COMPOSE(minus_assign_eval, -=) - PHOENIX_BINARY_COMPOSE(multiplies_assign_eval, *=) - PHOENIX_BINARY_COMPOSE(divides_assign_eval, /=) - PHOENIX_BINARY_COMPOSE(modulus_assign_eval, %=) - - PHOENIX_BINARY_COMPOSE(plus_eval, +) - PHOENIX_BINARY_COMPOSE(minus_eval, -) - PHOENIX_BINARY_COMPOSE(multiplies_eval, *) - PHOENIX_BINARY_COMPOSE(divides_eval, /) - PHOENIX_BINARY_COMPOSE(modulus_eval, %) - -#undef x -#undef y -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp deleted file mode 100644 index 0450db4..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/bitwise.hpp +++ /dev/null @@ -1,91 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_BITWISE_HPP -#define PHOENIX_OPERATOR_BITWISE_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> - -#ifdef BOOST_MSVC -# pragma warning(push) -# pragma warning(disable : 4800) -#endif - -namespace boost { namespace phoenix -{ - struct invert_eval; - - struct and_assign_eval; - struct or_assign_eval; - struct xor_assign_eval; - struct shift_left_assign_eval; - struct shift_right_assign_eval; - - struct and_eval; - struct or_eval; - struct xor_eval; - struct shift_left_eval; - struct shift_right_eval; - - BOOST_UNARY_RESULT_OF(~x, result_of_invert) - - BOOST_BINARY_RESULT_OF(x &= y, result_of_and_assign) - BOOST_BINARY_RESULT_OF(x |= y, result_of_or_assign) - BOOST_BINARY_RESULT_OF(x ^= y, result_of_xor_assign) - BOOST_BINARY_RESULT_OF(x <<= y, result_of_shift_left_assign) - BOOST_BINARY_RESULT_OF(x >>= y, result_of_shift_right_assign) - - BOOST_BINARY_RESULT_OF(x & y, result_of_and) - BOOST_BINARY_RESULT_OF(x | y, result_of_or) - BOOST_BINARY_RESULT_OF(x ^ y, result_of_xor) - BOOST_BINARY_RESULT_OF(x << y, result_of_shift_left) - BOOST_BINARY_RESULT_OF(x >> y, result_of_shift_right) - -#define x a0.eval(env) -#define y a1.eval(env) - - PHOENIX_UNARY_EVAL(invert_eval, result_of_invert, ~x) - PHOENIX_UNARY_COMPOSE(invert_eval, ~) - - PHOENIX_BINARY_EVAL(and_assign_eval, result_of_and_assign, x &= y) - PHOENIX_BINARY_EVAL(or_assign_eval, result_of_or_assign, x |= y) - PHOENIX_BINARY_EVAL(xor_assign_eval, result_of_xor_assign, x ^= y) - PHOENIX_BINARY_EVAL(shift_left_assign_eval, result_of_shift_left_assign, x <<= y) - PHOENIX_BINARY_EVAL(shift_right_assign_eval, result_of_shift_right_assign, x >>= y) - - PHOENIX_BINARY_EVAL(and_eval, result_of_and, x & y) - PHOENIX_BINARY_EVAL(or_eval, result_of_or, x | y) - PHOENIX_BINARY_EVAL(xor_eval, result_of_xor, x ^ y) - PHOENIX_BINARY_EVAL(shift_left_eval, result_of_shift_left, x << y) - PHOENIX_BINARY_EVAL(shift_right_eval, result_of_shift_right, x >> y) - - PHOENIX_BINARY_COMPOSE(and_assign_eval, &=) - PHOENIX_BINARY_COMPOSE(or_assign_eval, |=) - PHOENIX_BINARY_COMPOSE(xor_assign_eval, ^=) - PHOENIX_BINARY_COMPOSE(shift_left_assign_eval, <<=) - PHOENIX_BINARY_COMPOSE(shift_right_assign_eval, >>=) - - PHOENIX_BINARY_COMPOSE(and_eval, &) - PHOENIX_BINARY_COMPOSE(or_eval, |) - PHOENIX_BINARY_COMPOSE(xor_eval, ^) - PHOENIX_BINARY_COMPOSE(shift_left_eval, <<) - PHOENIX_BINARY_COMPOSE(shift_right_eval, >>) - -#undef x -#undef y -}} - -#if defined(BOOST_MSVC) -# pragma warning(pop) -#endif - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp deleted file mode 100644 index fe9298c..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/comparison.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_COMPARISON_HPP -#define PHOENIX_OPERATOR_COMPARISON_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> - -namespace boost { namespace phoenix -{ - struct equal_to_eval; - struct not_equal_to_eval; - struct less_eval; - struct less_equal_eval; - struct greater_eval; - struct greater_equal_eval; - - BOOST_BINARY_RESULT_OF(x == y, result_of_equal_to) - BOOST_BINARY_RESULT_OF(x != y, result_of_not_equal_to) - BOOST_BINARY_RESULT_OF(x < y, result_of_less) - BOOST_BINARY_RESULT_OF(x <= y, result_of_less_equal) - BOOST_BINARY_RESULT_OF(x > y, result_of_greater) - BOOST_BINARY_RESULT_OF(x >= y, result_of_greater_equal) - -#define x a0.eval(env) -#define y a1.eval(env) - - PHOENIX_BINARY_EVAL(equal_to_eval, result_of_equal_to, x == y) - PHOENIX_BINARY_EVAL(not_equal_to_eval, result_of_not_equal_to, x != y) - PHOENIX_BINARY_EVAL(less_eval, result_of_less, x < y) - PHOENIX_BINARY_EVAL(less_equal_eval, result_of_less_equal, x <= y) - PHOENIX_BINARY_EVAL(greater_eval, result_of_greater, x > y) - PHOENIX_BINARY_EVAL(greater_equal_eval, result_of_greater_equal, x >= y) - - PHOENIX_BINARY_COMPOSE(equal_to_eval, ==) - PHOENIX_BINARY_COMPOSE(not_equal_to_eval, !=) - PHOENIX_BINARY_COMPOSE(less_eval, <) - PHOENIX_BINARY_COMPOSE(less_equal_eval, <=) - PHOENIX_BINARY_COMPOSE(greater_eval, >) - PHOENIX_BINARY_COMPOSE(greater_equal_eval, >=) - -#undef x -#undef y -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp deleted file mode 100644 index 49335fd..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_compose.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP -#define PHOENIX_OPERATOR_DETAIL_BINARY_COMPOSE_HPP - -#define PHOENIX_BINARY_COMPOSE(eval_name, op) \ - template <typename T0, typename T1> \ - inline actor<typename as_composite<eval_name, actor<T0>, actor<T1> >::type> \ - operator op (actor<T0> const& a0, actor<T1> const& a1) \ - { \ - return compose<eval_name>(a0, a1); \ - } \ - \ - template <typename T0, typename T1> \ - inline actor<typename as_composite<eval_name, actor<T0>, T1>::type> \ - operator op (actor<T0> const& a0, T1 const& a1) \ - { \ - return compose<eval_name>(a0, a1); \ - } \ - \ - template <typename T0, typename T1> \ - inline actor<typename as_composite<eval_name, T0, actor<T1> >::type> \ - operator op (T0 const& a0, actor<T1> const& a1) \ - { \ - return compose<eval_name>(a0, a1); \ - } - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp deleted file mode 100644 index 1789882..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/binary_eval.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP -#define PHOENIX_OPERATOR_DETAIL_BINARY_EVAL_HPP - -#include <boost/mpl/or.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> - -#define PHOENIX_BINARY_EVAL(eval_name, op_result, expr) \ - struct eval_name \ - { \ - template <typename Env, typename A0, typename A1> \ - struct result \ - { \ - typedef typename A0::template result<Env>::type x_type; \ - typedef typename A1::template result<Env>::type y_type; \ - \ - typedef typename \ - mpl::eval_if< \ - mpl::or_<is_actor<x_type>, is_actor<y_type> > \ - , re_curry<eval_name, x_type, y_type> \ - , op_result<x_type, y_type> \ - >::type \ - type; \ - }; \ - \ - template <typename RT, typename Env, typename A0, typename A1> \ - static RT \ - eval(Env const& env, A0& a0, A1& a1) \ - { \ - return expr; \ - } \ - }; - -#undef x -#undef y -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp deleted file mode 100644 index d82a153..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/io.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_DETAIL_IO_HPP -#define PHOENIX_OPERATOR_DETAIL_IO_HPP - -#include <boost/spirit/home/phoenix/operator/bitwise.hpp> -#include <boost/spirit/home/phoenix/core/reference.hpp> -#include <boost/utility/addressof.hpp> -#include <boost/utility/enable_if.hpp> -#include <iostream> - -namespace boost { namespace phoenix { namespace detail -{ - typedef char(&no)[1]; - typedef char(&yes)[2]; - - template <typename CharType, typename CharTrait> - yes ostream_test(std::basic_ostream<CharType, CharTrait>*); - no ostream_test(...); - - template <typename CharType, typename CharTrait> - yes istream_test(std::basic_istream<CharType, CharTrait>*); - no istream_test(...); - - template <typename T> - struct is_ostream - { - static T x; - BOOST_STATIC_CONSTANT(bool, - value = sizeof(detail::ostream_test(boost::addressof(x))) == sizeof(yes)); - }; - - template <typename T> - struct is_istream - { - static T x; - BOOST_STATIC_CONSTANT(bool, - value = sizeof(detail::istream_test(boost::addressof(x))) == sizeof(yes)); - }; - - template <typename T0, typename T1> - struct enable_if_ostream : - enable_if< - detail::is_ostream<T0> - , actor< - typename as_composite< - shift_left_eval - , actor<reference<T0> > - , actor<T1> - >::type - > - > - {}; - - template <typename T0, typename T1> - struct enable_if_istream : - enable_if< - detail::is_istream<T0> - , actor< - typename as_composite< - shift_right_eval - , actor<reference<T0> > - , actor<T1> - >::type - > - > - {}; - - typedef std::ios_base& (*iomanip_type)(std::ios_base&); - typedef std::istream& (*imanip_type)(std::istream&); - typedef std::ostream& (*omanip_type)(std::ostream&); -}}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp deleted file mode 100644 index cb77613..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp +++ /dev/null @@ -1,76 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 Dan Marsden - Copyright (c) 2005-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP -#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_EVAL_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> - -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/iteration/iterate.hpp> -#include <boost/preprocessor/arithmetic/sub.hpp> -#include <boost/preprocessor/arithmetic/dec.hpp> - -#include <boost/mpl/void.hpp> - -#include <boost/type_traits/function_traits.hpp> - -#include <boost/get_pointer.hpp> - -#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp> - -namespace boost { namespace phoenix { - - struct mem_fun_ptr_eval - { - template<typename Env, typename PtrActor, typename MemFunPtrActor, - BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_SUB(PHOENIX_MEMBER_LIMIT, 2), typename Arg, mpl::void_)> - - struct result - : detail::mem_fun_ptr_return<typename eval_result<MemFunPtrActor, Env>::type> { }; - - template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor> - static typename result<Env,PtrActor,MemFunPtrActor>::type - eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor) - { - return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(); - } - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp")) - -#include BOOST_PP_ITERATE() - - }; -}} - -#endif - -#else - -#define PHOENIX_ITERATION BOOST_PP_ITERATION() - -#define PHOENIX_EVAL_ARG(z,n,_) arg ## n.eval(env) - - template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor, - BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)> - static typename result<Env,PtrActor,MemFunPtrActor, BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION,Arg)>::type - eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor, - BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, Arg, & arg)) - { - return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))( - BOOST_PP_ENUM(PHOENIX_ITERATION,PHOENIX_EVAL_ARG,_)); - } - -#undef PHOENIX_EVAL_ARG -#undef PHOENIX_ITERATION - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp deleted file mode 100644 index 31d5413..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 Dan Marsden - Copyright (c) 2005-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP -#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_GEN_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/core/as_actor.hpp> -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> - -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/repetition/enum_binary_params.hpp> -#include <boost/preprocessor/iteration/iterate.hpp> -#include <boost/preprocessor/arithmetic/dec.hpp> - -#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_eval.hpp> - -namespace boost { namespace phoenix { - template<typename Actor, typename MemFunPtr> - struct mem_fun_ptr_gen - { - mem_fun_ptr_gen( - const Actor& actor, MemFunPtr memFunPtr) - : mActor(actor), mMemFunPtr(memFunPtr) { } - - actor<typename as_composite<mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type>::type> - operator()() const - { - return compose<mem_fun_ptr_eval>( - mActor, as_actor<MemFunPtr>::convert(mMemFunPtr)); - } - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, BOOST_PP_DEC(BOOST_PP_DEC(PHOENIX_MEMBER_LIMIT)), "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp")) - -#include BOOST_PP_ITERATE() - - Actor mActor; - MemFunPtr mMemFunPtr; - }; -}} - -#endif -#else - -#define PHOENIX_ITERATION BOOST_PP_ITERATION() - - template<BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename Arg)> - actor<typename as_composite< - mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type, - BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, Arg)>::type> - operator()( - BOOST_PP_ENUM_BINARY_PARAMS(PHOENIX_ITERATION, const Arg, &arg)) const - { - return compose<mem_fun_ptr_eval>( - mActor, as_actor<MemFunPtr>::convert(mMemFunPtr), - BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, arg)); - } - -#undef PHOENIX_ITERATION - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp deleted file mode 100644 index 102f17f..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 Dan Marsden - Copyright (c) 2005-2007 Joel de Guzman - - 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_PP_IS_ITERATING -#ifndef PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP -#define PHOENIX_OPERATOR_DETAIL_MEM_FUN_PTR_RETURN_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> - -#include <boost/preprocessor/repetition/enum_params.hpp> -#include <boost/preprocessor/iteration/iterate.hpp> - -namespace boost { namespace phoenix { -namespace detail -{ - template<typename MemFunPtr> - struct mem_fun_ptr_return; - - template<typename Ret, typename Class> - struct mem_fun_ptr_return<Ret (Class::*)()> - { - typedef Ret type; - }; - - template<typename Ret, typename Class> - struct mem_fun_ptr_return<Ret (Class::*)() const> - { - typedef Ret type; - }; - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (1, PHOENIX_MEMBER_LIMIT, "boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_return.hpp")) - -#include BOOST_PP_ITERATE() - -} -}} - -#endif - -#else - -#define PHOENIX_ITERATION BOOST_PP_ITERATION() - - template<typename Ret, typename Class, - BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)> - struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T))> - { - typedef Ret type; - }; - - template<typename Ret, typename Class, - BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, typename T)> - struct mem_fun_ptr_return<Ret (Class::*)(BOOST_PP_ENUM_PARAMS(PHOENIX_ITERATION, T)) const> - { - typedef Ret type; - }; - -#undef PHOENIX_ITERATION - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp deleted file mode 100644 index fd9a8c7..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_compose.hpp +++ /dev/null @@ -1,18 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP -#define PHOENIX_OPERATOR_DETAIL_UNARY_COMPOSE_HPP - -#define PHOENIX_UNARY_COMPOSE(eval_name, op) \ - template <typename T0> \ - inline actor<typename as_composite<eval_name, actor<T0> >::type> \ - operator op (actor<T0> const& a0) \ - { \ - return compose<eval_name>(a0); \ - } - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp deleted file mode 100644 index 501f6df..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/detail/unary_eval.hpp +++ /dev/null @@ -1,40 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP -#define PHOENIX_OPERATOR_DETAIL_UNARY_EVAL_HPP - -#include <boost/mpl/eval_if.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> - -#define PHOENIX_UNARY_EVAL(eval_name, op_result, expr) \ - struct eval_name \ - { \ - template <typename Env, typename A0> \ - struct result \ - { \ - typedef typename A0::template result<Env>::type x_type; \ - \ - typedef typename \ - mpl::eval_if< \ - is_actor<x_type> \ - , re_curry<eval_name, x_type> \ - , op_result<x_type> \ - >::type \ - type; \ - }; \ - \ - template <typename RT, typename Env, typename A0> \ - static RT \ - eval(Env const& env, A0& a0) \ - { \ - return expr; \ - } \ - }; - -#endif - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp deleted file mode 100644 index 8492e90..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/if_else.hpp +++ /dev/null @@ -1,78 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_IF_ELSE_HPP -#define PHOENIX_OPERATOR_IF_ELSE_HPP - -#include <boost/mpl/and.hpp> -#include <boost/mpl/if.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/type_traits/is_reference.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> - -namespace boost { namespace phoenix -{ - BOOST_BINARY_RESULT_OF(true ? x : y, result_of_if_else) - - struct if_else_op_eval - { - template < - typename Env - , typename Cond - , typename Then - , typename Else - > - struct result - { - typedef typename Then::template result<Env>::type then_type; - typedef typename Else::template result<Env>::type else_type; - - typedef typename - result_of_if_else<then_type, else_type>::type - ite_result; - - // Note: c ? x : y can return an lvalue! Allow if_else_op_eval - // to return an lvalue IFF then_type and else_type are both lvalues - // with the same type. - - typedef typename - mpl::if_< - mpl::and_< - is_same<then_type, else_type> - , is_reference<then_type> - > - , ite_result - , typename remove_reference<ite_result>::type - >::type - type; - }; - - template < - typename RT - , typename Env - , typename Cond - , typename Then - , typename Else - > - static RT - eval(Env const& env, Cond& cond, Then& then, Else& else_) - { - return cond.eval(env) ? then.eval(env) : else_.eval(env); - } - }; - - template <typename Cond, typename Then, typename Else> - inline actor<typename as_composite<if_else_op_eval, Cond, Then, Else>::type> - if_else(Cond const& cond, Then const& then, Else const& else_) - { - return compose<if_else_op_eval>(cond, then, else_); - } -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp deleted file mode 100644 index 360a46f..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/io.hpp +++ /dev/null @@ -1,86 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_IO_HPP -#define PHOENIX_OPERATOR_IO_HPP - -#include <boost/spirit/home/phoenix/operator/detail/io.hpp> - -namespace boost { namespace phoenix -{ -/////////////////////////////////////////////////////////////////////////////// -// -// overloads for std::basic_ostream and std::basic_istream -// -/////////////////////////////////////////////////////////////////////////////// - template <typename T0, typename T1> - inline typename detail::enable_if_ostream<T0, T1>::type - operator<<(T0& a0, actor<T1> const& a1) - { - return compose<shift_left_eval>(phoenix::ref(a0), a1); - } - - template <typename T0, typename T1> - inline typename detail::enable_if_istream<T0, T1>::type - operator>>(T0& a0, actor<T1> const& a1) - { - return compose<shift_right_eval>(phoenix::ref(a0), a1); - } - - // resolve ambiguities with fusion. - template <typename T1> - inline typename detail::enable_if_ostream<std::ostream, T1>::type - operator<<(std::ostream& a0, actor<T1> const& a1) - { - return compose<shift_left_eval>(phoenix::ref(a0), a1); - } - - template <typename T1> - inline typename detail::enable_if_istream<std::istream, T1>::type - operator>>(std::istream& a0, actor<T1> const& a1) - { - return compose<shift_right_eval>(phoenix::ref(a0), a1); - } - -/////////////////////////////////////////////////////////////////////////////// -// -// overloads for I/O manipulators. -// -/////////////////////////////////////////////////////////////////////////////// - template <typename T0> - inline actor<typename as_composite< - shift_left_eval, actor<T0>, detail::omanip_type>::type> - operator<<(actor<T0> const& a0, detail::omanip_type a1) - { - return compose<shift_left_eval>(a0, a1); - } - - template <typename T0> - inline actor<typename as_composite< - shift_left_eval, actor<T0>, detail::iomanip_type>::type> - operator<<(actor<T0> const& a0, detail::iomanip_type a1) - { - return compose<shift_left_eval>(a0, a1); - } - - template <typename T0> - inline actor<typename as_composite< - shift_right_eval, actor<T0>, detail::imanip_type>::type> - operator>>(actor<T0> const& a0, detail::imanip_type a1) - { - return compose<shift_right_eval>(a0, a1); - } - - template <typename T0> - inline actor<typename as_composite< - shift_right_eval, actor<T0>, detail::iomanip_type>::type> - operator>>(actor<T0> const& a0, detail::iomanip_type a1) - { - return compose<shift_right_eval>(a0, a1); - } -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp deleted file mode 100644 index 84619aa..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/logical.hpp +++ /dev/null @@ -1,43 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_LOGICAL_HPP -#define PHOENIX_OPERATOR_LOGICAL_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> - -namespace boost { namespace phoenix -{ - struct logical_not_eval; - struct logical_and_eval; - struct logical_or_eval; - - BOOST_UNARY_RESULT_OF(!x, result_of_logical_not) - BOOST_BINARY_RESULT_OF(x && y, result_of_logical_and) - BOOST_BINARY_RESULT_OF(x || y, result_of_logical_or) - -#define x a0.eval(env) -#define y a1.eval(env) - - PHOENIX_UNARY_EVAL(logical_not_eval, result_of_logical_not, !x) - PHOENIX_BINARY_EVAL(logical_and_eval, result_of_logical_and, x && y) - PHOENIX_BINARY_EVAL(logical_or_eval, result_of_logical_or, x || y) - - PHOENIX_UNARY_COMPOSE(logical_not_eval, !) - PHOENIX_BINARY_COMPOSE(logical_and_eval, &&) - PHOENIX_BINARY_COMPOSE(logical_or_eval, ||) - -#undef x -#undef y -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp deleted file mode 100644 index 27f3e8d..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/member.hpp +++ /dev/null @@ -1,145 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 Dan Marsden - Copyright (c) 2005-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_MEMBER_HPP -#define PHOENIX_OPERATOR_MEMBER_HPP - -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> - -#include <boost/type_traits/add_reference.hpp> -#include <boost/type_traits/add_const.hpp> -#include <boost/type_traits/is_const.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/type_traits/is_member_pointer.hpp> -#include <boost/type_traits/is_member_function_pointer.hpp> - -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/mpl/and.hpp> -#include <boost/mpl/not.hpp> - -#include <boost/utility/enable_if.hpp> - -#include <boost/get_pointer.hpp> - -#include <boost/spirit/home/phoenix/operator/detail/mem_fun_ptr_gen.hpp> - -#include <memory> - -namespace boost { - template<typename T> class shared_ptr; - template<typename T> class scoped_ptr; - -namespace phoenix { - namespace detail - { - template<typename T> - struct member_type; - - template<typename Class, typename MemberType> - struct member_type<MemberType (Class::*)> - { - typedef MemberType type; - }; - } - - namespace meta - { - template<typename T> - struct pointed_type; - - template<typename T> - struct pointed_type<T*> - { - typedef T type; - }; - - template<typename T> - struct pointed_type<shared_ptr<T> > - { - typedef T type; - }; - - template<typename T> - struct pointed_type<scoped_ptr<T> > - { - typedef T type; - }; - - template<typename T> - struct pointed_type<std::auto_ptr<T> > - { - typedef T type; - }; - } - - struct member_object_eval - { - template<typename Env, typename PtrActor, typename MemPtrActor> - struct result - { - typedef typename detail::member_type< - typename eval_result<MemPtrActor, Env>::type>::type member_type; - - typedef typename meta::pointed_type< - typename remove_reference< - typename eval_result<PtrActor, Env>::type>::type>::type object_type; - - typedef typename add_reference< - typename mpl::eval_if< - is_const<object_type>, - add_const<member_type>, - mpl::identity<member_type> >::type>::type type; - }; - - template<typename Rt, typename Env, typename PtrActor, typename MemPtrActor> - static typename result<Env,PtrActor,MemPtrActor>::type - eval(const Env& env, PtrActor& ptrActor, MemPtrActor& memPtrActor) - { - return get_pointer(ptrActor.eval(env))->*memPtrActor.eval(env); - } - }; - - namespace member_object - { - template<typename T0, typename MemObjPtr> - typename enable_if< - mpl::and_<is_member_pointer<MemObjPtr>, mpl::not_<is_member_function_pointer<MemObjPtr> > >, - actor<typename as_composite< - member_object_eval, actor<T0>, - typename as_actor<MemObjPtr>::type>::type> >::type - operator->*( - const actor<T0>& ptrActor, - MemObjPtr memObjPtr) - { - return compose<member_object_eval>( - ptrActor, - as_actor<MemObjPtr>::convert(memObjPtr)); - } - } - - namespace member_function - { - template<typename T0, typename MemFunPtr> - typename enable_if< - is_member_function_pointer<MemFunPtr>, - mem_fun_ptr_gen<actor<T0>, MemFunPtr> >::type - operator->*(const actor<T0>& ptrActor, MemFunPtr memFunPtr) - { - return mem_fun_ptr_gen<actor<T0>, MemFunPtr>( - ptrActor, memFunPtr); - } - } - - using member_object::operator->*; - using member_function::operator->*; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp deleted file mode 100644 index 294adf6..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/operator/self.hpp +++ /dev/null @@ -1,75 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_OPERATOR_SELF_HPP -#define PHOENIX_OPERATOR_SELF_HPP - -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/core/compose.hpp> -#include <boost/spirit/home/phoenix/detail/type_deduction.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/unary_compose.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_eval.hpp> -#include <boost/spirit/home/phoenix/operator/detail/binary_compose.hpp> - -namespace boost { namespace phoenix -{ - struct reference_eval; - struct dereference_eval; - struct assign_eval; - struct index_eval; - - BOOST_UNARY_RESULT_OF(&x, result_of_reference) - BOOST_UNARY_RESULT_OF(*x, result_of_dereference) - BOOST_BINARY_RESULT_OF(x = y, result_of_assign) - BOOST_ASYMMETRIC_BINARY_RESULT_OF(x[y], result_of_index) - - namespace detail - { - template <typename T0, typename T1> - struct make_assign_composite - { - typedef actor<typename as_composite<assign_eval, T0, T1>::type> type; - }; - - template <typename T0, typename T1> - struct make_index_composite - { - typedef actor<typename as_composite<index_eval, T0, T1>::type> type; - }; - } - - template <typename Base> - template <typename T1> - typename detail::make_assign_composite<actor<Base>, T1>::type - actor<Base>::operator=(T1 const& a1) const - { - return compose<assign_eval>(*this, a1); - } - - template <typename Base> - template <typename T1> - typename detail::make_index_composite<actor<Base>, T1>::type - actor<Base>::operator[](T1 const& a1) const - { - return compose<index_eval>(*this, a1); - } - -#define x a0.eval(env) -#define y a1.eval(env) - - PHOENIX_UNARY_EVAL(reference_eval, result_of_reference, &x) - PHOENIX_UNARY_EVAL(dereference_eval, result_of_dereference, *x) - PHOENIX_UNARY_COMPOSE(reference_eval, &) - PHOENIX_UNARY_COMPOSE(dereference_eval, *) - - PHOENIX_BINARY_EVAL(assign_eval, result_of_assign, x = y) - PHOENIX_BINARY_EVAL(index_eval, result_of_index, x[y]) -}} - -#undef x -#undef y -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp deleted file mode 100644 index c1b9ae3..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope.hpp +++ /dev/null @@ -1,16 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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 PHOENIX_SCOPE_HPP -#define PHOENIX_SCOPE_HPP - -#include <boost/spirit/home/phoenix/version.hpp> -#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp> -#include <boost/spirit/home/phoenix/scope/lambda.hpp> -#include <boost/spirit/home/phoenix/scope/let.hpp> -#include <boost/spirit/home/phoenix/scope/local_variable.hpp> - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp deleted file mode 100644 index 6a74df6..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_gen.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - - 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_PP_IS_ITERATING -// Allow multiple inclusion. let.hpp and lambda.hpp will have the guards - -#include <boost/preprocessor/iterate.hpp> -#include <boost/preprocessor/repetition/enum.hpp> -#include <boost/preprocessor/repetition/enum_params.hpp> - -#define PHOENIX_LOCAL_GEN_PARAM(z, n, data) \ - actor<composite<assign_eval \ - , fusion::vector<local_variable<K##n>, V##n> > > const& a##n - -#define PHOENIX_LOCAL_GEN_ACTOR(z, n, data) \ - fusion::at_c<1>(a##n) - -#define BOOST_PP_ITERATION_PARAMS_1 \ - (3, (3, PHOENIX_LOCAL_LIMIT, \ - "boost/spirit/home/phoenix/scope/detail/local_gen.hpp")) -#include BOOST_PP_ITERATE() - -#undef PHOENIX_LOCAL_GEN_PARAM -#undef PHOENIX_LOCAL_GEN_ACTOR - -/////////////////////////////////////////////////////////////////////////////// -// -// Preprocessor vertical repetition code -// -/////////////////////////////////////////////////////////////////////////////// -#else // defined(BOOST_PP_IS_ITERATING) - -#define N BOOST_PP_ITERATION() - - template < - BOOST_PP_ENUM_PARAMS(N, typename K) - , BOOST_PP_ENUM_PARAMS(N, typename V) - > - PHOENIX_LOCAL_GEN_NAME< - fusion::vector<BOOST_PP_ENUM_PARAMS(N, V)> - , detail::map_local_index_to_tuple<BOOST_PP_ENUM_PARAMS(N, K)> - > - operator()( - BOOST_PP_ENUM(N, PHOENIX_LOCAL_GEN_PARAM, _) - ) const - { - return fusion::vector<BOOST_PP_ENUM_PARAMS(N, V)>( - BOOST_PP_ENUM(N, PHOENIX_LOCAL_GEN_ACTOR, _)); - } - -#undef N -#endif // defined(BOOST_PP_IS_ITERATING) - - diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp deleted file mode 100644 index 1ad7932..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/detail/local_variable.hpp +++ /dev/null @@ -1,198 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - Copyright (c) 2004 Daniel Wallin - - 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 PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP -#define PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP - -#include <boost/mpl/int.hpp> -#include <boost/mpl/bool.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/equal_to.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/mpl/less.hpp> -#include <boost/mpl/size.hpp> -#include <boost/fusion/include/at.hpp> -#include <boost/fusion/include/value_at.hpp> -#include <boost/preprocessor/enum.hpp> -#include <boost/preprocessor/repeat.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/type_traits/is_reference.hpp> - -#define PHOENIX_MAP_LOCAL_TEMPLATE_PARAM(z, n, data) \ - typename T##n = unused<n> - -#define PHOENIX_MAP_LOCAL_DISPATCH(z, n, data) \ - typedef char(&result##n)[n+2]; \ - static result##n get(T##n*); - -namespace boost { namespace phoenix -{ - template <typename Env, typename OuterEnv, typename Locals, typename Map> - struct scoped_environment; - - namespace detail - { - template <typename Env> - struct initialize_local - { - template <class F> - struct result; - - template <class F, class Actor> - struct result<F(Actor)> - { - typedef typename remove_reference<Actor>::type actor_type; - typedef typename actor_type::template result<Env>::type type; - }; - - initialize_local(Env const& env) - : env(env) {} - - template <typename Actor> - typename result<initialize_local(Actor)>::type - operator()(Actor const& actor) const - { - return actor.eval(env); - } - - Env const& env; - - private: - // silence MSVC warning C4512: assignment operator could not be generated - initialize_local& operator= (initialize_local const&); - }; - - template <typename T> - struct is_scoped_environment : mpl::false_ {}; - - template <typename Env, typename OuterEnv, typename Locals, typename Map> - struct is_scoped_environment<scoped_environment<Env, OuterEnv, Locals, Map> > - : mpl::true_ {}; - - template <int N> - struct unused; - - template <BOOST_PP_ENUM( - PHOENIX_LOCAL_LIMIT, PHOENIX_MAP_LOCAL_TEMPLATE_PARAM, _)> - struct map_local_index_to_tuple - { - typedef char(¬_found)[1]; - static not_found get(...); - - BOOST_PP_REPEAT(PHOENIX_LOCAL_LIMIT, PHOENIX_MAP_LOCAL_DISPATCH, _) - }; - - template<typename T> - T* generate_pointer(); - - template <typename Map, typename Tag> - struct get_index - { - BOOST_STATIC_CONSTANT(int, - value = ( - static_cast<int>((sizeof(Map::get(generate_pointer<Tag>()))) / sizeof(char)) - 2 - )); - - // if value == -1, Tag is not found - typedef mpl::int_<value> type; - }; - - template <typename Local, typename Env> - struct apply_local; - - template <typename Local, typename Env> - struct outer_local - { - typedef typename - apply_local<Local, typename Env::outer_env_type>::type - type; - }; - - template <typename Locals, typename Index> - struct get_local_or_void - { - typedef typename - mpl::eval_if< - mpl::less<Index, mpl::size<Locals> > - , fusion::result_of::at<Locals, Index> - , mpl::identity<fusion::void_> - >::type - type; - }; - - template <typename Local, typename Env, typename Index> - struct get_local_from_index - { - typedef typename - mpl::eval_if< - mpl::equal_to<Index, mpl::int_<-1> > - , outer_local<Local, Env> - , get_local_or_void<typename Env::locals_type, Index> - >::type - type; - }; - - template <typename Local, typename Env> - struct get_local - { - typedef typename - get_index< - typename Env::map_type, typename Local::key_type>::type - index_type; - - typedef typename - get_local_from_index<Local, Env, index_type>::type - type; - }; - - template <typename Local, typename Env> - struct apply_local - { - // $$$ TODO: static assert that Env is a scoped_environment $$$ - typedef typename get_local<Local, Env>::type type; - }; - - template <typename Key> - struct eval_local - { - template <typename RT, typename Env, typename Index> - static RT - get(Env const& env, Index, mpl::false_) - { - return RT(fusion::at<Index>(env.locals)); - } - - template <typename RT, typename Env, typename Index> - static RT - get(Env const& env, Index index, mpl::true_) - { - typedef typename - get_index<typename Env::outer_env_type::map_type, Key>::type - index_type; - - return get<RT>( - env.outer_env - , index_type() - , mpl::equal_to<index_type, mpl::int_<-1> >()); - } - - template <typename RT, typename Env, typename Index> - static RT - get(Env const& env, Index index) - { - return get<RT>( - env - , index - , mpl::equal_to<Index, mpl::int_<-1> >()); - } - }; - } -}} - -#undef PHOENIX_MAP_LOCAL_TEMPLATE_PARAM -#undef PHOENIX_MAP_LOCAL_DISPATCH -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp deleted file mode 100644 index c4a7ce8..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/lambda.hpp +++ /dev/null @@ -1,176 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - Copyright (c) 2004 Daniel Wallin - - 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 PHOENIX_SCOPE_LAMBDA_HPP -#define PHOENIX_SCOPE_LAMBDA_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp> -#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp> -#include <boost/spirit/home/phoenix/detail/local_reference.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/fusion/include/transform.hpp> -#include <boost/fusion/include/as_vector.hpp> - -namespace boost { namespace phoenix -{ - template <typename Base, typename OuterEnv, typename Locals, typename Map> - struct lambda_eval : Base - { - template <typename Env> - struct result - { - typedef typename Base::template - result<scoped_environment<Env, OuterEnv, Locals, Map> >::type - result_type; - - typedef typename - detail::unwrap_local_reference<result_type>::type - type; - }; - - lambda_eval( - Base const& base - , OuterEnv const& outer_env - , Locals const& locals) - : Base(base) - , outer_env(outer_env) - , locals(locals) {} - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename result<Env>::type RT; - return RT(Base::eval( - scoped_environment<Env, OuterEnv, Locals, Map>( - env, outer_env, locals))); - } - - OuterEnv outer_env; - mutable Locals locals; - }; - - template <typename Base, typename Vars, typename Map> - struct lambda_actor - { - typedef typename - mpl::fold< - Vars - , mpl::false_ - , detail::compute_no_nullary - >::type - no_nullary; - - template <typename Env> - struct result - { - typedef typename - fusion::result_of::as_vector< - typename fusion::result_of::transform< - Vars - , detail::initialize_local<Env> - >::type - >::type - locals_type; - - typedef actor<lambda_eval<Base, Env, locals_type, Map> > type; - }; - - lambda_actor(Base const& f, Vars const& vars) - : f(f), vars(vars) {} - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename result<Env>::type result_type; - - return result_type( - f, env, fusion::as_vector( - fusion::transform( - vars - , detail::initialize_local<Env>(env) - ))); - } - - Base f; - Vars vars; - }; - - template <typename Vars, typename Map> - struct lambda_actor_gen - { - template <typename Base> - actor<lambda_actor<Base, Vars, Map> > const - operator[](actor<Base> const& f) const - { - return lambda_actor<Base, Vars, Map>(f, vars); - } - - lambda_actor_gen(Vars const& vars) - : vars(vars) {} - - Vars vars; - }; - - template <typename Key> - struct local_variable; // forward - struct assign_eval; // forward - - struct lambda_gen - : lambda_actor_gen< - fusion::vector<> - , detail::map_local_index_to_tuple<> > - { - typedef - lambda_actor_gen< - fusion::vector<> - , detail::map_local_index_to_tuple<> > - base_type; - - lambda_gen() - : base_type(fusion::vector<>()) - { - } - - template <typename K0, typename V0> - lambda_actor_gen< - fusion::vector<V0> - , detail::map_local_index_to_tuple<K0> - > - operator()( - actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0 - ) const - { - return fusion::vector<V0>(fusion::at_c<1>(a0)); - } - - template <typename K0, typename K1, typename V0, typename V1> - lambda_actor_gen< - fusion::vector<V0, V1> - , detail::map_local_index_to_tuple<K0, K1> - > - operator()( - actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0 - , actor<composite<assign_eval, fusion::vector<local_variable<K1>, V1> > > const& a1 - ) const - { - return fusion::vector<V0, V1>(fusion::at_c<1>(a0), fusion::at_c<1>(a1)); - } - - // Bring in the rest... - #define PHOENIX_LOCAL_GEN_NAME lambda_actor_gen - #include <boost/spirit/home/phoenix/scope/detail/local_gen.hpp> - #undef PHOENIX_LOCAL_GEN_NAME - }; - - lambda_gen const lambda = lambda_gen(); -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp deleted file mode 100644 index 40e951a..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/let.hpp +++ /dev/null @@ -1,145 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - Copyright (c) 2004 Daniel Wallin - - 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 PHOENIX_SCOPE_LET_HPP -#define PHOENIX_SCOPE_LET_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/core/composite.hpp> -#include <boost/spirit/home/phoenix/scope/scoped_environment.hpp> -#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp> -#include <boost/spirit/home/phoenix/detail/local_reference.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/fusion/include/transform.hpp> -#include <boost/fusion/include/as_vector.hpp> -#include <boost/mpl/eval_if.hpp> -#include <boost/mpl/bool.hpp> - -namespace boost { namespace phoenix -{ - template <typename Base, typename Vars, typename Map> - struct let_actor : Base - { - typedef typename - mpl::fold< - Vars - , mpl::false_ - , detail::compute_no_nullary - >::type - no_nullary; - - template <typename Env> - struct result - { - typedef typename - fusion::result_of::as_vector< - typename fusion::result_of::transform< - Vars - , detail::initialize_local<Env> - >::type - >::type - locals_type; - - typedef typename Base::template - result<scoped_environment<Env, Env, locals_type, Map> >::type - result_type; - - typedef typename - detail::unwrap_local_reference<result_type>::type - type; - }; - - let_actor(Base const& base, Vars const& vars) - : Base(base), vars(vars) {} - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename - fusion::result_of::as_vector< - typename fusion::result_of::transform< - Vars - , detail::initialize_local<Env> - >::type - >::type - locals_type; - - locals_type locals = - fusion::as_vector( - fusion::transform( - vars - , detail::initialize_local<Env>(env))); - - typedef typename result<Env>::type RT; - return RT(Base::eval( - scoped_environment<Env, Env, locals_type, Map>( - env - , env - , locals))); - } - - Vars vars; - }; - - template <typename Vars, typename Map> - struct let_actor_gen - { - template <typename Base> - actor<let_actor<Base, Vars, Map> > const - operator[](actor<Base> const& base) const - { - return let_actor<Base, Vars, Map>(base, vars); - } - - let_actor_gen(Vars const& vars) - : vars(vars) {} - - Vars vars; - }; - - template <typename Key> - struct local_variable; // forward - struct assign_eval; // forward - - struct let_gen - { - template <typename K0, typename V0> - let_actor_gen< - fusion::vector<V0> - , detail::map_local_index_to_tuple<K0> - > - operator()( - actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0 - ) const - { - return fusion::vector<V0>(fusion::at_c<1>(a0)); - } - - template <typename K0, typename K1, typename V0, typename V1> - let_actor_gen< - fusion::vector<V0, V1> - , detail::map_local_index_to_tuple<K0, K1> - > - operator()( - actor<composite<assign_eval, fusion::vector<local_variable<K0>, V0> > > const& a0 - , actor<composite<assign_eval, fusion::vector<local_variable<K1>, V1> > > const& a1 - ) const - { - return fusion::vector<V0, V1>(fusion::at_c<1>(a0), fusion::at_c<1>(a1)); - } - - // Bring in the rest... - #define PHOENIX_LOCAL_GEN_NAME let_actor_gen - #include <boost/spirit/home/phoenix/scope/detail/local_gen.hpp> - #undef PHOENIX_LOCAL_GEN_NAME - }; - - let_gen const let = let_gen(); -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp deleted file mode 100644 index 5987ed4..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/local_variable.hpp +++ /dev/null @@ -1,111 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - Copyright (c) 2004 Daniel Wallin - - 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 PHOENIX_SCOPE_LOCAL_VARIABLE_HPP -#define PHOENIX_SCOPE_LOCAL_VARIABLE_HPP - -#include <boost/spirit/home/phoenix/core/limits.hpp> -#include <boost/spirit/home/phoenix/detail/local_reference.hpp> -#include <boost/spirit/home/phoenix/scope/detail/local_variable.hpp> -#include <boost/spirit/home/phoenix/core/actor.hpp> -#include <boost/mpl/bool.hpp> - -namespace boost { namespace phoenix -{ - template <typename Key> - struct local_variable - { - typedef Key key_type; - - // This will prevent actor::operator()() from kicking in. - // Actually, we do not need all actor::operator()s for - // all arities, but this will suffice. The nullary - // actor::operator() is particularly troublesome because - // it is always eagerly evaluated by the compiler. - typedef mpl::true_ no_nullary; - - template <typename Env> - struct result : detail::apply_local<local_variable<Key>, Env> {}; - - template <typename Env> - typename result<Env>::type - eval(Env const& env) const - { - typedef typename result<Env>::type return_type; - typedef typename - detail::get_index<typename Env::map_type, Key>::type - index_type; - typedef detail::eval_local<Key> eval_local; - - return eval_local::template get<return_type>( - env - , index_type()); - } - - private: - // silence MSVC warning C4512: assignment operator could not be generated - local_variable& operator= (local_variable const&); - }; - - namespace local_names - { - actor<local_variable<struct _a_key> > const _a - = local_variable<struct _a_key>(); - actor<local_variable<struct _b_key> > const _b - = local_variable<struct _b_key>(); - actor<local_variable<struct _c_key> > const _c - = local_variable<struct _c_key>(); - actor<local_variable<struct _d_key> > const _d - = local_variable<struct _d_key>(); - actor<local_variable<struct _e_key> > const _e - = local_variable<struct _e_key>(); - actor<local_variable<struct _f_key> > const _f - = local_variable<struct _f_key>(); - actor<local_variable<struct _g_key> > const _g - = local_variable<struct _g_key>(); - actor<local_variable<struct _h_key> > const _h - = local_variable<struct _h_key>(); - actor<local_variable<struct _i_key> > const _i - = local_variable<struct _i_key>(); - actor<local_variable<struct _j_key> > const _j - = local_variable<struct _j_key>(); - actor<local_variable<struct _k_key> > const _k - = local_variable<struct _k_key>(); - actor<local_variable<struct _l_key> > const _l - = local_variable<struct _l_key>(); - actor<local_variable<struct _m_key> > const _m - = local_variable<struct _m_key>(); - actor<local_variable<struct _n_key> > const _n - = local_variable<struct _n_key>(); - actor<local_variable<struct _o_key> > const _o - = local_variable<struct _o_key>(); - actor<local_variable<struct _p_key> > const _p - = local_variable<struct _p_key>(); - actor<local_variable<struct _q_key> > const _q - = local_variable<struct _q_key>(); - actor<local_variable<struct _r_key> > const _r - = local_variable<struct _r_key>(); - actor<local_variable<struct _s_key> > const _s - = local_variable<struct _s_key>(); - actor<local_variable<struct _t_key> > const _t - = local_variable<struct _t_key>(); - actor<local_variable<struct _u_key> > const _u - = local_variable<struct _u_key>(); - actor<local_variable<struct _v_key> > const _v - = local_variable<struct _v_key>(); - actor<local_variable<struct _w_key> > const _w - = local_variable<struct _w_key>(); - actor<local_variable<struct _x_key> > const _x - = local_variable<struct _x_key>(); - actor<local_variable<struct _y_key> > const _y - = local_variable<struct _y_key>(); - actor<local_variable<struct _z_key> > const _z - = local_variable<struct _z_key>(); - } -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp deleted file mode 100644 index b23f9ee..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/scope/scoped_environment.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 Joel de Guzman - Copyright (c) 2004 Daniel Wallin - - 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 PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP -#define PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP - -namespace boost { namespace phoenix -{ - template <typename Env, typename OuterEnv, typename Locals, typename Map> - struct scoped_environment - { - typedef Env env_type; - typedef OuterEnv outer_env_type; - typedef Locals locals_type; - typedef Map map_type; - typedef typename Env::args_type args_type; - typedef typename Env::tie_type tie_type; - - scoped_environment( - Env const& env - , OuterEnv const& outer_env - , Locals& locals) - : env(env) - , outer_env(outer_env) - , locals(locals) {} - - tie_type const& - args() const - { - return env.args(); - } - - Env const& env; - OuterEnv const& outer_env; - Locals& locals; - - private: - // silence MSVC warning C4512: assignment operator could not be generated - scoped_environment& operator= (scoped_environment const&); - }; -}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp deleted file mode 100644 index c29baf8..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/version.hpp +++ /dev/null @@ -1,18 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2008 Hartmut Kaiser - Copyright (c) 2005-2007 Joel de Guzman - - 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 PHOENIX_VERSION_HPP -#define PHOENIX_VERSION_HPP - -/////////////////////////////////////////////////////////////////////////////// -// -// This is the version of the library -// -/////////////////////////////////////////////////////////////////////////////// -#define BOOST_PHOENIX_VERSION 0x2000 // 2.0.0 - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp index c1405d6..b8a51f3 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp @@ -11,14 +11,15 @@ #endif #include <boost/spirit/home/support/unused.hpp> +#include <boost/mpl/bool.hpp> namespace boost { namespace spirit { namespace qi { namespace detail { template <typename Skipper> struct unused_skipper : unused_type { - unused_skipper(Skipper const& skipper) - : skipper(skipper) {} + unused_skipper(Skipper const& skipper_) + : skipper(skipper_) {} Skipper const& skipper; private: @@ -26,12 +27,24 @@ namespace boost { namespace spirit { namespace qi { namespace detail unused_skipper& operator= (unused_skipper const&); }; + template <typename Skipper> + struct is_unused_skipper + : mpl::false_ {}; + + template <typename Skipper> + struct is_unused_skipper<unused_skipper<Skipper> > + : mpl::true_ {}; + + template <> + struct is_unused_skipper<unused_type> + : mpl::true_ {}; + // If a surrounding lexeme[] directive was specified, the current - // skipper is of the type unused_skipper. In this case we + // skipper is of the type unused_skipper. In this case we // re-activate the skipper which was active before the skip[] // directive. template <typename Skipper> - inline Skipper const& + inline Skipper const& get_skipper(unused_skipper<Skipper> const& u) { return u.skipper; @@ -39,7 +52,7 @@ namespace boost { namespace spirit { namespace qi { namespace detail // If no surrounding lexeme[] directive was specified we keep what we got. template <typename Skipper> - inline Skipper const& + inline Skipper const& get_skipper(Skipper const& u) { return u; diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp index 0300a06..825fa40 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp @@ -27,8 +27,8 @@ namespace boost { namespace spirit { namespace qi struct parameterized_nonterminal : parser<parameterized_nonterminal<Subject, Params> > { - parameterized_nonterminal(Subject const& subject, Params const& params) - : ref(subject), params(params) + parameterized_nonterminal(Subject const& subject, Params const& params_) + : ref(subject), params(params_) { } @@ -41,11 +41,11 @@ namespace boost { namespace spirit { namespace qi , typename Skipper, typename Attribute> bool parse(Iterator& first, Iterator const& last , Context& context, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_) const { // Forward to subject, passing the additional // params argument to parse. - return ref.get().parse(first, last, context, skipper, attr, params); + return ref.get().parse(first, last, context, skipper, attr_, params); } template <typename Context> diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp index 91bceba..87d8e84 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp @@ -21,8 +21,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template <typename Parser, typename Auto> struct parser_binder { - parser_binder(Parser const& p) - : p(p) {} + parser_binder(Parser const& p_) + : p(p_) {} template <typename Iterator, typename Skipper, typename Context> bool call(Iterator& first, Iterator const& last @@ -60,8 +60,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template <typename Parser> struct parser_binder<Parser, mpl::true_> { - parser_binder(Parser const& p) - : p(p) {} + parser_binder(Parser const& p_) + : p(p_) {} template <typename Iterator, typename Skipper, typename Context> bool operator()( diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp index 982e49b..d41590c 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/grammar.hpp @@ -56,9 +56,9 @@ namespace boost { namespace spirit { namespace qi grammar( start_type const& start - , std::string const& name_ = "unnamed-grammar") + , std::string const& name = "unnamed-grammar") : proto::extends<terminal, base_type>(terminal::make(reference_(start))) - , name_(name_) + , name_(name) {} // This constructor is used to catch if the start rule is not @@ -90,10 +90,10 @@ namespace boost { namespace spirit { namespace qi template <typename Context, typename Skipper, typename Attribute> bool parse(Iterator& first, Iterator const& last , Context& context, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_) const { return this->proto_base().child0.parse( - first, last, context, skipper, attr); + first, last, context, skipper, attr_); } template <typename Context> diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp index 23d2559..8dd4237 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/nonterminal/rule.hpp @@ -41,6 +41,7 @@ #if defined(BOOST_MSVC) # pragma warning(push) # pragma warning(disable: 4355) // 'this' : used in base member initializer list warning +# pragma warning(disable: 4127) // conditional expression is constant #endif namespace boost { namespace spirit { namespace qi @@ -154,9 +155,9 @@ namespace boost { namespace spirit { namespace qi >::type encoding_modifier_type; - explicit rule(std::string const& name_ = "unnamed-rule") + explicit rule(std::string const& name = "unnamed-rule") : base_type(terminal::make(reference_(*this))) - , name_(name_) + , name_(name) { } @@ -168,7 +169,7 @@ namespace boost { namespace spirit { namespace qi } template <typename Auto, typename Expr> - static void define(rule& lhs, Expr const& expr, mpl::false_) + static void define(rule& /*lhs*/, Expr const& /*expr*/, mpl::false_) { // Report invalid expression error as early as possible. // If you got an error_invalid_expression error message here, @@ -184,9 +185,9 @@ namespace boost { namespace spirit { namespace qi } template <typename Expr> - rule(Expr const& expr, std::string const& name_ = "unnamed-rule") + rule(Expr const& expr, std::string const& name = "unnamed-rule") : base_type(terminal::make(reference_(*this))) - , name_(name_) + , name_(name) { define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>()); } @@ -231,7 +232,7 @@ namespace boost { namespace spirit { namespace qi return r; } -#if defined(BOOST_NO_RVALUE_REFERENCES) +#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) // non-const version needed to suppress proto's %= kicking in template <typename Expr> friend rule& operator%=(rule& r, Expr& expr) @@ -272,7 +273,7 @@ namespace boost { namespace spirit { namespace qi template <typename Context, typename Skipper, typename Attribute> bool parse(Iterator& first, Iterator const& last , Context& /*context*/, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_param) const { if (f) { @@ -288,7 +289,7 @@ namespace boost { namespace spirit { namespace qi typename make_attribute::type, attr_type, domain> transform; - typename make_attribute::type made_attr = make_attribute::call(attr); + typename make_attribute::type made_attr = make_attribute::call(attr_param); typename transform::type attr_ = transform::pre(made_attr); // If you are seeing a compilation error here, you are probably @@ -304,12 +305,12 @@ namespace boost { namespace spirit { namespace qi { // do up-stream transformation, this integrates the results // back into the original attribute value, if appropriate - traits::post_transform(attr, attr_); + traits::post_transform(attr_param, attr_); return true; } // inform attribute transformation of failed rhs - traits::fail_transform(attr, attr_); + traits::fail_transform(attr_param, attr_); } return false; } @@ -318,7 +319,7 @@ namespace boost { namespace spirit { namespace qi , typename Attribute, typename Params> bool parse(Iterator& first, Iterator const& last , Context& caller_context, Skipper const& skipper - , Attribute& attr, Params const& params) const + , Attribute& attr_param, Params const& params) const { if (f) { @@ -334,7 +335,7 @@ namespace boost { namespace spirit { namespace qi typename make_attribute::type, attr_type, domain> transform; - typename make_attribute::type made_attr = make_attribute::call(attr); + typename make_attribute::type made_attr = make_attribute::call(attr_param); typename transform::type attr_ = transform::pre(made_attr); // If you are seeing a compilation error here, you are probably @@ -350,12 +351,12 @@ namespace boost { namespace spirit { namespace qi { // do up-stream transformation, this integrates the results // back into the original attribute value, if appropriate - traits::post_transform(attr, attr_); + traits::post_transform(attr_param, attr_); return true; } // inform attribute transformation of failed rhs - traits::fail_transform(attr, attr_); + traits::fail_transform(attr_param, attr_); } return false; } diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp index f6fcabc..f1f5c67 100644 --- a/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/qi/reference.hpp @@ -38,9 +38,9 @@ namespace boost { namespace spirit { namespace qi , typename Skipper, typename Attribute> bool parse(Iterator& first, Iterator const& last , Context& context, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_) const { - return ref.get().parse(first, last, context, skipper, attr); + return ref.get().parse(first, last, context, skipper, attr_); } template <typename Context> diff --git a/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp b/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp index db36072..f1433da 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/assert_msg.hpp @@ -1,4 +1,4 @@ -// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2013 Hartmut Kaiser // // 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) @@ -10,12 +10,21 @@ #pragma once #endif -// Allow to work around the MPL problem in BOOST_MPL_ASSERT_MSG generating -// multiple definition linker errors for certain compilers (VC++) -#if BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG != 0 +#include <boost/config.hpp> + +// Work around the MPL problem in BOOST_MPL_ASSERT_MSG generating +// multiple definition linker errors for certain compilers (VC++ 8). +// BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG can also be defined by user. +#if !defined(BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG) +# if defined(BOOST_MSVC) && BOOST_MSVC < 1500 +# define BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG 1 +# endif +#endif + +#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || BOOST_SPIRIT_DONT_USE_MPL_ASSERT_MSG != 0 #include <boost/static_assert.hpp> #define BOOST_SPIRIT_ASSERT_MSG(Cond, Msg, Types) \ - BOOST_STATIC_ASSERT(Cond) + BOOST_STATIC_ASSERT_MSG(Cond, # Msg) #else #include <boost/mpl/assert.hpp> #define BOOST_SPIRIT_ASSERT_MSG(Cond, Msg, Types) \ @@ -24,8 +33,22 @@ #define BOOST_SPIRIT_ASSERT_MATCH(Domain, Expr) \ BOOST_SPIRIT_ASSERT_MSG(( \ - boost::spirit::traits::matches<Domain, Expr>::value \ + boost::spirit::traits::matches< Domain, Expr >::value \ ), error_invalid_expression, (Expr)) +// GCC 4.7 will overeagerly instantiate static_asserts in template functions, +// if the assert condition does not depend on template parameters +// (see https://svn.boost.org/trac/boost/ticket/8381). +// There are places where we want to use constant false as the condition in +// template functions to indicate that these function overloads should never +// be called. This allows to generate better error messages. To solve this +// problem we make the condition dependent on the template argument and use +// the following macro in such places. +#include <boost/type_traits/is_same.hpp> + +#define BOOST_SPIRIT_ASSERT_FAIL(TemplateParam, Msg, Types) \ + BOOST_SPIRIT_ASSERT_MSG((!boost::is_same< \ + TemplateParam, TemplateParam >::value), Msg, Types) + #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp b/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp index 48bff06..163f11c 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/attributes.hpp @@ -1,6 +1,6 @@ /*============================================================================= Copyright (c) 2001-2011 Joel de Guzman - Copyright (c) 2001-2011 Hartmut Kaiser + Copyright (c) 2001-2012 Hartmut Kaiser 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) @@ -202,6 +202,19 @@ namespace boost { namespace spirit { namespace traits struct is_weak_substitute<T, optional<Expected> > : is_weak_substitute<T, Expected> {}; +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) + template <typename T, typename Expected> + struct is_weak_substitute<boost::variant<T>, Expected> + : is_weak_substitute<T, Expected> + {}; + + template <typename T0, typename T1, typename ...TN, typename Expected> + struct is_weak_substitute<boost::variant<T0, T1, TN...>, + Expected> + : mpl::bool_<is_weak_substitute<T0, Expected>::type::value && + is_weak_substitute<boost::variant<T1, TN...>, Expected>::type::value> + {}; +#else #define BOOST_SPIRIT_IS_WEAK_SUBSTITUTE(z, N, _) \ is_weak_substitute<BOOST_PP_CAT(T, N), Expected>::type::value && \ /***/ @@ -220,6 +233,7 @@ namespace boost { namespace spirit { namespace traits {}; #undef BOOST_SPIRIT_IS_WEAK_SUBSTITUTE +#endif template <typename T> struct is_weak_substitute<T, T @@ -516,7 +530,30 @@ namespace boost { namespace spirit { namespace traits { if (!val) return 0; - return val.get(); + return traits::size(val.get()); + } + }; + + namespace detail + { + struct attribute_size_visitor : static_visitor<std::size_t> + { + template <typename T> + std::size_t operator()(T const& val) const + { + return spirit::traits::size(val); + } + }; + } + + template <BOOST_VARIANT_ENUM_PARAMS(typename T)> + struct attribute_size<variant<BOOST_VARIANT_ENUM_PARAMS(T)> > + { + typedef std::size_t type; + + static type call(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& val) + { + return apply_visitor(detail::attribute_size_visitor(), val); } }; @@ -748,7 +785,7 @@ namespace boost { namespace spirit { namespace traits }; // never called, but needed for decltype-based result_of (C++0x) -#ifndef BOOST_NO_RVALUE_REFERENCES +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template <typename Element> typename result<element_attribute(Element)>::type operator()(Element&&) const; @@ -1158,8 +1195,8 @@ namespace boost { namespace spirit { namespace traits template <typename Out> struct print_fusion_sequence { - print_fusion_sequence(Out& out) - : out(out), is_first(true) {} + print_fusion_sequence(Out& out_) + : out(out_), is_first(true) {} typedef void result_type; @@ -1181,7 +1218,7 @@ namespace boost { namespace spirit { namespace traits template <typename Out> struct print_visitor : static_visitor<> { - print_visitor(Out& out) : out(out) {} + print_visitor(Out& out_) : out(out_) {} template <typename T> void operator()(T const& val) const diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp index 9b8a72f..8bd6c11 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/ascii.hpp @@ -188,7 +188,7 @@ namespace boost { namespace spirit { namespace char_encoding return isascii_(ch); } - static int + static bool isalnum(int ch) { BOOST_ASSERT(isascii_(ch)); @@ -196,78 +196,78 @@ namespace boost { namespace spirit { namespace char_encoding || (ascii_char_types[ch] & BOOST_CC_DIGIT); } - static int + static bool isalpha(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_ALPHA); + return (ascii_char_types[ch] & BOOST_CC_ALPHA) ? true : false; } - static int + static bool isdigit(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_DIGIT); + return (ascii_char_types[ch] & BOOST_CC_DIGIT) ? true : false; } - static int + static bool isxdigit(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_XDIGIT); + return (ascii_char_types[ch] & BOOST_CC_XDIGIT) ? true : false; } - static int + static bool iscntrl(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_CTRL); + return (ascii_char_types[ch] & BOOST_CC_CTRL) ? true : false; } - static int + static bool isgraph(int ch) { return ('\x21' <= ch && ch <= '\x7e'); } - static int + static bool islower(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_LOWER); + return (ascii_char_types[ch] & BOOST_CC_LOWER) ? true : false; } - static int + static bool isprint(int ch) { return ('\x20' <= ch && ch <= '\x7e'); } - static int + static bool ispunct(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_PUNCT); + return (ascii_char_types[ch] & BOOST_CC_PUNCT) ? true : false; } - static int + static bool isspace(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_SPACE); + return (ascii_char_types[ch] & BOOST_CC_SPACE) ? true : false; } - static int + static bool isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch) { return ('\x09' == ch || '\x20' == ch); } - static int + static bool isupper(int ch) { BOOST_ASSERT(isascii_(ch)); - return (ascii_char_types[ch] & BOOST_CC_UPPER); + return (ascii_char_types[ch] & BOOST_CC_UPPER) ? true : false; } /////////////////////////////////////////////////////////////////////// diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp index 37d2e6f..b2b5dd1 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/iso8859_1.hpp @@ -584,7 +584,7 @@ namespace boost { namespace spirit { namespace char_encoding return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false; } - static int + static bool isalnum(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); @@ -592,78 +592,78 @@ namespace boost { namespace spirit { namespace char_encoding || (iso8859_1_char_types[ch] & BOOST_CC_DIGIT); } - static int + static bool isalpha(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_ALPHA); + return (iso8859_1_char_types[ch] & BOOST_CC_ALPHA) ? true : false; } - static int + static bool isdigit(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_DIGIT); + return (iso8859_1_char_types[ch] & BOOST_CC_DIGIT) ? true : false; } - static int + static bool isxdigit(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_XDIGIT); + return (iso8859_1_char_types[ch] & BOOST_CC_XDIGIT) ? true : false; } - static int + static bool iscntrl(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_CTRL); + return (iso8859_1_char_types[ch] & BOOST_CC_CTRL) ? true : false; } - static int + static bool isgraph(int ch) { return ('\x21' <= ch && ch <= '\x7e') || ('\xa1' <= ch && ch <= '\xff'); } - static int + static bool islower(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_LOWER); + return (iso8859_1_char_types[ch] & BOOST_CC_LOWER) ? true : false; } - static int + static bool isprint(int ch) { return ('\x20' <= ch && ch <= '\x7e') || ('\xa0' <= ch && ch <= '\xff'); } - static int + static bool ispunct(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_PUNCT); + return (iso8859_1_char_types[ch] & BOOST_CC_PUNCT) ? true : false; } - static int + static bool isspace(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_SPACE); + return (iso8859_1_char_types[ch] & BOOST_CC_SPACE) ? true : false; } - static int + static bool isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch) { return ('\x09' == ch || '\x20' == ch || '\xa0' == ch); } - static int + static bool isupper(int ch) { BOOST_ASSERT(0 == (ch & ~UCHAR_MAX)); - return (iso8859_1_char_types[ch] & BOOST_CC_UPPER); + return (iso8859_1_char_types[ch] & BOOST_CC_UPPER) ? true : false; } /////////////////////////////////////////////////////////////////////////// diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp index c32a9e7..fb307ce 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard.hpp @@ -38,81 +38,82 @@ namespace boost { namespace spirit { namespace char_encoding return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false; } - static int + static bool isalnum(int ch) { - return std::isalnum(ch); + return std::isalnum(ch) ? true : false; } - static int + static bool isalpha(int ch) { - return std::isalpha(ch); + return std::isalpha(ch) ? true : false; } - static int + static bool isdigit(int ch) { - return std::isdigit(ch); + return std::isdigit(ch) ? true : false; } - static int + static bool isxdigit(int ch) { - return std::isxdigit(ch); + return std::isxdigit(ch) ? true : false; } - static int + static bool iscntrl(int ch) { - return std::iscntrl(ch); + return std::iscntrl(ch) ? true : false; } - static int + static bool isgraph(int ch) { - return std::isgraph(ch); + return std::isgraph(ch) ? true : false; } - static int + static bool islower(int ch) { - return std::islower(ch); + return std::islower(ch) ? true : false; } - static int + static bool isprint(int ch) { - return std::isprint(ch); + return std::isprint(ch) ? true : false; } - static int + static bool ispunct(int ch) { - return std::ispunct(ch); + return std::ispunct(ch) ? true : false; } - static int + static bool isspace(int ch) { - return std::isspace(ch); + return std::isspace(ch) ? true : false; } - static int + static bool isblank BOOST_PREVENT_MACRO_SUBSTITUTION (int ch) { return (ch == ' ' || ch == '\t'); } - static int + static bool isupper(int ch) { - return std::isupper(ch); + return std::isupper(ch) ? true : false; } /////////////////////////////////////////////////////////////////////////////// // Simple character conversions /////////////////////////////////////////////////////////////////////////////// + static int tolower(int ch) { diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp index 99c918c..515a388 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/standard_wide.hpp @@ -154,6 +154,10 @@ namespace boost { namespace spirit { namespace char_encoding return (ch == L' ' || ch == L'\t'); } + /////////////////////////////////////////////////////////////////////// + // Simple character conversions + /////////////////////////////////////////////////////////////////////// + static wchar_t tolower(wchar_t ch) { diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp index 9febf7e..b5ec3e6 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode.hpp @@ -100,7 +100,7 @@ namespace boost { namespace spirit { namespace char_encoding return ucd::is_white_space(ch); } - static int + static bool isblank BOOST_PREVENT_MACRO_SUBSTITUTION (char_type ch) { return ucd::is_blank(ch); diff --git a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp index 3a0526c..370ab67 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/char_encoding/unicode/query.hpp @@ -284,7 +284,7 @@ namespace boost { namespace spirit { namespace ucd inline properties::script get_script(::boost::uint32_t ch) { - return static_cast<properties::script>(detail::script_lookup(ch) & 0x3F); + return static_cast<properties::script>(detail::script_lookup(ch) & 0x7F); } inline ::boost::uint32_t to_lowercase(::boost::uint32_t ch) diff --git a/3rdParty/Boost/src/boost/spirit/home/support/container.hpp b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp index 7f491aa..5e154cd 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/container.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp @@ -59,6 +59,19 @@ namespace boost { namespace spirit { namespace traits : is_container<T> {}; +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) + template<typename T> + struct is_container<boost::variant<T> > + : is_container<T> + {}; + + template<typename T0, typename T1, typename ...TN> + struct is_container<boost::variant<T0, T1, TN...> > + : mpl::bool_<is_container<T0>::value || + is_container<boost::variant<T1, TN...> >::value> + {}; + +#else #define BOOST_SPIRIT_IS_CONTAINER(z, N, data) \ is_container<BOOST_PP_CAT(T, N)>::value || \ /***/ @@ -76,6 +89,7 @@ namespace boost { namespace spirit { namespace traits {}; #undef BOOST_SPIRIT_IS_CONTAINER +#endif template <typename T, typename Enable/* = void*/> struct is_iterator_range @@ -238,7 +252,7 @@ namespace boost { namespace spirit { namespace traits static bool is_valid(boost::optional<T> const& val) { - return val; + return !!val; } }; diff --git a/3rdParty/Boost/src/boost/spirit/home/support/context.hpp b/3rdParty/Boost/src/boost/spirit/home/support/context.hpp index b728b4f..ada873a 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/context.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/context.hpp @@ -98,7 +98,7 @@ namespace boost { namespace spirit typedef Locals locals_type; context(typename Attributes::car_type attribute) - : attributes(attribute, fusion::nil()), locals() {} + : attributes(attribute, fusion::nil_()), locals() {} template <typename Args, typename Context> context( @@ -116,8 +116,8 @@ namespace boost { namespace spirit ) , locals() {} - context(Attributes const& attributes) - : attributes(attributes), locals() {} + context(Attributes const& attributes_) + : attributes(attributes_), locals() {} Attributes attributes; // The attributes Locals locals; // Local variables diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp index e2fe18d..9312042 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/as_variant.hpp @@ -23,6 +23,7 @@ #include <boost/mpl/push_back.hpp> #include <boost/mpl/equal_to.hpp> #include <boost/mpl/contains.hpp> +#include <boost/mpl/limits/list.hpp> #include <boost/type_traits/is_same.hpp> namespace boost { namespace spirit { namespace detail @@ -30,6 +31,8 @@ namespace boost { namespace spirit { namespace detail template <int size> struct as_variant_impl; +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) +#else template <> struct as_variant_impl<0> { @@ -39,6 +42,7 @@ namespace boost { namespace spirit { namespace detail typedef variant<> type; }; }; +#endif #define BOOST_FUSION_NEXT_ITERATOR(z, n, data) \ typedef typename fusion::result_of::next<BOOST_PP_CAT(I, n)>::type \ @@ -53,7 +57,13 @@ namespace boost { namespace spirit { namespace detail BOOST_PP_CAT(T, n); #define BOOST_PP_FILENAME_1 <boost/spirit/home/support/detail/as_variant.hpp> + +#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) +#define BOOST_PP_ITERATION_LIMITS (1, BOOST_MPL_LIMIT_LIST_SIZE) +#else #define BOOST_PP_ITERATION_LIMITS (1, BOOST_VARIANT_LIMIT_TYPES) +#endif + #include BOOST_PP_ITERATE() #undef BOOST_FUSION_NEXT_ITERATOR diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp index 4332fa2..f9a3ff1 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/hold_any.hpp @@ -98,7 +98,6 @@ namespace boost { namespace spirit } static void move(void* const* src, void** dest) { - reinterpret_cast<T*>(dest)->~T(); *reinterpret_cast<T*>(dest) = *reinterpret_cast<T const*>(src); } @@ -144,7 +143,6 @@ namespace boost { namespace spirit } static void move(void* const* src, void** dest) { - (*reinterpret_cast<T**>(dest))->~T(); **reinterpret_cast<T**>(dest) = **reinterpret_cast<T* const*>(src); } @@ -300,11 +298,25 @@ namespace boost { namespace spirit } // assignment operator +#ifdef BOOST_HAS_RVALUE_REFS + template <typename T> + basic_hold_any& operator=(T&& x) + { + return assign(std::forward<T>(x)); + } +#else + template <typename T> + basic_hold_any& operator=(T& x) + { + return assign(x); + } + template <typename T> basic_hold_any& operator=(T const& x) { return assign(x); } +#endif // utility functions basic_hold_any& swap(basic_hold_any& x) @@ -405,15 +417,6 @@ namespace boost { namespace spirit { typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type nonref; -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - // If 'nonref' is still reference type, it means the user has not - // specialized 'remove_reference'. - - // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro - // to generate specialization of remove_reference for your class - // See type traits library documentation for details - BOOST_STATIC_ASSERT(!is_reference<nonref>::value); -#endif nonref* result = any_cast<nonref>(&operand); if(!result) @@ -426,11 +429,6 @@ namespace boost { namespace spirit { typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type nonref; -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - // The comment in the above version of 'any_cast' explains when this - // assert is fired and what to do. - BOOST_STATIC_ASSERT(!is_reference<nonref>::value); -#endif return any_cast<nonref const&>(const_cast<basic_hold_any<Char> &>(operand)); } diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp index 73269e2..e8f9f6d 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/is_spirit_tag.hpp @@ -11,10 +11,6 @@ #pragma once #endif -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 -#define BOOST_SPIRIT_IS_TAG() -#else #define BOOST_SPIRIT_IS_TAG() typedef void is_spirit_tag; -#endif #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp index 23cda87..36ee1bb 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/debug.hpp @@ -31,11 +31,7 @@ public: const CharT *ptr_ = in_.c_str (); std::size_t size_ = in_.size (); -#if defined _MSC_VER && _MSC_VER <= 1200 - out_.erase (); -#else out_.clear (); -#endif while (size_) { diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp index 49bea2f..daa06e7 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/generator.hpp @@ -12,6 +12,7 @@ #include "partition/charset.hpp" #include "partition/equivset.hpp" #include <memory> +#include <limits> #include "parser/tree/node.hpp" #include "parser/parser.hpp" #include "containers/ptr_list.hpp" @@ -185,10 +186,10 @@ protected: while (regex_iter_ != regex_iter_end_) { // re-declare var, otherwise we perform an assignment..! - const typename rules::string ®ex_ = *regex_iter_; + const typename rules::string ®ex2_ = *regex_iter_; - root_ = parser::parse (regex_.c_str (), - regex_.c_str () + regex_.size (), *ids_iter_, + root_ = parser::parse (regex2_.c_str (), + regex2_.c_str () + regex2_.size (), *ids_iter_, *unique_ids_iter_, *states_iter_, rules_.flags (), rules_.locale (), node_ptr_vector_, macromap_, token_map_, internals_._seen_BOL_assertion, @@ -336,16 +337,16 @@ protected: equiv_end_ = equivset_->_index_vector.end (); equiv_iter_ != equiv_end_; ++equiv_iter_) { - const std::size_t index_ = *equiv_iter_; + const std::size_t equiv_index_ = *equiv_iter_; - if (index_ == bol_token) + if (equiv_index_ == bol_token) { if (ptr_[eol_index] == 0) { ptr_[bol_index] = transition_; } } - else if (index_ == eol_token) + else if (equiv_index_ == eol_token) { if (ptr_[bol_index] == 0) { @@ -354,7 +355,7 @@ protected: } else { - ptr_[index_ + dfa_offset] = transition_; + ptr_[equiv_index_ + dfa_offset] = transition_; } } } @@ -560,7 +561,12 @@ protected: if (token_._negated) { - CharT curr_char_ = sizeof (CharT) == 1 ? -128 : 0; + // $$$ FIXME JDG July 2014 $$$ + // this code is problematic on platforms where wchar_t is signed + // with min generating negative numbers. This crashes with BAD_ACCESS + // because of the vector index below: + // ptr_[static_cast<typename Traits::index_type>(curr_char_)] + CharT curr_char_ = 0; // (std::numeric_limits<CharT>::min)(); std::size_t i_ = 0; while (curr_ < chars_end_) diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp index 349aa6d..449ff4d 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/size_t.hpp @@ -8,14 +8,6 @@ #include <stddef.h> // ptrdiff_t -#if defined _MSC_VER && _MSC_VER <= 1200 -namespace std -{ - using ::ptrdiff_t; - using ::size_t; -} -#else #include <string> -#endif #endif diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp index e09e991..46e50c9 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/state_machine.hpp @@ -29,11 +29,7 @@ public: class iterator { public: -#if defined _MSC_VER && _MSC_VER <= 1200 - friend basic_state_machine; -#else friend class basic_state_machine; -#endif struct data { @@ -225,11 +221,7 @@ public: } }; -#if defined _MSC_VER && _MSC_VER <= 1200 - friend iterator; -#else friend class iterator; -#endif basic_state_machine () { @@ -365,7 +357,7 @@ private: { const std::size_t col_ = lu_->at (alpha_index_); - if (col_ != dead_state_index) + if (col_ != static_cast<std::size_t>(dead_state_index)) { chars_[col_ - dfa_offset] += static_cast<CharT> (alpha_index_); diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp index 6bfa6ff..dd58c98 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/lexer/string_token.hpp @@ -10,6 +10,7 @@ #include "size_t.hpp" #include "consts.hpp" // num_chars, num_wchar_ts #include <string> +#include <limits> namespace boost { @@ -55,11 +56,7 @@ struct basic_string_token if (_charset.length () == max_chars_) { _negated = !_negated; -#if defined _MSC_VER && _MSC_VER <= 1200 - _charset.erase (); -#else _charset.clear (); -#endif } else if (_charset.length () > max_chars_ / 2) { @@ -71,7 +68,7 @@ struct basic_string_token { const std::size_t max_chars_ = sizeof (CharT) == 1 ? num_chars : num_wchar_ts; - CharT curr_char_ = sizeof (CharT) == 1 ? -128 : 0; + CharT curr_char_ = (std::numeric_limits<CharT>::min)(); string temp_; const CharT *curr_ = _charset.c_str (); const CharT *chars_end_ = curr_ + _charset.size (); @@ -126,11 +123,7 @@ struct basic_string_token void clear () { _negated = false; -#if defined _MSC_VER && _MSC_VER <= 1200 - _charset.erase (); -#else - _charset.clear (); -#endif + _charset.clear (); } void intersect (basic_string_token &rhs_, basic_string_token &overlap_) diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp index cbbb73b..0d6b0ae 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/make_cons.hpp @@ -42,11 +42,10 @@ namespace boost { namespace spirit { namespace detail namespace result_of { - template <typename Car, typename Cdr = fusion::nil> + template <typename Car, typename Cdr = fusion::nil_> struct make_cons { - typedef typename as_meta_element<Car>::type car_type; - typedef typename fusion::cons<car_type, Cdr> type; + typedef typename as_meta_element<Car>::type car_type; typedef typename fusion::cons<car_type, Cdr> type; }; } diff --git a/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp b/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp index 70979a6..1b35043 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/detail/scoped_enum_emulation.hpp @@ -17,8 +17,8 @@ #if BOOST_VERSION >= 104000 # include <boost/detail/scoped_enum_emulation.hpp> #else -# if !defined(BOOST_NO_SCOPED_ENUMS) -# define BOOST_NO_SCOPED_ENUMS +# if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) +# define BOOST_NO_CXX11_SCOPED_ENUMS # endif # define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type # define BOOST_SCOPED_ENUM_END }; diff --git a/3rdParty/Boost/src/boost/spirit/home/support/info.hpp b/3rdParty/Boost/src/boost/spirit/home/support/info.hpp index ff523ab..9b991ac 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/info.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/info.hpp @@ -28,11 +28,11 @@ namespace boost { namespace spirit // for uniformity. struct info { - struct nil {}; + struct nil_ {}; typedef boost::variant< - nil + nil_ , utf8_string , recursive_wrapper<info> , recursive_wrapper<std::pair<info, info> > @@ -40,30 +40,30 @@ namespace boost { namespace spirit > value_type; - explicit info(utf8_string const& tag) - : tag(tag), value(nil()) {} + explicit info(utf8_string const& tag_) + : tag(tag_), value(nil_()) {} template <typename T> - info(utf8_string const& tag, T const& value) - : tag(tag), value(value) {} + info(utf8_string const& tag_, T const& value_) + : tag(tag_), value(value_) {} - info(utf8_string const& tag, char value) - : tag(tag), value(utf8_string(1, value)) {} + info(utf8_string const& tag_, char value_) + : tag(tag_), value(utf8_string(1, value_)) {} - info(utf8_string const& tag, wchar_t value) - : tag(tag), value(to_utf8(value)) {} + info(utf8_string const& tag_, wchar_t value_) + : tag(tag_), value(to_utf8(value_)) {} - info(utf8_string const& tag, ucs4_char value) - : tag(tag), value(to_utf8(value)) {} + info(utf8_string const& tag_, ucs4_char value_) + : tag(tag_), value(to_utf8(value_)) {} template <typename Char> - info(utf8_string const& tag, Char const* str) - : tag(tag), value(to_utf8(str)) {} + info(utf8_string const& tag_, Char const* str) + : tag(tag_), value(to_utf8(str)) {} template <typename Char, typename Traits, typename Allocator> - info(utf8_string const& tag + info(utf8_string const& tag_ , std::basic_string<Char, Traits, Allocator> const& str) - : tag(tag), value(to_utf8(str)) {} + : tag(tag_), value(to_utf8(str)) {} utf8_string tag; value_type value; @@ -75,10 +75,10 @@ namespace boost { namespace spirit typedef void result_type; typedef basic_info_walker<Callback> this_type; - basic_info_walker(Callback& callback, utf8_string const& tag, int depth) - : callback(callback), tag(tag), depth(depth) {} + basic_info_walker(Callback& callback_, utf8_string const& tag_, int depth_) + : callback(callback_), tag(tag_), depth(depth_) {} - void operator()(info::nil) const + void operator()(info::nil_) const { callback.element(tag, "", depth); } @@ -128,8 +128,8 @@ namespace boost { namespace spirit { typedef utf8_string string; - simple_printer(Out& out) - : out(out) {} + simple_printer(Out& out_) + : out(out_) {} void element(string const& tag, string const& value, int /*depth*/) const { diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp index cfac882..06946b8 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/combine_policies.hpp @@ -21,43 +21,6 @@ namespace boost { namespace spirit { namespace iterator_policies // single multi_pass_policy as required by the multi_pass template /////////////////////////////////////////////////////////////////////////// -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - // without partial template specialization there is nothing much to do in - // terms of empty base optimization anyways... - template <typename T, typename Ownership, typename Checking, - typename Input, typename Storage> - struct multi_pass_unique - : Ownership, Checking, Input, Storage - { - multi_pass_unique() {} - multi_pass_unique(T& x) : Input(x) {} - multi_pass_unique(T const& x) : Input(x) {} - - template <typename MultiPass> - static void destroy(MultiPass& mp) - { - Ownership::destroy(mp); - Checking::destroy(mp); - Input::destroy(mp); - Storage::destroy(mp); - } - - void swap(multi_pass_unique& x) - { - this->Ownership::swap(x); - this->Checking::swap(x); - this->Input::swap(x); - this->Storage::swap(x); - } - - template <typename MultiPass> - inline static void clear_queue(MultiPass& mp) - { - Checking::clear_queue(mp); - Storage::clear_queue(mp); - } - }; -#else /////////////////////////////////////////////////////////////////////////// // select the correct derived classes based on if a policy is empty template <typename T @@ -470,7 +433,6 @@ namespace boost { namespace spirit { namespace iterator_policies inline static bool is_unique(MultiPass const& mp) { return Ownership::is_unique(mp); } }; -#endif /////////////////////////////////////////////////////////////////////////// // the multi_pass_shared structure is used to combine the shared data items diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp index 088b39a..8f8e6c7 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/detail/multi_pass.hpp @@ -17,29 +17,6 @@ /////////////////////////////////////////////////////////////////////////////// namespace boost { namespace spirit { namespace detail { -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - /////////////////////////////////////////////////////////////////////////// - // Meta-function to generate a std::iterator<> base class for multi_pass. - // This is used mainly to improve conformance of compilers not supporting - // PTS and thus relying on inheritance to recognize an iterator. - // - // We are using boost::iterator<> because it offers an automatic - // workaround for broken std::iterator<> implementations. - /////////////////////////////////////////////////////////////////////////// - template <typename T, typename InputPolicy> - struct iterator_base_creator - { - typedef typename InputPolicy::BOOST_NESTED_TEMPLATE unique<T> input_type; - - typedef boost::iterator < - std::forward_iterator_tag - , typename input_type::value_type - , typename input_type::difference_type - , typename input_type::pointer - , typename input_type::reference - > type; - }; -#endif /////////////////////////////////////////////////////////////////////////// // Default implementations of the different policies to be used with a diff --git a/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp index 2b355bf..3fc2440 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/iterators/multi_pass.hpp @@ -26,9 +26,6 @@ namespace boost { namespace spirit : private boost::base_from_member< typename Policies::BOOST_NESTED_TEMPLATE shared<T>*> , public Policies::BOOST_NESTED_TEMPLATE unique<T> -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - , typename iterator_base_creator<T, typename Policies::input_policy>::type -#endif { private: // unique and shared data types @@ -41,11 +38,7 @@ namespace boost { namespace spirit // define the types the standard embedded iterator typedefs are taken // from -#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) - typedef typename iterator_base_creator<Input, T>::type iterator_type; -#else typedef typename policies_base_type::input_policy iterator_type; -#endif public: // standard iterator typedefs diff --git a/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp b/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp index ff53967..8abb4f1 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/limits.hpp @@ -12,17 +12,6 @@ #include <boost/spirit/include/phoenix_core.hpp> -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - -#if !defined(SPIRIT_ARGUMENTS_LIMIT) -# define SPIRIT_ARGUMENTS_LIMIT PHOENIX_LIMIT -#endif -#if !defined(SPIRIT_ATTRIBUTES_LIMIT) -# define SPIRIT_ATTRIBUTES_LIMIT PHOENIX_LIMIT -#endif - -#else - #if !defined(SPIRIT_ARGUMENTS_LIMIT) # define SPIRIT_ARGUMENTS_LIMIT BOOST_PHOENIX_LIMIT #endif @@ -31,5 +20,3 @@ #endif #endif - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp b/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp index 04a7437..3868475 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/make_component.hpp @@ -258,7 +258,7 @@ namespace boost { namespace spirit { namespace detail typedef typename proto::reverse_fold_tree< proto::_ - , proto::make<fusion::nil> + , proto::make<fusion::nil_> , make_binary_helper<Grammar> >::template impl<Expr, State, Data> reverse_fold_tree; @@ -362,13 +362,6 @@ namespace boost { namespace spirit { namespace detail )>::type lhs_component; -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - typedef typename - proto::result_of::value< - typename proto::result_of::child_c<Expr, 1>::type - >::type - rhs_component; -#else typedef typename mpl::eval_if_c< phoenix::is_actor< @@ -380,7 +373,6 @@ namespace boost { namespace spirit { namespace detail > >::type rhs_component; -#endif typedef typename result_of::make_cons< @@ -396,24 +388,6 @@ namespace boost { namespace spirit { namespace detail result<make_component_(elements_type, Data)>::type result_type; -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - result_type operator()( - typename impl::expr_param expr - , typename impl::state_param state - , typename impl::data_param data - ) const - { - elements_type elements = - detail::make_cons( - Grammar()( - proto::child_c<0>(expr), state, data) // LHS - , detail::make_cons( - proto::value(proto::child_c<1>(expr))) // RHS - ); - - return make_component_()(elements, data); - } -#else result_type operator()( typename impl::expr_param expr , typename impl::state_param state @@ -466,7 +440,6 @@ namespace boost { namespace spirit { namespace detail return make_component_()(elements, data); } -#endif }; }; }}} diff --git a/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp index f037acc..f214096 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/nonterminal/expand_arg.hpp @@ -50,8 +50,8 @@ namespace boost { namespace spirit { namespace detail struct result<F(A0&)> : result_type<A0> {}; - expand_arg(Context& context) - : context(context) + expand_arg(Context& context_) + : context(context_) { } diff --git a/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp b/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp index d52fad2..3ef8c83 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/terminal.hpp @@ -33,10 +33,10 @@ namespace boost { namespace spirit typedef Terminal terminal_type; typedef Args args_type; - terminal_ex(Args const& args) - : args(args) {} - terminal_ex(Args const& args, Terminal const& term) - : args(args), term(term) {} + terminal_ex(Args const& args_) + : args(args_) {} + terminal_ex(Args const& args_, Terminal const& term_) + : args(args_), term(term_) {} Args args; // Args is guaranteed to be a fusion::vectorN so you // can use that template for detection and specialization @@ -50,10 +50,10 @@ namespace boost { namespace spirit typedef Actor actor_type; static int const arity = Arity; - lazy_terminal(Actor const& actor) - : actor(actor) {} - lazy_terminal(Actor const& actor, Terminal const& term) - : actor(actor), term(term) {} + lazy_terminal(Actor const& actor_) + : actor(actor_) {} + lazy_terminal(Actor const& actor_, Terminal const& term_) + : actor(actor_), term(term_) {} Actor actor; Terminal term; @@ -104,11 +104,11 @@ namespace boost { namespace spirit typedef result_type type; result_type - operator()(F f, A0 const& _0) const + operator()(F f, A0 const& _0_) const { typedef typename result_type::proto_child0 child_type; return result_type::make(child_type( - phoenix::detail::expression::function_eval<F, A0>::make(f, _0) + phoenix::detail::expression::function_eval<F, A0>::make(f, _0_) , f.proto_base().child0 )); } @@ -129,11 +129,11 @@ namespace boost { namespace spirit typedef result_type type; result_type - operator()(F f, A0 const& _0, A1 const& _1) const + operator()(F f, A0 const& _0_, A1 const& _1_) const { typedef typename result_type::proto_child0 child_type; return result_type::make(child_type( - phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0, _1) + phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0_, _1_) , f.proto_base().child0 )); } @@ -154,11 +154,11 @@ namespace boost { namespace spirit typedef result_type type; result_type - operator()(F f, A0 const& _0, A1 const& _1, A2 const& _2) const + operator()(F f, A0 const& _0_, A1 const& _1_, A2 const& _2_) const { typedef typename result_type::proto_child0 child_type; return result_type::make(child_type( - phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0, _1, _2) + phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0_, _1_, _2_) , f.proto_base().child0 )); } @@ -368,42 +368,42 @@ namespace boost { namespace spirit template <typename A0> typename result<A0>::type - operator()(A0 const& _0 + operator()(A0 const& _0_ , typename detail::contains_actor<A0>::is_false = 0) const { typedef typename result<A0>::type result_type; typedef typename result_type::proto_child0 child_type; return result_type::make( child_type( - detail::make_vector(_0) + detail::make_vector(_0_) , this->proto_base().child0) ); } template <typename A0, typename A1> typename result<A0, A1>::type - operator()(A0 const& _0, A1 const& _1 + operator()(A0 const& _0_, A1 const& _1_ , typename detail::contains_actor<A0, A1>::is_false = 0) const { typedef typename result<A0, A1>::type result_type; typedef typename result_type::proto_child0 child_type; return result_type::make( child_type( - detail::make_vector(_0, _1) + detail::make_vector(_0_, _1_) , this->proto_base().child0) ); } template <typename A0, typename A1, typename A2> typename result<A0, A1, A2>::type - operator()(A0 const& _0, A1 const& _1, A2 const& _2 + operator()(A0 const& _0_, A1 const& _1_, A2 const& _2_ , typename detail::contains_actor<A0, A1, A2>::is_false = 0) const { typedef typename result<A0, A1, A2>::type result_type; typedef typename result_type::proto_child0 child_type; return result_type::make( child_type( - detail::make_vector(_0, _1, _2) + detail::make_vector(_0_, _1_, _2_) , this->proto_base().child0) ); } @@ -412,38 +412,38 @@ namespace boost { namespace spirit // least one arg is a Phoenix actor. template <typename A0> typename result<A0>::type - operator()(A0 const& _0 + operator()(A0 const& _0_ , typename detail::contains_actor<A0>::is_true = 0) const { return make_lazy<this_type , typename phoenix::as_actor<A0>::type>()(*this - , phoenix::as_actor<A0>::convert(_0)); + , phoenix::as_actor<A0>::convert(_0_)); } template <typename A0, typename A1> typename result<A0, A1>::type - operator()(A0 const& _0, A1 const& _1 + operator()(A0 const& _0_, A1 const& _1_ , typename detail::contains_actor<A0, A1>::is_true = 0) const { return make_lazy<this_type , typename phoenix::as_actor<A0>::type , typename phoenix::as_actor<A1>::type>()(*this - , phoenix::as_actor<A0>::convert(_0) - , phoenix::as_actor<A1>::convert(_1)); + , phoenix::as_actor<A0>::convert(_0_) + , phoenix::as_actor<A1>::convert(_1_)); } template <typename A0, typename A1, typename A2> typename result<A0, A1, A2>::type - operator()(A0 const& _0, A1 const& _1, A2 const& _2 + operator()(A0 const& _0_, A1 const& _1_, A2 const& _2_ , typename detail::contains_actor<A0, A1, A2>::is_true = 0) const { return make_lazy<this_type , typename phoenix::as_actor<A0>::type , typename phoenix::as_actor<A1>::type , typename phoenix::as_actor<A2>::type>()(*this - , phoenix::as_actor<A0>::convert(_0) - , phoenix::as_actor<A1>::convert(_1) - , phoenix::as_actor<A2>::convert(_2)); + , phoenix::as_actor<A0>::convert(_0_) + , phoenix::as_actor<A1>::convert(_1_) + , phoenix::as_actor<A2>::convert(_2_)); } private: @@ -547,7 +547,6 @@ namespace boost { namespace spirit }} -#ifdef BOOST_SPIRIT_USE_PHOENIX_V3 namespace boost { namespace phoenix { template <typename Tag> @@ -558,6 +557,10 @@ namespace boost { namespace phoenix template <typename Tag> struct custom_terminal<Tag, typename Tag::is_spirit_tag> { +#ifndef BOOST_PHOENIX_NO_SPECIALIZE_CUSTOM_TERMINAL + typedef void _is_default_custom_terminal; // fix for #7730 +#endif + typedef spirit::terminal<Tag> result_type; template <typename Context> @@ -567,7 +570,6 @@ namespace boost { namespace phoenix } }; }} -#endif // Define a spirit terminal. This macro may be placed in any namespace. // Common placeholders are placed in the main boost::spirit namespace diff --git a/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp b/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp index cf6bc5d..0d206bf 100644 --- a/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp +++ b/3rdParty/Boost/src/boost/spirit/home/support/terminal_expression.hpp @@ -9,67 +9,4 @@ #if !defined(BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM) #define BOOST_SPIRIT_TERMINAL_EXPRESSION_MARCH_24_2011_1210AM -#ifndef BOOST_SPIRIT_USE_PHOENIX_V3 - -namespace boost { namespace phoenix { namespace detail -{ - namespace expression - { - template < - typename F, typename A0 = void, typename A1 = void - , typename A2 = void, typename Dummy = void> - struct function_eval; - - template <typename F, typename A0> - struct function_eval<F, A0> - { - typedef phoenix::actor< - typename phoenix::as_composite< - phoenix::detail::function_eval<1>, F, A0 - >::type - > type; - - static type make(F f, A0 const & _0) - { - return phoenix::compose< - phoenix::detail::function_eval<1> >(f, _0); - } - }; - - template <typename F, typename A0, typename A1> - struct function_eval<F, A0, A1> - { - typedef phoenix::actor< - typename phoenix::as_composite< - phoenix::detail::function_eval<2>, F, A0, A1 - >::type - > type; - - static type make(F f, A0 const & _0, A1 const & _1) - { - return phoenix::compose< - phoenix::detail::function_eval<2> >(f, _0, _1); - } - }; - - template <typename F, typename A0, typename A1, typename A2> - struct function_eval<F, A0, A1, A2> - { - typedef phoenix::actor< - typename phoenix::as_composite< - phoenix::detail::function_eval<3>, F, A0, A1, A2 - >::type - > type; - - static type make(F f, A0 const & _0, A1 const & _1, A2 const & _2) - { - return phoenix::compose< - phoenix::detail::function_eval<3> >(f, _0, _1, _2); - } - }; - } -}}} - -#endif // !BOOST_SPIRIT_USE_PHOENIX_V3 - #endif |