boost-spirit

( EDITED both title and main text and created a spin-off question that arose) For our application it would be ideal to parse a simple DSL of logical expressions. However the way I'd like to do this is to parse (at runtime) the input text which gives the expressions into some lazily evaluated structure (an expression template) which can then be later used within more performance sensitive code. Ideally the evaluation is as fast as possible using this technique as it will be used a large number of times with different values substituting into the placeholders each time. I'm not expecting the

I have the following structure struct MyStruct { char CODE; char NAME[5]; }; I make it a fusion struct BOOST_FUSION_ADAPT_STRUCT ( MyStruct, (char, MARKET_CODE) (char, NAME[5]) ) My grammar is implemented as follow: MyStruct_parser() : ticker_parser::base_type(start) { using qi::lexeme; using ascii::char_; a_word %= lexeme[+(char_)]; start %= a_word >> a_word; } qi::rule<Iterator, std::string(), ascii::space_type> quoted_string; qi::rule<Iterator, Ticker(), ascii::space_type> start; Unfortunately it does not compile. Now I use std::string instead of char[5] I have no problem. Can you please

Is it a good idea? For a reason I thought it should be faster than boost's tokenizer or split. however most of the time I'm stuck in the boost::spirit::compile template <typename Iterator> struct ValueList : bsq::grammar<Iterator, std::vector<std::string>()> { ValueList(const std::string& sep, bool isCaseSensitive) : ValueList::base_type(query) { if(isCaseSensitive) { query = value >> *(sep >> value); value = *(bsq::char_ - sep); } else { auto separator = bsq::no_case[sep]; query = value >> *(separator >> value); value = *(bsq::char_ - separator); } } bsq::rule<Iterator, std::vector<std:

I am trying to add a greater than operator > to a ast: the code is 95% identical to the code in the docs. Two points of interest below A block of code where I'm trying to write support for greater than: commented in the code below. A single line in the parse for term which fails to compile because I don't yet understand semantic actions yet: not sure how to bind the lhs of lhs > rhs through phoenix and semantic actions. The solution should be trivial for regular users of Spirit, but I am still learning, and only getting by through examples so far. Any help would be appreciated. TIA. Code

I want to tokenize my own extension of SQL syntax. This involves recognizing an escaped double quote inside a double quoted string. E.g. in MySQL these two string tokens are equivalent: """" (the second double quote acts as an escape character) and '"' . I have tried different things but I am stuck at how to replace a token's value. #include <boost/spirit/include/lex_lexertl.hpp> namespace lex = boost::spirit::lex; template <typename Lexer> struct sql_tokens : lex::lexer<Lexer> { sql_tokens() { string_quote_double = "\\\""; // '"' this->self("INITIAL") = string_quote_double [ lex::_state =

I came across a strange behaviour of boost spirit x3, after I splittet my grammar up into the recommended parser.hpp , parser_def.hpp , parser.cpp files. My example gramar parses some kind of easy enums: enum = "enum" > identifier > "{" > identifier % "," > "} this is my enum grammar. When I don't split the enum and identifier parser into the recommended files, everything works fine, especially the string "enum {foo, bar}" throws an expectation failure, as expected. This example can be found here: unsplitted working example But when I split the exactly same grammar up into the different files,