%define token.prefix.

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

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index e5133f0eb222d1d182e2e5d4780d05b6610673a2..f8fca8ac714f9f7a9cda4fb63dd4e97e073846e2 100755 (executable)
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -30,11 +30,15 @@ bench.pl - bench marks for Bison parsers.
 Specify the set of benches to run.  The following grammar defines the
 I<directives>:
 
 Specify the set of benches to run.  The following grammar defines the
 I<directives>:
 

-   I<directives> ::= I<directives> | I<directives>  -- Alternation
-                  |  I<directives> & I<directives>  -- Concatenation
-                  |  [ I<directives> ]              -- Optional
-                  |  ( I<directives> )              -- Parentheses
-                  | I<directive>
+   directives ::=
+       directives | directives  -- Alternation
+     | directives & directives  -- Concatenation
+     | [ directives> ]          -- Optional
+     | ( directives> )          -- Parentheses
+     | #d NAME[=VALUE]          -- %code { #define NAME [VALUE] }
+     | %d NAME[=VALUE]          -- %define NAME ["VALUE"]
+     | %s skeleton              -- %skeleton "skeleton"
+     | directive

 
 Parentheses only group to override precedence.  For instance:
 
 
 Parentheses only group to override precedence.  For instance:
 


@@ -575,12 +579,14 @@ sub generate_grammar_list ($$@)
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);

-  my $variant = grep { /%define variant/ } @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
   my $out = new IO::File ">$base.y"
     or die;
   print $out <<EOF;
 %language "C++"
 %defines

+%locations

 $directives
 
 %code requires // *.h
 $directives
 
 %code requires // *.h


@@ -594,24 +600,33 @@ $directives
 #include <iostream>
 #include <sstream>
 
 #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 STAGE_MAX    ($max * 10) // max = $max
 

+#define USE_LEX_SYMBOL $lex_symbol

 #define USE_VARIANTS $variant
 #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
 #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
 #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)
 EOF
 
   if ($variant)


@@ -621,7 +636,6 @@ EOF
 %token <int> NUMBER
 %printer { std::cerr << "Number: " << $$; } <int>
 %printer { std::cerr << "Text: " << $$; } <std::string>
 %token <int> NUMBER
 %printer { std::cerr << "Number: " << $$; } <int>
 %printer { std::cerr << "Text: " << $$; } <std::string>

-%token END_OF_FILE 0

 %type <std::string> text result
 
 %%
 %type <std::string> text result
 
 %%


@@ -631,13 +645,8 @@ result:
 
 text:
   /* nothing */                { /* This will generate an empty string */ }
 
 text:
   /* nothing */                { /* This will generate an empty string */ }

-| text TEXT            { std::swap($$,$1); $$.append($2); }
-| text NUMBER          {
-                         std::swap($$,$1);
-                          std::ostringstream ss;
-                         ss << ' ' << $2;
-                         $$.append(ss.str());
-                        }
+| text TEXT            { std::swap ($$, $2); }
+| text NUMBER          { $$ = string_cast($2); }

 ;
 EOF
     }
 ;
 EOF
     }


@@ -650,7 +659,6 @@ EOF
 %token <ival> NUMBER
 %printer { std::cerr << "Number: " << $$; } <ival>
 %printer { std::cerr << "Text: " << *$$; } <sval>
 %token <ival> NUMBER
 %printer { std::cerr << "Number: " << $$; } <ival>
 %printer { std::cerr << "Text: " << *$$; } <sval>

-%token END_OF_FILE 0

 %type <sval> text result
 
 %%
 %type <sval> text result
 
 %%


@@ -660,51 +668,71 @@ result:
 
 text:
   /* nothing */                { $$ = new std::string; }
 
 text:
   /* nothing */                { $$ = new std::string; }

-| text TEXT            { $$->append(*$2); delete $2; }
-| text NUMBER          {
-                         std::ostringstream ss;
-                         ss << ' ' << $2;
-                         $$->append(ss.str());
-                        }
+| text TEXT            { delete $1; $$ = $2; }
+| text NUMBER          { delete $1; $$ = new std::string (string_cast ($2)); }

 ;
 EOF
     }
 
   print $out <<'EOF';
 %%
 ;
 EOF
     }
 
   print $out <<'EOF';
 %%

+#
+

 static
 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)
   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)
     {
   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);
       yylval->build(stage);

