Require the generation of parse-gram.output.

[bison.git] / examples / variant.yy

diff --git a/examples/variant.yy b/examples/variant.yy
index fafb6556ad7da88fc08d188f04a8da2e657def66..d560e7dd63bb59cb92751a27cbd011b652a3b729 100644 (file)
--- a/examples/variant.yy
+++ b/examples/variant.yy
@@ -1,60 +1,88 @@
 /* Test file for C++ parsers using variants.
    Based on an example by Michiel De Wilde <mdewilde.agilent@gmail.com>. */
 /* Test file for C++ parsers using variants.
    Based on an example by Michiel De Wilde <mdewilde.agilent@gmail.com>. */

-%language "C++"

 %debug
 %debug

+%skeleton "lalr1.cc"

 %defines
 %define variant
 
 %code requires // *.hh
 {
 %defines
 %define variant
 
 %code requires // *.hh
 {

+#include <list>

 #include <string>
 #include <string>

+typedef std::list<std::string> strings_type;

 }
 
 %code // *.cc
 {
 #include <algorithm>
 #include <iostream>
 }
 
 %code // *.cc
 {
 #include <algorithm>
 #include <iostream>

+#include <iterator>

 #include <sstream>
 
 #include <sstream>
 

-static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
+  // Prototype of the yylex function providing subsequent tokens.
+  static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
+
+  // Printing a list of strings.
+  // Koening look up will look into std, since that's an std::list.
+  namespace std
+  {
+    std::ostream&
+    operator<<(std::ostream& o, const strings_type& s)
+    {
+      std::copy(s.begin(), s.end(),
+                std::ostream_iterator<strings_type::value_type>(o, "\n"));
+      return o;
+    }
+  }
+
+  // Conversion to string.
+  template <typename T>
+    inline
+    std::string
+    string_cast (const T& t)
+  {
+    std::ostringstream o;
+    o << t;
+    return o.str();
+  }

 }
 
 }
 

-%token <std::string> TEXT
-%token <int> NUMBER
-%printer { debug_stream() << $$; } <int> <std::string>
-%token END_OF_FILE 0
+%token <std::string> TEXT;
+%token <int> NUMBER;
+%printer { debug_stream () << $$; } <int> <std::string> <strings_type>;
+%token END_OF_FILE 0;

 
 

-%type <std::string> text result
+%type <std::string> item;
+%type <strings_type> list;

 
 %%
 
 result:
 
 %%
 
 result:

- text  { std::cout << $1 << std::endl; }
+  list { std::cout << $1 << std::endl; }
+;
+
+list:
+  /* nothing */ { /* Generates an empty string list */ }
+| list item     { std::swap ($$, $1); $$.push_back ($2); }

 ;
 
 ;
 

-text:
-  /* nothing */         { /* This will generate an empty string */ }
-| text TEXT             { std::swap($$,$1); $$.append($2); }
-| text NUMBER           {
-                          std::swap($$,$1);
-                          std::ostringstream o;
-                          o << ' ' << $2;
-                          $$.append(o.str());
-                        }
+item:
+  TEXT          { std::swap ($$, $1); }
+| NUMBER        { $$ = string_cast ($1); }

 ;
 %%
 
 // The yylex function providing subsequent tokens:
 ;
 %%
 
 // The yylex function providing subsequent tokens:

-// TEXT                "I have three numbers for you:"
-// NUMBER      1
-// NUMBER      2
-// NUMBER      3
-// TEXT                " and that's all!"
+// TEXT         "I have three numbers for you:"
+// NUMBER       1
+// NUMBER       2
+// NUMBER       3
+// TEXT         " and that's all!"

 // END_OF_FILE
 
 static
 yy::parser::token_type
 // END_OF_FILE
 
 static
 yy::parser::token_type

-yylex(yy::parser::semantic_type* yylval)
+yylex (yy::parser::semantic_type* yylval)

 {
   static int stage = 0;
   yy::parser::token_type result;
 {
   static int stage = 0;
   yy::parser::token_type result;


@@ -62,20 +90,18 @@ yylex(yy::parser::semantic_type* yylval)
   switch (stage)
   {
     case 0:
   switch (stage)
   {
     case 0:

-      yylval->build<std::string>();
-      yylval->as<std::string>() = std::string("I have three numbers for you:");
+      yylval->build<std::string> () =
+        std::string ("I have three numbers for you.");

       result = yy::parser::token::TEXT;
       break;
     case 1:
     case 2:
     case 3:
       result = yy::parser::token::TEXT;
       break;
     case 1:
     case 2:
     case 3:

-      yylval->build<int>();
-      yylval->as<int>() = stage;
+      yylval->build<int> () = stage;

       result = yy::parser::token::NUMBER;
       break;
     case 4:
       result = yy::parser::token::NUMBER;
       break;
     case 4:

-      yylval->build<std::string>();
-      yylval->as<std::string>() = std::string(" and that's all!");
+      yylval->build<std::string> () = std::string ("And that's all!");

       result = yy::parser::token::TEXT;
       break;
     default:
       result = yy::parser::token::TEXT;
       break;
     default:


@@ -89,18 +115,18 @@ yylex(yy::parser::semantic_type* yylval)
 
 // Mandatory error function
 void
 
 // Mandatory error function
 void

-yy::parser::error(const yy::parser::location_type& yylloc,
-                  const std::string& message)
+yy::parser::error (const yy::parser::location_type& yylloc,
+                   const std::string& message)

 {
   std::cerr << yylloc << ": " << message << std::endl;
 }
 
 int
 {
   std::cerr << yylloc << ": " << message << std::endl;
 }
 
 int

-main(int argc, char *argv[])
+main (int argc, char *argv[])

 {
   yy::parser p;
 {
   yy::parser p;

-  p.set_debug_level(!!getenv("YYDEBUG"));
-  p.parse();
+  p.set_debug_level (!!getenv ("YYDEBUG"));
+  p.parse ();

 }
 
 // Local Variables:
 }
 
 // Local Variables: