X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/9b0efa5bc24b3f412b6579b5068cb52bab5c197f..fc25770394e7dd123c9c85e25d64b6aeb0d75e04:/etc/bench.pl.in

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index 40023d3f..5d83fc7b 100755
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -1,6 +1,6 @@
 #! /usr/bin/perl -w
 
-# Copyright (C) 2006, 2008 Free Software Foundation, Inc.
+# Copyright (C) 2006, 2008-2012 Free Software Foundation, Inc.
 #
 # This file is part of Bison, the GNU Compiler Compiler.
 #
@@ -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>:
 
-   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:
 
@@ -53,11 +57,6 @@ request.
 
 =over 4
 
-=item I<fusion>
-
-Test F<lalr1.cc> with three stacks against F<lalr1-fusion.cc> which
-uses a single one.
-
 =item I<push>
 
 Test the push parser vs. the pull interface.  Use the C parser.
@@ -247,7 +246,6 @@ sub generate_grammar_triangular ($$@)
     or die;
   print $out <<EOF;
 %error-verbose
-%debug
 %{
 #include <stdio.h>
 #include <stdlib.h>
@@ -286,8 +284,8 @@ for my $size (1 .. $max)
   {
     use Text::Wrap;
     print $out wrap ("| ", "   ",
-		     (map { "\"$_\"" } (1 .. $size)),
-		     " END \n"),
+                     (map { "\"$_\"" } (1 .. $size)),
+                     " END \n"),
                "    { \$\$ = $size; }\n";
   };
 print $out ";\n";
@@ -319,7 +317,9 @@ yyerror (const char *msg)
 int
 main (void)
 {
+#if YYDEBUG
   yydebug = !!getenv ("YYDEBUG");
+#endif
   return yyparse ();
 }
 EOF
@@ -371,8 +371,8 @@ sub generate_grammar_calc ($$@)
     or die;
   print $out <<EOF;
 %{
+#include <assert.h>
 #include <stdio.h>
-
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
@@ -411,7 +411,7 @@ static int yylex (void);
 %token <ival> NUM "number"
 %type  <ival> exp
 
-%nonassoc '=' /* comparison	       */
+%nonassoc '=' /* comparison            */
 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */
@@ -528,9 +528,8 @@ yylex (void)
 static int
 power (int base, int exponent)
 {
+  assert (0 <= exponent);
   int res = 1;
-  if (exponent < 0)
-    exit (3);
   for (/* Niente */; exponent; --exponent)
     res *= base;
   return res;
@@ -544,6 +543,10 @@ main (int argc, const char **argv)
   int count = 0;
   int status;
 
+#if YYDEBUG
+  yydebug = !!getenv ("YYDEBUG");
+#endif
+
   input = fopen ("calc.input", "r");
   if (!input)
     {
@@ -575,13 +578,14 @@ sub generate_grammar_list ($$@)
 {
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
-  my $variant = grep { $_ eq '%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
+%locations
 $directives
 
 %code requires // *.h
@@ -595,17 +599,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
+
+  // Prototype of the yylex function providing subsequent tokens.
+  static
+#if USE_LEX_SYMBOL
+  yy::parser::symbol_type yylex();
 #else
-# define IF_VARIANTS(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)
@@ -615,23 +635,17 @@ 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
 
 %%
 result:
-  text			{ /* Throw away the result. */ }
+  text                  { /* Throw away the result. */ }
 ;
 
 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());
-			 }
+  /* nothing */         { /* This will generate an empty string */ }
+| text TEXT             { std::swap ($$, $2); }
+| text NUMBER           { $$ = string_cast($2); }
 ;
 EOF
     }
@@ -644,55 +658,86 @@ EOF
 %token <ival> NUMBER
 %printer { std::cerr << "Number: " << $$; } <ival>
 %printer { std::cerr << "Text: " << *$$; } <sval>
-%token END_OF_FILE 0
 %type <sval> text result
 
 %%
 result:
-  text			{ delete $1; }
+  text                  { delete $1; }
 ;
 
 text:
-  /* nothing */		{ $$ = new std::string; }
-| text TEXT		{ $$->append(*$2); delete $2; }
-| text NUMBER		{
-			  std::ostringstream ss;
-			  ss << ' ' << $2;
-			  $$->append(ss.str());
-			 }
+  /* nothing */         { $$ = new std::string; }
+| text TEXT             { delete $1; $$ = $2; }
+| 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::location_type location_type;
+  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_END_OF_FILE (location_type ());
+#else
+      *yylloc = location_type ();
+      return token::END_OF_FILE;
+#endif
+    }
   else if (stage % 2)
     {
-      IF_VARIANTS(yylval->build<int>(), yylval->ival) = stage;
-      return yy::parser::token::NUMBER;
+#if USE_LEX_SYMBOL
+      return yy::parser::make_NUMBER (stage, location_type ());
+#else
+# if defined ONE_STAGE_BUILD
+      yylval->build(stage);
+# elif USE_VARIANTS
+      yylval->build<int>() = stage;
+# else
+      yylval->ival = stage;
+# endif
+      *yylloc = location_type ();
+      return token::NUMBER;
+#endif
     }
   else
     {
-      IF_VARIANTS(yylval->build<std::string>() =, yylval->sval = new) std::string("A string.");
-      return yy::parser::token::TEXT;
+#if USE_LEX_SYMBOL
+      return yy::parser::make_TEXT ("A string.", location_type ());
+#else
+# if defined ONE_STAGE_BUILD
+      yylval->build(std::string("A string."));
+# elif USE_VARIANTS
+      yylval->build<std::string>() = std::string("A string.");
+# else
+      yylval->sval = new std::string("A string.");
+# endif
+      *yylloc = location_type ();
+      return token::TEXT;
+#endif
     }
   abort();
 }
 
 // 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& loc, const std::string& msg)
 {
-  std::cerr << yylloc << ": " << message << std::endl;
+  std::cerr << loc << ": " << msg << std::endl;
 }
 
 int main(int argc, char *argv[])