-# else
+      *yylloc = yy::location ();
+      return token::NUMBER;
+#elif USE_VARIANTS

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

-# endif
+      *yylloc = yy::location ();
+      return token::NUMBER;

 #else
       yylval->ival = stage;
 #else
       yylval->ival = stage;

+      *yylloc = yy::location ();
+      return token::NUMBER;

 #endif
 #endif

-      return yy::parser::token::NUMBER;

     }
   else
     {
     }
   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."));
       yylval->build(std::string("A string."));

-# else
+      *yylloc = yy::location ();
+      return token::TEXT;
+#elif USE_VARIANTS

       yylval->build<std::string>() = std::string("A string.");
       yylval->build<std::string>() = std::string("A string.");

-# endif
+      *yylloc = yy::location ();
+      return token::TEXT;

 #else
       yylval->sval = new std::string("A string.");
 #else
       yylval->sval = new std::string("A string.");

+      *yylloc = yy::location ();
+      return token::TEXT;

 #endif
 #endif

-      return yy::parser::token::TEXT;

     }
   abort();
 }
     }
   abort();
 }


@@ -869,10 +897,10 @@ interfaces.
 sub bench_push_parser ()
 {
   bench ('calc',
 sub bench_push_parser ()
 {
   bench ('calc',

-         (
-          '[', '%define api.pure', ']',
-          '&',
-          '[', '%define api.push_pull "both"', ']'
+         qw(
+            [ %d api.pure ]
+            &
+            [ %d api.push_pull=both ]

          ));
 }
 
          ));
 }
 


