ceph/src/boost/libs/spirit/test/qi/grammar.cpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2010 Joel de Guzman
   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/detail/lightweight_test.hpp>
   8 #include <boost/spirit/include/qi_operator.hpp>
   9 #include <boost/spirit/include/qi_char.hpp>
  10 #include <boost/spirit/include/qi_string.hpp>
  11 #include <boost/spirit/include/qi_numeric.hpp>
  12 #include <boost/spirit/include/qi_nonterminal.hpp>
  13 #include <boost/spirit/include/qi_action.hpp>
  14 #include <boost/spirit/include/phoenix_core.hpp>
  15 #include <boost/spirit/include/phoenix_operator.hpp>
  16
  17 #include <string>
  18 #include <iostream>
  19 #include "test.hpp"
  20
  21 using spirit_test::test;
  22 using spirit_test::test_attr;
  23
  24 using boost::spirit::ascii::space_type;
  25 using boost::spirit::ascii::space;
  26 using boost::spirit::int_;
  27 using boost::spirit::qi::grammar;
  28 using boost::spirit::qi::rule;
  29 using boost::spirit::_val;
  30 using boost::spirit::_r1;
  31 using boost::spirit::lit;
  32
  33 struct num_list : grammar<char const*, space_type>
  34 {
  35     num_list() : base_type(start)
  36     {
  37         using boost::spirit::int_;
  38         num = int_;
  39         start = num >> *(',' >> num);
  40     }
  41
  42     rule<char const*, space_type> start, num;
  43 };
  44
  45 struct inh_g : grammar<char const*, int(int), space_type>
  46 {
  47     inh_g() : base_type(start)
  48     {
  49         start = lit("inherited")[_val = _r1];
  50     }
  51
  52     rule<char const*, int(int), space_type> start, num;
  53 };
  54
  55 struct my_skipper : grammar<char const*>
  56 {
  57     my_skipper() : base_type(start)
  58     {
  59         start = space;
  60     }
  61
  62     rule<char const*> start, num;
  63 };
  64
  65 struct num_list2 : grammar<char const*, my_skipper>
  66 {
  67     num_list2() : base_type(start)
  68     {
  69         using boost::spirit::int_;
  70         num = int_;
  71         start = num >> *(',' >> num);
  72     }
  73
  74     rule<char const*, my_skipper> start, num;
  75 };
  76
  77 template <typename Iterator, typename Skipper>
  78 struct num_list3 : grammar<Iterator, Skipper>
  79 {
  80     template <typename Class>
  81     num_list3(Class&) : grammar<Iterator, Skipper>(start)
  82     {
  83         using boost::spirit::int_;
  84         num = int_;
  85         start = num >> *(',' >> num);
  86     }
  87
  88     rule<Iterator, Skipper> start, num;
  89 };
  90
  91 int
  92 main()
  93 {
  94     { // simple grammar test
  95
  96         num_list nlist;
  97         BOOST_TEST(test("123, 456, 789", nlist, space));
  98     }
  99
 100     { // simple grammar test with user-skipper
 101
 102         num_list2 nlist;
 103         my_skipper skip;
 104         BOOST_TEST(test("123, 456, 789", nlist, skip));
 105     }
 106
 107     { // direct access to the rules
 108
 109         num_list g;
 110         BOOST_TEST(test("123", g.num, space));
 111         BOOST_TEST(test("123, 456, 789", g.start, space));
 112     }
 113
 114     { // grammar with inherited attributes
 115
 116         inh_g g;
 117         int n = -1;
 118         BOOST_TEST(test_attr("inherited", g.start(123), n, space)); // direct to the rule
 119         BOOST_TEST(n == 123);
 120         BOOST_TEST(test_attr("inherited", g(123), n, space)); // using the grammar
 121         BOOST_TEST(n == 123);
 122     }
 123
 124     return boost::report_errors();
 125 }
 126