@@ -718,7 +763,7 @@ Generate F<$base.y> by calling C<&generate_grammar_$name>.
 sub generate_grammar ($$@)
 {
   my ($name, $base, @directive) = @_;
-  verbose 2, "Generating $base.y\n";
+  verbose 3, "Generating $base.y\n";
   my %generator =
     (
       "calc"       => \&generate_grammar_calc,
@@ -739,7 +784,7 @@ Run, possibly verbosely, the shell C<$command>.
 sub run ($)
 {
   my ($command) = @_;
-  verbose 2, "$command\n";
+  verbose 3, "$command\n";
   system ("$command") == 0
     or die "$command failed";
 }
@@ -813,7 +858,7 @@ sub bench ($@)
   # shows only wallclock and the two children times.  'auto' (the
   # default) will act as 'all' unless the children times are both
   # zero, in which case it acts as 'noc'.  'none' prevents output.
-  verbose 2, "Running the benches for $grammar\n";
+  verbose 3, "Running the benches for $grammar\n";
   my $res = timethese ($iterations, \%bench, 'nop');
 
   # Output the speed result.
@@ -847,10 +892,10 @@ interfaces.
 sub bench_push_parser ()
 {
   bench ('calc',
-         (
-          '[', '%define api.pure', ']',
-          '&',
-          '[', '%define api.push_pull "both"', ']'
+         qw(
+            [ %d api.pure ]
+            &
+            [ %d api.push-pull=both ]
          ));
 }
 
@@ -858,37 +903,21 @@ 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
 
 sub bench_variant_parser ()
-{
-  bench ('variant',
-         ('%skeleton "lalr1.cc"',
-          '&',
-          '[', '%debug', ']',
-          '&',
-          '[', '%define variant', ']',
-          '&',
-          '[', "%code {\n#define VARIANT_DESTROY\n}", ']'
-         ));
-}
-
-######################################################################
-
-=item C<bench_fusion_parser ()>
-
-Bench the C++ lalr1.cc parser using Boost.Variants or %union.
-
-=cut
-
-sub bench_fusion_parser ()
 {
   bench ('list',
-         ('%skeleton "lalr1-split.cc"',
-          '|',
-          '%skeleton "lalr1.cc"'));
+         qw(
+            [
+              %d variant
+              &
+              [ #d ONE_STAGE_BUILD | %d lex_symbol ]
+            ]
+         )
+    );
 }
 
 ############################################################################
@@ -906,26 +935,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;
 
+# 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
+#   dirs: %s SKELETON | #d NAME[=VALUE] | %d NAME[=VALUE] | directive
 sub parse (@)
 {
-  @token = @_;
-  verbose 2, "Parsing: @token\n";
-  return parse_expr ();
+  @token = (@_, $eod);
+  verbose 3, "Parsing: @token\n";
+  my @res = parse_expr ();
+  eat ($eod);
+  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 ();
     }
@@ -935,9 +980,9 @@ sub parse_expr ()
 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 = ();
@@ -945,7 +990,7 @@ sub parse_term ()
         {
           for my $lhs (@lhs)
             {
-              push @res, "$lhs\n$rhs";
+              push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
             }
         }
     }
@@ -960,18 +1005,47 @@ sub parse_fact ()
 
   if ($token[0] eq '(')
     {
-      shift @token;
+      eat ('(');
       @res = parse_expr ();
-      die "unexpected $token[0], expected )"
-        unless $token[0] eq ')';
-      shift @token;
+      eat (')');
     }
   elsif ($token[0] eq '[')
     {
-      shift @token;
+      eat ('[');
       @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
@@ -979,6 +1053,7 @@ sub parse_fact ()
       @res = $token[0];
       shift @token;
     }
+
   return @res;
 }
 
@@ -1000,36 +1075,52 @@ sub getopt ()
   Getopt::Long::Configure ("bundling", "pass_through");
   GetOptions (%option)
     or exit 1;
-
-  # Support -b: predefined benches.
-  my %bench =
-    (
-     "fusion"   => \&bench_fusion_parser,
-     "push"     => \&bench_push_parser,
-     "variant"  => \&bench_variant_parser,
-    );
-
-  if (defined $bench)
-    {
-      die "invalid argument for --bench: $bench"
-        unless defined $bench{$bench};
-      &{$bench{$bench}}();
-      exit 0;
-    }
 }
 
 ######################################################################
 
 getopt;
