boost-spirit-qi

Is it possible to reuse boost::spirit:qi grammar in another grammar (as a rule for example)? For example if I define a grammar to parse line of text into a structure holding street address. template< typename iter > struct address_grammar : qi::grammar< iter, address() > { ... qi::rule< iter, std::string() > street_name; qi::rule< iter, std::string() > street_number; qi::rule< iter, address() > address_; } I might want to reuse that grammar in two other grammars, for example one might be for parsing of a vector of addresses stored in a file. Another re-use might be in more complex structure

Following several tutorials (e.g. http://boost-spirit.com/home/articles/qi-example/nabialek-trick/ ) I want to use the Nabialek trick to have a dynamic parser. Parsing already works fine, but I don't get the attributes transported. Explanations like https://stackoverflow.com/a/9109972/2524462 suggest, that attributes should be possible but not arguments. This is just a small example parsing a string and a number into a struct. It is just for showcasing my problem; this method should be used in a larger system later on, where the dynamic parser is really needed. Question: How do I transport

I was wondering whether there is a way in Boost.Spirit.Qi to dynamically combine an arbitrary number of rules at runtime. The inner workings of Boost.Spirit are still a bit of a mystery to me, but since rules are implemented as objects it seems feasible. My motivation is to make certain parts of my grammar easily extendable. Consider the following contrived example: namespace qi = boost::spirit::qi; namespace px = boost::phoenix; typedef std::string::const_iterator iterator_t; template<typename Expr> inline bool parse_full(const std::string& input, const Expr& expr) { iterator_t first(input

I am using Spirit Qi as my parser, to parse mathematical expressions into an expression tree. I keep track of such things as the types of the symbols which are encountered as I parse, and which must be declared in the text I am parsing. Namely, I am parsing Bertini input files , a simple-ish example of which is here , a complicated example is here , and for completeness purposes, as below: %input: our first input file variable_group x,y; function f,g; f = x^2 - 1; g = y^2 - 4; END; The grammar I have been working on will ideally find declaration statements, and then parse the following comma

I would like to define a rule based on a previously parsed value, i. e. the input string has the following structure: D <double number> or I <integer number> . I keep in a local boolean variable whether the first read character is D or I . The complete code is: #define BOOST_SPIRIT_USE_PHOENIX_V3 #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix.hpp> #include <string> namespace qi = boost::spirit::qi; namespace spirit = boost::spirit; namespace ascii = boost::spirit::ascii; using boost::phoenix::ref; template <typename Iterator> struct x_grammar : public qi::grammar