{"id":857,"date":"2010-01-15T07:41:35","date_gmt":"2010-01-15T15:41:35","guid":{"rendered":"http:\/\/boost-spirit.com\/home\/?p=857"},"modified":"2010-06-24T06:19:26","modified_gmt":"2010-06-24T13:19:26","slug":"how-do-rules-propagate-attributes","status":"publish","type":"post","link":"http:\/\/boost-spirit.com\/home\/2010\/01\/15\/how-do-rules-propagate-attributes\/","title":{"rendered":"How Do Rules Propagate Their Attributes?"},"content":{"rendered":"

If you read the article about attribute handling for non-terminals (The Magical Power of Attributes in Spirit – Directives and Non-terminals<\/a>) you might remember that Spirit’s<\/em> non-terminals (rules and grammars) are somewhat special with regard to their attribute handling. In today’s ‘Tip of the Day’ I would like to revisit this topic as it still seems to be difficult to understand.<\/p>\n

<\/p>\n

Spirit’s<\/em> non-terminals can expose any attribute type, and the required type needs to be explicitly specified while declaring them. This is true for Qi<\/em> parsers and Karma<\/em> generators. The following example declares a rule exposing an (synthesized) attribute of type double<\/span> (if you wonder why it uses the unusual function declaration syntax, i.e. double()<\/span>, please read the article mentioned above):<\/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::rule<std::string::const_iterator, double()> r = qi::double_;\r\nqi::parse(b, input.end(), r, result);\r\n<\/pre>\n
The left hand side’s attribute (the result<\/span> passed in by the user) is directly handed over to the right hand side of the rule. The parser created by qi::double_<\/span> will put its result into the very same double<\/span> instance as passed in from the outside. No additional copies are created. We call this behavior auto attribute propagation<\/em>. For rules it is enabled by default as long as no semantic actions are attached to the right hand side’s expression.<\/p>\n
If you want to enforce auto attribute propagation even if the right hand side has semantic actions, you need to employ the ‘%=’ syntax as shown in the next Karma example:<\/p>\n
\r\nnamespace karma = boost::spirit::karma;\r\ntypedef std::back_insert_iterator<std::string> output_iterator;\r\nstd::string output;\r\noutput_iterator sink(output);\r\nkarma::rule<output_iterator, double()> r;\r\nr %= karma::double_[++karma::_1];\r\nkarma::generate(sink, r, 1.0);    \/\/ will emit: 2.0\r\n<\/pre>\n
This code will increment the attribute (the 1.0<\/span>)\u00a0 before emitting the result to the output iterator (remember, semantic actions in Karma<\/em> are called before invoking the related generator). Note, we incremented the attribute of the generator karma::double_<\/span>, not the left hand side’s attribute (which would have been ++karma::_val<\/span>). This works as we enforced the auto attribute propagation using the ‘%=’.<\/p>\n
There is one more important thing to remember: regardless of how the auto attribute propagation is enabled, either based on the default behavior of ‘=’<\/span> or by enforcing it using ‘%=’<\/span>, the attribute types of the rule and the right hand side must be compatible. It is not possible to define Spirit’s<\/em> ‘attribute compatibility’ in a short sentence, so we leave the topic for another day. But in the simplest case it means the attributes have to be convertible. In Qi<\/em> the right hand side’s attribute must at least be convertible to the rule’s attribute, while in Karma<\/em> the opposite needs to be true: the rule’s attribute should at least be convertible to the right hand side’s attribute.<\/p>\n
Share this:<\/h3>