May 16

Spirit: History and Evolution

By Hartmut Kaiser BoostCon 2010 4 Comments »

Yes, we were tempted to call our second BoostCon talk ‘Design and Evolution’, but we decided to to be modest. We wanted to give a very brief overview of the way Spirit has evolved over the last decade. While talking about a period of time this long in 90 minutes has to be very brief we nevertheless tried to highlight the main stepping stones and milestones in Spirits development. For me, developing the slides for ‘Spirit: History and Evolution’ was real fun: looking through ancient email archives, re-reading key private conversations, and realizing that most of the ideas implemented today have been already in place from the early years. All of this was exciting. To some extent, this even turned out to be educational.

I have to admit I was not sure how people would react to this kind of talk. It was not one of the usual, sophisticated, well thought through, and cutting edge presentations normally seen at BoostCon. This talk was merely a conversation with the attendees about Boost’s history guided by Spirits evolution. In the end I was relieved to see people reacted positively. Some came to me afterwards saying they enjoyed listening. For all of you not being at BoostCon, here are the slides: Spirit: History and Evolution.

Tagged with:
May 13

Using Spirit V2: Qi and Karma

By Hartmut Kaiser BoostCon 2010 10 Comments »

Michael Caisse (of Object Modeling Designs), some of you will know him from the Freenode #boost IRC channel, presented his talk about Spirit at BoostCon 2010 last Tuesday. I personally very much like listening to his knowledgeable and entertaining presentations. Apparently many people do so as well, the room he presented in was overfull. People even sat on the floor as all seats were taken. So in case you are interested – here is a link to his slides: Using Spirit V2: Qi and Karma.

Tagged with: •
May 11

A Framework for RAD Spirit

By Hartmut Kaiser BoostCon 2010, Build a Compiler 14 Comments »

Finally, yesterday was the day! Joel and I presented the current status of our work related to the ‘Writing a Compiler’ effort. We submitted this talk to BoostCon 2010 and got accepted back in January. Having to present at BoostCon just put a nice pressure onto us to get moving and to start working on the project. I don’t want to go into any detail about the presentation itself. This will be done in future articles to be published after BoostCon. I just wanted to provide a link to the slides for those interested in having a look. Ok, here we go: A Framework for RAD Spirit, grab it while it’s hot!

Tagged with: •
May 08

Next Week is BoostCon Week!

By Hartmut Kaiser BoostCon 2010, Build a Compiler No Comments »

Finally, the long wait and the preparations for BoostCon 2010 are over. The last weeks were dominated by writing the code and creating the slides for our talk ‘A Framework for RAD Spirit‘. Regular readers of this site probably have already wondered why we have been inactive here since mid-March. Well, that is mainly because of preparing for BoostCon turned out to be too time consuming to leave any room for writing posts and articles.

Continue reading »

Tagged with: •
Mar 11

S-expressions and variant

By Joel de Guzman Build a Compiler, Qi Example 35 Comments »

I have a mixed relationship with variant…

I just wrote a parser for S-expressions (that will be the basis of ASTs and intermediate types in my planned “write-a-compiler” article series). The parser itself is easy, but as always, I spent more time on the underlying data structures.

Continue reading »

Mar 09

Integer to String Conversion: Karma fastest again

By Hartmut Kaiser General, User Experience 23 Comments »

Tino Didriksin published yet another speed comparison of different ways to convert an integer into a string (see his blog A howl on the Wind…). And again, Karma turns out to be the leader of the pack by being upto 10 times faster than the other tested methods. This nicely supports our own measurements (see here). Thanks Tino!

Tagged with:
Mar 05

Tracking the Input Position While Parsing

By Peter Schüller Advanced, Beginner, Qi Example Comments Off on Tracking the Input Position While Parsing

The following article is about tracking the parsing position with Spirit V2. This is useful for generating error messages which tell the user exactly where an error has occurred. We also show how to use Spirit V2 to parse from an input stream without first reading the whole stream into a std::string.

Continue reading »

Tagged with: •
Mar 03

The Anatomy of Semantic Actions in Qi

By Hartmut Kaiser Beginner, General, Tip of the Day 11 Comments »

The concept of Spirit’s semantic actions seems to be easy enough to understand as most people new to the library prefer their usage over applying the built-in attribute propagation rules. That is not surprising. The idea of attaching a function to any point of a grammar which is called whenever the corresponding parser matched is straighforward to grasp. Earlier versions of Spirit required a semantic action to conform to a very specific interface. Today’s semantic actions are more flexible and more powerful. Recently, a couple of people asked questions about them. So I decided dedicating this Tip of the Day to the specifics and the usage model of semantic actions in Spirit Qi.

