[Spirit-general] Re: Understanding Spirit

[<aud...@nx...>]

Hi Andy, I looked at your 2 examples by the way I don't see anywhere any 
call to code to process what you parse. I can have my grammar to compile 
without any problem in the past but it was not parsing anything in real 
facts. I'd like to know what I should do to:

here's a little exemple of what I want to parse:

vector foo = [32,56.3,14,["test1","test2"]]; // var declaration of a 
vector of heterogen types (not a stl vector<>)

// a first section
[section_name_one] // the name of the section is refering to a function 
name that will be called to process the section
parameter_one=foo; // the fisr param is here the var previously declared
parameter_two="hello";
section_id_one;; // the id will hold behind the scene the result of the 
computed section

/* 2nd style of comment
    that can use more than a line */
[other_name]
param_one=[4,
        6,7
        ,"hi",section_id_one
        ]; // can be multi lined
another_id;;

print another_id; /*this asks for the result of the second section to be 
displayed*/

To do this parsing I'll need to build a list of everything I encounter 
before processing anything because I'll to check for any possible cycle 
and stuff like that. By the way I will have work to do for each parameter 
line multiple times. Can I do that with Spirit?

example:

value_p = ...;
parameter_p = (+alnum_p) >> char_p('=') >> value_p >> ch_p(';');
section_p = ch_p('[') >> (+alnum_p) >> char_p(']') >> *(parameter_p) >> 
(+alnum_p) >> ch_p(';') >> ch_p(';');

In this sub part of my grammar i'll need:
- call a method when a section is matched to create the object that'll 
hold my section data
- store the values of the data: section name, parameters, section id
- for each parameter i have to store name and value
- a value can either be a simple value or a vector of value (which can 
also be vector, ...)

As stated I don't see in the grammar examples how to do what I'm sayin. 
Can anyone give me a clear clue about it? Best would be a code sample.

Cheers.

--
Audric





Andy Elvey <and...@pa...>
29/01/2005 16:28
 
        Pour :  aud...@nx...
        cc : 
        Objet : Understanding Spirit



  Hi Audric!  -

    One thing that may help you (that I've found very useful to get 
going with Spirit)  is to look at the example apps in the Spirit 
applications repository -   here's the URL  -

 
http://spirit.sourceforge.net/repository/applications/show_contents.php 

 I'm biased in my choice here  :-)   , but I'd suggest having a look at 
the chess parser (spirit_chess.cpp) first,  then maybe the little SQL 
parser (spirit_sql.cpp ). 

 The chess one in particular should feel quite "familiar", using the 
usual notation for chess moves  (e.g.  Rc5,  b4,  Bxe7  and so on ... 
)    These should give you the feel of things, and then you'll be "up 
and running" in no time ....

 I apologise if these examples are "too easy" -  I'm just thinking that 
maybe one of them might provide you with the "aha!" moment -  the 
moment that is when you have a "blinding flash" and say "Aha!! - 
*that's* how it works!  "   :-) 

  My rule-of-thumb with Spirit is that I *always* use a grammar. 
Although there are one or two other ways to create parsers in Spirit 
(without using grammars),  I use a grammar and it works (for me!) every 
time! 

(  Oh, btw - as a little bonus for you, I've pasted in an example of 
what Spirit-2 will (probably) look like - Joel posted this code on the 
mailing-list a month or two back.  *This* is why I always use grammars 
:-)     ) 

*** Start of Spirit-2 preview ***

( Joel) -   That"s exactly what I am doing now in Spirit-2.
Productions (ala classic-spirit"s subrules) are placed in an associative
 tuple. I do not use enumerations because they are closed to
 extension. I use arbitrary types as keys. Here"s a sampler:
 
      template <typename Iterator>
      struct calculator : grammar<calculator, Iterator>
      {
          calculator()
          {
              this->def(
 
                  skipper = space,        // a grammar may have a skipper
                  start = expression,     // the grammar"s start rule
 
                  factor
                      =   ureal
                      |   "(" >> expression >> ")"
                      |   ("-" >> factor)
                      |   ("+" >> factor)
                      ,
 
                  term
                      =   factor
                          >> *(   ("*" >> factor)
                              |   ("/" >> factor)
                              )
                      ,
 
                  expression
                      =   term[result = arg1]
                          >> *(   ("+" >> term)
                              |   ("-" >> term)
                              )
              );
 
              rule_id<struct factor_>      factor;
              rule_id<struct term_>        term;
              rule_id<struct expression_>  expression;
          }
      };
 
 Notice how the rule_id is parameterized by the key which is an
 unnamed struct. This is very similar to the technique used by
 the newly accepted "Named Params" library by Dave A, Daniel W.
 and Fusion-2"s local variables.

*** End of Spirit-2   preview  ****

 I should also mention that although the list of Spirit developers (on 
S/F) shows me as a dev, I'm not really. I'm just an occasional 
contributor of examples like the above ones  (spirit-chess, spirit-sql ) . 

 Good luck!

 -  Andy




L'integrite de ce message n'etant pas assuree sur internet, Natexis
Banques Populaires ne peut etre tenu responsable de
son contenu. Toute utilisation ou diffusion non autorisee est
interdite. Si vous n'etes pas destinataire de ce message, merci de le
detruire et d'avertir l'expediteur.

The integrity of this message cannot be guaranteed
on the Internet. Natexis Banques Populaires can not therefore be
considered responsible for the contents.Any unauthorized use or dissemination is prohibited.
If you are not the intended recipient of this message, then please delete it and 
notify the sender.