Line data    Source code

       1             : /*=============================================================================
       2             :     Copyright (c) 1998-2003 Joel de Guzman
       3             :     Copyright (c) 2001 Daniel Nuffer
       4             :     Copyright (c) 2002 Hartmut Kaiser
       5             :     http://spirit.sourceforge.net/
       6             : 
       7             :   Distributed under the Boost Software License, Version 1.0. (See accompanying
       8             :   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       9             : =============================================================================*/
      10             : #if !defined(BOOST_SPIRIT_SEQUENCE_HPP)
      11             : #define BOOST_SPIRIT_SEQUENCE_HPP
      12             : 
      13             : #include <boost/spirit/home/classic/namespace.hpp>
      14             : #include <boost/spirit/home/classic/core/parser.hpp>
      15             : #include <boost/spirit/home/classic/core/primitives/primitives.hpp>
      16             : #include <boost/spirit/home/classic/core/composite/composite.hpp>
      17             : #include <boost/spirit/home/classic/meta/as_parser.hpp>
      18             : 
      19             : namespace boost { namespace spirit {
      20             : 
      21             : BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
      22             : 
      23             :     ///////////////////////////////////////////////////////////////////////////
      24             :     //
      25             :     //  sequence class
      26             :     //
      27             :     //      Handles expressions of the form:
      28             :     //
      29             :     //          a >> b
      30             :     //
      31             :     //      where a and b are parsers. The expression returns a composite
      32             :     //      parser that matches a and b in sequence. One (not both) of the
      33             :     //      operands may be a literal char, wchar_t or a primitive string
      34             :     //      char const*, wchar_t const*.
      35             :     //
      36             :     //////////////////////////////////////////////////////////////////////////
      37             :     struct sequence_parser_gen;
      38             :     
      39             : #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
      40             : #pragma warning(push)
      41             : #pragma warning(disable:4512) //assignment operator could not be generated
      42             : #endif
      43             : 
      44             :     template <typename A, typename B>
      45             :     struct sequence : public binary<A, B, parser<sequence<A, B> > >
      46             :     {
      47             :         typedef sequence<A, B>                  self_t;
      48             :         typedef binary_parser_category          parser_category_t;
      49             :         typedef sequence_parser_gen             parser_generator_t;
      50             :         typedef binary<A, B, parser<self_t> >   base_t;
      51             :     
      52           0 :         sequence(A const& a, B const& b)
      53           0 :         : base_t(a, b) {}
      54             :     
      55             :         template <typename ScannerT>
      56             :         typename parser_result<self_t, ScannerT>::type
      57           0 :         parse(ScannerT const& scan) const
      58             :         {
      59             :             typedef typename parser_result<self_t, ScannerT>::type result_t;
      60           0 :             if (result_t ma = this->left().parse(scan))
      61           0 :                 if (result_t mb = this->right().parse(scan))
      62             :                 {
      63           0 :                     scan.concat_match(ma, mb);
      64           0 :                     return ma;
      65             :                 }
      66           0 :             return scan.no_match();
      67             :         }
      68             :     };
      69             : 
      70             : #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
      71             : #pragma warning(pop)
      72             : #endif
      73             :     
      74             :     struct sequence_parser_gen
      75             :     {
      76             :         template <typename A, typename B>
      77             :         struct result 
      78             :         {
      79             :             typedef
      80             :                 sequence<
      81             :                     typename as_parser<A>::type
      82             :                   , typename as_parser<B>::type
      83             :                 >
      84             :             type;
      85             :         };
      86             :     
      87             :         template <typename A, typename B>
      88             :         static sequence<
      89             :             typename as_parser<A>::type
      90             :           , typename as_parser<B>::type
      91             :         >
      92             :         generate(A const& a, B const& b)
      93             :         {
      94             :             return sequence<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
      95             :                 BOOST_DEDUCED_TYPENAME as_parser<B>::type>
      96             :                     (as_parser<A>::convert(a), as_parser<B>::convert(b));
      97             :         }
      98             :     };
      99             :     
     100             :     template <typename A, typename B>
     101             :     sequence<A, B>
     102             :     operator>>(parser<A> const& a, parser<B> const& b);
     103             :     
     104             :     template <typename A>
     105             :     sequence<A, chlit<char> >
     106             :     operator>>(parser<A> const& a, char b);
     107             :     
     108             :     template <typename B>
     109             :     sequence<chlit<char>, B>
     110             :     operator>>(char a, parser<B> const& b);
     111             :     
     112             :     template <typename A>
     113             :     sequence<A, strlit<char const*> >
     114             :     operator>>(parser<A> const& a, char const* b);
     115             :     
     116             :     template <typename B>
     117             :     sequence<strlit<char const*>, B>
     118             :     operator>>(char const* a, parser<B> const& b);
     119             :     
     120             :     template <typename A>
     121             :     sequence<A, chlit<wchar_t> >
     122             :     operator>>(parser<A> const& a, wchar_t b);
     123             :     
     124             :     template <typename B>
     125             :     sequence<chlit<wchar_t>, B>
     126             :     operator>>(wchar_t a, parser<B> const& b);
     127             :     
     128             :     template <typename A>
     129             :     sequence<A, strlit<wchar_t const*> >
     130             :     operator>>(parser<A> const& a, wchar_t const* b);
     131             :     
     132             :     template <typename B>
     133             :     sequence<strlit<wchar_t const*>, B>
     134             :     operator>>(wchar_t const* a, parser<B> const& b);
     135             :     
     136             : BOOST_SPIRIT_CLASSIC_NAMESPACE_END
     137             : 
     138             : }} // namespace BOOST_SPIRIT_CLASSIC_NS
     139             : 
     140             : #endif
     141             : 
     142             : #include <boost/spirit/home/classic/core/composite/impl/sequence.ipp>