bison: avoid warnings from static code analysis

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

diff --git a/etc/bench.pl.in b/etc/bench.pl.in
index a95e646b56a62ac4e6ccb8bdab8d58a63efeec36..cbd9473df244069b8ebe33ac1f7fa2657c3a2ee2 100755 (executable)
--- a/etc/bench.pl.in
+++ b/etc/bench.pl.in
@@ -1,6 +1,6 @@
 #! /usr/bin/perl -w
 
 #! /usr/bin/perl -w
 

-# Copyright (C) 2006, 2008 Free Software Foundation, Inc.
+# Copyright (C) 2006, 2008-2015 Free Software Foundation, Inc.

 #
 # This file is part of Bison, the GNU Compiler Compiler.
 #
 #
 # This file is part of Bison, the GNU Compiler Compiler.
 #


@@ -35,6 +35,7 @@ I<directives>:
      | directives & directives  -- Concatenation
      | [ directives> ]          -- Optional
      | ( directives> )          -- Parentheses
      | directives & directives  -- Concatenation
      | [ directives> ]          -- Optional
      | ( directives> )          -- Parentheses

+     | %b PATH                  -- Use bison at PATH for this bench

      | #d NAME[=VALUE]          -- %code { #define NAME [VALUE] }
      | %d NAME[=VALUE]          -- %define NAME ["VALUE"]
      | %s skeleton              -- %skeleton "skeleton"
      | #d NAME[=VALUE]          -- %code { #define NAME [VALUE] }
      | %d NAME[=VALUE]          -- %define NAME ["VALUE"]
      | %s skeleton              -- %skeleton "skeleton"


@@ -57,11 +58,6 @@ request.
 
 =over 4
 
 
 =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.
 =item I<push>
 
 Test the push parser vs. the pull interface.  Use the C parser.


@@ -208,9 +204,9 @@ Format the list of directives for Bison for bench named C<$bench>.
 sub directives($@)
 {
   my ($bench, @directive) = @_;
 sub directives($@)
 {
   my ($bench, @directive) = @_;

-  my $res = "/* Directives for bench `$bench'. */\n";
+  my $res = "/* Directives for bench '$bench'. */\n";

   $res .= join ("\n", @directive) . "\n";
   $res .= join ("\n", @directive) . "\n";

-  $res .= "/* End of directives for bench `$bench'. */\n";
+  $res .= "/* End of directives for bench '$bench'. */\n";

   return $res;
 }
 
   return $res;
 }
 


@@ -251,7 +247,6 @@ sub generate_grammar_triangular ($$@)
     or die;
   print $out <<EOF;
 %error-verbose
     or die;
   print $out <<EOF;
 %error-verbose