@@ -880,24 +908,21 @@ sub bench_push_parser ()
 
 =item C<bench_variant_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
 
 sub bench_variant_parser ()
 {
   bench ('list',
 
 =cut
 
 sub bench_variant_parser ()
 {
   bench ('list',

-         ('%skeleton "lalr1.cc"',
-          '&',
-          '[', '%debug', ']',
-          '&',
-          '[', '%define variant',
-            '&',
-            '[', "%code {\n#define VARIANT_DESTROY\n}", ']',
-            '&',
-            '[', "%code {\n#define ONE_STAGE_BUILD\n}", ']',
-          ']'
-         ));
+         qw(
+            [
+              %d variant
+              &
+              [ #d ONE_STAGE_BUILD | %d lex_symbol ]
+            ]
+         )
+    );

 }
 
 ######################################################################
 }
 
 ######################################################################


@@ -911,9 +936,12 @@ Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 sub bench_fusion_parser ()
 {
   bench ('list',
 sub bench_fusion_parser ()
 {
   bench ('list',

-         ('%skeleton "lalr1-split.cc"',
-          '|',
-          '%skeleton "lalr1.cc"'));
+         qw(
+             %s lalr1-split.cc
+           |
+             %s lalr1.cc
+         )
+    );

 }
 
 ############################################################################
 }
 
 ############################################################################


@@ -931,29 +959,42 @@ sub help ($)
 
 ######################################################################
 
 
 ######################################################################
 

+# The end of the directives to parse.
+my $eod = "end of directives";

 # The list of tokens parsed by the following functions.
 my @token;
 
 # The list of tokens parsed by the following functions.
 my @token;
 

+# eat ($EXPECTED)
+# ---------------
+# Check that the current token is $EXPECTED, and move to the next.
+sub eat ($)
+{
+  my ($expected) = @_;
+  die "expected $expected, unexpected: $token[0] (@token)\n"
+    unless $token[0] eq $expected;
+  shift @token;
+}
+

 # Parse directive specifications:
 #   expr: term (| term)*
 #   term: fact (& fact)*
 #   fact: ( expr ) | [ expr ] | dirs
 # Parse directive specifications:
 #   expr: term (| term)*
 #   term: fact (& fact)*
 #   fact: ( expr ) | [ expr ] | dirs

+#   dirs: %s SKELETON | #d NAME[=VALUE] | %d NAME[=VALUE] | directive

 sub parse (@)
 {
 sub parse (@)
 {

-  @token = @_;
+  @token = (@_, $eod);

   verbose 3, "Parsing: @token\n";
   my @res = parse_expr ();
   verbose 3, "Parsing: @token\n";
   my @res = parse_expr ();

-  die "expected end of directives, unexpected: @token"
-    if defined $token[0];
+  eat ($eod);

   return @res;
 }
 
 sub parse_expr ()
 {
   my @res = parse_term ();
   return @res;
 }
 
 sub parse_expr ()
 {
   my @res = parse_term ();

-  while (defined $token[0] && $token[0] eq '|')
+  while ($token[0] eq '|')

     {
     {

-      shift @token;
+      eat ('|');

       # Alternation.
       push @res, parse_term ();
     }
       # Alternation.
       push @res, parse_term ();
     }


@@ -963,9 +1004,9 @@ sub parse_expr ()
 sub parse_term ()
 {
   my @res = parse_fact ();
 sub parse_term ()
 {
   my @res = parse_fact ();

-  while (defined $token[0] && $token[0] eq '&')
+  while ($token[0] eq '&')

     {
     {

-      shift @token;
+      eat ('&');

       # Cartesian product.
       my @lhs = @res;
       @res = ();
       # Cartesian product.
       my @lhs = @res;
       @res = ();


@@ -973,7 +1014,7 @@ sub parse_term ()
         {
           for my $lhs (@lhs)
             {
         {
           for my $lhs (@lhs)
             {

-              push @res, "$lhs\n$rhs";
+              push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;

             }
         }
     }
             }
         }
     }


@@ -988,18 +1029,47 @@ sub parse_fact ()
 
   if ($token[0] eq '(')
     {
 
   if ($token[0] eq '(')
     {

-      shift @token;
+      eat ('(');

       @res = parse_expr ();
       @res = parse_expr ();

-      die "unexpected $token[0], expected )"
-        unless $token[0] eq ')';
-      shift @token;
+      eat (')');

     }
   elsif ($token[0] eq '[')
     {
     }
   elsif ($token[0] eq '[')
     {

-      shift @token;
+      eat ('[');

       @res = (parse_expr (), '');
       @res = (parse_expr (), '');

-      die "unexpected $token[0], expected ]"
-        unless $token[0] eq ']';
+      eat (']');
+    }
+  else
+    {
+      @res = parse_dirs ();
+    }
+  return @res;
+}
+
+sub parse_dirs ()
+{
+  my @res;
+  die "unexpected end of expression"
+    unless defined $token[0];
+
+  if ($token[0] eq '#d')
+    {
+      eat ('#d');
+      $token[0] =~ s/(.*?)=(.*)/$1 $2/;
+      @res = ("%code {\n#define $token[0]\n}");
+      shift @token;
+    }
+  elsif ($token[0] eq '%d')
+    {
+      shift @token;
+      $token[0] =~ s/(.*?)=(.*)/$1 "$2"/;
+      @res = ("%define $token[0]");
+      shift @token;
+    }
+  elsif ($token[0] eq '%s')
+    {
+      shift @token;
+      @res = ("%skeleton \"$token[0]\"");

       shift @token;
     }
   else
       shift @token;
     }
   else


@@ -1007,6 +1077,7 @@ sub parse_fact ()
       @res = $token[0];
       shift @token;
     }
       @res = $token[0];
       shift @token;
     }

+

   return @res;
 }
 
   return @res;
 }
 


@@ -1035,15 +1106,19 @@ sub getopt ()
 getopt;
 
 # Create the directory we work in.
 getopt;
 
 # Create the directory we work in.

+mkdir "benches" or die "cannot create benches"
+  unless -d "benches";

 my $count = 1;
 ++$count
 my $count = 1;
 ++$count

-  while -d "bench-$count";
-my $dir = "bench-$count";
+  while -d "benches/$count";
+my $dir = "benches/$count";

 mkdir $dir
   or die "cannot create $dir";
 chdir $dir
   or die "cannot chdir $dir";
 mkdir $dir
   or die "cannot create $dir";
 chdir $dir
   or die "cannot chdir $dir";

-verbose 1, "Benching in $dir.\n";
+
+# The following message is tailored to please Emacs' compilation-mode.
+verbose 1, "Entering directory `$dir'\n";

 verbose 1, "Using bison=$bison.\n";
 verbose 2, "Using cc=$cc.\n";
 verbose 2, "Using cxx=$cxx.\n";
 verbose 1, "Using bison=$bison.\n";
 verbose 2, "Using cc=$cc.\n";
 verbose 2, "Using cxx=$cxx.\n";