%define token.prefix.

[bison.git] / etc / bench.pl.in

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index 0e5362901e4cc3ccbaa227dee0ea82c07f0f70f8..f8fca8ac714f9f7a9cda4fb63dd4e97e073846e2 100755 (executable)
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -580,11 +580,13 @@ sub generate_grammar_list ($$@)
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
   my $variant = grep { /%define "?variant"?/ } @directive;
+  my $lex_symbol = grep { /%define "?lex_symbol"?/ } @directive;
   my $out = new IO::File ">$base.y"
     or die;
   print $out <<EOF;
 %language "C++"
 %defines
+%locations
 $directives
 
 %code requires // *.h
@@ -598,24 +600,33 @@ $directives
 #include <iostream>
 #include <sstream>
 
-// Prototype of the yylex function providing subsequent tokens.
-static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
-
 #define STAGE_MAX    ($max * 10) // max = $max
 
+#define USE_LEX_SYMBOL $lex_symbol
 #define USE_VARIANTS $variant
-#if USE_VARIANTS
-# define IF_VARIANTS(True, False) True
-#else
-# define IF_VARIANTS(True, False) False
-#endif
 
-#ifdef ONE_STAGE_BUILD
-# define IF_ONE_STAGE_BUILD(True, False) True
+  // Prototype of the yylex function providing subsequent tokens.
+  static
+#if USE_LEX_SYMBOL
+  yy::parser::symbol_type yylex();
 #else
-# define IF_ONE_STAGE_BUILD(True, False) False
+  yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
+                               yy::parser::location_type* yylloc);
 #endif
+
+  // Conversion to string.
+  template <typename T>
+    inline
+    std::string
+    string_cast (const T& t)
+  {
+    std::ostringstream o;
+    o << t;
+    return o.str ();
+  }
 }
+
+%token END_OF_FILE 0
 EOF
 
   if ($variant)
@@ -625,7 +636,6 @@ EOF
 %token <int> NUMBER
 %printer { std::cerr << "Number: " << $$; } <int>
 %printer { std::cerr << "Text: " << $$; } <std::string>
-%token END_OF_FILE 0
 %type <std::string> text result
 
 %%
@@ -636,11 +646,7 @@ result:
 text:
   /* nothing */                { /* This will generate an empty string */ }
 | text TEXT            { std::swap ($$, $2); }
-| text NUMBER          {
-                         std::ostringstream ss;
-                         ss << ' ' << $2;
-                         $$ = ss.str();
-                        }
+| text NUMBER          { $$ = string_cast($2); }
 ;
 EOF
     }
@@ -653,7 +659,6 @@ EOF
 %token <ival> NUMBER
 %printer { std::cerr << "Number: " << $$; } <ival>
 %printer { std::cerr << "Text: " << *$$; } <sval>
-%token END_OF_FILE 0
 %type <sval> text result
 
 %%
@@ -664,51 +669,70 @@ result:
 text:
   /* nothing */                { $$ = new std::string; }
 | text TEXT            { delete $1; $$ = $2; }
-| text NUMBER          {
-                          delete $1;
-                          std::ostringstream ss;
-                         ss << ' ' << $2;
-                         $$ = new std::string (ss.str());
-                        }
+| text NUMBER          { delete $1; $$ = new std::string (string_cast ($2)); }
 ;
 EOF
     }
 
   print $out <<'EOF';
 %%
+#
+
 static
-yy::parser::token_type
-yylex(yy::parser::semantic_type* yylval)
+#if USE_LEX_SYMBOL
+yy::parser::symbol_type yylex()
+#else
+yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
+                             yy::parser::location_type* yylloc)
+#endif
 {
+  typedef yy::parser::token token;
   static int stage = -1;
   ++stage;
   if (stage == STAGE_MAX)
-    return yy::parser::token::END_OF_FILE;
+    {
+#if USE_LEX_SYMBOL
+      return yy::parser::make_symbol <token::END_OF_FILE> (yy::location());
+#else
+      *yylloc = yy::location ();
+      return token::END_OF_FILE;
+#endif
+    }
   else if (stage % 2)
     {
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
+#if USE_LEX_SYMBOL
+      return yy::parser::make_symbol <token::NUMBER> (stage, yy::location());
+#elif defined ONE_STAGE_BUILD
       yylval->build(stage);
-# else
+      *yylloc = yy::location ();
+      return token::NUMBER;
+#elif USE_VARIANTS
       yylval->build<int>() = stage;
-# endif
+      *yylloc = yy::location ();
+      return token::NUMBER;
 #else
       yylval->ival = stage;
+      *yylloc = yy::location ();
+      return token::NUMBER;
 #endif
-      return yy::parser::token::NUMBER;
     }
   else
     {
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
+#if USE_LEX_SYMBOL
+      return yy::parser::make_symbol <token::TEXT> ("A string.", yy::location());
+#elif defined ONE_STAGE_BUILD
       yylval->build(std::string("A string."));
-# else
+      *yylloc = yy::location ();
+      return token::TEXT;
+#elif USE_VARIANTS
       yylval->build<std::string>() = std::string("A string.");
-# endif
+      *yylloc = yy::location ();
+      return token::TEXT;
 #else
       yylval->sval = new std::string("A string.");
+      *yylloc = yy::location ();
+      return token::TEXT;
 #endif
-      return yy::parser::token::TEXT;
     }
   abort();
 }
@@ -884,7 +908,7 @@ sub bench_push_parser ()
 
 =item C<bench_variant_parser ()>
 
-Bench the C++ lalr1.cc parser using Boost.Variants or %union.
+Bench the C++ lalr1.cc parser using variants or %union.
 
 =cut
 
@@ -892,13 +916,10 @@ sub bench_variant_parser ()
 {
   bench ('list',
          qw(
-            [ %debug ]
-            &
-            [ %d variant
-              &
-              [ #d VARIANT_DESTROY ]
+            [
+              %d variant
               &
-              [ #d ONE_STAGE_BUILD ]
+              [ #d ONE_STAGE_BUILD | %d lex_symbol ]
             ]
          )
     );
@@ -993,7 +1014,7 @@ sub parse_term ()
         {
           for my $lhs (@lhs)
             {
-              push @res, "$lhs\n$rhs";
+              push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
             }
         }
     }