1

Boost Spirit newcomer here.

I have a string in the form of "Key:Value\r\nKey2:Value2\r\n" that I'm trying to parse. In that specific form, it's trivial to parse with Boost Spirit. However, in order to be more robust, I also need to handle cases such as this one:

" My Key : Value \r\n My2ndKey : Long<4 spaces>Value \r\n"

In this case, I need to trim leading and trailing spaces before and after the key/value separators so that I get the following map:

"My Key", "Value"

"My2ndKey", "Long<4 spaces>Value"

I played with qi::hold to achieve this but I get compile errors because of unsupported boost::multi_pass iterator with the embedded parser I was trying to use. There has to be a simple way to achieve this.

I read the following articles (and many others on the subject):

http://boost-spirit.com/home/articles/qi-example/parsing-a-list-of-key-value-pairs-using-spirit-qi/ http://boost-spirit.com/home/2010/02/24/parsing-skippers-and-skipping-parsers/

Boost spirit parsing string with leading and trailing whitespace

I am looking for a solution to my problem, which doesn't seem to be entirely covered by those articles. I would also like to better understand how this is achieved. As a small bonus question, I keep seeing the '%=' operator, is this useful in my case? MyRule %= MyRule ... is used for recursive parsing?

The code below parses my strings properly except that it doesn't remove the spaces between the last non-space character and the separator. :( The skipper used is qi::blank_type (space without EOL).

Thanks!

template <typename Iterator, typename Skipper>
struct KeyValueParser : qi::grammar<Iterator, std::map<std::string, std::string>(), Skipper> {
  KeyValueParser() : KeyValueParser::base_type(ItemRule) {
    ItemRule = PairRule >> *(qi::lit(END_OF_CMD) >> PairRule);
    PairRule = KeyRule >> PAIR_SEP >> ValueRule;
    KeyRule = +(qi::char_ - qi::lit(PAIR_SEP));
    ValueRule = +(qi::char_ - qi::lit(END_OF_CMD));
  }
  qi::rule<Iterator, std::map<std::string, std::string>(), Skipper> ItemRule;
  qi::rule<Iterator, std::pair<std::string, std::string>(), Skipper> PairRule;
  qi::rule<Iterator, std::string()> KeyRule;
  qi::rule<Iterator, std::string()> ValueRule;
};
Community
  • 1
  • 1
XanderLo
  • 35
  • 4
  • If instead of what you did, you had provided something like [this](http://coliru.stacked-crooked.com/a/3b30f7a280f0d0e1), it'd be much easier to help you. I'm pretty sure this is a duplicate, although I can't find it at the moment, [this](http://coliru.stacked-crooked.com/a/7539f0ebf856e242) is a possible solution. Regarding your question about `%=`, you can see [here](http://www.boost.org/libs/spirit/doc/html/spirit/qi/reference/nonterminal/rule.html#spirit.qi.reference.nonterminal.rule.expression_semantics) that it's basically the same as `=` except when there are semantic actions. – llonesmiz Feb 13 '16 at 07:51
  • This is exactly what I was looking for, thank you! Can you post the solution as an Answer so I can mark it such? The reason why I didn't post full code was because I was looking more for hints or explanation instead of a full blown solution like you kindly provided, but I'll be more explicit in the future. :) Even though the solution works fine, I don't fully understand it. I noticed you introduced the skipper for both Key/Value rules, but I would've thought the qi::raw directive would also eat the leading/trailing spaces. Can you explain? Thanks Also, thank you for the %= explanation link! – XanderLo Feb 13 '16 at 17:24
  • [This](http://stackoverflow.com/questions/19591694/how-to-extract-trimmed-text-using-boost-spirit) is the duplicate I was trying to find. Sadly it doesn't really explain how it works. I'll try to give an explanation. – llonesmiz Feb 14 '16 at 11:53

1 Answers1

0

You need to use KeyRule = qi::raw[ +(qi::char_ - qi::lit(PAIR_SEP)) ];

In order to see why, let's try to study several ways to parse the string "a b :".

First let's keep in mind how the following parsers/directives work:

  • lexeme[subject]: This directive matches subject while disabling the skipper.

  • raw[subject]: Discards subject's attribute and returns an iterator pair that points to the matched characters in the input stream.

  • +subject: The plus parser tries to match 1 or more times its subject.

  • a-b: The difference parser first tries to parse b and if b succeeds, a-b fails. When b fails, it matches a.

  • char_: matches any char. It's a PrimitiveParser.

  • lit(':'): matches ':' but ignores its attribute. It's a PrimitiveParser.

  1. lexeme[ +(char_ - lit(':')) ]: by removing the skipper from your rule you have an implicit lexeme. Since there is no skipper it goes like this:

'a' -> ':' fails, char_ matches 'a', the current synthesized attribute is "a"
' ' -> ':' fails, char_ matches ' ', the current synthesized attribute is "a "
'b' -> ':' fails, char_ matches 'b', the current synthesized attribute is "a b"
' ' -> ':' fails, char_ matches ' ', the current synthesized attribute is "a b "
':' -> ':' succeeds, the final synthesized attribute is "a b "

  1. +(char_ - lit(':')): Since it has a skipper every PrimitiveParser will pre-skip before being tried:

'a' -> ':' fails, char_ matches 'a', the current synthesized attribute is "a"
' ' -> this is skipped before ':' is tried
'b' -> ':' fails, char_ matches 'b', the current synthesized attribute is "ab"
' ' -> this is skipped before ':' is tried
':' -> ':' succeeds, the final synthesized attribute is "ab"

  1. raw[ +(char_ - lit(':') ) ]: The subject is exactly the same as 2.. The raw directive ignores "ab" and returns an iterator pair that goes from 'a' to 'b'. Since the attribute of your rule is std::string, a string is constructed from that iterator pair, resulting in "a b" which is what you want.
llonesmiz
  • 155
  • 2
  • 11
  • 20
  • Thanks for the thorough answer. I understood properly the other directives but I didn't know that qi::raw considers the skipper before returning the pair of iterators which effectively keeps the skipper in-between. :) – XanderLo Feb 14 '16 at 16:03