1// Copyright (c) 2001-2011 Hartmut Kaiser
2//
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6#include <boost/spirit/include/karma_operator.hpp>
7#include <boost/spirit/include/karma_char.hpp>
8#include <boost/spirit/include/karma_auxiliary.hpp>
9#include <boost/spirit/include/karma_string.hpp>
10#include <boost/spirit/include/karma_numeric.hpp>
11#include <boost/spirit/include/karma_nonterminal.hpp>
12#include <boost/spirit/include/karma_action.hpp>
13#include <boost/phoenix/core.hpp>
14#include <boost/phoenix/operator.hpp>
15
16#include "test.hpp"
17
18using namespace spirit_test;
19
20///////////////////////////////////////////////////////////////////////////////
21int main()
22{
23 using namespace boost;
24 using namespace boost::spirit;
25 using namespace boost::spirit::ascii;
26
27 typedef spirit_test::output_iterator<char>::type outiter_type;
28
29 // locals test
30 {
31 karma::rule<outiter_type, locals<std::string> > start;
32
33 start = string[(_1 = "abc", _a = _1)] << int_[_1 = 10] << string[_1 = _a];
34 BOOST_TEST(test("abc10abc", start));
35 }
36
37 {
38 karma::rule<outiter_type, space_type, locals<std::string> > start;
39
40 start = string[(_1 = "abc", _a = _1)] << int_[_1 = 10] << string[_1 = _a];
41 BOOST_TEST(test_delimited("abc 10 abc ", start, space));
42 }
43
44 // alias tests
45 {
46 typedef variant<char, int, double> var_type;
47
48 karma::rule<outiter_type, var_type()> d, start;
49
50 d = start.alias(); // d will always track start
51
52 start = (char_ | int_ | double_)[_1 = _val];
53
54 var_type v ('a');
55 BOOST_TEST(test("a", d, v));
56 v = 10;
57 BOOST_TEST(test("10", d, v));
58 v = 12.4;
59 BOOST_TEST(test("12.4", d, v));
60 }
61
62 {
63 typedef variant<char, int, double> var_type;
64
65 karma::rule<outiter_type, space_type, var_type()> d, start;
66
67 d = start.alias(); // d will always track start
68
69 start = (char_ | int_ | double_)[_1 = _val];
70
71 var_type v ('a');
72 BOOST_TEST(test_delimited("a ", d, v, space));
73 v = 10;
74 BOOST_TEST(test_delimited("10 ", d, v, space));
75 v = 12.4;
76 BOOST_TEST(test_delimited("12.4 ", d, v, space));
77 }
78
79 {
80 typedef variant<char, int, double> var_type;
81
82 karma::rule<outiter_type, var_type()> d, start;
83
84 d = start.alias(); // d will always track start
85
86 start %= char_ | int_ | double_;
87
88 var_type v ('a');
89 BOOST_TEST(test("a", d, v));
90 v = 10;
91 BOOST_TEST(test("10", d, v));
92 v = 12.4;
93 BOOST_TEST(test("12.4", d, v));
94
95 start = char_ | int_ | double_;
96
97 v = 'a';
98 BOOST_TEST(test("a", d, v));
99 v = 10;
100 BOOST_TEST(test("10", d, v));
101 v = 12.4;
102 BOOST_TEST(test("12.4", d, v));
103 }
104
105 {
106 typedef variant<char, int, double> var_type;
107
108 karma::rule<outiter_type, space_type, var_type()> d, start;
109
110 d = start.alias(); // d will always track start
111
112 start %= char_ | int_ | double_;
113
114 var_type v ('a');
115 BOOST_TEST(test_delimited("a ", d, v, space));
116 v = 10;
117 BOOST_TEST(test_delimited("10 ", d, v, space));
118 v = 12.4;
119 BOOST_TEST(test_delimited("12.4 ", d, v, space));
120
121 start = char_ | int_ | double_;
122
123 v = 'a';
124 BOOST_TEST(test_delimited("a ", d, v, space));
125 v = 10;
126 BOOST_TEST(test_delimited("10 ", d, v, space));
127 v = 12.4;
128 BOOST_TEST(test_delimited("12.4 ", d, v, space));
129 }
130
131 ///////////////////////////////////////////////////////////////////////////
132 {
133 using boost::spirit::karma::int_;
134 using boost::spirit::karma::_1;
135 using boost::spirit::karma::_val;
136 using boost::spirit::karma::space;
137 using boost::spirit::karma::space_type;
138
139 karma::rule<outiter_type, int()> r1 = int_;
140 karma::rule<outiter_type, space_type, int()> r2 = int_;
141
142 int i = 123;
143 int j = 456;
144 BOOST_TEST(test("123", r1[_1 = _val], i));
145 BOOST_TEST(test_delimited("456 ", r2[_1 = _val], j, space));
146 }
147
148 return boost::report_errors();
149}
150
151

source code of boost/libs/spirit/test/karma/pattern2.cpp