-%debug

 %{
 #include <stdio.h>
 #include <stdlib.h>
 %{
 #include <stdio.h>
 #include <stdlib.h>


@@ -290,8 +285,8 @@ for my $size (1 .. $max)
   {
     use Text::Wrap;
     print $out wrap ("| ", "   ",
   {
     use Text::Wrap;
     print $out wrap ("| ", "   ",

-                    (map { "\"$_\"" } (1 .. $size)),
-                    " END \n"),
+                     (map { "\"$_\"" } (1 .. $size)),
+                     " END \n"),

                "    { \$\$ = $size; }\n";
   };
 print $out ";\n";
                "    { \$\$ = $size; }\n";
   };
 print $out ";\n";


@@ -323,7 +318,9 @@ yyerror (const char *msg)
 int
 main (void)
 {
 int
 main (void)
 {

+#if YYDEBUG

   yydebug = !!getenv ("YYDEBUG");
   yydebug = !!getenv ("YYDEBUG");

+#endif

   return yyparse ();
 }
 EOF
   return yyparse ();
 }
 EOF


@@ -375,8 +372,8 @@ sub generate_grammar_calc ($$@)
     or die;
   print $out <<EOF;
 %{
     or die;
   print $out <<EOF;
 %{

+#include <assert.h>

 #include <stdio.h>
 #include <stdio.h>

-

 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>


@@ -415,7 +412,7 @@ static int yylex (void);
 %token <ival> NUM "number"
 %type  <ival> exp
 
 %token <ival> NUM "number"
 %type  <ival> exp
 

-%nonassoc '=' /* comparison           */
+%nonassoc '=' /* comparison            */

 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */
 %left '-' '+'
 %left '*' '/'
 %left NEG     /* negation--unary minus */


@@ -532,9 +529,8 @@ yylex (void)
 static int
 power (int base, int exponent)
 {
 static int
 power (int base, int exponent)
 {

+  assert (0 <= exponent);

   int res = 1;
   int res = 1;

-  if (exponent < 0)
-    exit (3);

   for (/* Niente */; exponent; --exponent)
     res *= base;
   return res;
   for (/* Niente */; exponent; --exponent)
     res *= base;
   return res;


@@ -548,6 +544,10 @@ main (int argc, const char **argv)
   int count = 0;
   int status;
 
   int count = 0;
   int status;
 

+#if YYDEBUG
+  yydebug = !!getenv ("YYDEBUG");
+#endif
+

   input = fopen ("calc.input", "r");
   if (!input)
     {
   input = fopen ("calc.input", "r");
   if (!input)
     {


@@ -580,7 +580,7 @@ sub generate_grammar_list ($$@)
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
   my $variant = grep { /%define "?variant"?/ } @directive;
   my ($base, $max, @directive) = @_;
   my $directives = directives ($base, @directive);
   my $variant = grep { /%define "?variant"?/ } @directive;

-  my $lex_symbol = grep { /%define "?lex_symbol"?/ } @directive;
+  my $token_ctor = grep { /%define "?api.token.constructor"?/ } @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;


@@ -602,16 +602,16 @@ $directives
 
 #define STAGE_MAX    ($max * 10) // max = $max
 
 
 #define STAGE_MAX    ($max * 10) // max = $max
 

-#define USE_LEX_SYMBOL $lex_symbol
+#define USE_TOKEN_CTOR $token_ctor

 #define USE_VARIANTS $variant
 
   // Prototype of the yylex function providing subsequent tokens.
   static
 #define USE_VARIANTS $variant
 
   // Prototype of the yylex function providing subsequent tokens.
   static

-#if USE_LEX_SYMBOL
+#if USE_TOKEN_CTOR

   yy::parser::symbol_type yylex();
 #else
   yy::parser::symbol_type yylex();
 #else

-  yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
-                               yy::parser::location_type* yylloc);
+  yy::parser::token_type yylex(yy::parser::semantic_type* yylvalp,
+                               yy::parser::location_type* yyllocp);

 #endif
 
   // Conversion to string.
 #endif
 
   // Conversion to string.


@@ -640,13 +640,13 @@ EOF
 
 %%
 result:
 
 %%
 result:

-  text                 { /* Throw away the result. */ }
+  text                  { /* Throw away the result. */ }

 ;
 
 text:
 ;
 
 text:

-  /* nothing */                { /* This will generate an empty string */ }
-| text TEXT            { std::swap ($$, $2); }
-| text NUMBER          { $$ = string_cast($2); }
+  /* nothing */         { /* This will generate an empty string */ }
+| text TEXT             { std::swap ($$, $2); }
+| text NUMBER           { $$ = string_cast($2); }

 ;
 EOF
     }
 ;
 EOF
     }


@@ -663,13 +663,13 @@ EOF
 
 %%
 result:
 
 %%
 result:

-  text                 { delete $1; }
+  text                  { delete $1; }

 ;
 
 text:
 ;
 
 text:

-  /* nothing */                { $$ = new std::string; }
-| text TEXT            { delete $1; $$ = $2; }
-| text NUMBER          { delete $1; $$ = new std::string (string_cast ($2)); }
+  /* nothing */         { $$ = new std::string; }
+| text TEXT             { delete $1; $$ = $2; }
+| text NUMBER           { delete $1; $$ = new std::string (string_cast ($2)); }

 ;
 EOF
     }
 ;
 EOF
     }


@@ -679,11 +679,11 @@ EOF
 #
 
 static
 #
 
 static

-#if USE_LEX_SYMBOL
+#if USE_TOKEN_CTOR

 yy::parser::symbol_type yylex()
 #else
 yy::parser::symbol_type yylex()
 #else

-yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
-                             yy::parser::location_type* yylloc)
+yy::parser::token_type yylex(yy::parser::semantic_type* yylvalp,
+                             yy::parser::location_type* yyllocp)

 #endif
 {
   typedef yy::parser::location_type location_type;
 #endif
 {
   typedef yy::parser::location_type location_type;


@@ -692,42 +692,42 @@ yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
   ++stage;
   if (stage == STAGE_MAX)
     {
   ++stage;
   if (stage == STAGE_MAX)
     {

-#if USE_LEX_SYMBOL
-      return yy::parser::make_END_OF_FILE (yy::location());
+#if USE_TOKEN_CTOR
+      return yy::parser::make_END_OF_FILE (location_type ());

 #else
 #else

-      *yylloc = location_type ();
+      *yyllocp = location_type ();

       return token::END_OF_FILE;
 #endif
     }
   else if (stage % 2)
     {
       return token::END_OF_FILE;
 #endif
     }
   else if (stage % 2)
     {

-#if USE_LEX_SYMBOL
-      return yy::parser::make_NUMBER (stage, yy::location());
+#if USE_TOKEN_CTOR
+      return yy::parser::make_NUMBER (stage, location_type ());

 #else
 # if defined ONE_STAGE_BUILD
 #else
 # if defined ONE_STAGE_BUILD

-      yylval->build(stage);
+      yylvalp->build(stage);

 # elif USE_VARIANTS
 # elif USE_VARIANTS

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

 # else
 # else

-      yylval->ival = stage;
+      yylvalp->ival = stage;

 # endif
 # endif

-      *yylloc = location_type ();
+      *yyllocp = location_type ();

       return token::NUMBER;
 #endif
     }
   else
     {
       return token::NUMBER;
 #endif
     }
   else
     {

-#if USE_LEX_SYMBOL
-      return yy::parser::make_TEXT ("A string.", yy::location());
+#if USE_TOKEN_CTOR
+      return yy::parser::make_TEXT ("A string.", location_type ());

 #else
 # if defined ONE_STAGE_BUILD
 #else
 # if defined ONE_STAGE_BUILD

-      yylval->build(std::string("A string."));
+      yylvalp->build(std::string("A string."));

 # elif USE_VARIANTS
 # elif USE_VARIANTS

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

 # else
 # else

-      yylval->sval = new std::string("A string.");
+      yylvalp->sval = new std::string("A string.");

 # endif
 # endif

-      *yylloc = location_type ();
+      *yyllocp = location_type ();

       return token::TEXT;
 #endif
     }
       return token::TEXT;
 #endif
     }


@@ -736,10 +736,9 @@ yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
 
 // Mandatory error function
 void
 
 // 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[])
 }
 
 int main(int argc, char *argv[])


@@ -808,7 +807,8 @@ sub compile ($)
 
   my $compiler = $language eq 'C++' ? $cxx : $cc;
 
 
   my $compiler = $language eq 'C++' ? $cxx : $cc;
 

-  run "$bison $base.y -o $base.c";
+  my $my_bison = `sed -ne '/%bison "\\(.*\\)"/{s//\\1/;p;q;}' $base.y`;
+  run ((length $my_bison ? $my_bison : $bison) . " $base.y -o $base.c");

   run "$compiler -o $base $cflags $base.c";
 }
 
   run "$compiler -o $base $cflags $base.c";
 }
 


@@ -897,7 +897,7 @@ sub bench_push_parser ()
          qw(
             [ %d api.pure ]
             &
          qw(
             [ %d api.pure ]
             &

-            [ %d api.push_pull=both ]
+            [ %d api.push-pull=both ]

          ));
 }
 
          ));
 }
 


