| /*============================================================================= |
| Copyright (c) 2001-2011 Joel de Guzman |
| Copyright (c) 2011 Thomas Bernard |
| |
| Distributed under the Boost Software License, Version 1.0. (See accompanying |
| file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| =============================================================================*/ |
| |
| #define FUSION_MAX_VECTOR_SIZE 50 |
| #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS |
| #define BOOST_MPL_LIMIT_LIST_SIZE 50 |
| #define BOOST_MPL_LIMIT_VECTOR_SIZE 50 |
| |
| #include "../measure.hpp" |
| #include <boost/config/warning_disable.hpp> |
| #include <boost/spirit/include/qi.hpp> |
| #include <boost/spirit/include/phoenix_core.hpp> |
| #include <boost/spirit/include/phoenix_operator.hpp> |
| #include <boost/spirit/include/phoenix_object.hpp> |
| #include <boost/spirit/include/phoenix_fusion.hpp> |
| #include <boost/spirit/include/phoenix_container.hpp> |
| #include <boost/fusion/include/adapt_struct.hpp> |
| #include <boost/fusion/include/io.hpp> |
| #include <boost/spirit/include/qi_permutation.hpp> |
| #include <boost/spirit/home/qi/string/tst_map.hpp> |
| #include <boost/spirit/repository/include/qi_kwd.hpp> |
| #include <boost/spirit/repository/include/qi_keywords.hpp> |
| #include <boost/optional.hpp> |
| #include <boost/spirit/home/phoenix/core/argument.hpp> |
| #include <boost/spirit/home/phoenix/bind/bind_member_variable.hpp> |
| |
| #include <iostream> |
| #include <string> |
| #include <complex> |
| #include <vector> |
| #include <iterator> |
| #include <stdexcept> |
| |
| #include <boost/preprocessor/control/if.hpp> |
| #include <boost/preprocessor/seq/for_each_i.hpp> |
| #include <boost/preprocessor/seq/size.hpp> |
| #include <boost/preprocessor/cat.hpp> |
| #include <boost/preprocessor/stringize.hpp> |
| |
| #define KEYS_5 |
| |
| #include "keywords.hpp" |
| |
| #define declOptions(r, data, i, elem) boost::optional<int> BOOST_PP_CAT(option,i); |
| #define fusionOptions(r, data, i, elem) (boost::optional<int>, BOOST_PP_CAT(option,i)) |
| |
| |
| namespace client |
| { |
| namespace qi = boost::spirit::qi; |
| namespace ascii = boost::spirit::ascii; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Our parsedData struct |
| /////////////////////////////////////////////////////////////////////////// |
| //[tutorial_parsedData_struct |
| struct parsedDataOptions |
| { |
| BOOST_PP_SEQ_FOR_EACH_I(declOptions,_,keys) |
| }; |
| struct parsedData |
| { |
| |
| std::string name; |
| parsedDataOptions options; |
| void clear() |
| { |
| name.clear(); |
| } |
| }; |
| |
| struct parsedData2 |
| { |
| std::string name; |
| BOOST_PP_SEQ_FOR_EACH_I(declOptions,_,keys) |
| |
| void clear() |
| { |
| name.clear(); |
| } |
| }; |
| } |
| |
| std::ostream &operator<<(std::ostream & os, client::parsedData &data) |
| { |
| os << data.name <<std::endl; |
| |
| #define generateOutput1(r, d, i, elem) if( BOOST_PP_CAT(data.options.option, i) ) os<< BOOST_PP_STRINGIZE( BOOST_PP_CAT(option,i)) <<" "<< * BOOST_PP_CAT(data.options.option , i)<<std::endl; |
| BOOST_PP_SEQ_FOR_EACH_I(generateOutput1,_,keys) |
| |
| os<<std::endl; |
| |
| return os; |
| } |
| |
| std::ostream &operator<<(std::ostream & os, client::parsedData2 &data) |
| { |
| os << data.name <<std::endl; |
| |
| #define generateOutput2(r, d, i, elem) if(BOOST_PP_CAT(data.option, i)) os<< BOOST_PP_STRINGIZE( BOOST_PP_CAT(option,i)) <<" "<< * BOOST_PP_CAT(data.option,i)<<std::endl; |
| BOOST_PP_SEQ_FOR_EACH_I(generateOutput2,_,keys) |
| |
| os<<std::endl; |
| |
| return os; |
| } |
| |
| |
| |
| BOOST_FUSION_ADAPT_STRUCT( |
| client::parsedDataOptions, |
| BOOST_PP_SEQ_FOR_EACH_I(fusionOptions,_,keys) |
| ) |
| |
| BOOST_FUSION_ADAPT_STRUCT( |
| client::parsedData, |
| (std::string, name) |
| (client::parsedDataOptions, options) |
| ) |
| |
| BOOST_FUSION_ADAPT_STRUCT( |
| client::parsedData2, |
| (std::string, name) |
| BOOST_PP_SEQ_FOR_EACH_I(fusionOptions,_,keys) |
| ) |
| enum variation |
| { |
| full, |
| no_assign, |
| assign |
| }; |
| namespace client |
| { |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Our parsedData parser |
| /////////////////////////////////////////////////////////////////////////////// |
| //[tutorial_parsedData_parser |
| template <typename Iterator> |
| struct permutation_parser : qi::grammar<Iterator, parsedData(), ascii::space_type> |
| { |
| permutation_parser() : permutation_parser::base_type(start) |
| { |
| using qi::int_; |
| using qi::lit; |
| using qi::double_; |
| using qi::lexeme; |
| using ascii::char_; |
| using boost::phoenix::at_c; |
| using boost::phoenix::assign; |
| using qi::_r1; |
| using qi::_1; |
| using qi::_val; |
| using qi::omit; |
| using qi::repeat; |
| |
| |
| quoted_string %= lexeme[+(char_-' ')]; |
| |
| #define generateOptions1(r, data, i, elem) BOOST_PP_IF(i, ^(lit(elem) > int_) , (lit(elem) > int_)) |
| options = (BOOST_PP_SEQ_FOR_EACH_I(generateOptions1,_,keys)); |
| |
| start %= |
| quoted_string |
| >> options; |
| ; |
| v_vals = repeat(1,2)[int_]; |
| } |
| |
| typedef parsedData parser_target_type; |
| |
| qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; |
| qi::rule<Iterator, parsedDataOptions(), ascii::space_type> options; |
| qi::rule<Iterator, std::vector<int>(), ascii::space_type> v_vals; |
| |
| qi::rule<Iterator, parsedData(), ascii::space_type> start; |
| }; |
| |
| template <typename Iterator> |
| struct alternative_parser : qi::grammar<Iterator, parsedData2(), ascii::space_type> |
| { |
| alternative_parser() : alternative_parser::base_type(start) |
| { |
| using qi::int_; |
| using qi::lit; |
| using qi::double_; |
| using qi::lexeme; |
| using ascii::char_; |
| using boost::phoenix::at_c; |
| using qi::_r1; |
| using qi::_1; |
| using qi::_val; |
| |
| quoted_string %= lexeme[+(char_-' ')]; |
| |
| #define generateOptions2(r, data, i, elem) BOOST_PP_IF(i, |(lit(elem) > int_[at_c<i+1>(_r1)=_1]) , (lit(elem) > int_[at_c<i+1>(_r1)=_1])) |
| options = (BOOST_PP_SEQ_FOR_EACH_I(generateOptions2,_,keys)); |
| |
| start = |
| quoted_string [at_c<0>(_val)=_1] |
| >> *options(_val); |
| ; |
| } |
| |
| typedef parsedData2 parser_target_type; |
| |
| qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; |
| qi::rule<Iterator, void(parsedData2 & ), ascii::space_type> options; |
| qi::rule<Iterator, parsedData2(), ascii::space_type> start; |
| }; |
| |
| |
| |
| template <typename Iterator,typename variation> |
| struct tst_parser : qi::grammar<Iterator, parsedData2(), ascii::space_type> |
| { |
| typedef variation variation_type; |
| |
| tst_parser() : tst_parser::base_type(startalias) |
| { |
| namespace phx = boost::phoenix; |
| using qi::int_; |
| using qi::lit; |
| using qi::double_; |
| using qi::lexeme; |
| using ascii::char_; |
| using boost::phoenix::at_c; |
| using qi::_r1; |
| using qi::_1; |
| using qi::_a; |
| using qi::_val; |
| using qi::locals; |
| using qi::parameterized_nonterminal; |
| |
| startalias = start.alias(); |
| quoted_string %= lexeme[+(char_-' ')]; |
| |
| #define generateRules(r, data, i, elem) BOOST_PP_CAT(rule,i) = int_[phx::at_c<i+1>(*phx::ref(currentObj))=_1]; |
| BOOST_PP_SEQ_FOR_EACH_I(generateRules,_,keys) |
| |
| #define generateOptions3(r, data, i, elem) (elem,& BOOST_PP_CAT(rule,i)) |
| |
| |
| options.add BOOST_PP_SEQ_FOR_EACH_I(generateOptions3,_,keys); |
| switch(variation_type::value) |
| { |
| case full: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options [_a=_1] >> lazy(*_a)); |
| ; |
| break; |
| } |
| case no_assign: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options >> int_); |
| ; |
| break; |
| } |
| case assign: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options [_a=_1] >> int_); |
| ; |
| break; |
| } |
| } |
| |
| |
| } |
| |
| parsedData2 *currentObj; |
| |
| typedef parsedData2 parser_target_type; |
| |
| qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; |
| typedef qi::rule<Iterator, ascii::space_type> optionsRule; |
| #define declareRules(r, data, i, elem) optionsRule BOOST_PP_CAT(rule,i); |
| |
| BOOST_PP_SEQ_FOR_EACH_I(declareRules,_,keys) |
| |
| qi::symbols<char,optionsRule* > options; |
| qi::rule<Iterator, parsedData2(), ascii::space_type> startalias; |
| qi::rule<Iterator, parsedData2(), qi::locals<optionsRule*>, ascii::space_type> start; |
| }; |
| |
| |
| |
| template <typename Iterator,typename variation> |
| struct tst_map_parser : qi::grammar<Iterator, parsedData2(), ascii::space_type> |
| { |
| typedef variation variation_type; |
| tst_map_parser() : tst_map_parser::base_type(startalias) |
| { |
| namespace phx = boost::phoenix; |
| using qi::int_; |
| using qi::lit; |
| using qi::double_; |
| using qi::lexeme; |
| using ascii::char_; |
| using boost::phoenix::at_c; |
| using qi::_r1; |
| using qi::_1; |
| using qi::_a; |
| using qi::_val; |
| using qi::locals; |
| using qi::parameterized_nonterminal; |
| |
| startalias = start.alias(); |
| quoted_string %= lexeme[+(char_-' ')]; |
| |
| #define generateRules3(r, data, i, elem) BOOST_PP_CAT(rule,i) = int_[phx::at_c<i+1>(*phx::ref(currentObj))=_1]; |
| BOOST_PP_SEQ_FOR_EACH_I(generateRules3,_,keys) |
| |
| #define generateOptions3(r, data, i, elem) (elem,& BOOST_PP_CAT(rule,i)) |
| |
| |
| options.add BOOST_PP_SEQ_FOR_EACH_I(generateOptions3,_,keys); |
| |
| switch(variation_type::value) |
| { |
| case full: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options [_a=_1] >> lazy(*_a)); |
| ; |
| break; |
| } |
| case no_assign: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options >> int_); |
| ; |
| break; |
| } |
| case assign: |
| { |
| start = |
| quoted_string [at_c<0>(_val)=_1][phx::ref(currentObj)=&_val] |
| >> *( options [_a=_1] >> int_); |
| ; |
| break; |
| } |
| } |
| } |
| |
| parsedData2 *currentObj; |
| |
| typedef parsedData2 parser_target_type; |
| |
| qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; |
| typedef qi::rule<Iterator, ascii::space_type> optionsRule; |
| #define declareRules(r, data, i, elem) optionsRule BOOST_PP_CAT(rule,i); |
| |
| BOOST_PP_SEQ_FOR_EACH_I(declareRules,_,keys) |
| |
| qi::symbols<char,optionsRule*, boost::spirit::qi::tst_map<char,optionsRule*> > options; |
| qi::rule<Iterator, parsedData2(), ascii::space_type> startalias; |
| qi::rule<Iterator, parsedData2(), qi::locals<optionsRule*>, ascii::space_type> start; |
| }; |
| |
| |
| template <typename Iterator> |
| struct kwd_parser : qi::grammar<Iterator, parsedData(), ascii::space_type> |
| { |
| kwd_parser() : kwd_parser::base_type(start) |
| { |
| using qi::int_; |
| using qi::lit; |
| using qi::double_; |
| using qi::lexeme; |
| using ascii::char_; |
| using qi::_r1; |
| using qi::_1; |
| using qi::_val; |
| using boost::spirit::repository::qi::kwd; |
| |
| quoted_string %= lexeme[+(char_-' ')]; |
| |
| #define generateOptions4(r, data, i, elem) BOOST_PP_IF(i, / kwd( elem )[ int_ ] , kwd( elem )[ int_ ] ) |
| options = (BOOST_PP_SEQ_FOR_EACH_I(generateOptions4,_,keys)); |
| |
| start %= |
| quoted_string |
| >> options; |
| ; |
| } |
| |
| typedef parsedData parser_target_type; |
| |
| qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; |
| qi::rule<Iterator, parsedDataOptions(), ascii::space_type> options; |
| qi::rule<Iterator, boost::fusion::vector<boost::optional<int>,boost::optional<int> > () , ascii::space_type> v_vals; |
| |
| qi::rule<Iterator, parsedData(), ascii::space_type> start; |
| }; |
| |
| } |
| |
| |
| template <typename parserType> |
| struct timeParser : test::base{ |
| timeParser(const std::string & str) : str(str) |
| { |
| } |
| parserType &get_parser(){ |
| static parserType parser; |
| return parser; |
| } |
| |
| std::string str; |
| |
| void benchmark() |
| { |
| |
| using boost::spirit::ascii::space; |
| bool r = false; |
| std::string::const_iterator end = str.end(); |
| std::string::const_iterator iter = str.begin(); |
| |
| |
| typename parserType::parser_target_type data; |
| r = phrase_parse(iter, end, get_parser(), space, data); |
| |
| if (r && iter == end) |
| { |
| this->val += data.name.size(); |
| } |
| else |
| { |
| throw std::runtime_error("Parsing failed"); |
| } |
| } |
| |
| }; |
| |
| |
| |
| |
| typedef std::string::const_iterator iterator_type; |
| typedef client::permutation_parser<iterator_type> permutation_parser; |
| typedef client::kwd_parser<iterator_type> kwd_parser; |
| typedef client::alternative_parser<iterator_type> alternative_parser; |
| typedef client::tst_map_parser<iterator_type, boost::mpl::int_<full> > tst_map_parser; |
| |
| struct permutation_timer_fwd : timeParser<permutation_parser> |
| { |
| permutation_timer_fwd() : timeParser<permutation_parser>(fwd) {} |
| }; |
| |
| struct permutation_timer_back : timeParser<permutation_parser> |
| { |
| permutation_timer_back() : timeParser<permutation_parser>(back) {} |
| }; |
| |
| struct alternative_timer_fwd : timeParser<alternative_parser> |
| { |
| alternative_timer_fwd() : timeParser<alternative_parser>(fwd) {} |
| }; |
| |
| struct alternative_timer_back : timeParser<alternative_parser> |
| { |
| alternative_timer_back() : timeParser<alternative_parser>(back) {} |
| }; |
| |
| struct tst_timer_fwd_full : timeParser< client::tst_parser<iterator_type, boost::mpl::int_<full> > > |
| { |
| tst_timer_fwd_full() : timeParser< client::tst_parser<iterator_type, boost::mpl::int_<full> > >(fwd) {} |
| }; |
| |
| struct tst_timer_fwd_no_assign : timeParser< client::tst_parser<iterator_type, boost::mpl::int_<no_assign> > > |
| { |
| tst_timer_fwd_no_assign() : timeParser< client::tst_parser<iterator_type,boost::mpl::int_<no_assign> > >(fwd) {} |
| }; |
| |
| struct tst_timer_fwd_assign : timeParser< client::tst_parser<iterator_type,boost::mpl::int_<assign> > > |
| { |
| tst_timer_fwd_assign() : timeParser< client::tst_parser<iterator_type,boost::mpl::int_<assign> > >(fwd) {} |
| }; |
| |
| |
| |
| struct tst_timer_back : timeParser< client::tst_parser<iterator_type,boost::mpl::int_<full> > > |
| { |
| tst_timer_back() : timeParser< client::tst_parser<iterator_type,boost::mpl::int_<full> > >(back) {} |
| }; |
| |
| struct tst_map_timer_fwd : timeParser<tst_map_parser> |
| { |
| tst_map_timer_fwd() : timeParser<tst_map_parser>(fwd) {} |
| }; |
| |
| struct tst_map_timer_back : timeParser<tst_map_parser> |
| { |
| tst_map_timer_back() : timeParser<tst_map_parser>(back) {} |
| }; |
| |
| struct kwd_timer_fwd : timeParser<kwd_parser> |
| { |
| kwd_timer_fwd() : timeParser<kwd_parser>(fwd) {} |
| }; |
| |
| struct kwd_timer_back : timeParser<kwd_parser> |
| { |
| kwd_timer_back() : timeParser<kwd_parser>(back) {} |
| }; |
| |
| |
| |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Main program |
| //////////////////////////////////////////////////////////////////////////// |
| int |
| main() |
| { |
| |
| BOOST_SPIRIT_TEST_BENCHMARK( |
| 10000000000, // This is the maximum repetitions to execute |
| (permutation_timer_fwd) |
| (permutation_timer_back) |
| (alternative_timer_fwd) |
| (alternative_timer_back) |
| (tst_timer_fwd_full) |
| (tst_timer_fwd_no_assign) |
| (tst_timer_fwd_assign) |
| (tst_timer_back) |
| (tst_map_timer_fwd) |
| (tst_map_timer_back) |
| (kwd_timer_fwd) |
| (kwd_timer_back) |
| ) |
| |
| // This is ultimately responsible for preventing all the test code |
| // from being optimized away. Change this to return 0 and you |
| // unplug the whole test's life support system. |
| return test::live_code != 0; |
| } |
| |
| |
