diff options
author | Vlad Voicu <vladv@rosedu.org> | 2012-03-02 10:01:11 (GMT) |
---|---|---|
committer | Kevin Smith <git@kismith.co.uk> | 2012-03-09 15:04:05 (GMT) |
commit | 1c8cd160b79b6bbcec72042bdb104ba530508a93 (patch) | |
tree | cff302b81e74c557fbc9e30fd43144d981b613d0 /3rdParty/Boost/src/boost/spirit/home/qi/detail | |
parent | 2944711aefec9a9dd66052440bc4f921910dd780 (diff) | |
download | swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.zip swift-contrib-1c8cd160b79b6bbcec72042bdb104ba530508a93.tar.bz2 |
Added spirit to bundled boost
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/qi/detail')
5 files changed, 791 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..73d3617 --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/assign_to.hpp @@ -0,0 +1,267 @@ +/*============================================================================= + 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/spirit/home/phoenix/core/actor.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. + /////////////////////////////////////////////////////////////////////////// + template <typename Attribute, typename Iterator, typename Enable> + struct assign_to_attribute_from_iterators + { + static void + call(Iterator const& first, Iterator const& last, 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< + 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 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<reference_wrapper<Attribute>, T> + { + static void + call(T const& val, reference_wrapper<Attribute> attr) + { + assign_to(val.get(), attr); + } + }; + + template <typename Attribute> + struct assign_to_attribute_from_value<optional<Attribute>, unused_type> + { + static void + call(unused_type, optional<Attribute> const&) + { + } + }; + + /////////////////////////////////////////////////////////////////////////// + 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) + template <typename T_> + static void call(T_ const& val, Attribute& attr, mpl::true_, 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)) + push_back(attr, traits::deref(i)); + } + + // 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) + push_back(attr, *i); + } + + template <typename T_, typename Pred> + static void call(T_ const& val, Attribute& attr, Pred, mpl::true_) + { + 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)); + } + + 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, typename T> + struct assign_to_container_from_value<reference_wrapper<Attribute>, T> + { + static void + call(T const& val, reference_wrapper<Attribute> attr) + { + assign_to(val.get(), attr); + } + }; + + template <typename Attribute> + struct assign_to_container_from_value<optional<Attribute>, unused_type> + { + static void + call(unused_type, optional<Attribute> const&) + { + } + }; + + /////////////////////////////////////////////////////////////////////////// + namespace detail + { + // overload for non-container attributes + template <typename T, typename Attribute, typename P1, typename P2> + inline void + assign_to(T const& val, Attribute& attr, P1, P2) + { + 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_, 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 traits::is_container<Attribute>::type is_container; + typedef typename mpl::and_< + traits::not_is_variant<Attribute> + , traits::not_is_optional<Attribute> + >::type is_not_wrapped_container; + + detail::assign_to(val, attr, is_container(), 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..ea0f74c --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/qi/detail/attributes.hpp @@ -0,0 +1,175 @@ +// 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> + +/////////////////////////////////////////////////////////////////////////////// +namespace boost { namespace spirit { namespace qi +{ + template <typename Exposed, typename Transformed> + struct default_transform_attribute + { + typedef Transformed type; + + static Transformed pre(Exposed& val) { 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& val, Transformed const& attr) { /* 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<optional<Exposed>, Transformed + , typename disable_if<is_same<optional<Exposed>, Transformed> >::type> + { + typedef Transformed& type; + static Transformed& pre(optional<Exposed>& val) + { + if (!val) + val = Transformed(); + return boost::get<Transformed>(val); + } + static void post(optional<Exposed>&, Transformed const&) {} + static void fail(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..b6ae3b1 --- /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& last, char& attr) + { + attr = *first; + } + }; + + template <typename Iterator> + struct assign_to_attribute_from_iterators<signed char, Iterator> + { + static void + call(Iterator const& first, Iterator const& last, 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& last, 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& last, 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& last, 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_, 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_, 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_, 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_, 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_, 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_, 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, 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, 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_, 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_, 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, 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 |