{"id":424,"date":"2009-11-06T12:30:21","date_gmt":"2009-11-06T20:30:21","guid":{"rendered":"http:\/\/boost-spirit.com\/home\/?page_id=424"},"modified":"2010-01-17T20:31:38","modified_gmt":"2010-01-18T04:31:38","slug":"spirit-v2-1-will-be-released-with-boost-v1-41","status":"publish","type":"page","link":"http:\/\/boost-spirit.com\/home\/articles\/spirit2-1-release\/spirit-v2-1-will-be-released-with-boost-v1-41\/","title":{"rendered":"Spirit V2.1 will be released with Boost V1.41"},"content":{"rendered":"

Now, as the release of the new Spirit<\/em> version is at our doorstep, I would like to whet your appetite. Let\u2019s start with a list of high level things worth knowing. Here is the one floor elevator speech I stole from Spirit\u2019s documentation<\/a>:<\/p>\n

Spirit<\/strong> is an object-oriented, recursive-descent parser and output generation library for C++. It allows you to write grammars and format descriptions using a domain specific embedded language (DSEL) directly in C++. The DSEL has a format similar to Parsing Expression Grammars<\/a> (PEG). These inline grammar specifications can mix freely with other C++ code and, thanks to the generative power of C++ templates, they are immediately executable.<\/p><\/blockquote>\n

Let\u2019s try to digest this piecewise. I think I do not need to dig into Spirit<\/em> being \u2018object-oriented\u2019, that stands for itself. ‘Recursive descent’ is a way to write parsers. Wikipedia<\/a> says:<\/p>\n

A recursive descent parser<\/strong> is a top-down parser built from a set of mutually-recursive procedures (or a non-recursive equivalent) where each such procedure usually implements one of the production rules of the grammar. Thus the structure of the resulting program closely mirrors that of the grammar it recognizes.<\/p><\/blockquote>\n

Spirit<\/em> is special as it applies the technology of using mutually recursive procedures not only for implementing parsers, but it uses the same approach for creating output generators. We are quite proud of this as we do not know of anybody doing this before. Compared to earlier Spirit<\/em> versions this extends the scope of the library considerably, as we now support two very important steps in any data transformation flow: Spirit.Qi<\/em> (the sub-library responsible for parsing) helps converting arbitrary formatted (text) input into some internal structured data format, while Spirit.Karma<\/em> (the sub-library for output generation) simplifies the opposite: converting the internal binary data structures into arbitrary formatted (text) output. This picture shows what I mean:<\/p>\n

\"The
\nThe place of Spirit.Qi and Spirit.Karma in a data transformation flow of a typical application<\/p>\n

Grammars for Spirit.Qi<\/em> and Spirit.Karma<\/em> are written directly in C++. We use extensive operator overloading to make the grammar syntax very similar to PEG, a well known way to unambiguously describe formal grammars. Let\u2019s have a look at a simple example. The following PEG grammar describes a trivial infix calculator supporting ‘*’, ‘\/’, ‘+’, ‘\u2013’, and allowing to group sub-expressions with parentheses:<\/p>\n

\r\nfact \u2190 integer \/ '(' expr ')'\r\nterm \u2190 fact (('*' fact) \/ ('\/' fact))*\r\nexpr \u2190 term (('+' term) \/ ('-' term))*\r\n<\/pre>\n
Here is the same grammar, but written in Spirit.Qi<\/em>, and yes, that\u2019s perfectly valid C++. <\/em>This code defines a parser which recognizes infix calculator expressions:<\/p>\n
\r\nnamespace qi = boost::spirit::qi;\r\ntypedef qi::rule<std::string::iterator> rule;\r\nrule fact, term, expr;\r\n\r\nfact = qi::int_ | '(' >> expr >> ')' ;\r\nterm = fact >> *(('*' >> fact) | ('\/' >> fact)) ;\r\nexpr = term >> *(('+' >> term) | ('-' >> term)) ;\r\n<\/pre>\n
The last three lines look almost similar to the original PEG grammar above, except for the ‘>>’ used to denote concatenation. Grammars written for output formatting in Spirit.Karma<\/em> look very similar, the most notable difference is probably that they use the left shift operator ‘<<‘ instead of Spirit.Qi<\/em>\u2019s right shift operator ‘>>’ for concatenation. Any C++ programmer will find that non-surprising as it follows the convention of using ‘<<‘ and ‘>>’ for normal input and output code.<\/p>\n
The last fact in our one floor elevator speech from above is obvious now. Spirit<\/em> is pure C++, uses only language constructs as provided by C++, and for this reason, integrates smoothly with any surrounding code. All data items in your program are easily accessible as the destination for parsing results or as the source for generating output. No additional (external) tools as normally required for conventional parser generators have to be utilized.<\/p>\n
Interested in trying out Spirit<\/em>? I suggest you start reading the documentation (here<\/a>) or browse through the extensive examples coming with the library as soon as Boost V1.41 has been released (or grab the beta here<\/a>). In the meantime, if you have any questions, leave a comment or use Spirit’s<\/em> mailing list<\/a>.<\/p>\n
Share this:<\/h3>