{"id":876,"date":"2010-01-17T09:12:21","date_gmt":"2010-01-17T17:12:21","guid":{"rendered":"http:\/\/boost-spirit.com\/home\/?p=876"},"modified":"2010-01-18T07:14:18","modified_gmt":"2010-01-18T15:14:18","slug":"whats-the-difference-between-qis-and","status":"publish","type":"post","link":"http:\/\/boost-spirit.com\/home\/2010\/01\/17\/whats-the-difference-between-qis-and\/","title":{"rendered":"What’s the Difference Between Qi’s ‘!’ and ‘~’?"},"content":{"rendered":"

The Freenet #boost IRC channel amazes me every day with the amount of interest Spirit<\/em> is getting from a lot of people. Thanks to everyone over there! But the best is those people are asking many interesting questions allowing me to come up with yet another Tip of the Day.<\/p>\n

Today’s question has been asked by @psicode: “What is the difference between the components created by the unary operators ‘!’<\/span> and ‘~’<\/span>?”. As the semantics of those operators are slightly dissimilar in Qi<\/em> and Karma<\/em>, I will talk about them separately. I will write about the Qi<\/em> operators today and about the corresponding Karma<\/em> operators in one of the next installments.<\/p>\n

<\/p>\n

Let us start with the commonality between the two operators: both negate whether the component they are being used with succeeds parsing. If the component ‘c’<\/span> succeeds, both compound constructs, ‘!c’<\/span> and ‘~c’<\/span> will fail, and similarly, if ‘c’<\/span> fails, the execution of components ‘!c’<\/span> and ‘~c’<\/span> will succeed.<\/p>\n

The differences are more interesting. The unary Qi<\/em> operator ‘~’ is applicable to character and character class parsers only. It negates the set of characters matched by the parser component it is attached to. Here are some examples:<\/p>\n\n\n\n\n\n\n
Expression<\/strong><\/td>\nDescription<\/strong><\/td>\n<\/tr>\n
~char_<\/span><\/td>\ndoes not match anything<\/td>\n<\/tr>\n
~digit<\/span><\/td>\nmatches everything except digits<\/td>\n<\/tr>\n
~char_(“a-z”)<\/span><\/td>\nmatches every character outside the character range spanned by ‘a’ and ‘z’<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\u00a0<\/p>\n

The parsers created by the operator ‘~’<\/span> do not wrap the underlying parser. It rather modifies the behavior of the component it is attached to. This means there is no performance difference if compared to the plain character parsers.<\/p>\n

The unary operator ‘!’<\/span> is creating a not-predicate parser. It can be attached to any (arbitrarily complex) parser expression. The not-predicate is a look-ahead matching parser trying to match the expression it is attached to. This is done without moving the current input position forward. In other words, the not-predicate does not consume any input . If the attached parser fails matching the overall not-predicate will succeed. In this case the parsing resumes at the same point where the not-predicate started matching. The following (slightly artificial) example will succeed matching a floating point number after making sure it is not a Boolean expression:<\/p>\n

\r\nnamespace qi = boost::spirit::qi;\r\nstd::string input("1.0");\r\nstd::string::const_iterator b = input.begin();\r\ndouble result = 0;\r\nqi::parse(b, input.end(), !qi::bool_ >> qi::double_, result);\r\n<\/pre>\n
Any parser created by the not-predicate is neutral in terms of attribute handling because it exposes unused_type<\/span> as its attribute. As a consequence, parser components augmented with ‘!’<\/span> will never expose their attribute, and never will participate in any attribute propagation.<\/p>\n
Share this:<\/h3>