@@ -916,31 +916,12 @@ sub bench_variant_parser ()
             [
               %d variant
               &
             [
               %d variant
               &

-              [ #d ONE_STAGE_BUILD | %d lex_symbol ]
+              [ #d ONE_STAGE_BUILD | %d api.token.constructor ]

             ]
          )
     );
 }
 
             ]
          )
     );
 }
 

-######################################################################
-
-=item C<bench_fusion_parser ()>
-
-Bench the C++ lalr1.cc parser using Boost.Variants or %union.
-
-=cut
-
-sub bench_fusion_parser ()
-{
-  bench ('list',
-         qw(
-             %s lalr1-split.cc
-           |
-             %s lalr1.cc
-         )
-    );
-}
-

 ############################################################################
 
 sub help ($)
 ############################################################################
 
 sub help ($)


@@ -1069,6 +1050,12 @@ sub parse_dirs ()
       @res = ("%skeleton \"$token[0]\"");
       shift @token;
     }
       @res = ("%skeleton \"$token[0]\"");
       shift @token;
     }

+  elsif ($token[0] eq '%b')
+    {
+      shift @token;
+      @res = ("/*\n%bison \"$token[0]\"\\\n*/");
+      shift @token;
+    }

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


@@ -1126,7 +1113,6 @@ verbose 2, "Grammar: $grammar\n";
 # Support -b: predefined benches.
 my %bench =
   (
 # Support -b: predefined benches.
 my %bench =
   (

-   "fusion"   => \&bench_fusion_parser,

    "push"     => \&bench_push_parser,
    "variant"  => \&bench_variant_parser,
   );
    "push"     => \&bench_push_parser,
    "variant"  => \&bench_variant_parser,
   );