PageRenderTime 52ms CodeModel.GetById 9ms app.highlight 35ms RepoModel.GetById 2ms app.codeStats 1ms

/src/contrib/boost/spirit/home/classic/core/scanner/skipper.hpp

http://pythonocc.googlecode.com/
C++ Header | 197 lines | 121 code | 34 blank | 42 comment | 2 complexity | 2797b5c85f0886c9ac2d7d8a00e230b2 MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 1998-2003 Joel de Guzman
  3    http://spirit.sourceforge.net/
  4
  5  Distributed under the Boost Software License, Version 1.0. (See accompanying
  6  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7=============================================================================*/
  8#if !defined(BOOST_SPIRIT_SKIPPER_HPP)
  9#define BOOST_SPIRIT_SKIPPER_HPP
 10
 11///////////////////////////////////////////////////////////////////////////////
 12#include <cctype>
 13
 14#include <boost/spirit/home/classic/namespace.hpp>
 15#include <boost/spirit/home/classic/core/scanner/scanner.hpp>
 16#include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp>
 17
 18#include <boost/spirit/home/classic/core/scanner/skipper_fwd.hpp>
 19
 20namespace boost { namespace spirit {
 21
 22BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 23
 24    ///////////////////////////////////////////////////////////////////////////
 25    //
 26    //  skipper_iteration_policy class
 27    //
 28    ///////////////////////////////////////////////////////////////////////////
 29    template <typename BaseT>
 30    struct skipper_iteration_policy : public BaseT
 31    {
 32        typedef BaseT base_t;
 33    
 34        skipper_iteration_policy()
 35        : BaseT() {}
 36    
 37        template <typename PolicyT>
 38        skipper_iteration_policy(PolicyT const& other)
 39        : BaseT(other) {}
 40    
 41        template <typename ScannerT>
 42        void
 43        advance(ScannerT const& scan) const
 44        {
 45            BaseT::advance(scan);
 46            scan.skip(scan);
 47        }
 48    
 49        template <typename ScannerT>
 50        bool
 51        at_end(ScannerT const& scan) const
 52        {
 53            scan.skip(scan);
 54            return BaseT::at_end(scan);
 55        }
 56    
 57        template <typename ScannerT>
 58        void
 59        skip(ScannerT const& scan) const
 60        {
 61            while (!BaseT::at_end(scan) && impl::isspace_(BaseT::get(scan)))
 62                BaseT::advance(scan);
 63        }
 64    };
 65    
 66    ///////////////////////////////////////////////////////////////////////////
 67    //
 68    //  no_skipper_iteration_policy class
 69    //
 70    ///////////////////////////////////////////////////////////////////////////
 71    template <typename BaseT>
 72    struct no_skipper_iteration_policy : public BaseT
 73    {
 74        typedef BaseT base_t;
 75
 76        no_skipper_iteration_policy()
 77        : BaseT() {}
 78
 79        template <typename PolicyT>
 80        no_skipper_iteration_policy(PolicyT const& other)
 81        : BaseT(other) {}
 82
 83        template <typename ScannerT>
 84        void
 85        skip(ScannerT const& /*scan*/) const {}
 86    };
 87
 88    ///////////////////////////////////////////////////////////////////////////
 89    //
 90    //  skip_parser_iteration_policy class
 91    //
 92    ///////////////////////////////////////////////////////////////////////////
 93    namespace impl
 94    {
 95        template <typename ST, typename ScannerT, typename BaseT>
 96        void
 97        skipper_skip(
 98            ST const& s,
 99            ScannerT const& scan,
100            skipper_iteration_policy<BaseT> const&);
101
102        template <typename ST, typename ScannerT, typename BaseT>
103        void
104        skipper_skip(
105            ST const& s,
106            ScannerT const& scan,
107            no_skipper_iteration_policy<BaseT> const&);
108
109        template <typename ST, typename ScannerT>
110        void
111        skipper_skip(
112            ST const& s,
113            ScannerT const& scan,
114            iteration_policy const&);
115    }
116
117    template <typename ParserT, typename BaseT>
118    class skip_parser_iteration_policy : public skipper_iteration_policy<BaseT>
119    {
120    public:
121    
122        typedef skipper_iteration_policy<BaseT> base_t;
123    
124        skip_parser_iteration_policy(
125            ParserT const& skip_parser,
126            base_t const& base = base_t())
127        : base_t(base), subject(skip_parser) {}
128    
129        template <typename PolicyT>
130        skip_parser_iteration_policy(PolicyT const& other)
131        : base_t(other), subject(other.skipper()) {}
132    
133        template <typename ScannerT>
134        void
135        skip(ScannerT const& scan) const
136        {
137            impl::skipper_skip(subject, scan, scan);
138        }
139    
140        ParserT const&
141        skipper() const
142        { 
143            return subject; 
144        }
145    
146    private:
147    
148        ParserT const& subject;
149    };
150    
151    ///////////////////////////////////////////////////////////////////////////////
152    //
153    //  Free parse functions using the skippers
154    //
155    ///////////////////////////////////////////////////////////////////////////////
156    template <typename IteratorT, typename ParserT, typename SkipT>
157    parse_info<IteratorT>
158    parse(
159        IteratorT const&        first,
160        IteratorT const&        last,
161        parser<ParserT> const&  p,
162        parser<SkipT> const&    skip);
163    
164    ///////////////////////////////////////////////////////////////////////////////
165    //
166    //  Parse function for null terminated strings using the skippers
167    //
168    ///////////////////////////////////////////////////////////////////////////////
169    template <typename CharT, typename ParserT, typename SkipT>
170    parse_info<CharT const*>
171    parse(
172        CharT const*            str,
173        parser<ParserT> const&  p,
174        parser<SkipT> const&    skip);
175    
176    ///////////////////////////////////////////////////////////////////////////////
177    //
178    //  phrase_scanner_t and wide_phrase_scanner_t
179    //
180    //      The most common scanners. Use these typedefs when you need
181    //      a scanner that skips white spaces.
182    //
183    ///////////////////////////////////////////////////////////////////////////////
184    typedef skipper_iteration_policy<>                  iter_policy_t;
185    typedef scanner_policies<iter_policy_t>             scanner_policies_t;
186    typedef scanner<char const*, scanner_policies_t>    phrase_scanner_t;
187    typedef scanner<wchar_t const*, scanner_policies_t> wide_phrase_scanner_t;
188    
189    ///////////////////////////////////////////////////////////////////////////////
190
191BOOST_SPIRIT_CLASSIC_NAMESPACE_END
192
193}} // namespace BOOST_SPIRIT_CLASSIC_NS
194
195#include <boost/spirit/home/classic/core/scanner/impl/skipper.ipp>
196#endif
197