PageRenderTime 32ms CodeModel.GetById 10ms app.highlight 17ms RepoModel.GetById 2ms app.codeStats 0ms

/src/contrib/boost/spirit/home/classic/core/composite/alternative.hpp

http://pythonocc.googlecode.com/
C++ Header | 147 lines | 97 code | 24 blank | 26 comment | 1 complexity | 2c010925b21485b07258f41711e003bb MD5 | raw file
  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
 19namespace boost { namespace spirit {
 20
 21BOOST_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    
 56        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
 61        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        >
 97        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
141BOOST_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>