/usr/local/CPAN/Petal-CodePerl/Petal/CodePerl/Parser.pm
package Petal::CodePerl::Parser;
use Parse::RecDescent;
{ my $ERRORS;
package Parse::RecDescent::Petal::CodePerl::Parser;
use strict;
use vars qw($skip $AUTOLOAD );
$skip = '';
{
local $SIG{__WARN__} = sub {0};
# PRETEND TO BE IN Parse::RecDescent NAMESPACE
*Parse::RecDescent::Petal::CodePerl::Parser::AUTOLOAD = sub
{
no strict 'refs';
$AUTOLOAD =~ s/^Parse::RecDescent::Petal::CodePerl::Parser/Parse::RecDescent/;
goto &{$AUTOLOAD};
}
}
push @Parse::RecDescent::Petal::CodePerl::Parser::ISA, 'Parse::RecDescent';
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::empty_method
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"empty_method"};
Parse::RecDescent::_trace(q{Trying rule: [empty_method]},
Parse::RecDescent::_tracefirst($_[1]),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [separator url_segment '()']},
Parse::RecDescent::_tracefirst($_[1]),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{empty_method});
%item = (__RULE__ => q{empty_method});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [separator]},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::separator($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [separator]>>},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [separator]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{separator}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying subrule: [url_segment]},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{url_segment})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::url_segment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [url_segment]>>},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [url_segment]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{url_segment}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: ['()']},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{'()'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(\)//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { ['method', $item{url_segment}] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [separator url_segment '()']<<},
Parse::RecDescent::_tracefirst($text),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{empty_method},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{empty_method},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{empty_method},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::mod_expr_revert
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"mod_expr_revert"};
Parse::RecDescent::_trace(q{Trying rule: [mod_expr_revert]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mod_name /\\s*/ ':' /.*/]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{mod_expr_revert});
%item = (__RULE__ => q{mod_expr_revert});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mod_name]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mod_name($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mod_name]>>},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mod_name]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mod_name}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: [/\\s*/]}, Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\s*/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\s*)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [':']},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{':'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\://)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [/.*/]}, Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/.*/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:.*)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN2__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
# make sure Petal doesn't escape it because we will
my $key = "structure ".join("", @item[1, 2, 3, 4]);
Code::Perl::Expr::callm(
$Petal::CodePerl::Compiler::root,
"get",
$key
);
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [mod_name /\\s*/ ':' /.*/]<<},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{mod_expr_revert},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{mod_expr_revert},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{mod_expr_revert},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"string"};
Parse::RecDescent::_trace(q{Trying rule: [string]},
Parse::RecDescent::_tracefirst($_[1]),
q{string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [string_piece]},
Parse::RecDescent::_tracefirst($_[1]),
q{string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{string});
%item = (__RULE__ => q{string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying repeated subrule: [string_piece]},
Parse::RecDescent::_tracefirst($text),
q{string},
$tracelevel)
if defined $::RD_TRACE;
$expectation->is(q{})->at($text);
unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Petal::CodePerl::Parser::string_piece, 0, 100000000, $_noactions,$expectation,undef)))
{
Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [string_piece]>>},
Parse::RecDescent::_tracefirst($text),
q{string},
$tracelevel)
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched repeated subrule: [string_piece]<< (}
. @$_tok . q{ times)},
Parse::RecDescent::_tracefirst($text),
q{string},
$tracelevel)
if defined $::RD_TRACE;
$item{q{string_piece(s?)}} = $_tok;
push @item, $_tok;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{string},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
Code::Perl::Expr::append(@{$item[1]})
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [string_piece]<<},
Parse::RecDescent::_tracefirst($text),
q{string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::path_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"path_expr"};
Parse::RecDescent::_trace(q{Trying rule: [path_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['path:' <commit> single_path]},
Parse::RecDescent::_tracefirst($_[1]),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{path_expr});
%item = (__RULE__ => q{path_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['path:']},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "path:"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { $commit = 1 };
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE1__}=$_tok;
Parse::RecDescent::_trace(q{Trying subrule: [single_path]},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{single_path})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_path]>>},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_path]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_path}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { $item{path} };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['path:' <commit> single_path]<<},
Parse::RecDescent::_tracefirst($text),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{path_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{path_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{path_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::_alternation_1_of_production_1_of_rule_plain_string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_plain_string"};
Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_plain_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [dollar]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{_alternation_1_of_production_1_of_rule_plain_string});
%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_plain_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [dollar]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::dollar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [dollar]>>},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [dollar]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$item{q{dollar}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [dollar]<<},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [non_dollar]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{_alternation_1_of_production_1_of_rule_plain_string});
%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_plain_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [non_dollar]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::non_dollar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [non_dollar]>>},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [non_dollar]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$item{q{non_dollar}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [non_dollar]<<},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{_alternation_1_of_production_1_of_rule_plain_string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::single_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"single_expr"};
Parse::RecDescent::_trace(q{Trying rule: [single_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [qual_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{single_expr});
%item = (__RULE__ => q{single_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [qual_expr]},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::qual_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [qual_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [qual_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{qual_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [qual_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [single_path]},
Parse::RecDescent::_tracefirst($_[1]),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{single_expr});
%item = (__RULE__ => q{single_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [single_path]},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_path]>>},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_path]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_path}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [single_path]<<},
Parse::RecDescent::_tracefirst($text),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{single_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{single_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{single_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::integer
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"integer"};
Parse::RecDescent::_trace(q{Trying rule: [integer]},
Parse::RecDescent::_tracefirst($_[1]),
q{integer},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [/[0-9]+/]},
Parse::RecDescent::_tracefirst($_[1]),
q{integer},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{integer});
%item = (__RULE__ => q{integer});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/[0-9]+/]}, Parse::RecDescent::_tracefirst($text),
q{integer},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[0-9]+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: [/[0-9]+/]<<},
Parse::RecDescent::_tracefirst($text),
q{integer},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{integer},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{integer},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{integer},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{integer},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::mm_string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"mm_string"};
Parse::RecDescent::_trace(q{Trying rule: [mm_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['--' /\\S+/]},
Parse::RecDescent::_tracefirst($_[1]),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{mm_string});
%item = (__RULE__ => q{mm_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['--']},
Parse::RecDescent::_tracefirst($text),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\-\-//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [/\\S+/]}, Parse::RecDescent::_tracefirst($text),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\S+/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\S+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: ['--' /\\S+/]<<},
Parse::RecDescent::_tracefirst($text),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{mm_string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{mm_string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{mm_string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::qual_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"qual_expr"};
Parse::RecDescent::_trace(q{Trying rule: [qual_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [path_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [path_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::path_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [path_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [path_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{path_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [path_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [not_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [not_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::not_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [not_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [not_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{not_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [not_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [string_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[2];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [string_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::string_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [string_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [string_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{string_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [string_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [exists_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[3];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [exists_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::exists_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [exists_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [exists_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{exists_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [exists_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [perl_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[4];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [perl_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::perl_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [perl_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [perl_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{perl_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [perl_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mod_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[5];
$text = $_[1];
my $_savetext;
@item = (q{qual_expr});
%item = (__RULE__ => q{qual_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mod_expr]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mod_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mod_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mod_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mod_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [mod_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{qual_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{qual_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{qual_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::hash_deref
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"hash_deref"};
Parse::RecDescent::_trace(q{Trying rule: [hash_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['\{' url_segment '\}']},
Parse::RecDescent::_tracefirst($_[1]),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{hash_deref});
%item = (__RULE__ => q{hash_deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['\{']},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\{//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying subrule: [url_segment]},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{url_segment})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::url_segment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [url_segment]>>},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [url_segment]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{url_segment}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: ['\}']},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{'\}'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\}//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING2__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { ['hash', $item{url_segment}] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['\{' url_segment '\}']<<},
Parse::RecDescent::_tracefirst($text),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{hash_deref},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{hash_deref},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{hash_deref},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::exists_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"exists_expr"};
Parse::RecDescent::_trace(q{Trying rule: [exists_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['exists:' <commit> path_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{exists_expr});
%item = (__RULE__ => q{exists_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['exists:']},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "exists:"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { $commit = 1 };
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE1__}=$_tok;
Parse::RecDescent::_trace(q{Trying subrule: [path_expr]},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{path_expr})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::path_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [path_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [path_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{path_expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { Petal::CodePerl::Expr::pathexists($item{expr}) };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['exists:' <commit> path_expr]<<},
Parse::RecDescent::_tracefirst($text),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{exists_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{exists_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{exists_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::dollar
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"dollar"};
Parse::RecDescent::_trace(q{Trying rule: [dollar]},
Parse::RecDescent::_tracefirst($_[1]),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['$$']},
Parse::RecDescent::_tracefirst($_[1]),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{dollar});
%item = (__RULE__ => q{dollar});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['$$']},
Parse::RecDescent::_tracefirst($text),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\$\$//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { '$' };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['$$']<<},
Parse::RecDescent::_tracefirst($text),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{dollar},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{dollar},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{dollar},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::deref
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"deref"};
Parse::RecDescent::_trace(q{Trying rule: [deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [method_call]},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{deref});
%item = (__RULE__ => q{deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [method_call]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::method_call($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [method_call]>>},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [method_call]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{method_call}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [method_call]<<},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [tal_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{deref});
%item = (__RULE__ => q{deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [tal_deref]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::tal_deref($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [tal_deref]>>},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [tal_deref]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{tal_deref}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [tal_deref]<<},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [hash_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[2];
$text = $_[1];
my $_savetext;
@item = (q{deref});
%item = (__RULE__ => q{deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [hash_deref]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::hash_deref($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [hash_deref]>>},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [hash_deref]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{hash_deref}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [hash_deref]<<},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [array_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[3];
$text = $_[1];
my $_savetext;
@item = (q{deref});
%item = (__RULE__ => q{deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [array_deref]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::array_deref($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [array_deref]>>},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [array_deref]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{array_deref}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [array_deref]<<},
Parse::RecDescent::_tracefirst($text),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{deref},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{deref},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{deref},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{deref},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::mod_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"mod_expr"};
Parse::RecDescent::_trace(q{Trying rule: [mod_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mod_expr_compile]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{mod_expr});
%item = (__RULE__ => q{mod_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mod_expr_compile]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mod_expr_compile($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mod_expr_compile]>>},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mod_expr_compile]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mod_expr_compile}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [mod_expr_compile]<<},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mod_expr_revert]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{mod_expr});
%item = (__RULE__ => q{mod_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mod_expr_revert]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mod_expr_revert($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mod_expr_revert]>>},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mod_expr_revert]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mod_expr_revert}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [mod_expr_revert]<<},
Parse::RecDescent::_tracefirst($text),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{mod_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{mod_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{mod_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::string_argument
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"string_argument"};
Parse::RecDescent::_trace(q{Trying rule: [string_argument]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mm_string, or qq_string, or q_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{string_argument});
%item = (__RULE__ => q{string_argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [_alternation_1_of_production_1_of_rule_string_argument]},
Parse::RecDescent::_tracefirst($text),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::_alternation_1_of_production_1_of_rule_string_argument($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [_alternation_1_of_production_1_of_rule_string_argument]>>},
Parse::RecDescent::_tracefirst($text),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [_alternation_1_of_production_1_of_rule_string_argument]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{_alternation_1_of_production_1_of_rule_string_argument}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
Code::Perl::Expr::string($item[1])
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [mm_string, or qq_string, or q_string]<<},
Parse::RecDescent::_tracefirst($text),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{string_argument},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{string_argument},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{string_argument},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::arg_method
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"arg_method"};
Parse::RecDescent::_trace(q{Trying rule: [arg_method]},
Parse::RecDescent::_tracefirst($_[1]),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [separator url_segment /\\s+/ <leftop: argument /\\s+/ argument>]},
Parse::RecDescent::_tracefirst($_[1]),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{arg_method});
%item = (__RULE__ => q{arg_method});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [separator]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::separator($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [separator]>>},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [separator]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{separator}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying subrule: [url_segment]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{url_segment})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::url_segment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [url_segment]>>},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [url_segment]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{url_segment}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: [/\\s+/]}, Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\s+/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\s+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying operator: [<leftop: argument /\\s+/ argument>]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->is(q{<leftop: argument /\\s+/ argument>})->at($text);
$_tok = undef;
OPLOOP: while (1)
{
$repcount = 0;
my @item;
# MATCH LEFTARG
Parse::RecDescent::_trace(q{Trying subrule: [argument]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{argument})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::argument($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [argument]>>},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [argument]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{argument}} = $_tok;
push @item, $_tok;
}
$repcount++;
my $savetext = $text;
my $backtrack;
# MATCH (OP RIGHTARG)(s)
while ($repcount < 100000000)
{
$backtrack = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/\\s+/]}, Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\s+/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\s+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN2__}=$&;
pop @item;
if (defined $1) {push @item, $item{'argument(s)'}=$1; $backtrack=1;}
Parse::RecDescent::_trace(q{Trying subrule: [argument]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{argument})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::argument($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [argument]>>},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [argument]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$item{q{argument}} = $_tok;
push @item, $_tok;
}
$savetext = $text;
$repcount++;
}
$text = $savetext;
pop @item if $backtrack;
unless (@item) { undef $_tok; last }
$_tok = [ @item ];
last;
}
unless ($repcount>=1)
{
Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: argument /\\s+/ argument>]>>},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: argument /\\s+/ argument>]<< (return value: [}
. qq{@{$_tok||[]}} . q{]},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
push @item, $item{'argument(s)'}=$_tok||[];
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
['method', $item{url_segment}, @{$item[4]}]
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [separator url_segment /\\s+/ <leftop: argument /\\s+/ argument>]<<},
Parse::RecDescent::_tracefirst($text),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{arg_method},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{arg_method},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{arg_method},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::non_dollar
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"non_dollar"};
Parse::RecDescent::_trace(q{Trying rule: [non_dollar]},
Parse::RecDescent::_tracefirst($_[1]),
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [/[^\\$]+/]},
Parse::RecDescent::_tracefirst($_[1]),
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{non_dollar});
%item = (__RULE__ => q{non_dollar});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/[^\\$]+/]}, Parse::RecDescent::_tracefirst($text),
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^\$]+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: [/[^\\$]+/]<<},
Parse::RecDescent::_tracefirst($text),
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{non_dollar},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{non_dollar},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{non_dollar},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::q_string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"q_string"};
Parse::RecDescent::_trace(q{Trying rule: [q_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [''' /[^']*/ ''']},
Parse::RecDescent::_tracefirst($_[1]),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{q_string});
%item = (__RULE__ => q{q_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: [''']},
Parse::RecDescent::_tracefirst($text),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "'"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying terminal: [/[^']*/]}, Parse::RecDescent::_tracefirst($text),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/[^']*/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^']*)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [''']},
Parse::RecDescent::_tracefirst($text),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{'''})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "'"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING2__}=$_tok;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { $item[2] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [''' /[^']*/ ''']<<},
Parse::RecDescent::_tracefirst($text),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{q_string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{q_string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{q_string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::plain_string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"plain_string"};
Parse::RecDescent::_trace(q{Trying rule: [plain_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [dollar, or non_dollar]},
Parse::RecDescent::_tracefirst($_[1]),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{plain_string});
%item = (__RULE__ => q{plain_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying repeated subrule: [dollar, or non_dollar]},
Parse::RecDescent::_tracefirst($text),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
$expectation->is(q{})->at($text);
unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Petal::CodePerl::Parser::_alternation_1_of_production_1_of_rule_plain_string, 1, 100000000, $_noactions,$expectation,undef)))
{
Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [dollar, or non_dollar]>>},
Parse::RecDescent::_tracefirst($text),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_1_of_rule_plain_string]<< (}
. @$_tok . q{ times)},
Parse::RecDescent::_tracefirst($text),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
$item{q{_alternation_1_of_production_1_of_rule_plain_string(s)}} = $_tok;
push @item, $_tok;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
Code::Perl::Expr::string( join("", @{$item[1]}) )
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [dollar, or non_dollar]<<},
Parse::RecDescent::_tracefirst($text),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{plain_string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{plain_string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{plain_string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::not_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"not_expr"};
Parse::RecDescent::_trace(q{Trying rule: [not_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['not:' <commit> expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{not_expr});
%item = (__RULE__ => q{not_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['not:']},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "not:"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { $commit = 1 };
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE1__}=$_tok;
Parse::RecDescent::_trace(q{Trying subrule: [expr]},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{expr})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
Code::Perl::Expr::not($item{expr})
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['not:' <commit> expr]<<},
Parse::RecDescent::_tracefirst($text),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{not_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{not_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{not_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::array_deref
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"array_deref"};
Parse::RecDescent::_trace(q{Trying rule: [array_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['[' integer ']']},
Parse::RecDescent::_tracefirst($_[1]),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{array_deref});
%item = (__RULE__ => q{array_deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['[']},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\[//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying subrule: [integer]},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{integer})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::integer($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [integer]>>},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [integer]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{integer}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: [']']},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{']'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\]//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING2__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { ['array', $item{integer}] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['[' integer ']']<<},
Parse::RecDescent::_tracefirst($text),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{array_deref},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{array_deref},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{array_deref},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::perl_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"perl_expr"};
Parse::RecDescent::_trace(q{Trying rule: [perl_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
Parse::RecDescent::_trace(q{Trying production: ['perl:' <commit> <perl_codeblock>]},
Parse::RecDescent::_tracefirst($_[1]),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{perl_expr});
%item = (__RULE__ => q{perl_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['perl:']},
Parse::RecDescent::_tracefirst($text),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "perl:"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
Parse::RecDescent::_tracefirst($text),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { $commit = 1 };
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<perl_codeblock>]},
Parse::RecDescent::_tracefirst($text),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { Text::Balanced::extract_codeblock($text,undef,$skip,'{}');
};
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE2__}=$_tok;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { Code::Perl::Expr::perl($item[2]) };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['perl:' <commit> <perl_codeblock>]<<},
Parse::RecDescent::_tracefirst($text),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{perl_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{perl_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{perl_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::argument
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"argument"};
Parse::RecDescent::_trace(q{Trying rule: [argument]},
Parse::RecDescent::_tracefirst($_[1]),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [string_argument]},
Parse::RecDescent::_tracefirst($_[1]),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{argument});
%item = (__RULE__ => q{argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [string_argument]},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::string_argument($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [string_argument]>>},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [string_argument]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{string_argument}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [string_argument]<<},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{argument});
%item = (__RULE__ => q{argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [expr]},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [expr]<<},
Parse::RecDescent::_tracefirst($text),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{argument},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{argument},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{argument},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{argument},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::qq_string
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"qq_string"};
Parse::RecDescent::_trace(q{Trying rule: [qq_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['"' /[^"]*/ '"']},
Parse::RecDescent::_tracefirst($_[1]),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{qq_string});
%item = (__RULE__ => q{qq_string});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['"']},
Parse::RecDescent::_tracefirst($text),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\"//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [/[^"]*/]}, Parse::RecDescent::_tracefirst($text),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/[^"]*/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^"]*)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: ['"']},
Parse::RecDescent::_tracefirst($text),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{'"'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\"//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING2__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { $item[2] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['"' /[^"]*/ '"']<<},
Parse::RecDescent::_tracefirst($text),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{qq_string},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{qq_string},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{qq_string},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"expr"};
Parse::RecDescent::_trace(q{Trying rule: [expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [<leftop: single_expr /\\|/ single_expr>]},
Parse::RecDescent::_tracefirst($_[1]),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{expr});
%item = (__RULE__ => q{expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying operator: [<leftop: single_expr /\\|/ single_expr>]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->is(q{})->at($text);
$_tok = undef;
OPLOOP: while (1)
{
$repcount = 0;
my @item;
# MATCH LEFTARG
Parse::RecDescent::_trace(q{Trying subrule: [single_expr]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{single_expr})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_expr}} = $_tok;
push @item, $_tok;
}
$repcount++;
my $savetext = $text;
my $backtrack;
# MATCH (OP RIGHTARG)(s)
while ($repcount < 100000000)
{
$backtrack = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/\\|/]}, Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\|/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\|)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
pop @item;
if (defined $1) {push @item, $item{'single_expr(s?)'}=$1; $backtrack=1;}
Parse::RecDescent::_trace(q{Trying subrule: [single_expr]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{single_expr})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_expr]>>},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_expr}} = $_tok;
push @item, $_tok;
}
$savetext = $text;
$repcount++;
}
$text = $savetext;
pop @item if $backtrack;
$_tok = [ @item ];
last;
}
unless ($repcount>=0)
{
Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: single_expr /\\|/ single_expr>]>>},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: single_expr /\\|/ single_expr>]<< (return value: [}
. qq{@{$_tok||[]}} . q{]},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
push @item, $item{'single_expr(s?)'}=$_tok||[];
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
Petal::CodePerl::Expr::alternate(@{$item[1]})
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [<leftop: single_expr /\\|/ single_expr>]<<},
Parse::RecDescent::_tracefirst($text),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::single_path
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"single_path"};
Parse::RecDescent::_trace(q{Trying rule: [single_path]},
Parse::RecDescent::_tracefirst($_[1]),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [url_segment deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{single_path});
%item = (__RULE__ => q{single_path});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [url_segment]},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::url_segment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [url_segment]>>},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [url_segment]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$item{q{url_segment}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying repeated subrule: [deref]},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$expectation->is(q{deref})->at($text);
unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Petal::CodePerl::Parser::deref, 0, 100000000, $_noactions,$expectation,undef)))
{
Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [deref]>>},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched repeated subrule: [deref]<< (}
. @$_tok . q{ times)},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$item{q{deref(s?)}} = $_tok;
push @item, $_tok;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
my $current = Code::Perl::Expr::derefh($Petal::CodePerl::Compiler::root, $item{url_segment});
foreach my $deref (@{$item[2]})
{
my ($type, $key, @others) = @$deref;
if ($type eq 'tal')
{
$current = Petal::CodePerl::Expr::dereft($current, $key);
}
elsif ($type eq 'hash')
{
$current = Code::Perl::Expr::derefh($current, $key);
}
elsif($type eq 'array')
{
$current = Code::Perl::Expr::derefa($current, $key);
}
elsif($type eq 'method')
{
$current = Code::Perl::Expr::callm($current, $key, @others);
}
else
{
die "Unknown type '$type'";
}
}
$current;
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [url_segment deref]<<},
Parse::RecDescent::_tracefirst($text),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{single_path},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{single_path},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{single_path},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::string_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"string_expr"};
Parse::RecDescent::_trace(q{Trying rule: [string_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['string:' <commit> string]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{string_expr});
%item = (__RULE__ => q{string_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['string:']},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "string:"; 1 } and
substr($text,0,length($_tok)) eq $_tok and
do { substr($text,0,length($_tok)) = ""; 1; }
)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$_tok;
Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = do { $commit = 1 };
if (defined($_tok))
{
Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
else
{
Parse::RecDescent::_trace(q{<<Didn't match directive>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
}
last unless defined $_tok;
push @item, $item{__DIRECTIVE1__}=$_tok;
Parse::RecDescent::_trace(q{Trying subrule: [string]},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{string})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::string($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [string]>>},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [string]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{string}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { $item{string} };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['string:' <commit> string]<<},
Parse::RecDescent::_tracefirst($text),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{string_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{string_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{string_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::varsub
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"varsub"};
Parse::RecDescent::_trace(q{Trying rule: [varsub]},
Parse::RecDescent::_tracefirst($_[1]),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['$' single_path]},
Parse::RecDescent::_tracefirst($_[1]),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{varsub});
%item = (__RULE__ => q{varsub});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['$']},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\$//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying subrule: [single_path]},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{single_path})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_path]>>},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_path]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_path}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: ['$' single_path]<<},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['$\{' single_path '\}']},
Parse::RecDescent::_tracefirst($_[1]),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{varsub});
%item = (__RULE__ => q{varsub});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['$\{']},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\$\{//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying subrule: [single_path]},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{single_path})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::single_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [single_path]>>},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [single_path]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$item{q{single_path}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: ['\}']},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{'\}'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\}//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING2__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { $item{single_path} };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: ['$\{' single_path '\}']<<},
Parse::RecDescent::_tracefirst($text),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{varsub},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{varsub},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{varsub},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::method_call
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"method_call"};
Parse::RecDescent::_trace(q{Trying rule: [method_call]},
Parse::RecDescent::_tracefirst($_[1]),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [empty_method]},
Parse::RecDescent::_tracefirst($_[1]),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{method_call});
%item = (__RULE__ => q{method_call});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [empty_method]},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::empty_method($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [empty_method]>>},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [empty_method]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$item{q{empty_method}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [empty_method]<<},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [arg_method]},
Parse::RecDescent::_tracefirst($_[1]),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{method_call});
%item = (__RULE__ => q{method_call});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [arg_method]},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::arg_method($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [arg_method]>>},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [arg_method]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$item{q{arg_method}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [arg_method]<<},
Parse::RecDescent::_tracefirst($text),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{method_call},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{method_call},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{method_call},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::url_segment
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"url_segment"};
Parse::RecDescent::_trace(q{Trying rule: [url_segment]},
Parse::RecDescent::_tracefirst($_[1]),
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [/[a-z0-9_\\-\\~]+/i]},
Parse::RecDescent::_tracefirst($_[1]),
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{url_segment});
%item = (__RULE__ => q{url_segment});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/[a-z0-9_\\-\\~]+/i]}, Parse::RecDescent::_tracefirst($text),
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[a-z0-9_\-\~]+)//i)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: [/[a-z0-9_\\-\\~]+/i]<<},
Parse::RecDescent::_tracefirst($text),
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{url_segment},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{url_segment},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{url_segment},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::_alternation_1_of_production_1_of_rule_string_argument
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_string_argument"};
Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_string_argument]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mm_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{_alternation_1_of_production_1_of_rule_string_argument});
%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_string_argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mm_string]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mm_string($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mm_string]>>},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mm_string]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mm_string}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [mm_string]<<},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [qq_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{_alternation_1_of_production_1_of_rule_string_argument});
%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_string_argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [qq_string]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::qq_string($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [qq_string]>>},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [qq_string]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{qq_string}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [qq_string]<<},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [q_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[2];
$text = $_[1];
my $_savetext;
@item = (q{_alternation_1_of_production_1_of_rule_string_argument});
%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_string_argument});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [q_string]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::q_string($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [q_string]>>},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [q_string]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$item{q{q_string}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [q_string]<<},
Parse::RecDescent::_tracefirst($text),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{_alternation_1_of_production_1_of_rule_string_argument},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::mod_name
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"mod_name"};
Parse::RecDescent::_trace(q{Trying rule: [mod_name]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [/\\w+/]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{mod_name});
%item = (__RULE__ => q{mod_name});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: [/\\w+/]}, Parse::RecDescent::_tracefirst($text),
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\w+)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: [/\\w+/]<<},
Parse::RecDescent::_tracefirst($text),
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{mod_name},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{mod_name},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{mod_name},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::only_expr
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"only_expr"};
Parse::RecDescent::_trace(q{Trying rule: [only_expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [expr /^\\z/]},
Parse::RecDescent::_tracefirst($_[1]),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{only_expr});
%item = (__RULE__ => q{only_expr});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [expr]},
Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$item{q{expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: [/^\\z/]}, Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/^\\z/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:^\z)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {$item{expr}};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [expr /^\\z/]<<},
Parse::RecDescent::_tracefirst($text),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{only_expr},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{only_expr},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{only_expr},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::tal_deref
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"tal_deref"};
Parse::RecDescent::_trace(q{Trying rule: [tal_deref]},
Parse::RecDescent::_tracefirst($_[1]),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [separator url_segment]},
Parse::RecDescent::_tracefirst($_[1]),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{tal_deref});
%item = (__RULE__ => q{tal_deref});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [separator]},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::separator($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [separator]>>},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [separator]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{separator}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying subrule: [url_segment]},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{url_segment})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::url_segment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [url_segment]>>},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [url_segment]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$item{q{url_segment}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do { ['tal', $item{url_segment}] };
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [separator url_segment]<<},
Parse::RecDescent::_tracefirst($text),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{tal_deref},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{tal_deref},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{tal_deref},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::separator
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"separator"};
Parse::RecDescent::_trace(q{Trying rule: [separator]},
Parse::RecDescent::_tracefirst($_[1]),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['/']},
Parse::RecDescent::_tracefirst($_[1]),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{separator});
%item = (__RULE__ => q{separator});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['/']},
Parse::RecDescent::_tracefirst($text),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\///)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: ['/']<<},
Parse::RecDescent::_tracefirst($text),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: ['.']},
Parse::RecDescent::_tracefirst($_[1]),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{separator});
%item = (__RULE__ => q{separator});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying terminal: ['.']},
Parse::RecDescent::_tracefirst($text),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\.//)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{>>Matched production: ['.']<<},
Parse::RecDescent::_tracefirst($text),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{separator},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{separator},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{separator},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{separator},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::mod_expr_compile
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"mod_expr_compile"};
Parse::RecDescent::_trace(q{Trying rule: [mod_expr_compile]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [mod_name /\\s*/ ':' expr]},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{mod_expr_compile});
%item = (__RULE__ => q{mod_expr_compile});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [mod_name]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::mod_name($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [mod_name]>>},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [mod_name]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$item{q{mod_name}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying terminal: [/\\s*/]}, Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{/\\s*/})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\s*)//)
{
$expectation->failed();
Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__PATTERN1__}=$&;
Parse::RecDescent::_trace(q{Trying terminal: [':']},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$lastsep = "";
$expectation->is(q{':'})->at($text);
unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\://)
{
$expectation->failed();
Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
. $& . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $item{__STRING1__}=$&;
Parse::RecDescent::_trace(q{Trying subrule: [expr]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{expr})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$item{q{expr}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{Trying action},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$_tok = ($_noactions) ? 0 : do {
my $name = $item{mod_name};
my $expr = $item{expr};
my $mod = $Petal::Hash::MODIFIERS{"$name:"} || die "Modifier '$name' does not exists";
my $compiled;
if (UNIVERSAL::can($mod, "inline") and $Petal::CodePerl::InlineMod)
{
$compiled = $mod->inline($Petal::CodePerl::Compiler::root, $expr);
}
elsif (UNIVERSAL::can($mod, "process_value"))
{
$compiled = Code::Perl::Expr::callm(
Code::Perl::Expr::scal("Petal::Hash::MODIFIERS{\"$name:\"}"), # this is a bit naughty
"process_value",
$Petal::CodePerl::Compiler::root,
$item{expr}
);
}
$compiled;
};
unless (defined $_tok)
{
Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
if defined $::RD_TRACE;
last;
}
Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
. $_tok . q{])},
Parse::RecDescent::_tracefirst($text))
if defined $::RD_TRACE;
push @item, $_tok;
$item{__ACTION1__}=$_tok;
Parse::RecDescent::_trace(q{>>Matched production: [mod_name /\\s*/ ':' expr]<<},
Parse::RecDescent::_tracefirst($text),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{mod_expr_compile},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{mod_expr_compile},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{mod_expr_compile},
$tracelevel)
}
$_[1] = $text;
return $return;
}
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
sub Parse::RecDescent::Petal::CodePerl::Parser::string_piece
{
my $thisparser = $_[0];
use vars q{$tracelevel};
local $tracelevel = ($tracelevel||0)+1;
$ERRORS = 0;
my $thisrule = $thisparser->{"rules"}{"string_piece"};
Parse::RecDescent::_trace(q{Trying rule: [string_piece]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
my $err_at = @{$thisparser->{errors}};
my $score;
my $score_return;
my $_tok;
my $return = undef;
my $_matched=0;
my $commit=0;
my @item = ();
my %item = ();
my $repeating = defined($_[2]) && $_[2];
my $_noactions = defined($_[3]) && $_[3];
my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
my %arg = ($#arg & 01) ? @arg : (@arg, undef);
my $text;
my $lastsep="";
my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
$expectation->at($_[1]);
my $thisline;
tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [plain_string]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[0];
$text = $_[1];
my $_savetext;
@item = (q{string_piece});
%item = (__RULE__ => q{string_piece});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [plain_string]},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::plain_string($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [plain_string]>>},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [plain_string]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$item{q{plain_string}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [plain_string]<<},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
while (!$_matched && !$commit)
{
Parse::RecDescent::_trace(q{Trying production: [varsub]},
Parse::RecDescent::_tracefirst($_[1]),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
my $thisprod = $thisrule->{"prods"}[1];
$text = $_[1];
my $_savetext;
@item = (q{string_piece});
%item = (__RULE__ => q{string_piece});
my $repcount = 0;
Parse::RecDescent::_trace(q{Trying subrule: [varsub]},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
if (1) { no strict qw{refs};
$expectation->is(q{})->at($text);
unless (defined ($_tok = Parse::RecDescent::Petal::CodePerl::Parser::varsub($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
{
Parse::RecDescent::_trace(q{<<Didn't match subrule: [varsub]>>},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$expectation->failed();
last;
}
Parse::RecDescent::_trace(q{>>Matched subrule: [varsub]<< (return value: [}
. $_tok . q{]},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$item{q{varsub}} = $_tok;
push @item, $_tok;
}
Parse::RecDescent::_trace(q{>>Matched production: [varsub]<<},
Parse::RecDescent::_tracefirst($text),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$_matched = 1;
last;
}
unless ( $_matched || defined($return) || defined($score) )
{
$_[1] = $text; # NOT SURE THIS IS NEEDED
Parse::RecDescent::_trace(q{<<Didn't match rule>>},
Parse::RecDescent::_tracefirst($_[1]),
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
return undef;
}
if (!defined($return) && defined($score))
{
Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
q{string_piece},
$tracelevel)
if defined $::RD_TRACE;
$return = $score_return;
}
splice @{$thisparser->{errors}}, $err_at;
$return = $item[$#item] unless defined $return;
if (defined $::RD_TRACE)
{
Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
$return . q{])}, "",
q{string_piece},
$tracelevel);
Parse::RecDescent::_trace(q{(consumed: [} .
Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
Parse::RecDescent::_tracefirst($text),
, q{string_piece},
$tracelevel)
}
$_[1] = $text;
return $return;
}
}
package Petal::CodePerl::Parser; sub new { my $self = bless( {
'_AUTOTREE' => undef,
'localvars' => '',
'startcode' => '',
'_check' => {
'thisoffset' => '',
'itempos' => '',
'prevoffset' => '',
'prevline' => '',
'prevcolumn' => '',
'thiscolumn' => ''
},
'namespace' => 'Parse::RecDescent::Petal::CodePerl::Parser',
'_AUTOACTION' => undef,
'rules' => {
'empty_method' => bless( {
'impcount' => 0,
'calls' => [
'separator',
'url_segment'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'separator',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 130
}, 'Parse::RecDescent::Subrule' ),
bless( {
'subrule' => 'url_segment',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 130
}, 'Parse::RecDescent::Subrule' ),
bless( {
'pattern' => '()',
'hashname' => '__STRING1__',
'description' => '\'()\'',
'lookahead' => 0,
'line' => 130
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 130,
'code' => '{ [\'method\', $item{url_segment}] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'empty_method',
'vars' => '',
'changed' => 0,
'line' => 130
}, 'Parse::RecDescent::Rule' ),
'mod_expr_revert' => bless( {
'impcount' => 0,
'calls' => [
'mod_name'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 2,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'mod_name',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 55
}, 'Parse::RecDescent::Subrule' ),
bless( {
'description' => '/\\\\s*/',
'rdelim' => '/',
'pattern' => '\\s*',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 55
}, 'Parse::RecDescent::Token' ),
bless( {
'pattern' => ':',
'hashname' => '__STRING1__',
'description' => '\':\'',
'lookahead' => 0,
'line' => 55
}, 'Parse::RecDescent::Literal' ),
bless( {
'description' => '/.*/',
'rdelim' => '/',
'pattern' => '.*',
'hashname' => '__PATTERN2__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 55
}, 'Parse::RecDescent::Token' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 55,
'code' => '{
# make sure Petal doesn\'t escape it because we will
my $key = "structure ".join("", @item[1, 2, 3, 4]);
Code::Perl::Expr::callm(
$Petal::CodePerl::Compiler::root,
"get",
$key
);
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'mod_expr_revert',
'vars' => '',
'changed' => 0,
'line' => 54
}, 'Parse::RecDescent::Rule' ),
'string' => bless( {
'impcount' => 0,
'calls' => [
'string_piece'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'string_piece',
'expected' => undef,
'min' => 0,
'argcode' => undef,
'max' => 100000000,
'matchrule' => 0,
'repspec' => 's?',
'lookahead' => 0,
'line' => 149
}, 'Parse::RecDescent::Repetition' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 149,
'code' => '{
Code::Perl::Expr::append(@{$item[1]})
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'string',
'vars' => '',
'changed' => 0,
'line' => 148
}, 'Parse::RecDescent::Rule' ),
'path_expr' => bless( {
'impcount' => 0,
'calls' => [
'single_path'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => 'path:',
'hashname' => '__STRING1__',
'description' => '\'path:\'',
'lookahead' => 0,
'line' => 15
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__DIRECTIVE1__',
'name' => '<commit>',
'lookahead' => 0,
'line' => 15,
'code' => '$commit = 1'
}, 'Parse::RecDescent::Directive' ),
bless( {
'subrule' => 'single_path',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 15
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 15,
'code' => '{ $item{path} }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'path_expr',
'vars' => '',
'changed' => 0,
'line' => 15
}, 'Parse::RecDescent::Rule' ),
'_alternation_1_of_production_1_of_rule_plain_string' => bless( {
'impcount' => 0,
'calls' => [
'dollar',
'non_dollar'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'dollar',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 169
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'non_dollar',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 169
}, 'Parse::RecDescent::Subrule' )
],
'line' => 169
}, 'Parse::RecDescent::Production' )
],
'name' => '_alternation_1_of_production_1_of_rule_plain_string',
'vars' => '',
'changed' => 0,
'line' => 169
}, 'Parse::RecDescent::Rule' ),
'single_expr' => bless( {
'impcount' => 0,
'calls' => [
'qual_expr',
'single_path'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'qual_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 9
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'single_path',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 9
}, 'Parse::RecDescent::Subrule' )
],
'line' => 9
}, 'Parse::RecDescent::Production' )
],
'name' => 'single_expr',
'vars' => '',
'changed' => 0,
'line' => 9
}, 'Parse::RecDescent::Rule' ),
'integer' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 0,
'items' => [
bless( {
'description' => '/[0-9]+/',
'rdelim' => '/',
'pattern' => '[0-9]+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 126
}, 'Parse::RecDescent::Token' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'integer',
'vars' => '',
'changed' => 0,
'line' => 126
}, 'Parse::RecDescent::Rule' ),
'mm_string' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 0,
'items' => [
bless( {
'pattern' => '--',
'hashname' => '__STRING1__',
'description' => '\'--\'',
'lookahead' => 0,
'line' => 142
}, 'Parse::RecDescent::Literal' ),
bless( {
'description' => '/\\\\S+/',
'rdelim' => '/',
'pattern' => '\\S+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 142
}, 'Parse::RecDescent::Token' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'mm_string',
'vars' => '',
'changed' => 0,
'line' => 142
}, 'Parse::RecDescent::Rule' ),
'qual_expr' => bless( {
'impcount' => 0,
'calls' => [
'path_expr',
'not_expr',
'string_expr',
'exists_expr',
'perl_expr',
'mod_expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'path_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 12
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'not_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 12
}, 'Parse::RecDescent::Subrule' )
],
'line' => 12
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '2',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'string_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 12
}, 'Parse::RecDescent::Subrule' )
],
'line' => 12
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '3',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'exists_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 12
}, 'Parse::RecDescent::Subrule' )
],
'line' => 12
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '4',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'perl_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 13
}, 'Parse::RecDescent::Subrule' )
],
'line' => 12
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '5',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'mod_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 13
}, 'Parse::RecDescent::Subrule' )
],
'line' => 13
}, 'Parse::RecDescent::Production' )
],
'name' => 'qual_expr',
'vars' => '',
'changed' => 0,
'line' => 11
}, 'Parse::RecDescent::Rule' ),
'hash_deref' => bless( {
'impcount' => 0,
'calls' => [
'url_segment'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 2,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '{',
'hashname' => '__STRING1__',
'description' => '\'\\{\'',
'lookahead' => 0,
'line' => 122
}, 'Parse::RecDescent::Literal' ),
bless( {
'subrule' => 'url_segment',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 122
}, 'Parse::RecDescent::Subrule' ),
bless( {
'pattern' => '}',
'hashname' => '__STRING2__',
'description' => '\'\\}\'',
'lookahead' => 0,
'line' => 122
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 122,
'code' => '{ [\'hash\', $item{url_segment}] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'hash_deref',
'vars' => '',
'changed' => 0,
'line' => 122
}, 'Parse::RecDescent::Rule' ),
'exists_expr' => bless( {
'impcount' => 0,
'calls' => [
'path_expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => 'exists:',
'hashname' => '__STRING1__',
'description' => '\'exists:\'',
'lookahead' => 0,
'line' => 24
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__DIRECTIVE1__',
'name' => '<commit>',
'lookahead' => 0,
'line' => 24,
'code' => '$commit = 1'
}, 'Parse::RecDescent::Directive' ),
bless( {
'subrule' => 'path_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 24
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 24,
'code' => '{ Petal::CodePerl::Expr::pathexists($item{expr}) }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'exists_expr',
'vars' => '',
'changed' => 0,
'line' => 24
}, 'Parse::RecDescent::Rule' ),
'dollar' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '$$',
'hashname' => '__STRING1__',
'description' => '\'$$\'',
'lookahead' => 0,
'line' => 163
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 163,
'code' => '{ \'$\' }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'dollar',
'vars' => '',
'changed' => 0,
'line' => 163
}, 'Parse::RecDescent::Rule' ),
'deref' => bless( {
'impcount' => 0,
'calls' => [
'method_call',
'tal_deref',
'hash_deref',
'array_deref'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'method_call',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 118
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'tal_deref',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 118
}, 'Parse::RecDescent::Subrule' )
],
'line' => 118
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '2',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'hash_deref',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 118
}, 'Parse::RecDescent::Subrule' )
],
'line' => 118
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '3',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'array_deref',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 118
}, 'Parse::RecDescent::Subrule' )
],
'line' => 118
}, 'Parse::RecDescent::Production' )
],
'name' => 'deref',
'vars' => '',
'changed' => 0,
'line' => 118
}, 'Parse::RecDescent::Rule' ),
'mod_expr' => bless( {
'impcount' => 0,
'calls' => [
'mod_expr_compile',
'mod_expr_revert'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'mod_expr_compile',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 28
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'mod_expr_revert',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 28
}, 'Parse::RecDescent::Subrule' )
],
'line' => 28
}, 'Parse::RecDescent::Production' )
],
'name' => 'mod_expr',
'vars' => '',
'changed' => 0,
'line' => 28
}, 'Parse::RecDescent::Rule' ),
'string_argument' => bless( {
'impcount' => 1,
'calls' => [
'_alternation_1_of_production_1_of_rule_string_argument'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => '_alternation_1_of_production_1_of_rule_string_argument',
'matchrule' => 0,
'implicit' => 'mm_string, or qq_string, or q_string',
'argcode' => undef,
'lookahead' => 0,
'line' => 138
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 138,
'code' => '{
Code::Perl::Expr::string($item[1])
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'string_argument',
'vars' => '',
'changed' => 0,
'line' => 138
}, 'Parse::RecDescent::Rule' ),
'arg_method' => bless( {
'impcount' => 0,
'calls' => [
'separator',
'url_segment',
'argument'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 2,
'actcount' => 1,
'op' => [],
'items' => [
bless( {
'subrule' => 'separator',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 132
}, 'Parse::RecDescent::Subrule' ),
bless( {
'subrule' => 'url_segment',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 132
}, 'Parse::RecDescent::Subrule' ),
bless( {
'description' => '/\\\\s+/',
'rdelim' => '/',
'pattern' => '\\s+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 132
}, 'Parse::RecDescent::Token' ),
bless( {
'expected' => '<leftop: argument /\\\\s+/ argument>',
'min' => 1,
'name' => '\'argument(s)\'',
'max' => 100000000,
'leftarg' => bless( {
'subrule' => 'argument',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 132
}, 'Parse::RecDescent::Subrule' ),
'rightarg' => bless( {
'subrule' => 'argument',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 132
}, 'Parse::RecDescent::Subrule' ),
'hashname' => '__DIRECTIVE1__',
'type' => 'leftop',
'op' => bless( {
'description' => '/\\\\s+/',
'rdelim' => '/',
'pattern' => '\\s+',
'hashname' => '__PATTERN2__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 132
}, 'Parse::RecDescent::Token' )
}, 'Parse::RecDescent::Operator' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 132,
'code' => '{
[\'method\', $item{url_segment}, @{$item[4]}]
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'arg_method',
'vars' => '',
'changed' => 0,
'line' => 132
}, 'Parse::RecDescent::Rule' ),
'non_dollar' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 0,
'items' => [
bless( {
'description' => '/[^\\\\$]+/',
'rdelim' => '/',
'pattern' => '[^\\$]+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 165
}, 'Parse::RecDescent::Token' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'non_dollar',
'vars' => '',
'changed' => 0,
'line' => 165
}, 'Parse::RecDescent::Rule' ),
'q_string' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 2,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '\'',
'hashname' => '__STRING1__',
'description' => '\'\'\'',
'lookahead' => 0,
'line' => 144
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'description' => '/[^\']*/',
'rdelim' => '/',
'pattern' => '[^\']*',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 144
}, 'Parse::RecDescent::Token' ),
bless( {
'pattern' => '\'',
'hashname' => '__STRING2__',
'description' => '\'\'\'',
'lookahead' => 0,
'line' => 144
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 144,
'code' => '{ $item[2] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'q_string',
'vars' => '',
'changed' => 0,
'line' => 144
}, 'Parse::RecDescent::Rule' ),
'plain_string' => bless( {
'impcount' => 1,
'calls' => [
'_alternation_1_of_production_1_of_rule_plain_string'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => '_alternation_1_of_production_1_of_rule_plain_string',
'expected' => 'dollar, or non_dollar',
'min' => 1,
'argcode' => undef,
'max' => 100000000,
'matchrule' => 0,
'repspec' => 's',
'lookahead' => 0,
'line' => 159
}, 'Parse::RecDescent::Repetition' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 159,
'code' => '{
Code::Perl::Expr::string( join("", @{$item[1]}) )
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'plain_string',
'vars' => '',
'changed' => 0,
'line' => 158
}, 'Parse::RecDescent::Rule' ),
'not_expr' => bless( {
'impcount' => 0,
'calls' => [
'expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => 'not:',
'hashname' => '__STRING1__',
'description' => '\'not:\'',
'lookahead' => 0,
'line' => 17
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__DIRECTIVE1__',
'name' => '<commit>',
'lookahead' => 0,
'line' => 17,
'code' => '$commit = 1'
}, 'Parse::RecDescent::Directive' ),
bless( {
'subrule' => 'expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 17
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 17,
'code' => '{
Code::Perl::Expr::not($item{expr})
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'not_expr',
'vars' => '',
'changed' => 0,
'line' => 17
}, 'Parse::RecDescent::Rule' ),
'array_deref' => bless( {
'impcount' => 0,
'calls' => [
'integer'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 2,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '[',
'hashname' => '__STRING1__',
'description' => '\'[\'',
'lookahead' => 0,
'line' => 124
}, 'Parse::RecDescent::Literal' ),
bless( {
'subrule' => 'integer',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 124
}, 'Parse::RecDescent::Subrule' ),
bless( {
'pattern' => ']',
'hashname' => '__STRING2__',
'description' => '\']\'',
'lookahead' => 0,
'line' => 124
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 124,
'code' => '{ [\'array\', $item{integer}] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'array_deref',
'vars' => '',
'changed' => 0,
'line' => 124
}, 'Parse::RecDescent::Rule' ),
'perl_expr' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 2,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => 'perl:',
'hashname' => '__STRING1__',
'description' => '\'perl:\'',
'lookahead' => 0,
'line' => 26
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__DIRECTIVE1__',
'name' => '<commit>',
'lookahead' => 0,
'line' => 26,
'code' => '$commit = 1'
}, 'Parse::RecDescent::Directive' ),
bless( {
'hashname' => '__DIRECTIVE2__',
'name' => '<perl_codeblock>',
'lookahead' => 0,
'line' => 26,
'code' => 'Text::Balanced::extract_codeblock($text,undef,$skip,\'{}\');
'
}, 'Parse::RecDescent::Directive' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 26,
'code' => '{ Code::Perl::Expr::perl($item[2]) }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'perl_expr',
'vars' => '',
'changed' => 0,
'line' => 26
}, 'Parse::RecDescent::Rule' ),
'argument' => bless( {
'impcount' => 0,
'calls' => [
'string_argument',
'expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'string_argument',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 136
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 136
}, 'Parse::RecDescent::Subrule' )
],
'line' => 136
}, 'Parse::RecDescent::Production' )
],
'name' => 'argument',
'vars' => '',
'changed' => 0,
'line' => 136
}, 'Parse::RecDescent::Rule' ),
'qq_string' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 2,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '"',
'hashname' => '__STRING1__',
'description' => '\'"\'',
'lookahead' => 0,
'line' => 143
}, 'Parse::RecDescent::Literal' ),
bless( {
'description' => '/[^"]*/',
'rdelim' => '/',
'pattern' => '[^"]*',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 143
}, 'Parse::RecDescent::Token' ),
bless( {
'pattern' => '"',
'hashname' => '__STRING2__',
'description' => '\'"\'',
'lookahead' => 0,
'line' => 143
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 143,
'code' => '{ $item[2] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'qq_string',
'vars' => '',
'changed' => 0,
'line' => 143
}, 'Parse::RecDescent::Rule' ),
'expr' => bless( {
'impcount' => 0,
'calls' => [
'single_expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 1,
'op' => [],
'items' => [
bless( {
'expected' => '<leftop: single_expr /\\\\|/ single_expr>',
'min' => 0,
'name' => '\'single_expr(s?)\'',
'max' => 100000000,
'leftarg' => bless( {
'subrule' => 'single_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 5
}, 'Parse::RecDescent::Subrule' ),
'rightarg' => bless( {
'subrule' => 'single_expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 5
}, 'Parse::RecDescent::Subrule' ),
'hashname' => '__DIRECTIVE1__',
'type' => 'leftop',
'op' => bless( {
'description' => '/\\\\|/',
'rdelim' => '/',
'pattern' => '\\|',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 5
}, 'Parse::RecDescent::Token' )
}, 'Parse::RecDescent::Operator' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 5,
'code' => '{
Petal::CodePerl::Expr::alternate(@{$item[1]})
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'expr',
'vars' => '',
'changed' => 0,
'line' => 5
}, 'Parse::RecDescent::Rule' ),
'single_path' => bless( {
'impcount' => 0,
'calls' => [
'url_segment',
'deref'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'url_segment',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 81
}, 'Parse::RecDescent::Subrule' ),
bless( {
'subrule' => 'deref',
'expected' => undef,
'min' => 0,
'argcode' => undef,
'max' => 100000000,
'matchrule' => 0,
'repspec' => 's?',
'lookahead' => 0,
'line' => 81
}, 'Parse::RecDescent::Repetition' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 81,
'code' => '{
my $current = Code::Perl::Expr::derefh($Petal::CodePerl::Compiler::root, $item{url_segment});
foreach my $deref (@{$item[2]})
{
my ($type, $key, @others) = @$deref;
if ($type eq \'tal\')
{
$current = Petal::CodePerl::Expr::dereft($current, $key);
}
elsif ($type eq \'hash\')
{
$current = Code::Perl::Expr::derefh($current, $key);
}
elsif($type eq \'array\')
{
$current = Code::Perl::Expr::derefa($current, $key);
}
elsif($type eq \'method\')
{
$current = Code::Perl::Expr::callm($current, $key, @others);
}
else
{
die "Unknown type \'$type\'";
}
}
$current;
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'single_path',
'vars' => '',
'changed' => 0,
'line' => 79
}, 'Parse::RecDescent::Rule' ),
'string_expr' => bless( {
'impcount' => 0,
'calls' => [
'string'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 1,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => 'string:',
'hashname' => '__STRING1__',
'description' => '\'string:\'',
'lookahead' => 0,
'line' => 22
}, 'Parse::RecDescent::InterpLit' ),
bless( {
'hashname' => '__DIRECTIVE1__',
'name' => '<commit>',
'lookahead' => 0,
'line' => 22,
'code' => '$commit = 1'
}, 'Parse::RecDescent::Directive' ),
bless( {
'subrule' => 'string',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 22
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 22,
'code' => '{ $item{string} }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'string_expr',
'vars' => '',
'changed' => 0,
'line' => 21
}, 'Parse::RecDescent::Rule' ),
'varsub' => bless( {
'impcount' => 0,
'calls' => [
'single_path'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'pattern' => '$',
'hashname' => '__STRING1__',
'description' => '\'$\'',
'lookahead' => 0,
'line' => 156
}, 'Parse::RecDescent::Literal' ),
bless( {
'subrule' => 'single_path',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 156
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 2,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'pattern' => '${',
'hashname' => '__STRING1__',
'description' => '\'$\\{\'',
'lookahead' => 0,
'line' => 156
}, 'Parse::RecDescent::Literal' ),
bless( {
'subrule' => 'single_path',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 156
}, 'Parse::RecDescent::Subrule' ),
bless( {
'pattern' => '}',
'hashname' => '__STRING2__',
'description' => '\'\\}\'',
'lookahead' => 0,
'line' => 156
}, 'Parse::RecDescent::Literal' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 156,
'code' => '{ $item{single_path} }'
}, 'Parse::RecDescent::Action' )
],
'line' => 156
}, 'Parse::RecDescent::Production' )
],
'name' => 'varsub',
'vars' => '',
'changed' => 0,
'line' => 156
}, 'Parse::RecDescent::Rule' ),
'method_call' => bless( {
'impcount' => 0,
'calls' => [
'empty_method',
'arg_method'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'empty_method',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 128
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'arg_method',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 128
}, 'Parse::RecDescent::Subrule' )
],
'line' => 128
}, 'Parse::RecDescent::Production' )
],
'name' => 'method_call',
'vars' => '',
'changed' => 0,
'line' => 128
}, 'Parse::RecDescent::Rule' ),
'url_segment' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 0,
'items' => [
bless( {
'description' => '/[a-z0-9_\\\\-\\\\~]+/i',
'rdelim' => '/',
'pattern' => '[a-z0-9_\\-\\~]+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => 'i',
'line' => 114
}, 'Parse::RecDescent::Token' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'url_segment',
'vars' => '',
'changed' => 0,
'line' => 114
}, 'Parse::RecDescent::Rule' ),
'_alternation_1_of_production_1_of_rule_string_argument' => bless( {
'impcount' => 0,
'calls' => [
'mm_string',
'qq_string',
'q_string'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'mm_string',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 169
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'qq_string',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 169
}, 'Parse::RecDescent::Subrule' )
],
'line' => 169
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '2',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'q_string',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 169
}, 'Parse::RecDescent::Subrule' )
],
'line' => 169
}, 'Parse::RecDescent::Production' )
],
'name' => '_alternation_1_of_production_1_of_rule_string_argument',
'vars' => '',
'changed' => 0,
'line' => 169
}, 'Parse::RecDescent::Rule' ),
'mod_name' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 0,
'items' => [
bless( {
'description' => '/\\\\w+/',
'rdelim' => '/',
'pattern' => '\\w+',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 77
}, 'Parse::RecDescent::Token' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'mod_name',
'vars' => '',
'changed' => 0,
'line' => 75
}, 'Parse::RecDescent::Rule' ),
'only_expr' => bless( {
'impcount' => 0,
'calls' => [
'expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 3
}, 'Parse::RecDescent::Subrule' ),
bless( {
'description' => '/^\\\\z/',
'rdelim' => '/',
'pattern' => '^\\z',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 3
}, 'Parse::RecDescent::Token' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 3,
'code' => '{$item{expr}}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'only_expr',
'vars' => '',
'changed' => 0,
'line' => 1
}, 'Parse::RecDescent::Rule' ),
'tal_deref' => bless( {
'impcount' => 0,
'calls' => [
'separator',
'url_segment'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'separator',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 120
}, 'Parse::RecDescent::Subrule' ),
bless( {
'subrule' => 'url_segment',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 120
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 120,
'code' => '{ [\'tal\', $item{url_segment}] }'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'tal_deref',
'vars' => '',
'changed' => 0,
'line' => 120
}, 'Parse::RecDescent::Rule' ),
'separator' => bless( {
'impcount' => 0,
'calls' => [],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'pattern' => '/',
'hashname' => '__STRING1__',
'description' => '\'/\'',
'lookahead' => 0,
'line' => 116
}, 'Parse::RecDescent::Literal' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'pattern' => '.',
'hashname' => '__STRING1__',
'description' => '\'.\'',
'lookahead' => 0,
'line' => 116
}, 'Parse::RecDescent::Literal' )
],
'line' => 116
}, 'Parse::RecDescent::Production' )
],
'name' => 'separator',
'vars' => '',
'changed' => 0,
'line' => 116
}, 'Parse::RecDescent::Rule' ),
'mod_expr_compile' => bless( {
'impcount' => 0,
'calls' => [
'mod_name',
'expr'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 1,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 1,
'actcount' => 1,
'items' => [
bless( {
'subrule' => 'mod_name',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 31
}, 'Parse::RecDescent::Subrule' ),
bless( {
'description' => '/\\\\s*/',
'rdelim' => '/',
'pattern' => '\\s*',
'hashname' => '__PATTERN1__',
'lookahead' => 0,
'ldelim' => '/',
'mod' => '',
'line' => 31
}, 'Parse::RecDescent::Token' ),
bless( {
'pattern' => ':',
'hashname' => '__STRING1__',
'description' => '\':\'',
'lookahead' => 0,
'line' => 31
}, 'Parse::RecDescent::Literal' ),
bless( {
'subrule' => 'expr',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 31
}, 'Parse::RecDescent::Subrule' ),
bless( {
'hashname' => '__ACTION1__',
'lookahead' => 0,
'line' => 31,
'code' => '{
my $name = $item{mod_name};
my $expr = $item{expr};
my $mod = $Petal::Hash::MODIFIERS{"$name:"} || die "Modifier \'$name\' does not exists";
my $compiled;
if (UNIVERSAL::can($mod, "inline") and $Petal::CodePerl::InlineMod)
{
$compiled = $mod->inline($Petal::CodePerl::Compiler::root, $expr);
}
elsif (UNIVERSAL::can($mod, "process_value"))
{
$compiled = Code::Perl::Expr::callm(
Code::Perl::Expr::scal("Petal::Hash::MODIFIERS{\\"$name:\\"}"), # this is a bit naughty
"process_value",
$Petal::CodePerl::Compiler::root,
$item{expr}
);
}
$compiled;
}'
}, 'Parse::RecDescent::Action' )
],
'line' => undef
}, 'Parse::RecDescent::Production' )
],
'name' => 'mod_expr_compile',
'vars' => '',
'changed' => 0,
'line' => 30
}, 'Parse::RecDescent::Rule' ),
'string_piece' => bless( {
'impcount' => 0,
'calls' => [
'plain_string',
'varsub'
],
'opcount' => 0,
'prods' => [
bless( {
'number' => '0',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'plain_string',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 154
}, 'Parse::RecDescent::Subrule' )
],
'line' => undef
}, 'Parse::RecDescent::Production' ),
bless( {
'number' => '1',
'strcount' => 0,
'dircount' => 0,
'uncommit' => undef,
'error' => undef,
'patcount' => 0,
'actcount' => 0,
'items' => [
bless( {
'subrule' => 'varsub',
'matchrule' => 0,
'implicit' => undef,
'argcode' => undef,
'lookahead' => 0,
'line' => 154
}, 'Parse::RecDescent::Subrule' )
],
'line' => 154
}, 'Parse::RecDescent::Production' )
],
'name' => 'string_piece',
'vars' => '',
'changed' => 0,
'line' => 153
}, 'Parse::RecDescent::Rule' )
}
}, 'Parse::RecDescent' );
}