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:
=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.
{
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
+%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_LEX_SYMBOL $lex_symbol
#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
-# define IF_ONE_STAGE_BUILD(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)
%token <int> NUMBER
%printer { std::cerr << "Number: " << $$; } <int>
%printer { std::cerr << "Text: " << $$; } <std::string>
-%token END_OF_FILE 0
%type <std::string> text 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());
- }
+| 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
%%
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';
%%
+#
+
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 (yy::location());
+#else
+ *yylloc = location_type ();
+ return token::END_OF_FILE;
+#endif
+ }
else if (stage % 2)
{
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
+#if USE_LEX_SYMBOL
+ return yy::parser::make_NUMBER (stage, yy::location());
+#else
+# if defined ONE_STAGE_BUILD
yylval->build(stage);
-# else
+# elif USE_VARIANTS
yylval->build<int>() = stage;
-# endif
-#else
+# else
yylval->ival = stage;
+# endif
+ *yylloc = location_type ();
+ return token::NUMBER;
#endif
- return yy::parser::token::NUMBER;
}
else
{
-#if USE_VARIANTS
-# ifdef ONE_STAGE_BUILD
+#if USE_LEX_SYMBOL
+ return yy::parser::make_TEXT ("A string.", yy::location());
+#else
+# if defined ONE_STAGE_BUILD
yylval->build(std::string("A string."));
-# else
+# elif USE_VARIANTS
yylval->build<std::string>() = std::string("A string.");
-# endif
-#else
+# else
yylval->sval = new std::string("A string.");
+# endif
+ *yylloc = location_type ();
+ return token::TEXT;
#endif
- return yy::parser::token::TEXT;
}
abort();
}
sub bench_push_parser ()
{
bench ('calc',
- (
- '[', '%define api.pure', ']',
- '&',
- '[', '%define api.push_pull "both"', ']'
+ qw(
+ [ %d api.pure ]
+ &
+ [ %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
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}", ']',
- ']'
- ));
-}
-
-######################################################################
-
-=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 ]
+ ]
+ )
+ );
}
############################################################################
######################################################################
+# 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 = @_;
+ @token = (@_, $eod);
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 ();
- while (defined $token[0] && $token[0] eq '|')
+ while ($token[0] eq '|')
{
- shift @token;
+ eat ('|');
# Alternation.
push @res, parse_term ();
}
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 = ();
{
for my $lhs (@lhs)
{
- push @res, "$lhs\n$rhs";
+ push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
}
}
}
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
@res = $token[0];
shift @token;
}
+
return @res;
}
getopt;
# Create the directory we work in.
+mkdir "benches" or die "cannot create benches"
+ unless -d "benches";
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";
-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";
# Support -b: predefined benches.
my %bench =
(
- "fusion" => \&bench_fusion_parser,
"push" => \&bench_push_parser,
"variant" => \&bench_variant_parser,
);
projects / bison.git / blobdiff