1 // Copyright (c) 2001-2010 Hartmut Kaiser
2 // Copyright (c) 2009 Francois Barel
3 //
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6
7 #include <boost/config/warning_disable.hpp>
8 #include <boost/detail/lightweight_test.hpp>
9
10 #include <boost/spirit/include/karma_operator.hpp>
11 #include <boost/spirit/include/karma_char.hpp>
12 #include <boost/spirit/include/karma_auxiliary.hpp>
13 #include <boost/spirit/include/karma_string.hpp>
14 #include <boost/spirit/include/karma_numeric.hpp>
15 #include <boost/spirit/include/karma_nonterminal.hpp>
16 #include <boost/spirit/include/karma_action.hpp>
17 #include <boost/spirit/include/phoenix_core.hpp>
18 #include <boost/spirit/include/phoenix_operator.hpp>
19 #include <boost/spirit/include/phoenix_statement.hpp>
20 #include <boost/spirit/include/phoenix_fusion.hpp>
21
22 #include <boost/spirit/repository/include/karma_subrule.hpp>
23
24 #include "test.hpp"
25
26 using namespace spirit_test;
27
28 ///////////////////////////////////////////////////////////////////////////////
main()29 int main()
30 {
31 using namespace boost;
32 using namespace boost::spirit;
33 using namespace boost::spirit::karma;
34 // using namespace boost::spirit::ascii;
35 using boost::spirit::repository::karma::subrule;
36
37 typedef spirit_test::output_iterator<char>::type outiter_type;
38
39 // basic tests
40 {
41 rule<outiter_type> start;
42 subrule<0> sr;
43
44 start = (
45 sr = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4]
46 );
47 BOOST_TEST(test("a1012.4", start));
48
49 BOOST_TEST(test("a1012.4", (
50 sr = (char_ << int_ << double_)[(_1 = 'a', _2 = 10, _3 = 12.4)]
51 )));
52
53 subrule<1> a;
54 subrule<2> b;
55 subrule<3> c;
56
57 start = (
58 sr = a << b << c
59 , a = char_[_1 = 'a']
60 , b = int_[_1 = 10]
61 , c = double_[_1 = 12.4]
62 );
63 BOOST_TEST(test("a1012.4", start));
64 }
65
66 // basic tests with delimiter
67 {
68 rule<outiter_type, space_type> start;
69 subrule<0> sr;
70
71 start = (
72 sr = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4]
73 );
74 BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
75
76 BOOST_TEST(test_delimited("a 10 12.4 ", (
77 sr = (char_ << int_ << double_)[(_1 = 'a', _2 = 10, _3 = 12.4)]
78 ), space));
79
80 subrule<1> a;
81 subrule<2> b;
82 subrule<3> c;
83
84 start = (
85 sr = a << b << c
86 , a = char_[_1 = 'a']
87 , b = int_[_1 = 10]
88 , c = double_[_1 = 12.4]
89 );
90 BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
91 }
92
93 // basic tests involving a direct parameter
94 {
95 typedef variant<char, int, double> var_type;
96
97 rule<outiter_type, var_type()> start;
98 subrule<0, var_type()> sr;
99
100 start = (
101 sr = (char_ | int_ | double_)[_1 = _r0]
102 )[_1 = _val];
103
104 var_type v ('a');
105 BOOST_TEST(test("a", start, v));
106 v = 10;
107 BOOST_TEST(test("10", start, v));
108 v = 12.4;
109 BOOST_TEST(test("12.4", start, v));
110 }
111
112 {
113 typedef variant<char, int, double> var_type;
114
115 rule<outiter_type, space_type, var_type()> start;
116 subrule<0, var_type()> sr;
117
118 start %= (
119 sr = (char_ | int_ | double_)[_1 = _r0]
120 );
121
122 var_type v ('a');
123 BOOST_TEST(test_delimited("a ", start, v, space));
124 v = 10;
125 BOOST_TEST(test_delimited("10 ", start, v, space));
126 v = 12.4;
127 BOOST_TEST(test_delimited("12.4 ", start, v, space));
128 }
129
130 {
131 rule<outiter_type, void(char, int, double)> start;
132 subrule<0, void(char, int, double)> sr;
133
134 start = (
135 sr = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3]
136 )(_r1, _r2, _r3);
137 BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
138
139 BOOST_TEST(test("a1012.4", (
140 sr = (char_ << int_ << double_)[(_1 = _r1, _2 = _r2, _3 = _r3)]
141 )('a', 10, 12.4)));
142
143 subrule<1, void(char, int, double)> entry;
144 subrule<2, void(char)> a;
145 subrule<3, void(int)> b;
146 subrule<4, void(double)> c;
147
148 start = (
149 entry = a(_r1) << b(_r2) << c(_r3)
150 , a = char_[_1 = _r1]
151 , b = int_[_1 = _r1]
152 , c = double_[_1 = _r1]
153 )(_r1, _r2, _r3);
154 BOOST_TEST(test("a1012.4", start('a', 10, 12.4)));
155 }
156
157 {
158 rule<outiter_type, space_type, void(char, int, double)> start;
159 subrule<0, void(char, int, double)> sr;
160
161 start = (
162 sr = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3]
163 )(_r1, _r2, _r3);
164 BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
165
166 BOOST_TEST(test_delimited("a 10 12.4 ", (
167 sr = (char_ << int_ << double_)[(_1 = _r1, _2 = _r2, _3 = _r3)]
168 )('a', 10, 12.4), space));
169
170 subrule<1, void(char, int, double)> entry;
171 subrule<2, void(char)> a;
172 subrule<3, void(int)> b;
173 subrule<4, void(double)> c;
174
175 start = (
176 entry = a(_r1) << b(_r2) << c(_r3)
177 , a = char_[_1 = _r1]
178 , b = int_[_1 = _r1]
179 , c = double_[_1 = _r1]
180 )(_r1, _r2, _r3);
181 BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space));
182 }
183
184 return boost::report_errors();
185 }
186
187