Avoid trailing spaces.

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

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index f71611f09a8b3954c0b0a9aebf8c3368e9059013..d058ce191d6774c8c348ed9df74185d6007704ab 100755 (executable)
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -23,18 +23,21 @@ bench.pl - bench marks for Bison parsers.
 
 =head1 SYNOPSIS
 
 
 =head1 SYNOPSIS
 

-  ./bench.pl [OPTIONS]... I<directives>
+  ./bench.pl [OPTIONS]... DIRECTIVES

 
 =head1 DIRECTIVES
 
 Specify the set of benches to run.  The following grammar defines the
 I<directives>:
 
 
 =head1 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
+     | %s skeleton              -- %skeleton "skeleton"
+     | #d definition            -- %code { #define definition }
+     | directive

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


@@ -575,8 +578,7 @@ 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 { $_ eq '%define variant' } @directive;
-
+  my $variant = grep { /%define "?variant"?/ } @directive;

   my $out = new IO::File ">$base.y"
     or die;
   print $out <<EOF;
   my $out = new IO::File ">$base.y"
     or die;
   print $out <<EOF;


@@ -599,12 +601,19 @@ $directives
 static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
 
 #define STAGE_MAX    ($max * 10) // max = $max
 static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
 
 #define STAGE_MAX    ($max * 10) // max = $max

+

 #define USE_VARIANTS $variant
 #if USE_VARIANTS
 # define IF_VARIANTS(True, False) True
 #else
 # define IF_VARIANTS(True, False) False
 #endif
 #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
+#else
+# define IF_ONE_STAGE_BUILD(True, False) False
+#endif

 }
 EOF
 
 }
 EOF
 


@@ -676,12 +685,28 @@ yylex(yy::parser::semantic_type* yylval)
     return yy::parser::token::END_OF_FILE;
   else if (stage % 2)
     {
     return yy::parser::token::END_OF_FILE;
   else if (stage % 2)
     {

-      IF_VARIANTS(yylval->build<int>(), yylval->ival) = stage;
+#if USE_VARIANTS
+# ifdef ONE_STAGE_BUILD
+      yylval->build(stage);
+# else
+      yylval->build<int>() = stage;
+# endif
+#else
+      yylval->ival = stage;
+#endif

       return yy::parser::token::NUMBER;
     }
   else
     {
       return yy::parser::token::NUMBER;
     }
   else
     {

-      IF_VARIANTS(yylval->build<std::string>() =, yylval->sval = new) std::string("A string.");
+#if USE_VARIANTS
+# ifdef ONE_STAGE_BUILD
+      yylval->build(std::string("A string."));
+# else
+      yylval->build<std::string>() = std::string("A string.");
+# endif
+#else
+      yylval->sval = new std::string("A string.");
+#endif

       return yy::parser::token::TEXT;
     }
   abort();
       return yy::parser::token::TEXT;
     }
   abort();


@@ -718,7 +743,7 @@ Generate F<$base.y> by calling C<&generate_grammar_$name>.
 sub generate_grammar ($$@)
 {
   my ($name, $base, @directive) = @_;
 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,
   my %generator =
     (
       "calc"       => \&generate_grammar_calc,


@@ -739,7 +764,7 @@ Run, possibly verbosely, the shell C<$command>.
 sub run ($)
 {
   my ($command) = @_;
 sub run ($)
 {
   my ($command) = @_;

-  verbose 2, "$command\n";
+  verbose 3, "$command\n";

   system ("$command") == 0
     or die "$command failed";
 }
   system ("$command") == 0
     or die "$command failed";
 }


@@ -813,7 +838,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.
   # 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.
   my $res = timethese ($iterations, \%bench, 'nop');
 
   # Output the speed result.


@@ -864,15 +889,20 @@ Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 
 sub bench_variant_parser ()
 {
 
 sub bench_variant_parser ()
 {

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

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


@@ -886,9 +916,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
+         )
+    );

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


@@ -913,11 +946,15 @@ my @token;
 #   expr: term (| term)*
 #   term: fact (& fact)*
 #   fact: ( expr ) | [ expr ] | dirs
 #   expr: term (| term)*
 #   term: fact (& fact)*
 #   fact: ( expr ) | [ expr ] | dirs

+#   dirs: %s SKELETON | #d DEFINE | directive

 sub parse (@)
 {
   @token = @_;
 sub parse (@)
 {
   @token = @_;

-  verbose 2, "Parsing: @token\n";
-  return parse_expr ();
+  verbose 3, "Parsing: @token\n";
+  my @res = parse_expr ();
+  die "expected end of directives, unexpected: @token"
+    if defined $token[0];
+  return @res;

 }
 
 sub parse_expr ()
 }
 
 sub parse_expr ()


@@ -974,11 +1011,37 @@ sub parse_fact ()
         unless $token[0] eq ']';
       shift @token;
     }
         unless $token[0] eq ']';
       shift @token;
     }

+  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')
+    {
+      shift @token;
+      @res = ("%code {\n#define\n}");
+      shift @token;
+    }
+  elsif ($token[0] eq '%s')
+    {
+      shift @token;
+      @res = ("%skeleton \"$token[0]\"");
+      shift @token;
+    }

   else
     {
       @res = $token[0];
       shift @token;
     }
   else
     {
       @res = $token[0];
       shift @token;
     }

+

   return @res;
 }
 
   return @res;
 }
 


@@ -1000,36 +1063,53 @@ sub getopt ()
   Getopt::Long::Configure ("bundling", "pass_through");
   GetOptions (%option)
     or exit 1;
   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;
 }
 
 ######################################################################
 
 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 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";
 
 verbose 2, "Grammar: $grammar\n";
 

-# Launch the bench marking.
-bench ($grammar, @ARGV);

 
 

+# 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;
+}
+else
+{
+  # Launch the bench marking.
+  bench ($grammar, @ARGV);
+}

 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables:
 
 ### Setup "GNU" style for perl-mode and cperl-mode.
 ## Local Variables: