Copyright (GPL) 2004  mmc mchirico@users.sourceforge.net or mchirico@comcast.net
Last Updated: Fri Sep  3 10:18:58 EDT 2004


The latest version of these documents can be downloaded from:
http://prdownloads.sourceforge.net/souptonuts/lemon_examples.tar.gz?download

To get emailed when there are update and additions:
http://sourceforge.net/project/filemodule_monitor.php?filemodule_id=124528




example1.y  

      This is a very simple calulator. To compile the
      example do the following:

         $ make

      Then, to run the example issue the following
      command:

         $ ./ex1

      OK, what is happening: Take a look at the file
      "main_part", then, take a look at "example1.c"
      This main_part is appended to the raw form of
      example1.c in the Makefile. lemon does not create
      a complete program - only the necessary subroutines. 
      So it is necessary to build in the main part of a 
      program.

      If you make your own changes to this example, you
      should make the changes to example1.y or main_part.
      example1.c is a generated file, and will be over
      written every time lemon is run.

      Disecting main_part:

      If you take a look at the documentation at the following
      link:
         http://www.hwaci.com/sw/lemon/lemon.html

      You'll see that these are the  essential functions that 
      must be called. Note, this is a stripped down simple
      version with no error checking or tokenizer.  The 
      tokens are hardwired in so we can see exactly how
      lemon operates.

             void* pParser = ParseAlloc (malloc);
      
      The next 4 lines parse the command  15 DIVIDE 5.

             Parse (pParser, INTEGER, 15);     
	     Parse (pParser, DIVIDE, 0);     
	     Parse (pParser, INTEGER, 5);    
      	     Parse (pParser, 0, 0);          

      INTEGER and  DIVIDE are assigned values in the
      generated file example1.h to be the following;

             #define PLUS                            1
	     #define MINUS                           2
	     #define DIVIDE                          3
    	     #define TIMES                           4
      	     #define INTEGER                         5
     
      Again, this is a generated file, so if any additions
      are made to this file, they'll be over-written when
      re-running lemon.



example2.y

      This example is more interesting. A custom token is 
      created in ex2def.h with the following 4 lines:

             struct Token {                
	       const char *z; 
	       int value;     
 	       unsigned n;    
	     };

      This structure supports both a value and a count.
      You could add many more values, and allocate memory
      to z if you wanted. One, note, you cannot put in 
      C++  strings or other STL containers directly into
      this structure; instead, you would need to have pointers
      to such structures. Note, if memory was allocated for z, you'd
      have to free it. 
               


example3.y         
   
      This shows the behavior of a destructor

             Parse (pParser, 0, t1);
                             ^--^------ only t1 will destruct, since
                          it is called with zero here.


example4.y

       This is the first example that ends the grammer with 
       a newline.  

       In the file example4.y take a look at the following:

          main ::= in.
          in ::= .
          in ::= in state NEWLINE.


       In main_part4 the last statement here can cause the
       output to print. Whereas in examples 1-3 it had to
       end with  " Parse (pParser, 0, t0)";


               Parse (pParser, ID, t0);
               Parse (pParser, PLUS, t0);
               Parse (pParser, ID, t1);
               Parse (pParser, NEWLINE, t1);


example5.y

       This example puts everything together with flex. But,
       take a peek at how lexer.l is complied in the Makefile
       with "flex lexer.l" instead of "flex++ lexer.l". The
       main_part5 for this example is in C++, so it's necessary
       to add the extern "C" directives.  True it could have been
       compiled with flex++; but, many people prefer flex for the
       speed of C in complex projects.


       This example is run interactively, so entering something
       like 3+5 is demonstrated below:

            $ ./ex5
             3+5                             
	     yylex() 6 yylval.dval 3        
     	     yylex() 1 yylval.dval 3        
	     yylex() 6 yylval.dval 5        
	     yylex() 5 yylval.dval 5        
	    In token_destructor t.value= 3  
	    In token_destructor t.n= 0      
	    Result.value=8                  
	    Result.n=4                      


desktop_calc.cc

       This is an example of a C++ calculator that has not been
       written with a parser.






REFERENCES:

(1) Complete source for all examples including the lemon parser generator
http://prdownloads.sourceforge.net/souptonuts/lemon_examples.tar.gz?download

(2) Example desktop calculator from scratch
http://souptonuts.sourceforge.net/code/desktop_calc.cc.html] 

(3) Example of flex and bison parser
http://prdownloads.sourceforge.net/souptonuts/flex_bison.tar.gz?download

(3) Home of the lemon parser generator
http://www.hwaci.com/sw/lemon/

(4) Home of sqlite
http://www.sqlite.org/

(5) Glossory of paser terms
http://www.parsifalsoft.com/gloss.html

(6) Good introduction to parsers
http://www.parsifalsoft.com/isdp.html

(7) GNU flex manual
http://www.gnu.org/software/flex/manual/

(8) GNU bison manual
http://www.gnu.org/software/bison/manual/

(9) The spirit parser
September 2003, C/C++ Users Journal
Powerful parsing made easy via modern template techniques.
Joel de Guzman and Dan Nuffer.
http://spirit.sourceforge.net/

(10)
Getting a C++ Bison parser to use a C Flex lexer
http://www.iunknown.com/000123.html