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_PARSER_HPP)
9#define BOOST_SPIRIT_PARSER_HPP
10
11#include <boost/config.hpp>
12#include <boost/type_traits/remove_reference.hpp>
13#include <boost/spirit/home/classic/namespace.hpp>
14#include <boost/spirit/home/classic/core/scanner/scanner.hpp>
15#include <boost/spirit/home/classic/core/nil.hpp>
16
17namespace boost { namespace spirit {
18
19BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
20
21 template <typename ParserT, typename ActionT>
22 class action; // forward declaration
23
24 ///////////////////////////////////////////////////////////////////////////
25 //
26 // Parser categories
27 //
28 // Helper template classes to distinguish different types of
29 // parsers. The following categories are the most generic. More
30 // specific types may inherit from these. Each parser has a typedef
31 // parser_category_t that defines its category. By default, if one
32 // is not specified, it will inherit from the base parser class
33 // which typedefs its parser_category_t as plain_parser_category.
34 //
35 // - plain parser has nothing special
36 // - binary parser has subject a and b (e.g. alternative)
37 // - unary parser has single subject (e.g. kleene star)
38 // - action parser has an attached action parser
39 //
40 ///////////////////////////////////////////////////////////////////////////
41 struct plain_parser_category {};
42 struct binary_parser_category : plain_parser_category {};
43 struct unary_parser_category : plain_parser_category {};
44 struct action_parser_category : unary_parser_category {};
45
46 ///////////////////////////////////////////////////////////////////////////
47 //
48 // parser_result metafunction
49 //
50 // Given a scanner type ScannerT and a parser type ParserT, the
51 // parser_result metafunction provides the actual result of the
52 // parser.
53 //
54 // Usage:
55 //
56 // typename parser_result<ParserT, ScannerT>::type
57 //
58 ///////////////////////////////////////////////////////////////////////////
59 template <typename ParserT, typename ScannerT>
60 struct parser_result
61 {
62 typedef typename boost::remove_reference<ParserT>::type parser_type;
63 typedef typename parser_type::template result<ScannerT>::type type;
64 };
65
66 ///////////////////////////////////////////////////////////////////////////
67 //
68 // parser class
69 //
70 // This class is a protocol base class for all parsers. This is
71 // essentially an interface contract. The parser class does not
72 // really know how to parse anything but instead relies on the
73 // template parameter DerivedT (which obviously is assumed to be a
74 // subclass) to do the actual parsing.
75 //
76 // Concrete sub-classes inheriting from parser must have a
77 // corresponding member function parse(...) compatible with the
78 // conceptual Interface:
79 //
80 // template <typename ScannerT>
81 // RT parse(ScannerT const& scan) const;
82 //
83 // where RT is the desired return type of the parser and ScannerT
84 // scan is the scanner (see scanner.hpp).
85 //
86 // Concrete sub-classes inheriting from parser in most cases need to
87 // have a nested meta-function result that returns the result type
88 // of the parser's parse member function, given a scanner type. The
89 // meta-function has the form:
90 //
91 // template <typename ScannerT>
92 // struct result
93 // {
94 // typedef RT type;
95 // };
96 //
97 // where RT is the desired return type of the parser. This is
98 // usually, but not always, dependent on the template parameter
99 // ScannerT. If a parser does not supply a result metafunction, a
100 // default is provided by the base parser class.
101 //
102 // The parser's derived() member function returns a reference to the
103 // parser as its derived object.
104 //
105 // An operator[] is provided. The operator returns a semantic action
106 // handler (see actions.hpp).
107 //
108 // Each parser has a typedef embed_t. This typedef specifies how a
109 // parser is embedded in a composite (see composite.hpp). By
110 // default, if one is not specified, the parser will be embedded by
111 // value. That is, a copy of the parser is placed as a member
112 // variable of the composite. Most parsers are embedded by value. In
113 // certain situations however, this is not desirable or possible.
114 //
115 ///////////////////////////////////////////////////////////////////////////
116 template <typename DerivedT>
117 struct parser
118 {
119 typedef DerivedT embed_t;
120 typedef DerivedT derived_t;
121 typedef plain_parser_category parser_category_t;
122
123 template <typename ScannerT>
124 struct result
125 {
126 typedef typename match_result<ScannerT, nil_t>::type type;
127 };
128
129 DerivedT& derived()
130 {
131 return *static_cast<DerivedT*>(this);
132 }
133
134 DerivedT const& derived() const
135 {
136 return *static_cast<DerivedT const*>(this);
137 }
138
139 template <typename ActionT>
140 action<DerivedT, ActionT>
141 operator[](ActionT const& actor) const
142 {
143 return action<DerivedT, ActionT>(derived(), actor);
144 }
145 };
146
147 ///////////////////////////////////////////////////////////////////////////
148 //
149 // parse_info
150 //
151 // Results returned by the free parse functions:
152 //
153 // stop: points to the final parse position (i.e parsing
154 // processed the input up to this point).
155 //
156 // hit: true if parsing is successful. This may be full:
157 // the parser consumed all the input, or partial:
158 // the parser consumed only a portion of the input.
159 //
160 // full: true when we have a full hit (i.e the parser
161 // consumed all the input.
162 //
163 // length: The number of characters consumed by the parser.
164 // This is valid only if we have a successful hit
165 // (either partial or full).
166 //
167 ///////////////////////////////////////////////////////////////////////////
168 template <typename IteratorT = char const*>
169 struct parse_info
170 {
171 IteratorT stop;
172 bool hit;
173 bool full;
174 std::size_t length;
175
176 parse_info(
177 IteratorT const& stop_ = IteratorT(),
178 bool hit_ = false,
179 bool full_ = false,
180 std::size_t length_ = 0)
181 : stop(stop_)
182 , hit(hit_)
183 , full(full_)
184 , length(length_) {}
185
186 template <typename ParseInfoT>
187 parse_info(ParseInfoT const& pi)
188 : stop(pi.stop)
189 , hit(pi.hit)
190 , full(pi.full)
191 , length(pi.length) {}
192 };
193
194 ///////////////////////////////////////////////////////////////////////////
195 //
196 // Generic parse function
197 //
198 ///////////////////////////////////////////////////////////////////////////
199 template <typename IteratorT, typename DerivedT>
200 parse_info<IteratorT>
201 parse(
202 IteratorT const& first,
203 IteratorT const& last,
204 parser<DerivedT> const& p);
205
206 ///////////////////////////////////////////////////////////////////////////
207 //
208 // Parse function for null terminated strings
209 //
210 ///////////////////////////////////////////////////////////////////////////
211 template <typename CharT, typename DerivedT>
212 parse_info<CharT const*>
213 parse(
214 CharT const* str,
215 parser<DerivedT> const& p);
216
217BOOST_SPIRIT_CLASSIC_NAMESPACE_END
218
219}} // namespace BOOST_SPIRIT_CLASSIC_NS
220
221#endif
222
223#include <boost/spirit/home/classic/core/impl/parser.ipp>
224

source code of boost/libs/spirit/include/boost/spirit/home/classic/core/parser.hpp