Continue reading »

Tagged with: •
Feb 24

Parsing Skippers and Skipping Parsers

By Hartmut Kaiser Beginner, Qi Example, Tip of the Day 29 Comments »

Spirit supports skipper based parsing since its very invention. So this is definitely not something new to Spirit V2. Nevertheless, the recent discussion on the Spirit mailing list around the semantics of Qi’s lexeme[] directive shows the need for some clarification. Today I try to answer questions like: “What does it mean to use a skipper while parsing?”, or “When do I want to use a skipper and when not?”.

Continue reading »

Tagged with:
Feb 17

Parsing Arbitrary Things in Any Sequence

By Hartmut Kaiser Beginner, Intermediate, Qi Example, Tip of the Day 13 Comments »

Recently, there have been a couple of questions on the Spirit mailing list asking how to parse as set of things known in advance in any sequence and any combination. A simple example would be a list of key/value pairs with known keys but the keys may be ordered in any sequence. This use case seems to be quite common. Fortunately Spirit provides you with a predefined parser component designed for exactly that purpose: the permutation parser.

Continue reading »

Tagged with:
Feb 08

How to Adapt Templates as a Fusion Sequence

By Hartmut Kaiser Intermediate, Qi Example, Tip of the Day 5 Comments »

Here is another question raised from time to time: “I know how to use a plain struct as an attribute for a sequence parser in Qi by adapting it with BOOST_FUSION_ADAPT_STRUCT. Unfortunately this does not work if the struct is a template. What can I do in this case?”.

There have been plans for a while to create a separate Fusion facility BOOST_FUSION_ADAPT_TPL_STRUCT allowing to adapt templated data types, but this is not in place yet. Today I will describe a trick you can apply to adapt your templates into ‘proper’ Fusion sequences anyway.

Continue reading »

Tagged with:
Feb 05

BoostCon 2010

By Joel de Guzman BoostCon, General No Comments »

Promising to be the main face-to-face event for all things Boost, BoostCon 2010 opens the door to your C++ future. From using the Boost libraries to writing and maintaining them, from evangelizing to deploying Boost within your organization, from infrastructure and process to vision and mission, and from TR1 to TR2, BoostCon brings together the sessions, the colleagues, and the inspiration to support your work with Boost for the next year.

To reflect the breadth of the Boost community, the conference includes sessions aimed at two constituencies: Boost end-users and hard-core Boost library and tool developers. The program fosters interaction and engagement within and across those two groups, with an emphasis on hands-on, participatory sessions.

Continue reading »

Jan 31

What is the Attribute Type Exposed by a Parser?

By Hartmut Kaiser Intermediate, Qi Example, Tip of the Day 3 Comments »

Most questions on the main Spirit mailing list are centered around attributes and how to correctly utilize Spirit’s attribute propagation rules. We discussed the related basics in several posts already, but many people still have problems to understand the rules. Somebody recently asked on the mailing list whether it would be possible to print the attribute type exposed by an arbitrary parser expression. I answered by posting a sketchy code snippet (see here), but afterwards I realized it might be a good topic for yet another ‘Tip of the Day’.

Continue reading »

Tagged with:
Jan 28

Can the Classic Dynamic Parsers be Ported to Qi?

By Hartmut Kaiser Intermediate, Tip of the Day 1 Comment »

After writing about local variables for rules here I would like to get back to some information I have had lying around for some time already. Today’s topic seems to be a nice fit as porting the dynamic parsers from Spirit.Classic requires to utilize local variables. This allows me to give you some more examples for this facility.

Previous versions of Spirit, which are the versions we refer to as Spirit.Classic today, implemented special dynamic parsers allowing to insert control statements into the parsing process (such as if_p, while_p, and for_p). These dynamic parsers are not available anymore in Qi. But it is easy enough to achieve the same behavior using existing Qi components. This ‘Tip of the Day’ describes those techniques, which have been developed and contributed by Carl Barron. Thanks Carl!

Continue reading »

Tagged with:
Jan 26

What’s the Difference Between Karma’s ‘!’ and ‘~’?

By Hartmut Kaiser Beginner, Tip of the Day No Comments »

A couple of days ago I promised to get back to this topic (if you want to refresh your memory, here is the discussion of those operators in Qi). Today we will discuss Karma’s unary operators ‘!’ and ‘~’. These have very similar semantics as their counterparts in Qi, but as usual, we have to turn things inside out in order to make them fit to output generation.

Continue reading »

Tagged with:
Previous Entries Next Entries
preload preload preload