ceph/src/boost/libs/spirit/classic/test/rule_tests.cpp

   1 /*=============================================================================
   2     Copyright (c) 1998-2003 Joel de Guzman
   3     http://spirit.sourceforge.net/
   4
   5     Use, modification and distribution is subject to the Boost Software
   6     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   7     http://www.boost.org/LICENSE_1_0.txt)
   8 =============================================================================*/
   9 #include <iostream>
  10
  11
  12 //#define BOOST_SPIRIT_DEBUG
  13 #define BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT 3
  14
  15 #include <boost/spirit/include/classic_core.hpp>
  16 #include <boost/spirit/include/classic_stored_rule.hpp>
  17
  18 #include <boost/core/lightweight_test.hpp>
  19
  20 using namespace BOOST_SPIRIT_CLASSIC_NS;
  21
  22 ///////////////////////////////////////////////////////////////////////////////
  23 //
  24 //  Rule tests
  25 //
  26 ///////////////////////////////////////////////////////////////////////////////
  27 void
  28 aliasing_tests()
  29 {
  30     rule<>  a = ch_p('a');
  31     rule<>  b = ch_p('b');
  32     rule<>  c = ch_p('c');
  33
  34     std::cout << "sizeof(rule<>): " << sizeof(rule<>) << std::endl;
  35
  36     BOOST_SPIRIT_DEBUG_RULE(a);
  37     BOOST_SPIRIT_DEBUG_RULE(b);
  38     BOOST_SPIRIT_DEBUG_RULE(c);
  39
  40     rule<>  start;
  41     BOOST_SPIRIT_DEBUG_RULE(start);
  42
  43     rule<>  d;
  44     d = start;  // aliasing
  45
  46     parse_info<char const*> pi;
  47
  48     start = *(a | b | c);
  49     pi = parse("abcabcacb", d);
  50     BOOST_TEST(pi.hit);
  51     BOOST_TEST(pi.full);
  52     BOOST_TEST(pi.length == 9);
  53     BOOST_TEST(*pi.stop == 0);
  54
  55     start   = (a | b) >> (start | b);
  56     pi = parse("aaaabababaaabbb", d);
  57     BOOST_TEST(pi.hit);
  58     BOOST_TEST(pi.full);
  59     BOOST_TEST(pi.length == 15);
  60     BOOST_TEST(*pi.stop == 0);
  61 }
  62
  63 void
  64 rule_template_param_tests()
  65 {
  66     // test that rules can be issued its template params in any order:
  67
  68     rule<> rx1;
  69     rule<scanner<> > rx2;
  70     rule<scanner<>, parser_context<> > rx3;
  71     rule<scanner<>, parser_context<>, parser_address_tag> rx4;
  72
  73     rule<parser_context<> > rx5;
  74     rule<parser_context<>, parser_address_tag> rx6;
  75     rule<parser_context<>, parser_address_tag, scanner<> > rx7;
  76
  77     rule<parser_address_tag> rx8;
  78     rule<parser_address_tag, scanner<> > rx9;
  79     rule<parser_address_tag, scanner<>, parser_context<> > rx10;
  80
  81     rule<parser_address_tag, parser_context<> > rx11;
  82     rule<parser_address_tag, parser_context<>, scanner<> > rx12;
  83
  84     rule<parser_context<>, scanner<> > rx13;
  85     rule<parser_context<>, scanner<>, parser_address_tag> rx14;
  86 }
  87
  88 struct my_grammar : public grammar<my_grammar>
  89 {
  90     template <typename ScannerT>
  91     struct definition
  92     {
  93         definition(my_grammar const& /*self*/)
  94         {
  95             r = lower_p;
  96             rr = +(lexeme_d[r] >> as_lower_d[r] >> r);
  97         }
  98
  99         typedef scanner_list<
 100             ScannerT
 101           , typename lexeme_scanner<ScannerT>::type
 102           , typename as_lower_scanner<ScannerT>::type
 103         > scanners;
 104
 105         rule<scanners> r;
 106         rule<ScannerT> rr;
 107         rule<ScannerT> const& start() const { return rr; }
 108     };
 109 };
 110
 111 void
 112 rule_2_or_more_scanners_tests()
 113 {
 114     { // 2 scanners
 115         typedef scanner_list<scanner<>, phrase_scanner_t> scanners;
 116
 117         rule<scanners>  r = +anychar_p;
 118         BOOST_TEST(parse("abcdefghijk", r).full);
 119         BOOST_TEST(parse("a b c d e f g h i j k", r, space_p).full);
 120     }
 121
 122     { // 3 scanners
 123         my_grammar g;
 124         BOOST_TEST(parse("abcdef aBc d e f aBc d E f", g, space_p).full);
 125     }
 126 }
 127
 128 void
 129 rule_basic_tests()
 130 {
 131     rule<>  a = ch_p('a');
 132     rule<>  b = ch_p('b');
 133     rule<>  c = ch_p('c');
 134
 135     BOOST_SPIRIT_DEBUG_RULE(a);
 136     BOOST_SPIRIT_DEBUG_RULE(b);
 137     BOOST_SPIRIT_DEBUG_RULE(c);
 138
 139     parse_info<char const*> pi;
 140
 141     rule<>  start = *(a | b | c);
 142
 143     BOOST_SPIRIT_DEBUG_RULE(start);
 144
 145     pi = parse("abcabcacb", start);
 146     BOOST_TEST(pi.hit);
 147     BOOST_TEST(pi.full);
 148     BOOST_TEST(pi.length == 9);
 149     BOOST_TEST(*pi.stop == 0);
 150
 151     start   = (a | b) >> (start | b);
 152     pi = parse("aaaabababaaabbb", start);
 153     BOOST_TEST(pi.hit);
 154     BOOST_TEST(pi.full);
 155     BOOST_TEST(pi.length == 15);
 156     BOOST_TEST(*pi.stop == 0);
 157
 158     pi = parse("aaaabababaaabba", start);
 159     BOOST_TEST(pi.hit);
 160     BOOST_TEST(!pi.full);
 161     BOOST_TEST(pi.length == 14);
 162
 163     rule<> r = anychar_p;
 164     r.copy(); // copy test (compile only)
 165 }
 166
 167 void
 168 stored_rule_basic_tests()
 169 {
 170     stored_rule<>  a = ch_p('a');
 171     stored_rule<>  b = ch_p('b');
 172     stored_rule<>  c = ch_p('c');
 173
 174     BOOST_SPIRIT_DEBUG_RULE(a);
 175     BOOST_SPIRIT_DEBUG_RULE(b);
 176     BOOST_SPIRIT_DEBUG_RULE(c);
 177
 178     parse_info<char const*> pi;
 179
 180     stored_rule<>  start = *(a | b | c);
 181
 182     BOOST_SPIRIT_DEBUG_RULE(start);
 183
 184     pi = parse("abcabcacb", start);
 185     BOOST_TEST(pi.hit);
 186     BOOST_TEST(pi.full);
 187     BOOST_TEST(pi.length == 9);
 188     BOOST_TEST(*pi.stop == 0);
 189
 190     start   = (a | b) >> (start | b);
 191     pi = parse("aaaabababaaabbb", start);
 192     BOOST_TEST(pi.hit);
 193     BOOST_TEST(pi.full);
 194     BOOST_TEST(pi.length == 15);
 195     BOOST_TEST(*pi.stop == 0);
 196
 197     pi = parse("aaaabababaaabba", start);
 198     BOOST_TEST(pi.hit);
 199     BOOST_TEST(!pi.full);
 200     BOOST_TEST(pi.length == 14);
 201 }
 202
 203 void
 204 stored_rule_dynamic_tests()
 205 {
 206     rule<>  a = ch_p('a');
 207     rule<>  b = ch_p('b');
 208     rule<>  c = ch_p('c');
 209
 210     BOOST_SPIRIT_DEBUG_RULE(a);
 211     BOOST_SPIRIT_DEBUG_RULE(b);
 212     BOOST_SPIRIT_DEBUG_RULE(c);
 213
 214     parse_info<char const*> pi;
 215
 216     // The FF is the dynamic equivalent of start = *(a | b | c);
 217     stored_rule<>  start = a;
 218     start = start.copy() | b;
 219     start = start.copy() | c;
 220     start = *(start.copy());
 221
 222     std::cout << "sizeof(stored_rule<>): " << sizeof(stored_rule<>) << std::endl;
 223
 224     BOOST_SPIRIT_DEBUG_RULE(start);
 225
 226     pi = parse("abcabcacb", start);
 227     BOOST_TEST(pi.hit);
 228     BOOST_TEST(pi.full);
 229     BOOST_TEST(pi.length == 9);
 230     BOOST_TEST(*pi.stop == 0);
 231
 232     // The FF is the dynamic equivalent of start = (a | b) >> (start | b);
 233     start = b;
 234     start = a | start.copy();
 235     start = start.copy() >> (start | b);
 236
 237     pi = parse("aaaabababaaabbb", start);
 238     BOOST_TEST(pi.hit);
 239     BOOST_TEST(pi.full);
 240     BOOST_TEST(pi.length == 15);
 241     BOOST_TEST(*pi.stop == 0);
 242
 243     pi = parse("aaaabababaaabba", start);
 244     BOOST_TEST(pi.hit);
 245     BOOST_TEST(!pi.full);
 246     BOOST_TEST(pi.length == 14);
 247 }
 248
 249 ///////////////////////////////////////////////////////////////////////////////
 250 //
 251 //  Main
 252 //
 253 ///////////////////////////////////////////////////////////////////////////////
 254 int
 255 main()
 256 {
 257     rule_basic_tests();
 258     aliasing_tests();
 259     rule_template_param_tests();
 260     rule_2_or_more_scanners_tests();
 261     stored_rule_basic_tests();
 262     stored_rule_dynamic_tests();
 263
 264     return boost::report_errors();
 265 }
 266