]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 1998-2003 Joel de Guzman | |
3 | Copyright (c) 2001 Daniel Nuffer | |
4 | Copyright (c) 2001 Bruce Florman | |
5 | Copyright (c) 2002 Raghavendra Satish | |
6 | http://spirit.sourceforge.net/ | |
7 | ||
8 | Use, modification and distribution is subject to the Boost Software | |
9 | License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
10 | http://www.boost.org/LICENSE_1_0.txt) | |
11 | =============================================================================*/ | |
12 | #if !defined(BOOST_SPIRIT_DIRECTIVES_IPP) | |
13 | #define BOOST_SPIRIT_DIRECTIVES_IPP | |
14 | ||
15 | /////////////////////////////////////////////////////////////////////////////// | |
16 | #include <boost/spirit/home/classic/core/scanner/skipper.hpp> | |
17 | ||
18 | namespace boost { namespace spirit { | |
19 | ||
20 | BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
21 | ||
22 | template <typename BaseT> | |
23 | struct no_skipper_iteration_policy; | |
24 | ||
25 | template <typename BaseT> | |
26 | struct inhibit_case_iteration_policy; | |
27 | ||
28 | template <typename A, typename B> | |
29 | struct alternative; | |
30 | ||
31 | template <typename A, typename B> | |
32 | struct longest_alternative; | |
33 | ||
34 | template <typename A, typename B> | |
35 | struct shortest_alternative; | |
36 | ||
37 | namespace impl | |
38 | { | |
39 | template <typename RT, typename ST, typename ScannerT, typename BaseT> | |
40 | inline RT | |
41 | contiguous_parser_parse( | |
42 | ST const& s, | |
43 | ScannerT const& scan, | |
44 | skipper_iteration_policy<BaseT> const&) | |
45 | { | |
46 | typedef scanner_policies< | |
47 | no_skipper_iteration_policy< | |
48 | BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, | |
49 | BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, | |
50 | BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t | |
51 | > policies_t; | |
52 | ||
53 | scan.skip(scan); | |
54 | RT hit = s.parse(scan.change_policies(policies_t(scan))); | |
55 | // We will not do a post skip!!! | |
56 | return hit; | |
57 | } | |
58 | ||
59 | template <typename RT, typename ST, typename ScannerT, typename BaseT> | |
60 | inline RT | |
61 | contiguous_parser_parse( | |
62 | ST const& s, | |
63 | ScannerT const& scan, | |
64 | no_skipper_iteration_policy<BaseT> const&) | |
65 | { | |
66 | return s.parse(scan); | |
67 | } | |
68 | ||
69 | template <typename RT, typename ST, typename ScannerT> | |
70 | inline RT | |
71 | contiguous_parser_parse( | |
72 | ST const& s, | |
73 | ScannerT const& scan, | |
74 | iteration_policy const&) | |
75 | { | |
76 | return s.parse(scan); | |
77 | } | |
78 | ||
79 | template < | |
80 | typename RT, | |
81 | typename ParserT, | |
82 | typename ScannerT, | |
83 | typename BaseT> | |
84 | inline RT | |
85 | implicit_lexeme_parse( | |
86 | ParserT const& p, | |
87 | ScannerT const& scan, | |
88 | skipper_iteration_policy<BaseT> const&) | |
89 | { | |
90 | typedef scanner_policies< | |
91 | no_skipper_iteration_policy< | |
92 | BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, | |
93 | BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, | |
94 | BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t | |
95 | > policies_t; | |
96 | ||
97 | scan.skip(scan); | |
98 | RT hit = p.parse_main(scan.change_policies(policies_t(scan))); | |
99 | // We will not do a post skip!!! | |
100 | return hit; | |
101 | } | |
102 | ||
103 | template < | |
104 | typename RT, | |
105 | typename ParserT, | |
106 | typename ScannerT, | |
107 | typename BaseT> | |
108 | inline RT | |
109 | implicit_lexeme_parse( | |
110 | ParserT const& p, | |
111 | ScannerT const& scan, | |
112 | no_skipper_iteration_policy<BaseT> const&) | |
113 | { | |
114 | return p.parse_main(scan); | |
115 | } | |
116 | ||
117 | template <typename RT, typename ParserT, typename ScannerT> | |
118 | inline RT | |
119 | implicit_lexeme_parse( | |
120 | ParserT const& p, | |
121 | ScannerT const& scan, | |
122 | iteration_policy const&) | |
123 | { | |
124 | return p.parse_main(scan); | |
125 | } | |
126 | ||
127 | template <typename RT, typename ST, typename ScannerT> | |
128 | inline RT | |
129 | inhibit_case_parser_parse( | |
130 | ST const& s, | |
131 | ScannerT const& scan, | |
132 | iteration_policy const&) | |
133 | { | |
134 | typedef scanner_policies< | |
135 | inhibit_case_iteration_policy< | |
136 | BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, | |
137 | BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, | |
138 | BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t | |
139 | > policies_t; | |
140 | ||
141 | return s.parse(scan.change_policies(policies_t(scan))); | |
142 | } | |
143 | ||
144 | template <typename RT, typename ST, typename ScannerT, typename BaseT> | |
145 | inline RT | |
146 | inhibit_case_parser_parse( | |
147 | ST const& s, | |
148 | ScannerT const& scan, | |
149 | inhibit_case_iteration_policy<BaseT> const&) | |
150 | { | |
151 | return s.parse(scan); | |
152 | } | |
153 | ||
154 | template <typename T> | |
155 | struct to_longest_alternative | |
156 | { | |
157 | typedef T result_t; | |
158 | static result_t const& | |
159 | convert(T const& a) // Special (end) case | |
160 | { return a; } | |
161 | }; | |
162 | ||
163 | template <typename A, typename B> | |
164 | struct to_longest_alternative<alternative<A, B> > | |
165 | { | |
166 | typedef typename to_longest_alternative<A>::result_t a_t; | |
167 | typedef typename to_longest_alternative<B>::result_t b_t; | |
168 | typedef longest_alternative<a_t, b_t> result_t; | |
169 | ||
170 | static result_t | |
171 | convert(alternative<A, B> const& alt) // Recursive case | |
172 | { | |
173 | return result_t( | |
174 | to_longest_alternative<A>::convert(alt.left()), | |
175 | to_longest_alternative<B>::convert(alt.right())); | |
176 | } | |
177 | }; | |
178 | ||
179 | template <typename T> | |
180 | struct to_shortest_alternative | |
181 | { | |
182 | typedef T result_t; | |
183 | static result_t const& | |
184 | convert(T const& a) // Special (end) case | |
185 | { return a; } | |
186 | }; | |
187 | ||
188 | template <typename A, typename B> | |
189 | struct to_shortest_alternative<alternative<A, B> > | |
190 | { | |
191 | typedef typename to_shortest_alternative<A>::result_t a_t; | |
192 | typedef typename to_shortest_alternative<B>::result_t b_t; | |
193 | typedef shortest_alternative<a_t, b_t> result_t; | |
194 | ||
195 | static result_t | |
196 | convert(alternative<A, B> const& alt) // Recursive case | |
197 | { | |
198 | return result_t( | |
199 | to_shortest_alternative<A>::convert(alt.left()), | |
200 | to_shortest_alternative<B>::convert(alt.right())); | |
201 | } | |
202 | }; | |
203 | } | |
204 | ||
205 | BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
206 | ||
207 | }} // namespace boost::spirit | |
208 | ||
209 | #endif | |
210 |