boost-spirit

I want to use boost spirit to parse an expression like function1(arg1, arg2, function2(arg1, arg2, arg3), function3(arg1,arg2)) and call corresponding c++ functions. What should be the grammar to parse above expression and call the corresponding c++ function by phoneix::bind()? I have 2 types of functions to call 1) string functions; wstring GetSubString(wstring stringToCut, int position, int length); wstring GetStringToken(wstring stringToTokenize, wstring seperators, int tokenNumber ); 2) Functions that return integer; int GetCount(); int GetId(wstring srcId, wstring srcType); Second Answer

I'm working on a compiler and I would like to improve its performances. I found that about 50% of the time is spent parsing the source files. As the source file are quite small and I do quite a lot of transformations after that, it seems to me that it is perfectible. My parser is a Boost Spirit parser with a lexer (with lexer::pos_iterator) and I have a middle sized grammar. I'm parsing the source into an AST. My problem is that I have no idea what takes the most time during the parsing: copies of AST nodes, lexer, parser rules or memory. I don't think that it is I/O problem since I'm working

I want to parse a float, but not allow NaN values, so I generate a policy which inherits from the default policy and create a real_parser with it: // using boost::spirit::qi::{real_parser,real_policies, // phrase_parse,double_,char_}; template <typename T> struct no_nan_policy : real_policies<T> { template <typename I, typename A> static bool parse_nan(I&, I const&, A&) { return false; } }; real_parser<double, no_nan_policy<double> > no_nan; // then I can use no_nan to parse, as in the following grammar bool ok = phrase_parse(first, last, no_nan[ref(valA) = _1] >> char_('@') >> double_[ref(b)

I try learning to use boost::spirit. To do that, I wanted to create some simple lexer, combine them and then start parsing using spirit. I tried modifying the example, but it doesn't run as expected (the result r isn't true). Here's the lexer: #include <boost/spirit/include/lex_lexertl.hpp> namespace lex = boost::spirit::lex; template <typename Lexer> struct lexer_identifier : lex::lexer<Lexer> { lexer_identifier() : identifier("[a-zA-Z_][a-zA-Z0-9_]*") , white_space("[ \\t\\n]+") { using boost::spirit::lex::_start; using boost::spirit::lex::_end; this->self = identifier; this->self("WS") =

I'm looking for a way to parse a string as an int or a double, the parser should try both alternatives and choose the one matching the longest portion of the input stream. There is a deprecated directive (longest_d) that does exactly what I'm looking for: number = longest_d[ integer | real ]; ...since it's deprecated, there are any other alternatives? In case it's necessary to implement a semantic action to achieve the desired behavior, does anyone have a suggestion? Firstly, do switch to Spirit V2 - which has superseded classical spirit for years now. Second, you need to make sure an int gets

I found a really good example about boolean translator, * Boolean expression (grammar) parser in c++ What I am thinking now is to do a further step, translate (!T|F)&T into F or 0 , so it is very convenient for calculating a very long boolean expression. Is there some examples about this using spirit? What I have done is making a calculator first, and then let it calculate '(T+!F*T)', which equal to (T||!F&&T) but when I type () , there is an error. How to modify it? Thanks a lot! #include <iostream> #include <stack> #include <boost/lexical_cast.hpp> #include <boost/config/warning_disable.hpp>

I'm trying to parse a sequence of the syntax: < direction > < type > < name >. For example: in float foo where the direction can be either in , out , or in_out . I've succeeded in parsing correct text by using a qi::symbols class to convert the direction keywords to an enum. However, the problem shows when I don't have correct text. Take the example: int foo The symbol table parser will except the 'in' part of the 'int' type and so the results will be: direction: in type: t name: foo And the error is not detected. What's the best way to be able to parse the in, out and in_out reserved words

I have another problem with my boost::spirit parser. template<typename Iterator> struct expression: qi::grammar<Iterator, ast::expression(), ascii::space_type> { expression() : expression::base_type(expr) { number %= lexeme[double_]; varname %= lexeme[alpha >> *(alnum | '_')]; binop = (expr >> '+' >> expr)[_val = construct<ast::binary_op<ast::add>>(_1,_2)] | (expr >> '-' >> expr)[_val = construct<ast::binary_op<ast::sub>>(_1,_2)] | (expr >> '*' >> expr)[_val = construct<ast::binary_op<ast::mul>>(_1,_2)] | (expr >> '/' >> expr)[_val = construct<ast::binary_op<ast::div>>(_1,_2)] ; expr %= number