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_ALTERNATIVE_HPP)
11 #define BOOST_SPIRIT_ALTERNATIVE_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     //  alternative 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 or b. One (not both) of the operands may
33     //      be a literal char, wchar_t or a primitive string char const*,
34     //      wchar_t const*.
35     //
36     //      The expression is short circuit evaluated. b is never touched
37     //      when a is returns a successful match.
38     //
39     ///////////////////////////////////////////////////////////////////////////
40     struct alternative_parser_gen;
41 
42 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
43 #pragma warning(push)
44 #pragma warning(disable:4512) //assignment operator could not be generated
45 #endif
46 
47     template <typename A, typename B>
48     struct alternative
49     :   public binary<A, B, parser<alternative<A, B> > >
50     {
51         typedef alternative<A, B>               self_t;
52         typedef binary_parser_category          parser_category_t;
53         typedef alternative_parser_gen          parser_generator_t;
54         typedef binary<A, B, parser<self_t> >   base_t;
55 
alternativeboost::spirit::alternative56         alternative(A const& a, B const& b)
57         : base_t(a, b) {}
58 
59         template <typename ScannerT>
60         typename parser_result<self_t, ScannerT>::type
parseboost::spirit::alternative61         parse(ScannerT const& scan) const
62         {
63             typedef typename parser_result<self_t, ScannerT>::type result_t;
64             typedef typename ScannerT::iterator_t iterator_t;
65             { // scope for save
66                 iterator_t save = scan.first;
67                 if (result_t hit = this->left().parse(scan))
68                     return hit;
69                 scan.first = save;
70             }
71             return this->right().parse(scan);
72         }
73     };
74 
75 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
76 #pragma warning(pop)
77 #endif
78 
79     struct alternative_parser_gen
80     {
81         template <typename A, typename B>
82         struct result
83         {
84             typedef
85                 alternative<
86                     typename as_parser<A>::type
87                   , typename as_parser<B>::type
88                 >
89             type;
90         };
91 
92         template <typename A, typename B>
93         static alternative<
94             typename as_parser<A>::type
95           , typename as_parser<B>::type
96         >
generateboost::spirit::alternative_parser_gen97         generate(A const& a, B const& b)
98         {
99             return alternative<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
100                 BOOST_DEDUCED_TYPENAME as_parser<B>::type>
101                     (as_parser<A>::convert(a), as_parser<B>::convert(b));
102         }
103     };
104 
105     template <typename A, typename B>
106     alternative<A, B>
107     operator|(parser<A> const& a, parser<B> const& b);
108 
109     template <typename A>
110     alternative<A, chlit<char> >
111     operator|(parser<A> const& a, char b);
112 
113     template <typename B>
114     alternative<chlit<char>, B>
115     operator|(char a, parser<B> const& b);
116 
117     template <typename A>
118     alternative<A, strlit<char const*> >
119     operator|(parser<A> const& a, char const* b);
120 
121     template <typename B>
122     alternative<strlit<char const*>, B>
123     operator|(char const* a, parser<B> const& b);
124 
125     template <typename A>
126     alternative<A, chlit<wchar_t> >
127     operator|(parser<A> const& a, wchar_t b);
128 
129     template <typename B>
130     alternative<chlit<wchar_t>, B>
131     operator|(wchar_t a, parser<B> const& b);
132 
133     template <typename A>
134     alternative<A, strlit<wchar_t const*> >
135     operator|(parser<A> const& a, wchar_t const* b);
136 
137     template <typename B>
138     alternative<strlit<wchar_t const*>, B>
139     operator|(wchar_t const* a, parser<B> const& b);
140 
141 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
142 
143 }} // namespace BOOST_SPIRIT_CLASSIC_NS
144 
145 #endif
146 
147 #include <boost/spirit/home/classic/core/composite/impl/alternative.ipp>
148