#! /usr/bin/perl -w
-# Copyright (C) 2006, 2008 Free Software Foundation, Inc.
+# Copyright (C) 2006, 2008-2013 Free Software Foundation, Inc.
#
# This file is part of Bison, the GNU Compiler Compiler.
#
| 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"
=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.
or die;
print $out <<EOF;
%error-verbose
-%debug
%{
#include <stdio.h>
#include <stdlib.h>
{
use Text::Wrap;
print $out wrap ("| ", " ",
- (map { "\"$_\"" } (1 .. $size)),
- " END \n"),
+ (map { "\"$_\"" } (1 .. $size)),
+ " END \n"),
" { \$\$ = $size; }\n";
};
print $out ";\n";
int
main (void)
{
+#if YYDEBUG
yydebug = !!getenv ("YYDEBUG");
+#endif
return yyparse ();
}
EOF
or die;
print $out <<EOF;
%{
+#include <assert.h>
#include <stdio.h>
-
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
%token <ival> NUM "number"
%type <ival> exp
-%nonassoc '=' /* comparison */
+%nonassoc '=' /* comparison */
%left '-' '+'
%left '*' '/'
%left NEG /* negation--unary minus */
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;
int count = 0;
int status;
+#if YYDEBUG
+ yydebug = !!getenv ("YYDEBUG");
+#endif
+
input = fopen ("calc.input", "r");
if (!input)
{
my ($base, $max, @directive) = @_;
my $directives = directives ($base, @directive);
my $variant = grep { /%define "?variant"?/ } @directive;
+ my $token_ctor = grep { /%define "?api.token.constructor"?/ } @directive;
my $out = new IO::File ">$base.y"
or die;
print $out <<EOF;
%language "C++"
%defines
+%locations
$directives
%code requires // *.h
#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_TOKEN_CTOR $token_ctor
#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_TOKEN_CTOR
+ yy::parser::symbol_type yylex();
#else
-# define IF_ONE_STAGE_BUILD(True, False) False
+ yy::parser::token_type yylex(yy::parser::semantic_type* yylvalp,
+ yy::parser::location_type* yyllocp);
#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)
%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 ($$, $2); }
-| text NUMBER {
- std::ostringstream ss;
- ss << ' ' << $2;
- $$ = ss.str();
- }
+ /* nothing */ { /* This will generate an empty string */ }
+| text TEXT { std::swap ($$, $2); }
+| text NUMBER { $$ = string_cast($2); }
;
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 { delete $1; $$ = $2; }
-| text NUMBER {
- delete $1;
- std::ostringstream ss;
- ss << ' ' << $2;
- $$ = new std::string (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_TOKEN_CTOR
+yy::parser::symbol_type yylex()
+#else
+yy::parser::token_type yylex(yy::parser::semantic_type* yylvalp,
+ yy::parser::location_type* yyllocp)
+#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_TOKEN_CTOR
+ return yy::parser::make_END_OF_FILE (location_type ());
+#else
+ *yyllocp = location_type ();
+ return token::END_OF_FILE;
+#endif
+ }
else if (stage % 2)
{
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
- yylval->build(stage);
+#if USE_TOKEN_CTOR
+ return yy::parser::make_NUMBER (stage, location_type ());
+#else
+# if defined ONE_STAGE_BUILD
+ yylvalp->build(stage);
+# elif USE_VARIANTS
+ yylvalp->build<int>() = stage;
# else
- yylval->build<int>() = stage;
+ yylvalp->ival = stage;
# endif
-#else
- yylval->ival = stage;
+ *yyllocp = location_type ();
+ return token::NUMBER;
#endif
- return yy::parser::token::NUMBER;
}
else
{
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
- yylval->build(std::string("A string."));
+#if USE_TOKEN_CTOR
+ return yy::parser::make_TEXT ("A string.", location_type ());
+#else
+# if defined ONE_STAGE_BUILD
+ yylvalp->build(std::string("A string."));
+# elif USE_VARIANTS
+ yylvalp->build<std::string>() = std::string("A string.");
# else
- yylval->build<std::string>() = std::string("A string.");
+ yylvalp->sval = new std::string("A string.");
# endif
-#else
- yylval->sval = new std::string("A string.");
+ *yyllocp = location_type ();
+ return token::TEXT;
#endif
- return yy::parser::token::TEXT;
}
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[])
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";
}
qw(
[ %d api.pure ]
&
- [ %d api.push_pull=both ]
+ [ %d api.push-pull=both ]
));
}
=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
{
bench ('list',
qw(
- [ %debug ]
- &
- [ %d variant
+ [
+ %d variant
&
- [ #d VARIANT_DESTROY ]
- &
- [ #d ONE_STAGE_BUILD ]
+ [ #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 ($)
{
for my $lhs (@lhs)
{
- push @res, "$lhs\n$rhs";
+ push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
}
}
}
@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];
# Support -b: predefined benches.
my %bench =
(
- "fusion" => \&bench_fusion_parser,
"push" => \&bench_push_parser,
"variant" => \&bench_variant_parser,
);
projects / bison.git / blobdiff