| /*============================================================================= | |
| Copyright (c) 1998-2003 Joel de Guzman | |
| Copyright (c) 2001 Daniel Nuffer | |
| 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_DIRECTIVES_HPP) | |
| #define BOOST_SPIRIT_DIRECTIVES_HPP | |
| /////////////////////////////////////////////////////////////////////////////// | |
| #include <algorithm> | |
| #include <boost/spirit/home/classic/namespace.hpp> | |
| #include <boost/spirit/home/classic/core/parser.hpp> | |
| #include <boost/spirit/home/classic/core/scanner/skipper.hpp> | |
| #include <boost/spirit/home/classic/core/primitives/primitives.hpp> | |
| #include <boost/spirit/home/classic/core/composite/composite.hpp> | |
| #include <boost/spirit/home/classic/core/composite/impl/directives.ipp> | |
| namespace boost { namespace spirit { | |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // contiguous class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| struct lexeme_parser_gen; | |
| template <typename ParserT> | |
| struct contiguous | |
| : public unary<ParserT, parser<contiguous<ParserT> > > | |
| { | |
| typedef contiguous<ParserT> self_t; | |
| typedef unary_parser_category parser_category_t; | |
| typedef lexeme_parser_gen parser_generator_t; | |
| typedef unary<ParserT, parser<self_t> > base_t; | |
| template <typename ScannerT> | |
| struct result | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type type; | |
| }; | |
| contiguous(ParserT const& p) | |
| : base_t(p) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| return impl::contiguous_parser_parse<result_t> | |
| (this->subject(), scan, scan); | |
| } | |
| }; | |
| struct lexeme_parser_gen | |
| { | |
| template <typename ParserT> | |
| struct result { | |
| typedef contiguous<ParserT> type; | |
| }; | |
| template <typename ParserT> | |
| static contiguous<ParserT> | |
| generate(parser<ParserT> const& subject) | |
| { | |
| return contiguous<ParserT>(subject.derived()); | |
| } | |
| template <typename ParserT> | |
| contiguous<ParserT> | |
| operator[](parser<ParserT> const& subject) const | |
| { | |
| return contiguous<ParserT>(subject.derived()); | |
| } | |
| }; | |
| ////////////////////////////////// | |
| const lexeme_parser_gen lexeme_d = lexeme_parser_gen(); | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // lexeme_scanner | |
| // | |
| // Given a Scanner, return the correct scanner type that | |
| // the lexeme_d uses. Scanner is assumed to be a phrase | |
| // level scanner (see skipper.hpp) | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename ScannerT> | |
| struct lexeme_scanner | |
| { | |
| typedef scanner_policies< | |
| no_skipper_iteration_policy< | |
| typename ScannerT::iteration_policy_t>, | |
| typename ScannerT::match_policy_t, | |
| typename ScannerT::action_policy_t | |
| > policies_t; | |
| typedef typename | |
| rebind_scanner_policies<ScannerT, policies_t>::type type; | |
| }; | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // inhibit_case_iteration_policy class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename BaseT> | |
| struct inhibit_case_iteration_policy : public BaseT | |
| { | |
| typedef BaseT base_t; | |
| inhibit_case_iteration_policy() | |
| : BaseT() {} | |
| template <typename PolicyT> | |
| inhibit_case_iteration_policy(PolicyT const& other) | |
| : BaseT(other) {} | |
| template <typename CharT> | |
| CharT filter(CharT ch) const | |
| { return impl::tolower_(ch); } | |
| }; | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // inhibit_case class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| struct inhibit_case_parser_gen; | |
| template <typename ParserT> | |
| struct inhibit_case | |
| : public unary<ParserT, parser<inhibit_case<ParserT> > > | |
| { | |
| typedef inhibit_case<ParserT> self_t; | |
| typedef unary_parser_category parser_category_t; | |
| typedef inhibit_case_parser_gen parser_generator_t; | |
| typedef unary<ParserT, parser<self_t> > base_t; | |
| template <typename ScannerT> | |
| struct result | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type type; | |
| }; | |
| inhibit_case(ParserT const& p) | |
| : base_t(p) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| return impl::inhibit_case_parser_parse<result_t> | |
| (this->subject(), scan, scan); | |
| } | |
| }; | |
| template <int N> | |
| struct inhibit_case_parser_gen_base | |
| { | |
| // This hack is needed to make borland happy. | |
| // If these member operators were defined in the | |
| // inhibit_case_parser_gen class, or if this class | |
| // is non-templated, borland ICEs. | |
| static inhibit_case<strlit<char const*> > | |
| generate(char const* str) | |
| { return inhibit_case<strlit<char const*> >(str); } | |
| static inhibit_case<strlit<wchar_t const*> > | |
| generate(wchar_t const* str) | |
| { return inhibit_case<strlit<wchar_t const*> >(str); } | |
| static inhibit_case<chlit<char> > | |
| generate(char ch) | |
| { return inhibit_case<chlit<char> >(ch); } | |
| static inhibit_case<chlit<wchar_t> > | |
| generate(wchar_t ch) | |
| { return inhibit_case<chlit<wchar_t> >(ch); } | |
| template <typename ParserT> | |
| static inhibit_case<ParserT> | |
| generate(parser<ParserT> const& subject) | |
| { return inhibit_case<ParserT>(subject.derived()); } | |
| inhibit_case<strlit<char const*> > | |
| operator[](char const* str) const | |
| { return inhibit_case<strlit<char const*> >(str); } | |
| inhibit_case<strlit<wchar_t const*> > | |
| operator[](wchar_t const* str) const | |
| { return inhibit_case<strlit<wchar_t const*> >(str); } | |
| inhibit_case<chlit<char> > | |
| operator[](char ch) const | |
| { return inhibit_case<chlit<char> >(ch); } | |
| inhibit_case<chlit<wchar_t> > | |
| operator[](wchar_t ch) const | |
| { return inhibit_case<chlit<wchar_t> >(ch); } | |
| template <typename ParserT> | |
| inhibit_case<ParserT> | |
| operator[](parser<ParserT> const& subject) const | |
| { return inhibit_case<ParserT>(subject.derived()); } | |
| }; | |
| ////////////////////////////////// | |
| struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0> | |
| { | |
| inhibit_case_parser_gen() {} | |
| }; | |
| ////////////////////////////////// | |
| // Depracated | |
| const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen(); | |
| // Preferred syntax | |
| const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen(); | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // as_lower_scanner | |
| // | |
| // Given a Scanner, return the correct scanner type that | |
| // the as_lower_d uses. Scanner is assumed to be a scanner | |
| // with an inhibit_case_iteration_policy. | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename ScannerT> | |
| struct as_lower_scanner | |
| { | |
| typedef scanner_policies< | |
| inhibit_case_iteration_policy< | |
| typename ScannerT::iteration_policy_t>, | |
| typename ScannerT::match_policy_t, | |
| typename ScannerT::action_policy_t | |
| > policies_t; | |
| typedef typename | |
| rebind_scanner_policies<ScannerT, policies_t>::type type; | |
| }; | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // longest_alternative class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| struct longest_parser_gen; | |
| template <typename A, typename B> | |
| struct longest_alternative | |
| : public binary<A, B, parser<longest_alternative<A, B> > > | |
| { | |
| typedef longest_alternative<A, B> self_t; | |
| typedef binary_parser_category parser_category_t; | |
| typedef longest_parser_gen parser_generator_t; | |
| typedef binary<A, B, parser<self_t> > base_t; | |
| longest_alternative(A const& a, B const& b) | |
| : base_t(a, b) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| typename ScannerT::iterator_t save = scan.first; | |
| result_t l = this->left().parse(scan); | |
| std::swap(scan.first, save); | |
| result_t r = this->right().parse(scan); | |
| if (l || r) | |
| { | |
| if (l.length() > r.length()) | |
| { | |
| scan.first = save; | |
| return l; | |
| } | |
| return r; | |
| } | |
| return scan.no_match(); | |
| } | |
| }; | |
| struct longest_parser_gen | |
| { | |
| template <typename A, typename B> | |
| struct result { | |
| typedef typename | |
| impl::to_longest_alternative<alternative<A, B> >::result_t | |
| type; | |
| }; | |
| template <typename A, typename B> | |
| static typename | |
| impl::to_longest_alternative<alternative<A, B> >::result_t | |
| generate(alternative<A, B> const& alt) | |
| { | |
| return impl::to_longest_alternative<alternative<A, B> >:: | |
| convert(alt); | |
| } | |
| //'generate' for binary composite | |
| template <typename A, typename B> | |
| static | |
| longest_alternative<A, B> | |
| generate(A const &left, B const &right) | |
| { | |
| return longest_alternative<A, B>(left, right); | |
| } | |
| template <typename A, typename B> | |
| typename impl::to_longest_alternative<alternative<A, B> >::result_t | |
| operator[](alternative<A, B> const& alt) const | |
| { | |
| return impl::to_longest_alternative<alternative<A, B> >:: | |
| convert(alt); | |
| } | |
| }; | |
| const longest_parser_gen longest_d = longest_parser_gen(); | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // shortest_alternative class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| struct shortest_parser_gen; | |
| template <typename A, typename B> | |
| struct shortest_alternative | |
| : public binary<A, B, parser<shortest_alternative<A, B> > > | |
| { | |
| typedef shortest_alternative<A, B> self_t; | |
| typedef binary_parser_category parser_category_t; | |
| typedef shortest_parser_gen parser_generator_t; | |
| typedef binary<A, B, parser<self_t> > base_t; | |
| shortest_alternative(A const& a, B const& b) | |
| : base_t(a, b) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| typename ScannerT::iterator_t save = scan.first; | |
| result_t l = this->left().parse(scan); | |
| std::swap(scan.first, save); | |
| result_t r = this->right().parse(scan); | |
| if (l || r) | |
| { | |
| if ((l.length() < r.length() && l) || !r) | |
| { | |
| scan.first = save; | |
| return l; | |
| } | |
| return r; | |
| } | |
| return scan.no_match(); | |
| } | |
| }; | |
| struct shortest_parser_gen | |
| { | |
| template <typename A, typename B> | |
| struct result { | |
| typedef typename | |
| impl::to_shortest_alternative<alternative<A, B> >::result_t | |
| type; | |
| }; | |
| template <typename A, typename B> | |
| static typename | |
| impl::to_shortest_alternative<alternative<A, B> >::result_t | |
| generate(alternative<A, B> const& alt) | |
| { | |
| return impl::to_shortest_alternative<alternative<A, B> >:: | |
| convert(alt); | |
| } | |
| //'generate' for binary composite | |
| template <typename A, typename B> | |
| static | |
| shortest_alternative<A, B> | |
| generate(A const &left, B const &right) | |
| { | |
| return shortest_alternative<A, B>(left, right); | |
| } | |
| template <typename A, typename B> | |
| typename impl::to_shortest_alternative<alternative<A, B> >::result_t | |
| operator[](alternative<A, B> const& alt) const | |
| { | |
| return impl::to_shortest_alternative<alternative<A, B> >:: | |
| convert(alt); | |
| } | |
| }; | |
| const shortest_parser_gen shortest_d = shortest_parser_gen(); | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // min_bounded class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename BoundsT> | |
| struct min_bounded_gen; | |
| template <typename ParserT, typename BoundsT> | |
| struct min_bounded | |
| : public unary<ParserT, parser<min_bounded<ParserT, BoundsT> > > | |
| { | |
| typedef min_bounded<ParserT, BoundsT> self_t; | |
| typedef unary_parser_category parser_category_t; | |
| typedef min_bounded_gen<BoundsT> parser_generator_t; | |
| typedef unary<ParserT, parser<self_t> > base_t; | |
| template <typename ScannerT> | |
| struct result | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type type; | |
| }; | |
| min_bounded(ParserT const& p, BoundsT const& min__) | |
| : base_t(p) | |
| , min_(min__) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| result_t hit = this->subject().parse(scan); | |
| if (hit.has_valid_attribute() && hit.value() < min_) | |
| return scan.no_match(); | |
| return hit; | |
| } | |
| BoundsT min_; | |
| }; | |
| template <typename BoundsT> | |
| struct min_bounded_gen | |
| { | |
| min_bounded_gen(BoundsT const& min__) | |
| : min_(min__) {} | |
| template <typename DerivedT> | |
| min_bounded<DerivedT, BoundsT> | |
| operator[](parser<DerivedT> const& p) const | |
| { return min_bounded<DerivedT, BoundsT>(p.derived(), min_); } | |
| BoundsT min_; | |
| }; | |
| template <typename BoundsT> | |
| inline min_bounded_gen<BoundsT> | |
| min_limit_d(BoundsT const& min_) | |
| { return min_bounded_gen<BoundsT>(min_); } | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // max_bounded class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename BoundsT> | |
| struct max_bounded_gen; | |
| template <typename ParserT, typename BoundsT> | |
| struct max_bounded | |
| : public unary<ParserT, parser<max_bounded<ParserT, BoundsT> > > | |
| { | |
| typedef max_bounded<ParserT, BoundsT> self_t; | |
| typedef unary_parser_category parser_category_t; | |
| typedef max_bounded_gen<BoundsT> parser_generator_t; | |
| typedef unary<ParserT, parser<self_t> > base_t; | |
| template <typename ScannerT> | |
| struct result | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type type; | |
| }; | |
| max_bounded(ParserT const& p, BoundsT const& max__) | |
| : base_t(p) | |
| , max_(max__) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| result_t hit = this->subject().parse(scan); | |
| if (hit.has_valid_attribute() && hit.value() > max_) | |
| return scan.no_match(); | |
| return hit; | |
| } | |
| BoundsT max_; | |
| }; | |
| template <typename BoundsT> | |
| struct max_bounded_gen | |
| { | |
| max_bounded_gen(BoundsT const& max__) | |
| : max_(max__) {} | |
| template <typename DerivedT> | |
| max_bounded<DerivedT, BoundsT> | |
| operator[](parser<DerivedT> const& p) const | |
| { return max_bounded<DerivedT, BoundsT>(p.derived(), max_); } | |
| BoundsT max_; | |
| }; | |
| ////////////////////////////////// | |
| template <typename BoundsT> | |
| inline max_bounded_gen<BoundsT> | |
| max_limit_d(BoundsT const& max_) | |
| { return max_bounded_gen<BoundsT>(max_); } | |
| /////////////////////////////////////////////////////////////////////////// | |
| // | |
| // bounded class | |
| // | |
| /////////////////////////////////////////////////////////////////////////// | |
| template <typename BoundsT> | |
| struct bounded_gen; | |
| template <typename ParserT, typename BoundsT> | |
| struct bounded | |
| : public unary<ParserT, parser<bounded<ParserT, BoundsT> > > | |
| { | |
| typedef bounded<ParserT, BoundsT> self_t; | |
| typedef unary_parser_category parser_category_t; | |
| typedef bounded_gen<BoundsT> parser_generator_t; | |
| typedef unary<ParserT, parser<self_t> > base_t; | |
| template <typename ScannerT> | |
| struct result | |
| { | |
| typedef typename parser_result<ParserT, ScannerT>::type type; | |
| }; | |
| bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__) | |
| : base_t(p) | |
| , min_(min__) | |
| , max_(max__) {} | |
| template <typename ScannerT> | |
| typename parser_result<self_t, ScannerT>::type | |
| parse(ScannerT const& scan) const | |
| { | |
| typedef typename parser_result<self_t, ScannerT>::type result_t; | |
| result_t hit = this->subject().parse(scan); | |
| if (hit.has_valid_attribute() && | |
| (hit.value() < min_ || hit.value() > max_)) | |
| return scan.no_match(); | |
| return hit; | |
| } | |
| BoundsT min_, max_; | |
| }; | |
| template <typename BoundsT> | |
| struct bounded_gen | |
| { | |
| bounded_gen(BoundsT const& min__, BoundsT const& max__) | |
| : min_(min__) | |
| , max_(max__) {} | |
| template <typename DerivedT> | |
| bounded<DerivedT, BoundsT> | |
| operator[](parser<DerivedT> const& p) const | |
| { return bounded<DerivedT, BoundsT>(p.derived(), min_, max_); } | |
| BoundsT min_, max_; | |
| }; | |
| template <typename BoundsT> | |
| inline bounded_gen<BoundsT> | |
| limit_d(BoundsT const& min_, BoundsT const& max_) | |
| { return bounded_gen<BoundsT>(min_, max_); } | |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
| }} // namespace BOOST_SPIRIT_CLASSIC_NS | |
| #endif | |