Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/qi/detail')
5 files changed, 917 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp new file mode 100644 index 0000000..38142bf --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp @@ -0,0 +1,392 @@ +/*============================================================================= + Copyright (c) 2001-2011 Joel de Guzman + Copyright (c) 2001-2011 Hartmut Kaiser + http://spirit.sourceforge.net/ + + 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_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM) +#define BOOST_SPIRIT_ASSIGN_TO_APR_16_2006_0812PM + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/spirit/home/qi/detail/construct.hpp> +#include <boost/spirit/home/support/unused.hpp> +#include <boost/spirit/home/qi/detail/attributes.hpp> +#include <boost/spirit/home/support/container.hpp> +#include <boost/fusion/include/copy.hpp> +#include <boost/ref.hpp> +#include <boost/range/iterator_range.hpp> + +namespace boost { namespace spirit { namespace traits +{ + /////////////////////////////////////////////////////////////////////////// + // This file contains assignment utilities. The utilities provided also + // accept spirit's unused_type; all no-ops. Compiler optimization will + // easily strip these away. + /////////////////////////////////////////////////////////////////////////// + namespace detail + { + template <typename T> + struct is_iter_range : mpl::false_ {}; + + template <typename I> + struct is_iter_range<boost::iterator_range<I> > : mpl::true_ {}; + + template <typename C> + struct is_container_of_ranges + : is_iter_range<typename C::value_type> {}; + } + + template <typename Attribute, typename Iterator, typename Enable> + struct assign_to_attribute_from_iterators + { + // Common case + static void + call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::false_) + { + if (traits::is_empty(attr)) + attr = Attribute(first, last); + else { + for (Iterator i = first; i != last; ++i) + push_back(attr, *i); + } + } + + // If Attribute is a container with value_type==iterator_range<T> just push the + // iterator_range into it + static void + call(Iterator const& first, Iterator const& last, Attribute& attr, mpl::true_) + { + typename Attribute::value_type rng(first, last); + push_back(attr, rng); + } + + static void + call(Iterator const& first, Iterator const& last, Attribute& attr) + { + call(first, last, attr, detail::is_container_of_ranges<Attribute>()); + } + }; + + template <typename Attribute, typename Iterator> + struct assign_to_attribute_from_iterators< + reference_wrapper<Attribute>, Iterator> + { + static void + call(Iterator const& first, Iterator const& last + , reference_wrapper<Attribute> attr) + { + if (traits::is_empty(attr)) + attr = Attribute(first, last); + else { + for (Iterator i = first; i != last; ++i) + push_back(attr, *i); + } + } + }; + + template <typename Attribute, typename Iterator> + struct assign_to_attribute_from_iterators< + boost::optional<Attribute>, Iterator> + { + static void + call(Iterator const& first, Iterator const& last + , boost::optional<Attribute>& attr) + { + Attribute val; + assign_to(first, last, val); + attr = val; + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators< + iterator_range<Iterator>, Iterator> + { + static void + call(Iterator const& first, Iterator const& last + , iterator_range<Iterator>& attr) + { + attr = iterator_range<Iterator>(first, last); + } + }; + + template <typename Iterator, typename Attribute> + inline void + assign_to(Iterator const& first, Iterator const& last, Attribute& attr) + { + assign_to_attribute_from_iterators<Attribute, Iterator>:: + call(first, last, attr); + } + + template <typename Iterator> + inline void + assign_to(Iterator const&, Iterator const&, unused_type) + { + } + + /////////////////////////////////////////////////////////////////////////// + template <typename T, typename Attribute> + void assign_to(T const& val, Attribute& attr); + + template <typename Attribute, typename T, typename Enable> + struct assign_to_attribute_from_value + { + typedef typename traits::one_element_sequence<Attribute>::type + is_one_element_sequence; + + typedef typename mpl::eval_if< + is_one_element_sequence + , fusion::result_of::at_c<Attribute, 0> + , mpl::identity<Attribute&> + >::type type; + + template <typename T_> + static void + call(T_ const& val, Attribute& attr, mpl::false_) + { + attr = static_cast<Attribute>(val); + } + + // This handles the case where the attribute is a single element fusion + // sequence. We silently assign to the only element and treat it as the + // attribute to parse the results into. + template <typename T_> + static void + call(T_ const& val, Attribute& attr, mpl::true_) + { + typedef typename fusion::result_of::value_at_c<Attribute, 0>::type + element_type; + fusion::at_c<0>(attr) = static_cast<element_type>(val); + } + + static void + call(T const& val, Attribute& attr) + { + call(val, attr, is_one_element_sequence()); + } + }; + + template <typename Attribute> + struct assign_to_attribute_from_value<Attribute, Attribute> + { + static void + call(Attribute const& val, Attribute& attr) + { + attr = val; + } + }; + + template <typename Attribute, typename T> + struct assign_to_attribute_from_value<Attribute, reference_wrapper<T> + , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type> + { + static void + call(reference_wrapper<T> const& val, Attribute& attr) + { + assign_to(val.get(), attr); + } + }; + + template <typename Attribute, typename T> + struct assign_to_attribute_from_value<Attribute, boost::optional<T> + , typename disable_if<is_same<Attribute, boost::optional<T> > >::type> + { + static void + call(boost::optional<T> const& val, Attribute& attr) + { + assign_to(val.get(), attr); + } + }; + + namespace detail + { + template <typename A, typename B> + struct is_same_size_sequence + : mpl::bool_<fusion::result_of::size<A>::value + == fusion::result_of::size<B>::value> + {}; + } + + template <typename Attribute, typename T> + struct assign_to_attribute_from_value<Attribute, T, + mpl::and_< + fusion::traits::is_sequence<Attribute>, + fusion::traits::is_sequence<T>, + detail::is_same_size_sequence<Attribute, T> + > + > + { + static void + call(T const& val, Attribute& attr) + { + fusion::copy(val, attr); + } + }; + + /////////////////////////////////////////////////////////////////////////// + template <typename Attribute, typename T, typename Enable> + struct assign_to_container_from_value + { + // T is not a container and not a string + template <typename T_> + static void call(T_ const& val, Attribute& attr, mpl::false_, mpl::false_) + { + traits::push_back(attr, val); + } + + // T is a container (but not a string), and T is convertible to the + // value_type of the Attribute container + template <typename T_> + static void + append_to_container_not_string(T_ const& val, Attribute& attr, mpl::true_) + { + traits::push_back(attr, val); + } + + // T is a container (but not a string), generic overload + template <typename T_> + static void + append_to_container_not_string(T_ const& val, Attribute& attr, mpl::false_) + { + typedef typename traits::container_iterator<T_ const>::type + iterator_type; + + iterator_type end = traits::end(val); + for (iterator_type i = traits::begin(val); i != end; traits::next(i)) + traits::push_back(attr, traits::deref(i)); + } + + // T is a container (but not a string) + template <typename T_> + static void call(T_ const& val, Attribute& attr, mpl::true_, mpl::false_) + { + typedef typename container_value<Attribute>::type value_type; + typedef typename is_convertible<T, value_type>::type is_value_type; + + append_to_container_not_string(val, attr, is_value_type()); + } + + /////////////////////////////////////////////////////////////////////// + // T is a string + template <typename Iterator> + static void append_to_string(Attribute& attr, Iterator begin, Iterator end) + { + for (Iterator i = begin; i != end; ++i) + traits::push_back(attr, *i); + } + + // T is string, but not convertible to value_type of container + template <typename T_> + static void append_to_container(T_ const& val, Attribute& attr, mpl::false_) + { + typedef typename char_type_of<T_>::type char_type; + + append_to_string(attr, traits::get_begin<char_type>(val) + , traits::get_end<char_type>(val)); + } + + // T is string, and convertible to value_type of container + template <typename T_> + static void append_to_container(T_ const& val, Attribute& attr, mpl::true_) + { + traits::push_back(attr, val); + } + + template <typename T_, typename Pred> + static void call(T_ const& val, Attribute& attr, Pred, mpl::true_) + { + typedef typename container_value<Attribute>::type value_type; + typedef typename is_convertible<T, value_type>::type is_value_type; + + append_to_container(val, attr, is_value_type()); + } + + /////////////////////////////////////////////////////////////////////// + static void call(T const& val, Attribute& attr) + { + typedef typename traits::is_container<T>::type is_container; + typedef typename traits::is_string<T>::type is_string; + + call(val, attr, is_container(), is_string()); + } + }; + + template <typename Attribute> + struct assign_to_container_from_value<Attribute, Attribute> + { + static void + call(Attribute const& val, Attribute& attr) + { + attr = val; + } + }; + + template <typename Attribute, typename T> + struct assign_to_container_from_value<Attribute, boost::optional<T> + , typename disable_if<is_same<Attribute, boost::optional<T> > >::type> + { + static void + call(boost::optional<T> const& val, Attribute& attr) + { + assign_to(val.get(), attr); + } + }; + + template <typename Attribute, typename T> + struct assign_to_container_from_value<Attribute, reference_wrapper<T> + , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type> + { + static void + call(reference_wrapper<T> const& val, Attribute& attr) + { + assign_to(val.get(), attr); + } + }; + + /////////////////////////////////////////////////////////////////////////// + namespace detail + { + // overload for non-container attributes + template <typename T, typename Attribute> + inline void + assign_to(T const& val, Attribute& attr, mpl::false_) + { + assign_to_attribute_from_value<Attribute, T>::call(val, attr); + } + + // overload for containers (but not for variants or optionals + // holding containers) + template <typename T, typename Attribute> + inline void + assign_to(T const& val, Attribute& attr, mpl::true_) + { + assign_to_container_from_value<Attribute, T>::call(val, attr); + } + } + + template <typename T, typename Attribute> + inline void + assign_to(T const& val, Attribute& attr) + { + typedef typename mpl::and_< + traits::is_container<Attribute> + , traits::not_is_variant<Attribute> + , traits::not_is_optional<Attribute> + >::type is_not_wrapped_container; + + detail::assign_to(val, attr, is_not_wrapped_container()); + } + + template <typename T> + inline void + assign_to(T const&, unused_type) + { + } +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp new file mode 100644 index 0000000..0a66a65 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp @@ -0,0 +1,176 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 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(SPIRIT_QI_DETAIL_ATTRIBUTES_APR_18_2010_0458PM) +#define SPIRIT_QI_DETAIL_ATTRIBUTES_APR_18_2010_0458PM + +#include <boost/spirit/home/qi/domain.hpp> +#include <boost/spirit/home/support/attributes_fwd.hpp> +#include <boost/spirit/home/support/attributes.hpp> +#include <boost/spirit/home/support/utree/utree_traits_fwd.hpp> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace spirit { namespace qi +{ + template <typename Exposed, typename Transformed> + struct default_transform_attribute + { + typedef Transformed type; + + static Transformed pre(Exposed&) { return Transformed(); } + + static void post(Exposed& val, Transformed const& attr) + { + traits::assign_to(attr, val); + } + + // fail() will be called by Qi rule's if the rhs failed parsing + static void fail(Exposed&) {} + }; + + // handle case where no transformation is required as the types are the same + template <typename Attribute> + struct default_transform_attribute<Attribute, Attribute> + { + typedef Attribute& type; + static Attribute& pre(Attribute& val) { return val; } + static void post(Attribute&, Attribute const&) {} + static void fail(Attribute&) {} + }; + + template <typename Exposed, typename Transformed> + struct proxy_transform_attribute + { + typedef Transformed type; + + static Transformed pre(Exposed& val) { return Transformed(val); } + static void post(Exposed&, Transformed const&) { /* no-op */ } + + // fail() will be called by Qi rule's if the rhs failed parsing + static void fail(Exposed&) {} + }; + + // handle case where no transformation is required as the types are the same + template <typename Attribute> + struct proxy_transform_attribute<Attribute, Attribute> + { + typedef Attribute& type; + static Attribute& pre(Attribute& val) { return val; } + static void post(Attribute&, Attribute const&) {} + static void fail(Attribute&) {} + }; + + // main specialization for Qi + template <typename Exposed, typename Transformed, typename Enable = void> + struct transform_attribute + : mpl::if_< + mpl::and_< + mpl::not_<is_const<Exposed> > + , mpl::not_<is_reference<Exposed> > + , traits::is_proxy<Transformed> > + , proxy_transform_attribute<Exposed, Transformed> + , default_transform_attribute<Exposed, Transformed> + >::type + {}; + + template <typename Exposed, typename Transformed> + struct transform_attribute<boost::optional<Exposed>, Transformed + , typename disable_if<is_same<boost::optional<Exposed>, Transformed> >::type> + { + typedef Transformed& type; + static Transformed& pre(boost::optional<Exposed>& val) + { + if (!val) + val = Transformed(); + return boost::get<Transformed>(val); + } + static void post(boost::optional<Exposed>&, Transformed const&) {} + static void fail(boost::optional<Exposed>& val) + { + val = none_t(); // leave optional uninitialized if rhs failed + } + }; + + // reference types need special handling + template <typename Attribute> + struct transform_attribute<Attribute&, Attribute> + { + typedef Attribute& type; + static Attribute& pre(Attribute& val) { return val; } + static void post(Attribute&, Attribute const&) {} + static void fail(Attribute&) {} + }; + + // unused_type needs some special handling as well + template <> + struct transform_attribute<unused_type, unused_type> + { + typedef unused_type type; + static unused_type pre(unused_type) { return unused; } + static void post(unused_type, unused_type) {} + static void fail(unused_type) {} + }; + + template <> + struct transform_attribute<unused_type const, unused_type> + : transform_attribute<unused_type, unused_type> + {}; + + template <typename Attribute> + struct transform_attribute<unused_type, Attribute> + : transform_attribute<unused_type, unused_type> + {}; + + template <typename Attribute> + struct transform_attribute<unused_type const, Attribute> + : transform_attribute<unused_type, unused_type> + {}; + + template <typename Attribute> + struct transform_attribute<Attribute, unused_type> + : transform_attribute<unused_type, unused_type> + {}; + + template <typename Attribute> + struct transform_attribute<Attribute const, unused_type> + : transform_attribute<unused_type, unused_type> + {}; +}}} + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace spirit { namespace traits +{ + template <typename Exposed, typename Transformed> + struct transform_attribute<Exposed, Transformed, qi::domain> + : qi::transform_attribute<Exposed, Transformed> + {}; + + template <typename Exposed, typename Transformed> + struct transform_attribute<Exposed&, Transformed, qi::domain> + : transform_attribute<Exposed, Transformed, qi::domain> + {}; + + template <typename Attribute> + struct transform_attribute<Attribute&, Attribute, qi::domain> + : qi::transform_attribute<Attribute&, Attribute> + {}; + + /////////////////////////////////////////////////////////////////////////// + template <typename Exposed, typename Transformed> + void post_transform(Exposed& dest, Transformed const& attr) + { + return transform_attribute<Exposed, Transformed, qi::domain>::post(dest, attr); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Exposed, typename Transformed> + void fail_transform(Exposed& dest, Transformed const&) + { + return transform_attribute<Exposed, Transformed, qi::domain>::fail(dest); + } +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp new file mode 100644 index 0000000..5d8122f --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/construct.hpp @@ -0,0 +1,202 @@ +/*============================================================================= + Copyright (c) 2001-2011 Hartmut Kaiser + http://spirit.sourceforge.net/ + + 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_SPIRIT_CONSTRUCT_MAR_24_2007_0629PM) +#define BOOST_SPIRIT_CONSTRUCT_MAR_24_2007_0629PM + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/config.hpp> +#include <boost/spirit/home/qi/parse.hpp> +#include <boost/spirit/home/support/common_terminals.hpp> +#include <boost/spirit/home/support/attributes_fwd.hpp> + +namespace boost { namespace spirit { namespace traits +{ + /////////////////////////////////////////////////////////////////////////// + // We provide overloads for the assign_to_attribute_from_iterators + // customization point for all built in types + /////////////////////////////////////////////////////////////////////////// + template <typename Iterator> + struct assign_to_attribute_from_iterators<char, Iterator> + { + static void + call(Iterator const& first, Iterator const&, char& attr) + { + attr = *first; + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<signed char, Iterator> + { + static void + call(Iterator const& first, Iterator const&, signed char& attr) + { + attr = *first; + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<unsigned char, Iterator> + { + static void + call(Iterator const& first, Iterator const&, unsigned char& attr) + { + attr = *first; + } + }; + + // wchar_t is intrinsic + template <typename Iterator> + struct assign_to_attribute_from_iterators<wchar_t, Iterator> + { + static void + call(Iterator const& first, Iterator const&, wchar_t& attr) + { + attr = *first; + } + }; + +#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) + // wchar_t is intrinsic, have separate overload for unsigned short + template <typename Iterator> + struct assign_to_attribute_from_iterators<unsigned short, Iterator> + { + static void + call(Iterator const& first, Iterator const&, unsigned short& attr) + { + attr = *first; + } + }; +#endif + + template <typename Iterator> + struct assign_to_attribute_from_iterators<bool, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, bool& attr) + { + Iterator first_ = first; + qi::parse(first_, last, bool_type(), attr); + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<short, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, short& attr) + { + Iterator first_ = first; + qi::parse(first_, last, short_type(), attr); + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<int, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, int& attr) + { + Iterator first_ = first; + qi::parse(first_, last, int_type(), attr); + } + }; + template <typename Iterator> + struct assign_to_attribute_from_iterators<unsigned int, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, unsigned int& attr) + { + Iterator first_ = first; + qi::parse(first_, last, uint_type(), attr); + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<long, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, long& attr) + { + Iterator first_ = first; + qi::parse(first_, last, long_type(), attr); + } + }; + template <typename Iterator> + struct assign_to_attribute_from_iterators<unsigned long, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, unsigned long& attr) + { + Iterator first_ = first; + qi::parse(first_, last, ulong_type(), attr); + } + }; + +#ifdef BOOST_HAS_LONG_LONG + template <typename Iterator> + struct assign_to_attribute_from_iterators<long_long_type, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, long_long_type& attr) + { + Iterator first_ = first; + qi::parse(first_, last, long_long_type(), attr); + } + }; + template <typename Iterator> + struct assign_to_attribute_from_iterators<ulong_long_type, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, ulong_long_type& attr) + { + Iterator first_ = first; + qi::parse(first_, last, ulong_long_type(), attr); + } + }; +#endif + + template <typename Iterator> + struct assign_to_attribute_from_iterators<float, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, float& attr) + { + Iterator first_ = first; + qi::parse(first_, last, float_type(), attr); + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<double, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, double& attr) + { + Iterator first_ = first; + qi::parse(first_, last, double_type(), attr); + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<long double, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, long double& attr) + { + Iterator first_ = first; + qi::parse(first_, last, long_double_type(), attr); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp b/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp new file mode 100644 index 0000000..b81f1e7 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/parse.hpp @@ -0,0 +1,97 @@ +/*============================================================================= + Copyright (c) 2001-2011 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) +=============================================================================*/ +#if !defined(BOOST_SPIRIT_DETAIL_PARSE_DEC_02_2009_0411PM) +#define BOOST_SPIRIT_DETAIL_PARSE_DEC_02_2009_0411PM + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/spirit/home/qi/meta_compiler.hpp> +#include <boost/spirit/home/qi/skip_flag.hpp> +#include <boost/spirit/home/qi/skip_over.hpp> +#include <boost/spirit/home/support/unused.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/mpl/bool.hpp> + +namespace boost { namespace spirit { namespace qi { namespace detail +{ + /////////////////////////////////////////////////////////////////////////// + template <typename Expr, typename Enable = void> + struct parse_impl + { + // Report invalid expression error as early as possible. + // If you got an error_invalid_expression error message here, + // then the expression (expr) is not a valid spirit qi expression. + // Did you intend to use the auto_ facilities while forgetting to + // #include <boost/spirit/include/qi_auto.hpp>? + BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr); + }; + + template <typename Expr> + struct parse_impl<Expr + , typename enable_if<traits::matches<qi::domain, Expr> >::type> + { + template <typename Iterator> + static bool call( + Iterator& first + , Iterator last + , Expr const& expr) + { + return compile<qi::domain>(expr).parse( + first, last, unused, unused, unused); + } + }; + + /////////////////////////////////////////////////////////////////////////// + template <typename Expr, typename Enable = void> + struct phrase_parse_impl + { + // Report invalid expression error as early as possible. + // If you got an error_invalid_expression error message here, + // then the expression (expr) is not a valid spirit qi expression. + // Did you intend to use the auto_ facilities while forgetting to + // #include <boost/spirit/include/qi_auto.hpp>? + BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Expr); + }; + + template <typename Expr> + struct phrase_parse_impl<Expr + , typename enable_if<traits::matches<qi::domain, Expr> >::type> + { + template <typename Iterator, typename Skipper> + static bool call( + Iterator& first + , Iterator last + , Expr const& expr + , Skipper const& skipper + , BOOST_SCOPED_ENUM(skip_flag) post_skip) + { + // Report invalid expression error as early as possible. + // If you got an error_invalid_expression error message here, + // then the skipper is not a valid spirit qi expression. + BOOST_SPIRIT_ASSERT_MATCH(qi::domain, Skipper); + + typedef + typename result_of::compile<qi::domain, Skipper>::type + skipper_type; + skipper_type const skipper_ = compile<qi::domain>(skipper); + + if (!compile<qi::domain>(expr).parse( + first, last, unused, skipper_, unused)) + return false; + + if (post_skip == skip_flag::postskip) + qi::skip_over(first, last, skipper_); + return true; + } + }; + +}}}} + +#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 new file mode 100644 index 0000000..c1405d6 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/unused_skipper.hpp @@ -0,0 +1,50 @@ +// Copyright (c) 2001-2011 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) + +#if !defined(BOOST_SPIRIT_QI_UNUSED_SKIPPER_JUL_25_2009_0921AM) +#define BOOST_SPIRIT_QI_UNUSED_SKIPPER_JUL_25_2009_0921AM + +#if defined(_MSC_VER) +#pragma once +#endif + +#include <boost/spirit/home/support/unused.hpp> + +namespace boost { namespace spirit { namespace qi { namespace detail +{ + template <typename Skipper> + struct unused_skipper : unused_type + { + unused_skipper(Skipper const& skipper) + : skipper(skipper) {} + Skipper const& skipper; + + private: + // silence MSVC warning C4512: assignment operator could not be generated + unused_skipper& operator= (unused_skipper const&); + }; + + // If a surrounding lexeme[] directive was specified, the current + // 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& + get_skipper(unused_skipper<Skipper> const& u) + { + return u.skipper; + } + + // If no surrounding lexeme[] directive was specified we keep what we got. + template <typename Skipper> + inline Skipper const& + get_skipper(Skipper const& u) + { + return u; + } + +}}}} + +#endif |