]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*============================================================================= |
2 | Copyright (c) 2001-2011 Joel de Guzman | |
3 | Copyright (c) 2001-2011 Hartmut Kaiser | |
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 | #include <boost/detail/lightweight_test.hpp> | |
9 | #include <boost/mpl/print.hpp> | |
10 | #include <boost/spirit/include/qi_operator.hpp> | |
11 | #include <boost/spirit/include/qi_char.hpp> | |
12 | #include <boost/spirit/include/qi_string.hpp> | |
13 | #include <boost/spirit/include/qi_numeric.hpp> | |
14 | #include <boost/spirit/include/qi_directive.hpp> | |
15 | #include <boost/spirit/include/qi_action.hpp> | |
16 | #include <boost/spirit/include/qi_nonterminal.hpp> | |
17 | #include <boost/spirit/include/qi_auxiliary.hpp> | |
18 | #include <boost/spirit/include/qi_rule.hpp> | |
19 | #include <boost/spirit/include/support_argument.hpp> | |
20 | #include <boost/spirit/include/phoenix_core.hpp> | |
21 | #include <boost/spirit/include/phoenix_operator.hpp> | |
22 | #include <boost/fusion/include/adapt_struct.hpp> | |
23 | #include <boost/variant.hpp> | |
24 | #include <boost/assert.hpp> | |
25 | ||
26 | #include <string> | |
27 | #include <iostream> | |
28 | #include <vector> | |
29 | #include "test.hpp" | |
30 | ||
31 | struct test_action | |
32 | { | |
33 | test_action(char last) | |
34 | : last_(last) {} | |
35 | ||
36 | template<typename Context> | |
37 | void operator()(std::vector<char> const& v, Context const&, bool&) const | |
38 | { | |
39 | BOOST_TEST(v.size() == 4 && | |
40 | v[0] == 'a' && v[1] == 'b' && v[2] == '1' && v[3] == last_); | |
41 | } | |
42 | ||
43 | char last_; | |
44 | }; | |
45 | ||
46 | struct test_action_2 | |
47 | { | |
48 | typedef std::vector<boost::optional<char> > result_type; | |
49 | ||
50 | template<typename Context> | |
51 | void operator()(result_type const& v, Context const&, bool&) const | |
52 | { | |
53 | BOOST_TEST(v.size() == 5 && | |
54 | !v[0] && v[1] == 'a' && v[2] == 'b' && v[3] == '1' && v[4] == '2'); | |
55 | } | |
56 | }; | |
57 | ||
58 | struct DIgnore | |
59 | { | |
60 | std::string text; | |
61 | }; | |
62 | ||
63 | struct DInclude | |
64 | { | |
65 | std::string FileName; | |
66 | }; | |
67 | ||
68 | BOOST_FUSION_ADAPT_STRUCT( | |
69 | DIgnore, | |
70 | (std::string, text) | |
71 | ) | |
72 | ||
73 | BOOST_FUSION_ADAPT_STRUCT( | |
74 | DInclude, | |
75 | (std::string, FileName) | |
76 | ) | |
77 | ||
78 | int | |
79 | main() | |
80 | { | |
81 | using spirit_test::test; | |
82 | using spirit_test::test_attr; | |
83 | ||
84 | using boost::spirit::ascii::char_; | |
85 | using boost::spirit::qi::int_; | |
86 | using boost::spirit::qi::lit; | |
87 | using boost::spirit::qi::unused_type; | |
88 | using boost::spirit::qi::_1; | |
89 | using boost::spirit::qi::omit; | |
90 | ||
91 | { | |
92 | BOOST_TEST((test("a", char_ | char_))); | |
93 | BOOST_TEST((test("x", lit('x') | lit('i')))); | |
94 | BOOST_TEST((test("i", lit('x') | lit('i')))); | |
95 | BOOST_TEST((!test("z", lit('x') | lit('o')))); | |
96 | BOOST_TEST((test("rock", lit("rock") | lit("roll")))); | |
97 | BOOST_TEST((test("roll", lit("rock") | lit("roll")))); | |
98 | BOOST_TEST((test("rock", lit("rock") | int_))); | |
99 | BOOST_TEST((test("12345", lit("rock") | int_))); | |
100 | } | |
101 | ||
102 | { | |
103 | boost::variant<unused_type, int, char> v; | |
104 | ||
105 | BOOST_TEST((test_attr("12345", lit("rock") | int_ | char_, v))); | |
106 | BOOST_TEST(boost::get<int>(v) == 12345); | |
107 | ||
108 | BOOST_TEST((test_attr("rock", lit("rock") | int_ | char_, v))); | |
109 | BOOST_TEST(v.which() == 1); | |
110 | ||
111 | BOOST_TEST((test_attr("x", lit("rock") | int_ | char_, v))); | |
112 | BOOST_TEST(boost::get<char>(v) == 'x'); | |
113 | } | |
114 | ||
115 | { // Make sure that we are using the actual supplied attribute types | |
116 | // from the variant and not the expected type. | |
117 | // $$$ Fixed: <2/19/2011> JDG $$$ | |
118 | boost::variant<int, std::string> v; | |
119 | BOOST_TEST((test_attr("12345", int_ | +char_, v))); | |
120 | BOOST_TEST(boost::get<int>(v) == 12345); | |
121 | ||
122 | BOOST_TEST((test_attr("abc", int_ | +char_, v))); | |
123 | BOOST_TEST(boost::get<std::string>(v) == "abc"); | |
124 | ||
125 | BOOST_TEST((test_attr("12345", +char_ | int_, v))); | |
126 | BOOST_TEST(boost::get<std::string>(v) == "12345"); | |
127 | } | |
128 | ||
129 | { // test action | |
130 | ||
131 | namespace phx = boost::phoenix; | |
132 | boost::optional<boost::variant<int, char> > v; | |
133 | ||
134 | BOOST_TEST((test("12345", (lit("rock") | int_ | char_)[phx::ref(v) = _1]))); | |
135 | BOOST_TEST(boost::get<int>(boost::get(v)) == 12345); | |
136 | BOOST_TEST((test("rock", (lit("rock") | int_ | char_)[phx::ref(v) = _1]))); | |
137 | BOOST_TEST(!v); | |
138 | } | |
139 | ||
140 | { | |
141 | unused_type x; | |
142 | BOOST_TEST((test_attr("rock", lit("rock") | lit('x'), x))); | |
143 | } | |
144 | ||
145 | { | |
146 | // test if alternatives with all components having unused | |
147 | // attributes have an unused attribute | |
148 | ||
149 | using boost::fusion::vector; | |
150 | using boost::fusion::at_c; | |
151 | ||
152 | vector<char, char> v; | |
153 | BOOST_TEST((test_attr("abc", | |
154 | char_ >> (omit[char_] | omit[char_]) >> char_, v))); | |
155 | BOOST_TEST((at_c<0>(v) == 'a')); | |
156 | BOOST_TEST((at_c<1>(v) == 'c')); | |
157 | } | |
158 | ||
159 | { | |
160 | // Test that we can still pass a "compatible" attribute to | |
161 | // an alternate even if its "expected" attribute is unused type. | |
162 | ||
163 | std::string s; | |
164 | BOOST_TEST((test_attr("...", *(char_('.') | char_(',')), s))); | |
165 | BOOST_TEST(s == "..."); | |
166 | } | |
167 | ||
168 | { // make sure collapsing eps works as expected | |
169 | // (compile check only) | |
170 | ||
171 | using boost::spirit::qi::rule; | |
172 | using boost::spirit::qi::_val; | |
173 | using boost::spirit::qi::_1; | |
174 | using boost::spirit::eps; | |
175 | rule<const wchar_t*, wchar_t()> r1, r2, r3; | |
176 | ||
177 | r3 = ((eps >> r1))[_val += _1]; | |
178 | r3 = ((r1 ) | r2)[_val += _1]; | |
179 | ||
180 | r3 %= ((eps >> r1) | r2); | |
181 | r3 = ((eps >> r1) | r2)[_val += _1]; | |
182 | } | |
183 | ||
184 | // make sure the attribute of an alternative gets properly collapsed | |
185 | { | |
186 | using boost::spirit::qi::lexeme; | |
187 | using boost::spirit::ascii::alnum; | |
188 | using boost::spirit::ascii::alpha; | |
189 | using boost::spirit::ascii::digit; | |
190 | using boost::spirit::ascii::string; | |
191 | namespace phx = boost::phoenix; | |
192 | ||
193 | ||
194 | BOOST_TEST( (test("ab1_", (*(alnum | char_('_')))[test_action('_')])) ); | |
195 | BOOST_TEST( (test("ab12", (*(alpha | digit))[test_action('2')])) ); | |
196 | ||
197 | BOOST_TEST( (test("abcab12", (*("abc" | alnum))[test_action_2()])) ); | |
198 | ||
199 | std::vector<boost::optional<char> > v; | |
200 | BOOST_TEST( (test("x,y,z", (*(',' | char_))[phx::ref(v) = _1])) ); | |
201 | BOOST_ASSERT(v[0] == 'x'); | |
202 | BOOST_ASSERT(!v[1]); | |
203 | BOOST_ASSERT(v[2] == 'y'); | |
204 | BOOST_ASSERT(!v[3]); | |
205 | BOOST_ASSERT(v[4] == 'z'); | |
206 | } | |
207 | ||
208 | { | |
209 | using boost::spirit::qi::eps; | |
210 | ||
211 | // testing a sequence taking a container as attribute | |
212 | std::string s; | |
213 | BOOST_TEST( (test_attr("abc,a,b,c", | |
214 | char_ >> char_ >> (char_ % ','), s )) ); | |
215 | BOOST_TEST(s == "abcabc"); | |
216 | ||
217 | // test having an optional<container> inside a sequence | |
218 | s.erase(); | |
219 | BOOST_TEST( (test_attr("ab", | |
220 | char_ >> char_ >> -(char_ % ','), s )) ); | |
221 | BOOST_TEST(s == "ab"); | |
222 | ||
223 | // test having a variant<container, ...> inside a sequence | |
224 | s.erase(); | |
225 | BOOST_TEST( (test_attr("ab", | |
226 | char_ >> char_ >> ((char_ % ',') | eps), s )) ); | |
227 | BOOST_TEST(s == "ab"); | |
228 | s.erase(); | |
229 | BOOST_TEST( (test_attr("abc", | |
230 | char_ >> char_ >> ((char_ % ',') | eps), s )) ); | |
231 | BOOST_TEST(s == "abc"); | |
232 | } | |
233 | ||
234 | { | |
235 | using boost::spirit::qi::int_; | |
236 | ||
237 | int i = 0; | |
238 | BOOST_TEST( (test_attr("10", int_(5) | int_(10), i)) ); | |
239 | BOOST_TEST(i == 10); | |
240 | } | |
241 | ||
242 | { | |
243 | //compile test only (bug_march_10_2011_8_35_am) | |
244 | typedef boost::variant<double, std::string> value_type; | |
245 | ||
246 | using boost::spirit::qi::rule; | |
247 | using boost::spirit::qi::eps; | |
248 | rule<std::string::const_iterator, value_type()> r1 = r1 | eps; | |
249 | } | |
250 | ||
251 | { | |
252 | using boost::spirit::qi::rule; | |
253 | typedef boost::variant<DIgnore, DInclude> DLine; | |
254 | ||
255 | rule<char*, DIgnore()> ignore; | |
256 | rule<char*, DInclude()> include; | |
257 | rule<char*, DLine()> line = include | ignore; | |
258 | } | |
259 | ||
260 | return boost::report_errors(); | |
261 | } | |
262 |