+
+# Create the directory we work in.
+mkdir "benches" or die "cannot create benches"
+  unless -d "benches";
+my $count = 1;
+++$count
+  while -d "benches/$count";
+my $dir = "benches/$count";
+mkdir $dir
+  or die "cannot create $dir";
+chdir $dir
+  or die "cannot chdir $dir";
+
+# The following message is tailored to please Emacs' compilation-mode.
+verbose 1, "Entering directory `$dir'\n";
 verbose 1, "Using bison=$bison.\n";
-verbose 1, "Using cc=$cc.\n";
-verbose 1, "Using cxx=$cxx.\n";
-verbose 1, "Using cflags=$cflags.\n";
+verbose 2, "Using cc=$cc.\n";
+verbose 2, "Using cxx=$cxx.\n";
+verbose 2, "Using cflags=$cflags.\n";
 verbose 2, "Grammar: $grammar\n";
 
-# Launch the bench marking.
-bench ($grammar, @ARGV);
 
+# Support -b: predefined benches.
+my %bench =
+  (
+   "push"     => \&bench_push_parser,
+   "variant"  => \&bench_variant_parser,
+  );
+
+if (defined $bench)
+{
+  die "invalid argument for --bench: $bench"
+    unless defined $bench{$bench};
+  &{$bench{$bench}}();
+  exit 0;
+}
+else
+{
+  # Launch the bench marking.
+  bench ($grammar, @ARGV);
+}
 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables: