ceph/src/boost/libs/spirit/test/lex/regression_wide.cpp

   1 //  Copyright (c) 2001-2010 Hartmut Kaiser
   2 //  Copyright (c) 2010 Sergey "GooRoo" Olendarenko
   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/config/warning_disable.hpp>
   9
  10 #include <cstdlib>
  11 #include <iostream>
  12 #include <locale>
  13 #include <string>
  14
  15 #include <boost/spirit/include/lex_lexertl.hpp>
  16 #include <boost/spirit/include/phoenix_object.hpp>
  17 #include <boost/spirit/include/phoenix_operator.hpp>
  18 #include <boost/spirit/include/phoenix_statement.hpp>
  19 #include <boost/spirit/include/phoenix_container.hpp>
  20
  21 namespace lex = boost::spirit::lex;
  22 namespace phoenix = boost::phoenix;
  23
  24 typedef std::basic_string<wchar_t> wstring_type;
  25
  26 ///////////////////////////////////////////////////////////////////////////////
  27 enum tokenids
  28 {
  29     ID_IDENT = 1,
  30     ID_CONSTANT,
  31     ID_OPERATION,
  32     ID_BRACKET
  33 };
  34
  35 ///////////////////////////////////////////////////////////////////////////////
  36 struct test_data
  37 {
  38     tokenids     tokenid;
  39     wstring_type value;
  40 };
  41
  42 // alpha+x1*(2.836-x2[i])
  43 test_data data[] =
  44 {
  45     { ID_IDENT, L"alpha" },
  46     { ID_OPERATION, L"+" },
  47     { ID_IDENT, L"x1" },
  48     { ID_OPERATION, L"*" },
  49     { ID_BRACKET, L"(" },
  50     { ID_CONSTANT, L"2.836" },
  51     { ID_OPERATION, L"-" },
  52     { ID_IDENT, L"x2" },
  53     { ID_BRACKET, L"[" },
  54     { ID_IDENT, L"i" },
  55     { ID_BRACKET, L"]" },
  56     { ID_BRACKET, L")" }
  57 };
  58
  59 ///////////////////////////////////////////////////////////////////////////////
  60 struct test_impl
  61 {
  62     typedef void result_type;
  63     template <typename TokenId, typename Value>
  64     struct result { typedef void type; };
  65
  66     template <typename TokenId, typename Value>
  67     void operator()(TokenId const& tokenid, Value const& val) const
  68     {
  69         BOOST_TEST(sequence_counter < sizeof(data)/sizeof(data[0]));
  70         BOOST_TEST(data[sequence_counter].tokenid == tokenid);
  71         BOOST_TEST(0 == val.which());
  72
  73         typedef boost::iterator_range<wstring_type::iterator> iterator_range;
  74         iterator_range r = boost::get<iterator_range>(val);
  75         BOOST_TEST(data[sequence_counter].value ==
  76             wstring_type(r.begin(), r.end()));
  77
  78         ++sequence_counter;
  79     }
  80
  81     static std::size_t sequence_counter;
  82 };
  83 std::size_t test_impl::sequence_counter = 0;
  84
  85 phoenix::function<test_impl> const test = test_impl();
  86
  87 ///////////////////////////////////////////////////////////////////////////////
  88 template <typename Lexer>
  89 struct mega_tokens : lex::lexer<Lexer>
  90 {
  91     mega_tokens()
  92         : identifier(L"[a-zA-Z_][a-zA-Z0-9_]*", ID_IDENT)
  93         , constant  (L"[0-9]+(\\.[0-9]+)?", ID_CONSTANT)
  94         , operation (L"[\\+\\-\\*/]", ID_OPERATION)
  95         , bracket   (L"[\\(\\)\\[\\]]", ID_BRACKET)
  96     {
  97         using lex::_tokenid;
  98         using lex::_val;
  99
 100         this->self
 101             = operation  [ test(_tokenid, _val) ]
 102             | identifier [ test(_tokenid, _val) ]
 103             | constant   [ test(_tokenid, _val) ]
 104             | bracket    [ test(_tokenid, _val) ]
 105         ;
 106     }
 107
 108     lex::token_def<wstring_type, wchar_t, tokenids> identifier;
 109     lex::token_def<double, wchar_t, tokenids> constant;
 110     lex::token_def<wchar_t, wchar_t, tokenids> operation;
 111     lex::token_def<wchar_t, wchar_t, tokenids> bracket;
 112 };
 113
 114 ///////////////////////////////////////////////////////////////////////////////
 115 int main()
 116 {
 117     typedef wstring_type::iterator base_iterator;
 118     typedef lex::lexertl::token<
 119         base_iterator, boost::mpl::vector<wchar_t, wstring_type, double>
 120       , boost::mpl::true_, tokenids
 121     > token_type;
 122     typedef lex::lexertl::actor_lexer<token_type> lexer_type;
 123
 124     mega_tokens<lexer_type> mega_lexer;
 125
 126     wstring_type exampleStr = L"alpha+x1*(2.836-x2[i])";
 127     base_iterator first = exampleStr.begin();
 128
 129     BOOST_TEST(lex::tokenize(first, exampleStr.end(), mega_lexer));
 130     BOOST_TEST(test_impl::sequence_counter == sizeof(data)/sizeof(data[0]));
 131
 132     return boost::report_errors();
 133 }