Make variant.yy more complex.

std::list cannot be copied via memcpy, they are more demanding than
std::string.  Use one std::list to strengthen the test.

	* examples/variant.yy: Use lalr1-fusion.cc, not lalr1.cc.
	Adjust.
	Create a list of strings, instead of a single large string.

ChangeLog

@@ -1,3 +1,13 @@
+2008-11-04  Akim Demaille  <demaille@gostai.com>
+
+	Make variant.yy more complex.
+	std::list cannot be copied via memcpy, they are more demanding than
+	std::string.  Use one std::list to strengthen the test.
+	
+	* examples/variant.yy: Use lalr1-fusion.cc, not lalr1.cc.
+	Adjust.
+	Create a list of strings, instead of a single large string.
+
 2008-11-04  Akim Demaille  <demaille@gostai.com>
 
 	bench.pl --bench.

examples/variant.yy

@@ -1,46 +1,74 @@
 /* Test file for C++ parsers using variants.
    Based on an example by Michiel De Wilde <mdewilde.agilent@gmail.com>. */
-%language "C++"
 %debug
+%skeleton "lalr1-fusion.cc"
 %defines
 %define variant
 
 %code requires // *.hh
 {
+#include <list>
 #include <string>
+typedef std::list<std::string> strings_type;
 }
 
 %code // *.cc
 {
 #include <algorithm>
 #include <iostream>
+#include <iterator>
 #include <sstream>
 
+  // 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;
+    }
   }
 
-%token <std::string> TEXT
+  // Conversion to string.
-%token <int> NUMBER
+  template <typename T>
-%printer { debug_stream() << $$; } <int> <std::string>
+    inline
-%token END_OF_FILE 0
+    std::string
+    string_cast (const T& t)
+  {
+    std::ostringstream o;
+    o << t;
+    return o.str();
+  }
+}
 
-%type <std::string> text result
+%token <std::string> TEXT;
+%token <int> NUMBER;
+%printer { debug_stream () << $$; } <int> <std::string> <strings_type>;
+%token END_OF_FILE 0;
+
+%type <std::string> item;
+%type <strings_type> list;
 
 %%
 
 result:
- text  { std::cout << $1 << std::endl; }
+  list          { std::cout << $1 << std::endl; }
 ;
 
-text:
+list:
-  /* nothing */         { /* This will generate an empty string */ }
+  /* nothing */ { /* Generates an empty string list */ }
-| text TEXT             { std::swap($$,$1); $$.append($2); }
+| list item     { std::swap ($$, $1); $$.push_back ($2); }
-| text NUMBER           {
+;
-                          std::swap($$,$1);
+
-                          std::ostringstream o;
+item:
-                          o << ' ' << $2;
+  TEXT          { std::swap ($$, $1); }
-                          $$.append(o.str());
+| NUMBER        { $$ = string_cast ($1); }
-                        }
 ;
 %%
 
@@ -62,20 +90,18 @@ yylex(yy::parser::semantic_type* yylval)
   switch (stage)
   {
     case 0:
-      yylval->build<std::string>();
+      yylval->build<std::string> () =
-      yylval->as<std::string>() = std::string("I have three numbers for you:");
+        std::string ("I have three numbers for you.");
       result = yy::parser::token::TEXT;
       break;
     case 1:
     case 2:
     case 3:
-      yylval->build<int>();
+      yylval->build<int> () = stage;
-      yylval->as<int>() = stage;
       result = yy::parser::token::NUMBER;
       break;
     case 4:
-      yylval->build<std::string>();
+      yylval->build<std::string> () = std::string ("And that's all!");
-      yylval->as<std::string>() = std::string(" and that's all!");
       result = yy::parser::token::TEXT;
       break;
     default: