+++ /dev/null
-# GENERATE RECURSIVE DESCENT PARSER OBJECTS FROM A GRAMMARC
-# SEE RecDescent.pod FOR FULL DETAILS
-
-use 5.005;
-use strict;
-
-package Parse::RecDescent;
-
-use Text::Balanced qw ( extract_codeblock extract_bracketed extract_quotelike extract_delimited );
-
-use vars qw ( $skip );
-
- *defskip = \ '\s*'; # DEFAULT SEPARATOR IS OPTIONAL WHITESPACE
- $skip = '\s*'; # UNIVERSAL SEPARATOR IS OPTIONAL WHITESPACE
-my $MAXREP = 100_000_000; # REPETITIONS MATCH AT MOST 100,000,000 TIMES
-
-
-sub import # IMPLEMENT PRECOMPILER BEHAVIOUR UNDER:
- # perl -MParse::RecDescent - <grammarfile> <classname>
-{
- local *_die = sub { print @_, "\n"; exit };
-
- my ($package, $file, $line) = caller;
- if (substr($file,0,1) eq '-' && $line == 0)
- {
- _die("Usage: perl -MLocalTest - <grammarfile> <classname>")
- unless @ARGV == 2;
-
- my ($sourcefile, $class) = @ARGV;
-
- local *IN;
- open IN, $sourcefile
- or _die("Can't open grammar file '$sourcefile'");
-
- my $grammar = join '', <IN>;
-
- Parse::RecDescent->Precompile($grammar, $class, $sourcefile);
- exit;
- }
-}
-
-sub Save
-{
- my ($self, $class) = @_;
- $self->{saving} = 1;
- $self->Precompile(undef,$class);
- $self->{saving} = 0;
-}
-
-sub Precompile
-{
- my ($self, $grammar, $class, $sourcefile) = @_;
-
- $class =~ /^(\w+::)*\w+$/ or croak("Bad class name: $class");
-
- my $modulefile = $class;
- $modulefile =~ s/.*:://;
- $modulefile .= ".pm";
-
- open OUT, ">$modulefile"
- or croak("Can't write to new module file '$modulefile'");
-
- print STDERR "precompiling grammar from file '$sourcefile'\n",
- "to class $class in module file '$modulefile'\n"
- if $grammar && $sourcefile;
-
- # local $::RD_HINT = 1;
- $self = Parse::RecDescent->new($grammar,1,$class)
- || croak("Can't compile bad grammar")
- if $grammar;
-
- foreach ( keys %{$self->{rules}} )
- { $self->{rules}{$_}{changed} = 1 }
-
- print OUT "package $class;\nuse Parse::RecDescent;\n\n";
-
- print OUT "{ my \$ERRORS;\n\n";
-
- print OUT $self->_code();
-
- print OUT "}\npackage $class; sub new { ";
- print OUT "my ";
-
- require Data::Dumper;
- print OUT Data::Dumper->Dump([$self], [qw(self)]);
-
- print OUT "}";
-
- close OUT
- or croak("Can't write to new module file '$modulefile'");
-}
-
-
-package Parse::RecDescent::LineCounter;
-
-
-sub TIESCALAR # ($classname, \$text, $thisparser, $prevflag)
-{
- bless {
- text => $_[1],
- parser => $_[2],
- prev => $_[3]?1:0,
- }, $_[0];
-}
-
-my %counter_cache;
-
-sub FETCH
-{
- my $parser = $_[0]->{parser};
- my $from = $parser->{fulltextlen}-length(${$_[0]->{text}})-$_[0]->{prev}
-;
-
- unless (exists $counter_cache{$from}) {
- $parser->{lastlinenum} = $parser->{offsetlinenum}
- - Parse::RecDescent::_linecount(substr($parser->{fulltext},$from))
- + 1;
- $counter_cache{$from} = $parser->{lastlinenum};
- }
- return $counter_cache{$from};
-}
-
-sub STORE
-{
- my $parser = $_[0]->{parser};
- $parser->{offsetlinenum} -= $parser->{lastlinenum} - $_[1];
- return undef;
-}
-
-sub resync # ($linecounter)
-{
- my $self = tied($_[0]);
- die "Tried to alter something other than a LineCounter\n"
- unless $self =~ /Parse::RecDescent::LineCounter/;
-
- my $parser = $self->{parser};
- my $apparently = $parser->{offsetlinenum}
- - Parse::RecDescent::_linecount(${$self->{text}})
- + 1;
-
- $parser->{offsetlinenum} += $parser->{lastlinenum} - $apparently;
- return 1;
-}
-
-package Parse::RecDescent::ColCounter;
-
-sub TIESCALAR # ($classname, \$text, $thisparser, $prevflag)
-{
- bless {
- text => $_[1],
- parser => $_[2],
- prev => $_[3]?1:0,
- }, $_[0];
-}
-
-sub FETCH
-{
- my $parser = $_[0]->{parser};
- my $missing = $parser->{fulltextlen}-length(${$_[0]->{text}})-$_[0]->{prev}+1;
- substr($parser->{fulltext},0,$missing) =~ m/^(.*)\Z/m;
- return length($1);
-}
-
-sub STORE
-{
- die "Can't set column number via \$thiscolumn\n";
-}
-
-
-package Parse::RecDescent::OffsetCounter;
-
-sub TIESCALAR # ($classname, \$text, $thisparser, $prev)
-{
- bless {
- text => $_[1],
- parser => $_[2],
- prev => $_[3]?-1:0,
- }, $_[0];
-}
-
-sub FETCH
-{
- my $parser = $_[0]->{parser};
- return $parser->{fulltextlen}-length(${$_[0]->{text}})+$_[0]->{prev};
-}
-
-sub STORE
-{
- die "Can't set current offset via \$thisoffset or \$prevoffset\n";
-}
-
-
-
-package Parse::RecDescent::Rule;
-
-sub new ($$$$$)
-{
- my $class = ref($_[0]) || $_[0];
- my $name = $_[1];
- my $owner = $_[2];
- my $line = $_[3];
- my $replace = $_[4];
-
- if (defined $owner->{"rules"}{$name})
- {
- my $self = $owner->{"rules"}{$name};
- if ($replace && !$self->{"changed"})
- {
- $self->reset;
- }
- return $self;
- }
- else
- {
- return $owner->{"rules"}{$name} =
- bless
- {
- "name" => $name,
- "prods" => [],
- "calls" => [],
- "changed" => 0,
- "line" => $line,
- "impcount" => 0,
- "opcount" => 0,
- "vars" => "",
- }, $class;
- }
-}
-
-sub reset($)
-{
- @{$_[0]->{"prods"}} = ();
- @{$_[0]->{"calls"}} = ();
- $_[0]->{"changed"} = 0;
- $_[0]->{"impcount"} = 0;
- $_[0]->{"opcount"} = 0;
- $_[0]->{"vars"} = "";
-}
-
-sub DESTROY {}
-
-sub hasleftmost($$)
-{
- my ($self, $ref) = @_;
-
- my $prod;
- foreach $prod ( @{$self->{"prods"}} )
- {
- return 1 if $prod->hasleftmost($ref);
- }
-
- return 0;
-}
-
-sub leftmostsubrules($)
-{
- my $self = shift;
- my @subrules = ();
-
- my $prod;
- foreach $prod ( @{$self->{"prods"}} )
- {
- push @subrules, $prod->leftmostsubrule();
- }
-
- return @subrules;
-}
-
-sub expected($)
-{
- my $self = shift;
- my @expected = ();
-
- my $prod;
- foreach $prod ( @{$self->{"prods"}} )
- {
- my $next = $prod->expected();
- unless (! $next or _contains($next,@expected) )
- {
- push @expected, $next;
- }
- }
-
- return join ', or ', @expected;
-}
-
-sub _contains($@)
-{
- my $target = shift;
- my $item;
- foreach $item ( @_ ) { return 1 if $target eq $item; }
- return 0;
-}
-
-sub addcall($$)
-{
- my ( $self, $subrule ) = @_;
- unless ( _contains($subrule, @{$self->{"calls"}}) )
- {
- push @{$self->{"calls"}}, $subrule;
- }
-}
-
-sub addprod($$)
-{
- my ( $self, $prod ) = @_;
- push @{$self->{"prods"}}, $prod;
- $self->{"changed"} = 1;
- $self->{"impcount"} = 0;
- $self->{"opcount"} = 0;
- $prod->{"number"} = $#{$self->{"prods"}};
- return $prod;
-}
-
-sub addvar
-{
- my ( $self, $var, $parser ) = @_;
- if ($var =~ /\A\s*local\s+([%@\$]\w+)/)
- {
- $parser->{localvars} .= " $1";
- $self->{"vars"} .= "$var;\n" }
- else
- { $self->{"vars"} .= "my $var;\n" }
- $self->{"changed"} = 1;
- return 1;
-}
-
-sub addautoscore
-{
- my ( $self, $code ) = @_;
- $self->{"autoscore"} = $code;
- $self->{"changed"} = 1;
- return 1;
-}
-
-sub nextoperator($)
-{
- my $self = shift;
- my $prodcount = scalar @{$self->{"prods"}};
- my $opcount = ++$self->{"opcount"};
- return "_operator_${opcount}_of_production_${prodcount}_of_rule_$self->{name}";
-}
-
-sub nextimplicit($)
-{
- my $self = shift;
- my $prodcount = scalar @{$self->{"prods"}};
- my $impcount = ++$self->{"impcount"};
- return "_alternation_${impcount}_of_production_${prodcount}_of_rule_$self->{name}";
-}
-
-
-sub code
-{
- my ($self, $namespace, $parser) = @_;
-
-eval 'undef &' . $namespace . '::' . $self->{"name"} unless $parser->{saving};
-
- my $code =
-'
-# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
-sub ' . $namespace . '::' . $self->{"name"} . '
-{
- my $thisparser = $_[0];
- use vars q{$tracelevel};
- local $tracelevel = ($tracelevel||0)+1;
- $ERRORS = 0;
- my $thisrule = $thisparser->{"rules"}{"' . $self->{"name"} . '"};
-
- Parse::RecDescent::_trace(q{Trying rule: [' . $self->{"name"} . ']},
- Parse::RecDescent::_tracefirst($_[1]),
- q{' . $self->{"name"} . '},
- $tracelevel)
- if defined $::RD_TRACE;
-
- ' . ($parser->{deferrable}
- ? 'my $def_at = @{$thisparser->{deferred}};'
- : '') .
- '
- 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]);
- '. ($parser->{_check}{thisoffset}?'
- my $thisoffset;
- tie $thisoffset, q{Parse::RecDescent::OffsetCounter}, \$text, $thisparser;
- ':'') . ($parser->{_check}{prevoffset}?'
- my $prevoffset;
- tie $prevoffset, q{Parse::RecDescent::OffsetCounter}, \$text, $thisparser, 1;
- ':'') . ($parser->{_check}{thiscolumn}?'
- my $thiscolumn;
- tie $thiscolumn, q{Parse::RecDescent::ColCounter}, \$text, $thisparser;
- ':'') . ($parser->{_check}{prevcolumn}?'
- my $prevcolumn;
- tie $prevcolumn, q{Parse::RecDescent::ColCounter}, \$text, $thisparser, 1;
- ':'') . ($parser->{_check}{prevline}?'
- my $prevline;
- tie $prevline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser, 1;
- ':'') . '
- my $thisline;
- tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
-
- '. $self->{vars} .'
-';
-
- my $prod;
- foreach $prod ( @{$self->{"prods"}} )
- {
- $prod->addscore($self->{autoscore},0,0) if $self->{autoscore};
- next unless $prod->checkleftmost();
- $code .= $prod->code($namespace,$self,$parser);
-
- $code .= $parser->{deferrable}
- ? ' splice
- @{$thisparser->{deferred}}, $def_at unless $_matched;
- '
- : '';
- }
-
- $code .=
-'
- unless ( $_matched || defined($return) || defined($score) )
- {
- ' .($parser->{deferrable}
- ? ' splice @{$thisparser->{deferred}}, $def_at;
- '
- : '') . '
-
- $_[1] = $text; # NOT SURE THIS IS NEEDED
- Parse::RecDescent::_trace(q{<<Didn\'t match rule>>},
- Parse::RecDescent::_tracefirst($_[1]),
- q{' . $self->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- return undef;
- }
- if (!defined($return) && defined($score))
- {
- Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
- q{' . $self->{"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{' . $self->{"name"} .'},
- $tracelevel);
- Parse::RecDescent::_trace(q{(consumed: [} .
- Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
- Parse::RecDescent::_tracefirst($text),
- , q{' . $self->{"name"} .'},
- $tracelevel)
- }
- $_[1] = $text;
- return $return;
-}
-';
-
- return $code;
-}
-
-my @left;
-sub isleftrec($$)
-{
- my ($self, $rules) = @_;
- my $root = $self->{"name"};
- @left = $self->leftmostsubrules();
- my $next;
- foreach $next ( @left )
- {
- next unless defined $rules->{$next}; # SKIP NON-EXISTENT RULES
- return 1 if $next eq $root;
- my $child;
- foreach $child ( $rules->{$next}->leftmostsubrules() )
- {
- push(@left, $child)
- if ! _contains($child, @left) ;
- }
- }
- return 0;
-}
-
-package Parse::RecDescent::Production;
-
-sub describe ($;$)
-{
- return join ' ', map { $_->describe($_[1]) or () } @{$_[0]->{items}};
-}
-
-sub new ($$;$$)
-{
- my ($self, $line, $uncommit, $error) = @_;
- my $class = ref($self) || $self;
-
- bless
- {
- "items" => [],
- "uncommit" => $uncommit,
- "error" => $error,
- "line" => $line,
- strcount => 0,
- patcount => 0,
- dircount => 0,
- actcount => 0,
- }, $class;
-}
-
-sub expected ($)
-{
- my $itemcount = scalar @{$_[0]->{"items"}};
- return ($itemcount) ? $_[0]->{"items"}[0]->describe(1) : '';
-}
-
-sub hasleftmost ($$)
-{
- my ($self, $ref) = @_;
- return ${$self->{"items"}}[0] eq $ref if scalar @{$self->{"items"}};
- return 0;
-}
-
-sub leftmostsubrule($)
-{
- my $self = shift;
-
- if ( $#{$self->{"items"}} >= 0 )
- {
- my $subrule = $self->{"items"}[0]->issubrule();
- return $subrule if defined $subrule;
- }
-
- return ();
-}
-
-sub checkleftmost($)
-{
- my @items = @{$_[0]->{"items"}};
- if (@items==1 && ref($items[0]) =~ /\AParse::RecDescent::Error/
- && $items[0]->{commitonly} )
- {
- Parse::RecDescent::_warn(2,"Lone <error?> in production treated
- as <error?> <reject>");
- Parse::RecDescent::_hint("A production consisting of a single
- conditional <error?> directive would
- normally succeed (with the value zero) if the
- rule is not 'commited' when it is
- tried. Since you almost certainly wanted
- '<error?> <reject>' Parse::RecDescent
- supplied it for you.");
- push @{$_[0]->{items}},
- Parse::RecDescent::UncondReject->new(0,0,'<reject>');
- }
- elsif (@items==1 && ($items[0]->describe||"") =~ /<rulevar|<autoscore/)
- {
- # Do nothing
- }
- elsif (@items &&
- ( ref($items[0]) =~ /\AParse::RecDescent::UncondReject/
- || ($items[0]->describe||"") =~ /<autoscore/
- ))
- {
- Parse::RecDescent::_warn(1,"Optimizing away production: [". $_[0]->describe ."]");
- my $what = $items[0]->describe =~ /<rulevar/
- ? "a <rulevar> (which acts like an unconditional <reject> during parsing)"
- : $items[0]->describe =~ /<autoscore/
- ? "an <autoscore> (which acts like an unconditional <reject> during parsing)"
- : "an unconditional <reject>";
- my $caveat = $items[0]->describe =~ /<rulevar/
- ? " after the specified variable was set up"
- : "";
- my $advice = @items > 1
- ? "However, there were also other (useless) items after the leading "
- . $items[0]->describe
- . ", so you may have been expecting some other behaviour."
- : "You can safely ignore this message.";
- Parse::RecDescent::_hint("The production starts with $what. That means that the
- production can never successfully match, so it was
- optimized out of the final parser$caveat. $advice");
- return 0;
- }
- return 1;
-}
-
-sub changesskip($)
-{
- my $item;
- foreach $item (@{$_[0]->{"items"}})
- {
- if (ref($item) =~ /Parse::RecDescent::(Action|Directive)/)
- {
- return 1 if $item->{code} =~ /\$skip/;
- }
- }
- return 0;
-}
-
-sub adddirective
-{
- my ( $self, $whichop, $line, $name ) = @_;
- push @{$self->{op}},
- { type=>$whichop, line=>$line, name=>$name,
- offset=> scalar(@{$self->{items}}) };
-}
-
-sub addscore
-{
- my ( $self, $code, $lookahead, $line ) = @_;
- $self->additem(Parse::RecDescent::Directive->new(
- "local \$^W;
- my \$thisscore = do { $code } + 0;
- if (!defined(\$score) || \$thisscore>\$score)
- { \$score=\$thisscore; \$score_return=\$item[-1]; }
- undef;", $lookahead, $line,"<score: $code>") )
- unless $self->{items}[-1]->describe =~ /<score/;
- return 1;
-}
-
-sub check_pending
-{
- my ( $self, $line ) = @_;
- if ($self->{op})
- {
- while (my $next = pop @{$self->{op}})
- {
- Parse::RecDescent::_error("Incomplete <$next->{type}op:...>.", $line);
- Parse::RecDescent::_hint(
- "The current production ended without completing the
- <$next->{type}op:...> directive that started near line
- $next->{line}. Did you forget the closing '>'?");
- }
- }
- return 1;
-}
-
-sub enddirective
-{
- my ( $self, $line, $minrep, $maxrep ) = @_;
- unless ($self->{op})
- {
- Parse::RecDescent::_error("Unmatched > found.", $line);
- Parse::RecDescent::_hint(
- "A '>' angle bracket was encountered, which typically
- indicates the end of a directive. However no suitable
- preceding directive was encountered. Typically this
- indicates either a extra '>' in the grammar, or a
- problem inside the previous directive.");
- return;
- }
- my $op = pop @{$self->{op}};
- my $span = @{$self->{items}} - $op->{offset};
- if ($op->{type} =~ /left|right/)
- {
- if ($span != 3)
- {
- Parse::RecDescent::_error(
- "Incorrect <$op->{type}op:...> specification:
- expected 3 args, but found $span instead", $line);
- Parse::RecDescent::_hint(
- "The <$op->{type}op:...> directive requires a
- sequence of exactly three elements. For example:
- <$op->{type}op:leftarg /op/ rightarg>");
- }
- else
- {
- push @{$self->{items}},
- Parse::RecDescent::Operator->new(
- $op->{type}, $minrep, $maxrep, splice(@{$self->{"items"}}, -3));
- $self->{items}[-1]->sethashname($self);
- $self->{items}[-1]{name} = $op->{name};
- }
- }
-}
-
-sub prevwasreturn
-{
- my ( $self, $line ) = @_;
- unless (@{$self->{items}})
- {
- Parse::RecDescent::_error(
- "Incorrect <return:...> specification:
- expected item missing", $line);
- Parse::RecDescent::_hint(
- "The <return:...> directive requires a
- sequence of at least one item. For example:
- <return: list>");
- return;
- }
- push @{$self->{items}},
- Parse::RecDescent::Result->new();
-}
-
-sub additem
-{
- my ( $self, $item ) = @_;
- $item->sethashname($self);
- push @{$self->{"items"}}, $item;
- return $item;
-}
-
-
-sub preitempos
-{
- return q
- {
- push @itempos, {'offset' => {'from'=>$thisoffset, 'to'=>undef},
- 'line' => {'from'=>$thisline, 'to'=>undef},
- 'column' => {'from'=>$thiscolumn, 'to'=>undef} };
- }
-}
-
-sub incitempos
-{
- return q
- {
- $itempos[$#itempos]{'offset'}{'from'} += length($1);
- $itempos[$#itempos]{'line'}{'from'} = $thisline;
- $itempos[$#itempos]{'column'}{'from'} = $thiscolumn;
- }
-}
-
-sub postitempos
-{
- return q
- {
- $itempos[$#itempos]{'offset'}{'to'} = $prevoffset;
- $itempos[$#itempos]{'line'}{'to'} = $prevline;
- $itempos[$#itempos]{'column'}{'to'} = $prevcolumn;
- }
-}
-
-sub code($$$$)
-{
- my ($self,$namespace,$rule,$parser) = @_;
- my $code =
-'
- while (!$_matched'
- . (defined $self->{"uncommit"} ? '' : ' && !$commit')
- . ')
- {
- ' .
- ($self->changesskip()
- ? 'local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;'
- : '') .'
- Parse::RecDescent::_trace(q{Trying production: ['
- . $self->describe . ']},
- Parse::RecDescent::_tracefirst($_[1]),
- q{' . $rule ->{name}. '},
- $tracelevel)
- if defined $::RD_TRACE;
- my $thisprod = $thisrule->{"prods"}[' . $self->{"number"} . '];
- ' . (defined $self->{"error"} ? '' : '$text = $_[1];' ) . '
- my $_savetext;
- @item = (q{' . $rule->{"name"} . '});
- %item = (__RULE__ => q{' . $rule->{"name"} . '});
- my $repcount = 0;
-
-';
- $code .=
-' my @itempos = ({});
-' if $parser->{_check}{itempos};
-
- my $item;
- my $i;
-
- for ($i = 0; $i < @{$self->{"items"}}; $i++)
- {
- $item = ${$self->{items}}[$i];
-
- $code .= preitempos() if $parser->{_check}{itempos};
-
- $code .= $item->code($namespace,$rule,$parser->{_check});
-
- $code .= postitempos() if $parser->{_check}{itempos};
-
- }
-
- if ($parser->{_AUTOACTION} && defined($item) && !$item->isa("Parse::RecDescent::Action"))
- {
- $code .= $parser->{_AUTOACTION}->code($namespace,$rule);
- Parse::RecDescent::_warn(1,"Autogenerating action in rule
- \"$rule->{name}\":
- $parser->{_AUTOACTION}{code}")
- and
- Parse::RecDescent::_hint("The \$::RD_AUTOACTION was defined,
- so any production not ending in an
- explicit action has the specified
- \"auto-action\" automatically
- appended.");
- }
- elsif ($parser->{_AUTOTREE} && defined($item) && !$item->isa("Parse::RecDescent::Action"))
- {
- if ($i==1 && $item->isterminal)
- {
- $code .= $parser->{_AUTOTREE}{TERMINAL}->code($namespace,$rule);
- }
- else
- {
- $code .= $parser->{_AUTOTREE}{NODE}->code($namespace,$rule);
- }
- Parse::RecDescent::_warn(1,"Autogenerating tree-building action in rule
- \"$rule->{name}\"")
- and
- Parse::RecDescent::_hint("The directive <autotree> was specified,
- so any production not ending
- in an explicit action has
- some parse-tree building code
- automatically appended.");
- }
-
- $code .=
-'
-
- Parse::RecDescent::_trace(q{>>Matched production: ['
- . $self->describe . ']<<},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $_matched = 1;
- last;
- }
-
-';
- return $code;
-}
-
-1;
-
-package Parse::RecDescent::Action;
-
-sub describe { undef }
-
-sub sethashname { $_[0]->{hashname} = '__ACTION' . ++$_[1]->{actcount} .'__'; }
-
-sub new
-{
- my $class = ref($_[0]) || $_[0];
- bless
- {
- "code" => $_[1],
- "lookahead" => $_[2],
- "line" => $_[3],
- }, $class;
-}
-
-sub issubrule { undef }
-sub isterminal { 0 }
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
-'
- Parse::RecDescent::_trace(q{Trying action},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'
-
- $_tok = ($_noactions) ? 0 : do ' . $self->{"code"} . ';
- ' . ($self->{"lookahead"}<0?'if':'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;
- ' . ($self->{line}>=0 ? '$item{'. $self->{hashname} .'}=$_tok;' : '' ) .'
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-'
-}
-
-
-1;
-
-package Parse::RecDescent::Directive;
-
-sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} . '__'; }
-
-sub issubrule { undef }
-sub isterminal { 0 }
-sub describe { $_[1] ? '' : $_[0]->{name} }
-
-sub new ($$$$$)
-{
- my $class = ref($_[0]) || $_[0];
- bless
- {
- "code" => $_[1],
- "lookahead" => $_[2],
- "line" => $_[3],
- "name" => $_[4],
- }, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
-'
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'
-
- Parse::RecDescent::_trace(q{Trying directive: ['
- . $self->describe . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE; ' .'
- $_tok = do { ' . $self->{"code"} . ' };
- 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;
- }
- ' . ($self->{"lookahead"} ? '$text = $_savetext and ' : '' ) .'
- last '
- . ($self->{"lookahead"}<0?'if':'unless') . ' defined $_tok;
- push @item, $item{'.$self->{hashname}.'}=$_tok;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-'
-}
-
-1;
-
-package Parse::RecDescent::UncondReject;
-
-sub issubrule { undef }
-sub isterminal { 0 }
-sub describe { $_[1] ? '' : $_[0]->{name} }
-sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} . '__'; }
-
-sub new ($$$;$)
-{
- my $class = ref($_[0]) || $_[0];
- bless
- {
- "lookahead" => $_[1],
- "line" => $_[2],
- "name" => $_[3],
- }, $class;
-}
-
-# MARK, YOU MAY WANT TO OPTIMIZE THIS.
-
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
-'
- Parse::RecDescent::_trace(q{>>Rejecting production<< (found '
- . $self->describe . ')},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- undef $return;
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'
-
- $_tok = undef;
- ' . ($self->{"lookahead"} ? '$text = $_savetext and ' : '' ) .'
- last '
- . ($self->{"lookahead"}<0?'if':'unless') . ' defined $_tok;
-'
-}
-
-1;
-
-package Parse::RecDescent::Error;
-
-sub issubrule { undef }
-sub isterminal { 0 }
-sub describe { $_[1] ? '' : $_[0]->{commitonly} ? '<error?:...>' : '<error...>' }
-sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} . '__'; }
-
-sub new ($$$$$)
-{
- my $class = ref($_[0]) || $_[0];
- bless
- {
- "msg" => $_[1],
- "lookahead" => $_[2],
- "commitonly" => $_[3],
- "line" => $_[4],
- }, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
- my $action = '';
-
- if ($self->{"msg"}) # ERROR MESSAGE SUPPLIED
- {
- #WAS: $action .= "Parse::RecDescent::_error(qq{$self->{msg}}" . ',$thisline);';
- $action .= 'push @{$thisparser->{errors}}, [qq{'.$self->{msg}.'},$thisline];';
-
- }
- else # GENERATE ERROR MESSAGE DURING PARSE
- {
- $action .= '
- my $rule = $item[0];
- $rule =~ s/_/ /g;
- #WAS: Parse::RecDescent::_error("Invalid $rule: " . $expectation->message() ,$thisline);
- push @{$thisparser->{errors}}, ["Invalid $rule: " . $expectation->message() ,$thisline];
- ';
- }
-
- my $dir =
- new Parse::RecDescent::Directive('if (' .
- ($self->{"commitonly"} ? '$commit' : '1') .
- ") { do {$action} unless ".' $_noactions; undef } else {0}',
- $self->{"lookahead"},0,$self->describe);
- $dir->{hashname} = $self->{hashname};
- return $dir->code($namespace, $rule, 0);
-}
-
-1;
-
-package Parse::RecDescent::Token;
-
-sub sethashname { $_[0]->{hashname} = '__PATTERN' . ++$_[1]->{patcount} . '__'; }
-
-sub issubrule { undef }
-sub isterminal { 1 }
-sub describe ($) { shift->{'description'}}
-
-
-# ARGS ARE: $self, $pattern, $left_delim, $modifiers, $lookahead, $linenum
-sub new ($$$$$$)
-{
- my $class = ref($_[0]) || $_[0];
- my $pattern = $_[1];
- my $pat = $_[1];
- my $ldel = $_[2];
- my $rdel = $ldel;
- $rdel =~ tr/{[(</}])>/;
-
- my $mod = $_[3];
-
- my $desc;
-
- if ($ldel eq '/') { $desc = "$ldel$pattern$rdel$mod" }
- else { $desc = "m$ldel$pattern$rdel$mod" }
- $desc =~ s/\\/\\\\/g;
- $desc =~ s/\$$/\\\$/g;
- $desc =~ s/}/\\}/g;
- $desc =~ s/{/\\{/g;
-
- if (!eval "no strict;
- local \$SIG{__WARN__} = sub {0};
- '' =~ m$ldel$pattern$rdel" and $@)
- {
- Parse::RecDescent::_warn(3, "Token pattern \"m$ldel$pattern$rdel\"
- may not be a valid regular expression",
- $_[5]);
- $@ =~ s/ at \(eval.*/./;
- Parse::RecDescent::_hint($@);
- }
-
- # QUIETLY PREVENT (WELL-INTENTIONED) CALAMITY
- $mod =~ s/[gc]//g;
- $pattern =~ s/(\A|[^\\])\\G/$1/g;
-
- bless
- {
- "pattern" => $pattern,
- "ldelim" => $ldel,
- "rdelim" => $rdel,
- "mod" => $mod,
- "lookahead" => $_[4],
- "line" => $_[5],
- "description" => $desc,
- }, $class;
-}
-
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule, $check) = @_;
- my $ldel = $self->{"ldelim"};
- my $rdel = $self->{"rdelim"};
- my $sdel = $ldel;
- my $mod = $self->{"mod"};
-
- $sdel =~ s/[[{(<]/{}/;
-
-my $code = '
- Parse::RecDescent::_trace(q{Trying terminal: [' . $self->describe
- . ']}, Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $lastsep = "";
- $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
- : $self->describe ) . '})->at($text);
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '
-
- ' . ($self->{"lookahead"}<0?'if':'unless')
- . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
- . ($check->{itempos}? 'do {'.Parse::RecDescent::Production::incitempos().' 1} and ' : '')
- . ' $text =~ s' . $ldel . '\A(?:' . $self->{"pattern"} . ')'
- . $rdel . $sdel . $mod . ')
- {
- '.($self->{"lookahead"} ? '$text = $_savetext;' : '').'
- $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{'.$self->{hashname}.'}=$&;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-';
-
- return $code;
-}
-
-1;
-
-package Parse::RecDescent::Literal;
-
-sub sethashname { $_[0]->{hashname} = '__STRING' . ++$_[1]->{strcount} . '__'; }
-
-sub issubrule { undef }
-sub isterminal { 1 }
-sub describe ($) { shift->{'description'} }
-
-sub new ($$$$)
-{
- my $class = ref($_[0]) || $_[0];
-
- my $pattern = $_[1];
-
- my $desc = $pattern;
- $desc=~s/\\/\\\\/g;
- $desc=~s/}/\\}/g;
- $desc=~s/{/\\{/g;
-
- bless
- {
- "pattern" => $pattern,
- "lookahead" => $_[2],
- "line" => $_[3],
- "description" => "'$desc'",
- }, $class;
-}
-
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule, $check) = @_;
-
-my $code = '
- Parse::RecDescent::_trace(q{Trying terminal: [' . $self->describe
- . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $lastsep = "";
- $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
- : $self->describe ) . '})->at($text);
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '
-
- ' . ($self->{"lookahead"}<0?'if':'unless')
- . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
- . ($check->{itempos}? 'do {'.Parse::RecDescent::Production::incitempos().' 1} and ' : '')
- . ' $text =~ s/\A' . quotemeta($self->{"pattern"}) . '//)
- {
- '.($self->{"lookahead"} ? '$text = $_savetext;' : '').'
- $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{'.$self->{hashname}.'}=$&;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-';
-
- return $code;
-}
-
-1;
-
-package Parse::RecDescent::InterpLit;
-
-sub sethashname { $_[0]->{hashname} = '__STRING' . ++$_[1]->{strcount} . '__'; }
-
-sub issubrule { undef }
-sub isterminal { 1 }
-sub describe ($) { shift->{'description'} }
-
-sub new ($$$$)
-{
- my $class = ref($_[0]) || $_[0];
-
- my $pattern = $_[1];
- $pattern =~ s#/#\\/#g;
-
- my $desc = $pattern;
- $desc=~s/\\/\\\\/g;
- $desc=~s/}/\\}/g;
- $desc=~s/{/\\{/g;
-
- bless
- {
- "pattern" => $pattern,
- "lookahead" => $_[2],
- "line" => $_[3],
- "description" => "'$desc'",
- }, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule, $check) = @_;
-
-my $code = '
- Parse::RecDescent::_trace(q{Trying terminal: [' . $self->describe
- . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{name} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $lastsep = "";
- $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
- : $self->describe ) . '})->at($text);
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '
-
- ' . ($self->{"lookahead"}<0?'if':'unless')
- . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
- . ($check->{itempos}? 'do {'.Parse::RecDescent::Production::incitempos().' 1} and ' : '')
- . ' do { $_tok = "' . $self->{"pattern"} . '"; 1 } and
- substr($text,0,length($_tok)) eq $_tok and
- do { substr($text,0,length($_tok)) = ""; 1; }
- )
- {
- '.($self->{"lookahead"} ? '$text = $_savetext;' : '').'
- $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{'.$self->{hashname}.'}=$_tok;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-';
-
- return $code;
-}
-
-1;
-
-package Parse::RecDescent::Subrule;
-
-sub issubrule ($) { return $_[0]->{"subrule"} }
-sub isterminal { 0 }
-sub sethashname {}
-
-sub describe ($)
-{
- my $desc = $_[0]->{"implicit"} || $_[0]->{"subrule"};
- $desc = "<matchrule:$desc>" if $_[0]->{"matchrule"};
- return $desc;
-}
-
-sub callsyntax($$)
-{
- if ($_[0]->{"matchrule"})
- {
- return "&{'$_[1]'.qq{$_[0]->{subrule}}}";
- }
- else
- {
- return $_[1].$_[0]->{"subrule"};
- }
-}
-
-sub new ($$$$;$$$)
-{
- my $class = ref($_[0]) || $_[0];
- bless
- {
- "subrule" => $_[1],
- "lookahead" => $_[2],
- "line" => $_[3],
- "implicit" => $_[4] || undef,
- "matchrule" => $_[5],
- "argcode" => $_[6] || undef,
- }, $class;
-}
-
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
-'
- Parse::RecDescent::_trace(q{Trying subrule: [' . $self->{"subrule"} . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- if (1) { no strict qw{refs};
- $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
- # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
- : 'q{'.$self->describe.'}' ) . ')->at($text);
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' )
- . ($self->{"lookahead"}<0?'if':'unless')
- . ' (defined ($_tok = '
- . $self->callsyntax($namespace.'::')
- . '($thisparser,$text,$repeating,'
- . ($self->{"lookahead"}?'1':'$_noactions')
- . ($self->{argcode} ? ",sub { return $self->{argcode} }"
- : ',sub { \\@arg }')
- . ')))
- {
- '.($self->{"lookahead"} ? '$text = $_savetext;' : '').'
- Parse::RecDescent::_trace(q{<<Didn\'t match subrule: ['
- . $self->{subrule} . ']>>},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- $expectation->failed();
- last;
- }
- Parse::RecDescent::_trace(q{>>Matched subrule: ['
- . $self->{subrule} . ']<< (return value: [}
- . $_tok . q{]},
-
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- $item{q{' . $self->{subrule} . '}} = $_tok;
- push @item, $_tok;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
- }
-'
-}
-
-package Parse::RecDescent::Repetition;
-
-sub issubrule ($) { return $_[0]->{"subrule"} }
-sub isterminal { 0 }
-sub sethashname { }
-
-sub describe ($)
-{
- my $desc = $_[0]->{"expected"} || $_[0]->{"subrule"};
- $desc = "<matchrule:$desc>" if $_[0]->{"matchrule"};
- return $desc;
-}
-
-sub callsyntax($$)
-{
- if ($_[0]->{matchrule})
- { return "sub { goto &{''.qq{$_[1]$_[0]->{subrule}}} }"; }
- else
- { return "\\&$_[1]$_[0]->{subrule}"; }
-}
-
-sub new ($$$$$$$$$$)
-{
- my ($self, $subrule, $repspec, $min, $max, $lookahead, $line, $parser, $matchrule, $argcode) = @_;
- my $class = ref($self) || $self;
- ($max, $min) = ( $min, $max) if ($max<$min);
-
- my $desc;
- if ($subrule=~/\A_alternation_\d+_of_production_\d+_of_rule/)
- { $desc = $parser->{"rules"}{$subrule}->expected }
-
- if ($lookahead)
- {
- if ($min>0)
- {
- return new Parse::RecDescent::Subrule($subrule,$lookahead,$line,$desc,$matchrule,$argcode);
- }
- else
- {
- Parse::RecDescent::_error("Not symbol (\"!\") before
- \"$subrule\" doesn't make
- sense.",$line);
- Parse::RecDescent::_hint("Lookahead for negated optional
- repetitions (such as
- \"!$subrule($repspec)\" can never
- succeed, since optional items always
- match (zero times at worst).
- Did you mean a single \"!$subrule\",
- instead?");
- }
- }
- bless
- {
- "subrule" => $subrule,
- "repspec" => $repspec,
- "min" => $min,
- "max" => $max,
- "lookahead" => $lookahead,
- "line" => $line,
- "expected" => $desc,
- "argcode" => $argcode || undef,
- "matchrule" => $matchrule,
- }, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
- my ($subrule, $repspec, $min, $max, $lookahead) =
- @{$self}{ qw{subrule repspec min max lookahead} };
-
-'
- Parse::RecDescent::_trace(q{Trying repeated subrule: [' . $self->describe . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
- # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
- : 'q{'.$self->describe.'}' ) . ')->at($text);
- ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'
- unless (defined ($_tok = $thisparser->_parserepeat($text, '
- . $self->callsyntax($namespace.'::')
- . ', ' . $min . ', ' . $max . ', '
- . ($self->{"lookahead"}?'1':'$_noactions')
- . ',$expectation,'
- . ($self->{argcode} ? "sub { return $self->{argcode} }"
- : 'undef')
- . ')))
- {
- Parse::RecDescent::_trace(q{<<Didn\'t match repeated subrule: ['
- . $self->describe . ']>>},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- last;
- }
- Parse::RecDescent::_trace(q{>>Matched repeated subrule: ['
- . $self->{subrule} . ']<< (}
- . @$_tok . q{ times)},
-
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- $item{q{' . "$self->{subrule}($self->{repspec})" . '}} = $_tok;
- push @item, $_tok;
- ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
-
-'
-}
-
-package Parse::RecDescent::Result;
-
-sub issubrule { 0 }
-sub isterminal { 0 }
-sub describe { '' }
-
-sub new
-{
- my ($class, $pos) = @_;
-
- bless {}, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
- '
- $return = $item[-1];
- ';
-}
-
-package Parse::RecDescent::Operator;
-
-my @opertype = ( " non-optional", "n optional" );
-
-sub issubrule { 0 }
-sub isterminal { 0 }
-
-sub describe { $_[0]->{"expected"} }
-sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} . '__'; }
-
-
-sub new
-{
- my ($class, $type, $minrep, $maxrep, $leftarg, $op, $rightarg) = @_;
-
- bless
- {
- "type" => "${type}op",
- "leftarg" => $leftarg,
- "op" => $op,
- "min" => $minrep,
- "max" => $maxrep,
- "rightarg" => $rightarg,
- "expected" => "<${type}op: ".$leftarg->describe." ".$op->describe." ".$rightarg->describe.">",
- }, $class;
-}
-
-sub code($$$$)
-{
- my ($self, $namespace, $rule) = @_;
-
- my ($leftarg, $op, $rightarg) =
- @{$self}{ qw{leftarg op rightarg} };
-
- my $code = '
- Parse::RecDescent::_trace(q{Trying operator: [' . $self->describe . ']},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} . '},
- $tracelevel)
- if defined $::RD_TRACE;
- $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
- # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
- : 'q{'.$self->describe.'}' ) . ')->at($text);
-
- $_tok = undef;
- OPLOOP: while (1)
- {
- $repcount = 0;
- my @item;
- ';
-
- if ($self->{type} eq "leftop" )
- {
- $code .= '
- # MATCH LEFTARG
- ' . $leftarg->code(@_[1..2]) . '
-
- $repcount++;
-
- my $savetext = $text;
- my $backtrack;
-
- # MATCH (OP RIGHTARG)(s)
- while ($repcount < ' . $self->{max} . ')
- {
- $backtrack = 0;
- ' . $op->code(@_[1..2]) . '
- ' . ($op->isterminal() ? 'pop @item;' : '$backtrack=1;' ) . '
- ' . (ref($op) eq 'Parse::RecDescent::Token'
- ? 'if (defined $1) {push @item, $item{'.($self->{name}||$self->{hashname}).'}=$1; $backtrack=1;}'
- : "" ) . '
- ' . $rightarg->code(@_[1..2]) . '
- $savetext = $text;
- $repcount++;
- }
- $text = $savetext;
- pop @item if $backtrack;
-
- ';
- }
- else
- {
- $code .= '
- my $savetext = $text;
- my $backtrack;
- # MATCH (LEFTARG OP)(s)
- while ($repcount < ' . $self->{max} . ')
- {
- $backtrack = 0;
- ' . $leftarg->code(@_[1..2]) . '
- $repcount++;
- $backtrack = 1;
- ' . $op->code(@_[1..2]) . '
- $savetext = $text;
- ' . ($op->isterminal() ? 'pop @item;' : "" ) . '
- ' . (ref($op) eq 'Parse::RecDescent::Token' ? 'do { push @item, $item{'.($self->{name}||$self->{hashname}).'}=$1; } if defined $1;' : "" ) . '
- }
- $text = $savetext;
- pop @item if $backtrack;
-
- # MATCH RIGHTARG
- ' . $rightarg->code(@_[1..2]) . '
- $repcount++;
- ';
- }
-
- $code .= 'unless (@item) { undef $_tok; last }' unless $self->{min}==0;
-
- $code .= '
- $_tok = [ @item ];
- last;
- }
-
- unless ($repcount>='.$self->{min}.')
- {
- Parse::RecDescent::_trace(q{<<Didn\'t match operator: ['
- . $self->describe
- . ']>>},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
- $expectation->failed();
- last;
- }
- Parse::RecDescent::_trace(q{>>Matched operator: ['
- . $self->describe
- . ']<< (return value: [}
- . qq{@{$_tok||[]}} . q{]},
- Parse::RecDescent::_tracefirst($text),
- q{' . $rule->{"name"} .'},
- $tracelevel)
- if defined $::RD_TRACE;
-
- push @item, $item{'.($self->{name}||$self->{hashname}).'}=$_tok||[];
-
-';
- return $code;
-}
-
-
-package Parse::RecDescent::Expectation;
-
-sub new ($)
-{
- bless {
- "failed" => 0,
- "expected" => "",
- "unexpected" => "",
- "lastexpected" => "",
- "lastunexpected" => "",
- "defexpected" => $_[1],
- };
-}
-
-sub is ($$)
-{
- $_[0]->{lastexpected} = $_[1]; return $_[0];
-}
-
-sub at ($$)
-{
- $_[0]->{lastunexpected} = $_[1]; return $_[0];
-}
-
-sub failed ($)
-{
- return unless $_[0]->{lastexpected};
- $_[0]->{expected} = $_[0]->{lastexpected} unless $_[0]->{failed};
- $_[0]->{unexpected} = $_[0]->{lastunexpected} unless $_[0]->{failed};
- $_[0]->{failed} = 1;
-}
-
-sub message ($)
-{
- my ($self) = @_;
- $self->{expected} = $self->{defexpected} unless $self->{expected};
- $self->{expected} =~ s/_/ /g;
- if (!$self->{unexpected} || $self->{unexpected} =~ /\A\s*\Z/s)
- {
- return "Was expecting $self->{expected}";
- }
- else
- {
- $self->{unexpected} =~ /\s*(.*)/;
- return "Was expecting $self->{expected} but found \"$1\" instead";
- }
-}
-
-1;
-
-package Parse::RecDescent;
-
-use Carp;
-use vars qw ( $AUTOLOAD $VERSION );
-
-my $ERRORS = 0;
-
-$VERSION = '1.94';
-
-# BUILDING A PARSER
-
-my $nextnamespace = "namespace000001";
-
-sub _nextnamespace()
-{
- return "Parse::RecDescent::" . $nextnamespace++;
-}
-
-sub new ($$$)
-{
- my $class = ref($_[0]) || $_[0];
- local $Parse::RecDescent::compiling = $_[2];
- my $name_space_name = defined $_[3]
- ? "Parse::RecDescent::".$_[3]
- : _nextnamespace();
- my $self =
- {
- "rules" => {},
- "namespace" => $name_space_name,
- "startcode" => '',
- "localvars" => '',
- "_AUTOACTION" => undef,
- "_AUTOTREE" => undef,
- };
- if ($::RD_AUTOACTION)
- {
- my $sourcecode = $::RD_AUTOACTION;
- $sourcecode = "{ $sourcecode }"
- unless $sourcecode =~ /\A\s*\{.*\}\s*\Z/;
- $self->{_check}{itempos} =
- $sourcecode =~ /\@itempos\b|\$itempos\s*\[/;
- $self->{_AUTOACTION}
- = new Parse::RecDescent::Action($sourcecode,0,-1)
- }
-
- bless $self, $class;
- shift;
- return $self->Replace(@_)
-}
-
-sub Compile($$$$) {
-
- die "Compilation of Parse::RecDescent grammars not yet implemented\n";
-}
-
-sub DESTROY {} # SO AUTOLOADER IGNORES IT
-
-# BUILDING A GRAMMAR....
-
-sub Replace ($$)
-{
- splice(@_, 2, 0, 1);
- return _generate(@_);
-}
-
-sub Extend ($$)
-{
- splice(@_, 2, 0, 0);
- return _generate(@_);
-}
-
-sub _no_rule ($$;$)
-{
- _error("Ruleless $_[0] at start of grammar.",$_[1]);
- my $desc = $_[2] ? "\"$_[2]\"" : "";
- _hint("You need to define a rule for the $_[0] $desc
- to be part of.");
-}
-
-my $NEGLOOKAHEAD = '\G(\s*\.\.\.\!)';
-my $POSLOOKAHEAD = '\G(\s*\.\.\.)';
-my $RULE = '\G\s*(\w+)[ \t]*:';
-my $PROD = '\G\s*([|])';
-my $TOKEN = q{\G\s*/((\\\\/|[^/])*)/([cgimsox]*)};
-my $MTOKEN = q{\G\s*(m\s*[^\w\s])};
-my $LITERAL = q{\G\s*'((\\\\['\\\\]|[^'])*)'};
-my $INTERPLIT = q{\G\s*"((\\\\["\\\\]|[^"])*)"};
-my $SUBRULE = '\G\s*(\w+)';
-my $MATCHRULE = '\G(\s*<matchrule:)';
-my $SIMPLEPAT = '((\\s+/[^/\\\\]*(?:\\\\.[^/\\\\]*)*/)?)';
-my $OPTIONAL = '\G\((\?)'.$SIMPLEPAT.'\)';
-my $ANY = '\G\((s\?)'.$SIMPLEPAT.'\)';
-my $MANY = '\G\((s|\.\.)'.$SIMPLEPAT.'\)';
-my $EXACTLY = '\G\(([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $BETWEEN = '\G\((\d+)\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $ATLEAST = '\G\((\d+)\.\.'.$SIMPLEPAT.'\)';
-my $ATMOST = '\G\(\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
-my $BADREP = '\G\((-?\d+)?\.\.(-?\d+)?'.$SIMPLEPAT.'\)';
-my $ACTION = '\G\s*\{';
-my $IMPLICITSUBRULE = '\G\s*\(';
-my $COMMENT = '\G\s*(#.*)';
-my $COMMITMK = '\G\s*<commit>';
-my $UNCOMMITMK = '\G\s*<uncommit>';
-my $QUOTELIKEMK = '\G\s*<perl_quotelike>';
-my $CODEBLOCKMK = '\G\s*<perl_codeblock(?:\s+([][()<>{}]+))?>';
-my $VARIABLEMK = '\G\s*<perl_variable>';
-my $NOCHECKMK = '\G\s*<nocheck>';
-my $AUTOTREEMK = '\G\s*<autotree>';
-my $AUTOSTUBMK = '\G\s*<autostub>';
-my $AUTORULEMK = '\G\s*<autorule:(.*?)>';
-my $REJECTMK = '\G\s*<reject>';
-my $CONDREJECTMK = '\G\s*<reject:';
-my $SCOREMK = '\G\s*<score:';
-my $AUTOSCOREMK = '\G\s*<autoscore:';
-my $SKIPMK = '\G\s*<skip:';
-my $OPMK = '\G\s*<(left|right)op(?:=(\'.*?\'))?:';
-my $ENDDIRECTIVEMK = '\G\s*>';
-my $RESYNCMK = '\G\s*<resync>';
-my $RESYNCPATMK = '\G\s*<resync:';
-my $RULEVARPATMK = '\G\s*<rulevar:';
-my $DEFERPATMK = '\G\s*<defer:';
-my $TOKENPATMK = '\G\s*<token:';
-my $AUTOERRORMK = '\G\s*<error(\??)>';
-my $MSGERRORMK = '\G\s*<error(\??):';
-my $UNCOMMITPROD = $PROD.'\s*<uncommit';
-my $ERRORPROD = $PROD.'\s*<error';
-my $LONECOLON = '\G\s*:';
-my $OTHER = '\G\s*([^\s]+)';
-
-my $lines = 0;
-
-sub _generate($$$;$$)
-{
- my ($self, $grammar, $replace, $isimplicit, $isleftop) = (@_, 0);
-
- my $aftererror = 0;
- my $lookahead = 0;
- my $lookaheadspec = "";
- $lines = _linecount($grammar) unless $lines;
- $self->{_check}{itempos} = ($grammar =~ /\@itempos\b|\$itempos\s*\[/)
- unless $self->{_check}{itempos};
- for (qw(thisoffset thiscolumn prevline prevoffset prevcolumn))
- {
- $self->{_check}{$_} =
- ($grammar =~ /\$$_/) || $self->{_check}{itempos}
- unless $self->{_check}{$_};
- }
- my $line;
-
- my $rule = undef;
- my $prod = undef;
- my $item = undef;
- my $lastgreedy = '';
- pos $grammar = 0;
- study $grammar;
-
- while (pos $grammar < length $grammar)
- {
- $line = $lines - _linecount($grammar) + 1;
- my $commitonly;
- my $code = "";
- my @components = ();
- if ($grammar =~ m/$COMMENT/gco)
- {
- _parse("a comment",0,$line);
- next;
- }
- elsif ($grammar =~ m/$NEGLOOKAHEAD/gco)
- {
- _parse("a negative lookahead",$aftererror,$line);
- $lookahead = $lookahead ? -$lookahead : -1;
- $lookaheadspec .= $1;
- next; # SKIP LOOKAHEAD RESET AT END OF while LOOP
- }
- elsif ($grammar =~ m/$POSLOOKAHEAD/gco)
- {
- _parse("a positive lookahead",$aftererror,$line);
- $lookahead = $lookahead ? $lookahead : 1;
- $lookaheadspec .= $1;
- next; # SKIP LOOKAHEAD RESET AT END OF while LOOP
- }
- elsif ($grammar =~ m/(?=$ACTION)/gco
- and do { ($code) = extract_codeblock($grammar); $code })
- {
- _parse("an action", $aftererror, $line, $code);
- $item = new Parse::RecDescent::Action($code,$lookahead,$line);
- $prod and $prod->additem($item)
- or $self->_addstartcode($code);
- }
- elsif ($grammar =~ m/(?=$IMPLICITSUBRULE)/gco
- and do { ($code) = extract_codeblock($grammar,'{([',undef,'(',1);
- $code })
- {
- $code =~ s/\A\s*\(|\)\Z//g;
- _parse("an implicit subrule", $aftererror, $line,
- "( $code )");
- my $implicit = $rule->nextimplicit;
- $self->_generate("$implicit : $code",$replace,1);
- my $pos = pos $grammar;
- substr($grammar,$pos,0,$implicit);
- pos $grammar = $pos;;
- }
- elsif ($grammar =~ m/$ENDDIRECTIVEMK/gco)
- {
-
- # EXTRACT TRAILING REPETITION SPECIFIER (IF ANY)
-
- my ($minrep,$maxrep) = (1,$MAXREP);
- if ($grammar =~ m/\G[(]/gc)
- {
- pos($grammar)--;
-
- if ($grammar =~ m/$OPTIONAL/gco)
- { ($minrep, $maxrep) = (0,1) }
- elsif ($grammar =~ m/$ANY/gco)
- { $minrep = 0 }
- elsif ($grammar =~ m/$EXACTLY/gco)
- { ($minrep, $maxrep) = ($1,$1) }
- elsif ($grammar =~ m/$BETWEEN/gco)
- { ($minrep, $maxrep) = ($1,$2) }
- elsif ($grammar =~ m/$ATLEAST/gco)
- { $minrep = $1 }
- elsif ($grammar =~ m/$ATMOST/gco)
- { $maxrep = $1 }
- elsif ($grammar =~ m/$MANY/gco)
- { }
- elsif ($grammar =~ m/$BADREP/gco)
- {
- _parse("an invalid repetition specifier", 0,$line);
- _error("Incorrect specification of a repeated directive",
- $line);
- _hint("Repeated directives cannot have
- a maximum repetition of zero, nor can they have
- negative components in their ranges.");
- }
- }
-
- $prod && $prod->enddirective($line,$minrep,$maxrep);
- }
- elsif ($grammar =~ m/\G\s*<[^m]/gc)
- {
- pos($grammar)-=2;
-
- if ($grammar =~ m/$OPMK/gco)
- {
- # $DB::single=1;
- _parse("a $1-associative operator directive", $aftererror, $line, "<$1op:...>");
- $prod->adddirective($1, $line,$2||'');
- }
- elsif ($grammar =~ m/$UNCOMMITMK/gco)
- {
- _parse("an uncommit marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive('$commit=0;1',
- $lookahead,$line,"<uncommit>");
- $prod and $prod->additem($item)
- or _no_rule("<uncommit>",$line);
- }
- elsif ($grammar =~ m/$QUOTELIKEMK/gco)
- {
- _parse("an perl quotelike marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive(
- 'my ($match,@res);
- ($match,$text,undef,@res) =
- Text::Balanced::extract_quotelike($text,$skip);
- $match ? \@res : undef;
- ', $lookahead,$line,"<perl_quotelike>");
- $prod and $prod->additem($item)
- or _no_rule("<perl_quotelike>",$line);
- }
- elsif ($grammar =~ m/$CODEBLOCKMK/gco)
- {
- my $outer = $1||"{}";
- _parse("an perl codeblock marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive(
- 'Text::Balanced::extract_codeblock($text,undef,$skip,\''.$outer.'\');
- ', $lookahead,$line,"<perl_codeblock>");
- $prod and $prod->additem($item)
- or _no_rule("<perl_codeblock>",$line);
- }
- elsif ($grammar =~ m/$VARIABLEMK/gco)
- {
- _parse("an perl variable marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive(
- 'Text::Balanced::extract_variable($text,$skip);
- ', $lookahead,$line,"<perl_variable>");
- $prod and $prod->additem($item)
- or _no_rule("<perl_variable>",$line);
- }
- elsif ($grammar =~ m/$NOCHECKMK/gco)
- {
- _parse("a disable checking marker", $aftererror,$line);
- if ($rule)
- {
- _error("<nocheck> directive not at start of grammar", $line);
- _hint("The <nocheck> directive can only
- be specified at the start of a
- grammar (before the first rule
- is defined.");
- }
- else
- {
- local $::RD_CHECK = 1;
- }
- }
- elsif ($grammar =~ m/$AUTOSTUBMK/gco)
- {
- _parse("an autostub marker", $aftererror,$line);
- $::RD_AUTOSTUB = "";
- }
- elsif ($grammar =~ m/$AUTORULEMK/gco)
- {
- _parse("an autorule marker", $aftererror,$line);
- $::RD_AUTOSTUB = $1;
- }
- elsif ($grammar =~ m/$AUTOTREEMK/gco)
- {
- _parse("an autotree marker", $aftererror,$line);
- if ($rule)
- {
- _error("<autotree> directive not at start of grammar", $line);
- _hint("The <autotree> directive can only
- be specified at the start of a
- grammar (before the first rule
- is defined.");
- }
- else
- {
- undef $self->{_AUTOACTION};
- $self->{_AUTOTREE}{NODE}
- = new Parse::RecDescent::Action(q{{bless \%item, $item[0]}},0,-1);
- $self->{_AUTOTREE}{TERMINAL}
- = new Parse::RecDescent::Action(q{{bless {__VALUE__=>$item[1]}, $item[0]}},0,-1);
- }
- }
-
- elsif ($grammar =~ m/$REJECTMK/gco)
- {
- _parse("an reject marker", $aftererror,$line);
- $item = new Parse::RecDescent::UncondReject($lookahead,$line,"<reject>");
- $prod and $prod->additem($item)
- or _no_rule("<reject>",$line);
- }
- elsif ($grammar =~ m/(?=$CONDREJECTMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code })
- {
- _parse("a (conditional) reject marker", $aftererror,$line);
- $code =~ /\A\s*<reject:(.*)>\Z/s;
- $item = new Parse::RecDescent::Directive(
- "($1) ? undef : 1", $lookahead,$line,"<reject:$code>");
- $prod and $prod->additem($item)
- or _no_rule("<reject:$code>",$line);
- }
- elsif ($grammar =~ m/(?=$SCOREMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code })
- {
- _parse("a score marker", $aftererror,$line);
- $code =~ /\A\s*<score:(.*)>\Z/s;
- $prod and $prod->addscore($1, $lookahead, $line)
- or _no_rule($code,$line);
- }
- elsif ($grammar =~ m/(?=$AUTOSCOREMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code;
- } )
- {
- _parse("an autoscore specifier", $aftererror,$line,$code);
- $code =~ /\A\s*<autoscore:(.*)>\Z/s;
-
- $rule and $rule->addautoscore($1,$self)
- or _no_rule($code,$line);
-
- $item = new Parse::RecDescent::UncondReject($lookahead,$line,$code);
- $prod and $prod->additem($item)
- or _no_rule($code,$line);
- }
- elsif ($grammar =~ m/$RESYNCMK/gco)
- {
- _parse("a resync to newline marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive(
- 'if ($text =~ s/\A[^\n]*\n//) { $return = 0; $& } else { undef }',
- $lookahead,$line,"<resync>");
- $prod and $prod->additem($item)
- or _no_rule("<resync>",$line);
- }
- elsif ($grammar =~ m/(?=$RESYNCPATMK)/gco
- and do { ($code) = extract_bracketed($grammar,'<');
- $code })
- {
- _parse("a resync with pattern marker", $aftererror,$line);
- $code =~ /\A\s*<resync:(.*)>\Z/s;
- $item = new Parse::RecDescent::Directive(
- 'if ($text =~ s/\A'.$1.'//) { $return = 0; $& } else { undef }',
- $lookahead,$line,$code);
- $prod and $prod->additem($item)
- or _no_rule($code,$line);
- }
- elsif ($grammar =~ m/(?=$SKIPMK)/gco
- and do { ($code) = extract_codeblock($grammar,'<');
- $code })
- {
- _parse("a skip marker", $aftererror,$line);
- $code =~ /\A\s*<skip:(.*)>\Z/s;
- $item = new Parse::RecDescent::Directive(
- 'my $oldskip = $skip; $skip='.$1.'; $oldskip',
- $lookahead,$line,$code);
- $prod and $prod->additem($item)
- or _no_rule($code,$line);
- }
- elsif ($grammar =~ m/(?=$RULEVARPATMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code;
- } )
- {
- _parse("a rule variable specifier", $aftererror,$line,$code);
- $code =~ /\A\s*<rulevar:(.*)>\Z/s;
-
- $rule and $rule->addvar($1,$self)
- or _no_rule($code,$line);
-
- $item = new Parse::RecDescent::UncondReject($lookahead,$line,$code);
- $prod and $prod->additem($item)
- or _no_rule($code,$line);
- }
- elsif ($grammar =~ m/(?=$DEFERPATMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code;
- } )
- {
- _parse("a deferred action specifier", $aftererror,$line,$code);
- $code =~ s/\A\s*<defer:(.*)>\Z/$1/s;
- if ($code =~ /\A\s*[^{]|[^}]\s*\Z/)
- {
- $code = "{ $code }"
- }
-
- $item = new Parse::RecDescent::Directive(
- "push \@{\$thisparser->{deferred}}, sub $code;",
- $lookahead,$line,"<defer:$code>");
- $prod and $prod->additem($item)
- or _no_rule("<defer:$code>",$line);
-
- $self->{deferrable} = 1;
- }
- elsif ($grammar =~ m/(?=$TOKENPATMK)/gco
- and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
- $code;
- } )
- {
- _parse("a token constructor", $aftererror,$line,$code);
- $code =~ s/\A\s*<token:(.*)>\Z/$1/s;
-
- my $types = eval 'no strict; local $SIG{__WARN__} = sub {0}; my @arr=('.$code.'); @arr' || ();
- if (!$types)
- {
- _error("Incorrect token specification: \"$@\"", $line);
- _hint("The <token:...> directive requires a list
- of one or more strings representing possible
- types of the specified token. For example:
- <token:NOUN,VERB>");
- }
- else
- {
- $item = new Parse::RecDescent::Directive(
- 'no strict;
- $return = { text => $item[-1] };
- @{$return->{type}}{'.$code.'} = (1..'.$types.');',
- $lookahead,$line,"<token:$code>");
- $prod and $prod->additem($item)
- or _no_rule("<token:$code>",$line);
- }
- }
- elsif ($grammar =~ m/$COMMITMK/gco)
- {
- _parse("an commit marker", $aftererror,$line);
- $item = new Parse::RecDescent::Directive('$commit = 1',
- $lookahead,$line,"<commit>");
- $prod and $prod->additem($item)
- or _no_rule("<commit>",$line);
- }
- elsif ($grammar =~ m/$AUTOERRORMK/gco)
- {
- $commitonly = $1;
- _parse("an error marker", $aftererror,$line);
- $item = new Parse::RecDescent::Error('',$lookahead,$1,$line);
- $prod and $prod->additem($item)
- or _no_rule("<error>",$line);
- $aftererror = !$commitonly;
- }
- elsif ($grammar =~ m/(?=$MSGERRORMK)/gco
- and do { $commitonly = $1;
- ($code) = extract_bracketed($grammar,'<');
- $code })
- {
- _parse("an error marker", $aftererror,$line,$code);
- $code =~ /\A\s*<error\??:(.*)>\Z/s;
- $item = new Parse::RecDescent::Error($1,$lookahead,$commitonly,$line);
- $prod and $prod->additem($item)
- or _no_rule("$code",$line);
- $aftererror = !$commitonly;
- }
- elsif (do { $commitonly = $1;
- ($code) = extract_bracketed($grammar,'<');
- $code })
- {
- if ($code =~ /^<[A-Z_]+>$/)
- {
- _error("Token items are not yet
- supported: \"$code\"",
- $line);
- _hint("Items like $code that consist of angle
- brackets enclosing a sequence of
- uppercase characters will eventually
- be used to specify pre-lexed tokens
- in a grammar. That functionality is not
- yet implemented. Or did you misspell
- \"$code\"?");
- }
- else
- {
- _error("Untranslatable item encountered: \"$code\"",
- $line);
- _hint("Did you misspell \"$code\"
- or forget to comment it out?");
- }
- }
- }
- elsif ($grammar =~ m/$RULE/gco)
- {
- _parseunneg("a rule declaration", 0,
- $lookahead,$line) or next;
- my $rulename = $1;
- if ($rulename =~ /Replace|Extend|Precompile|Save/ )
- {
- _warn(2,"Rule \"$rulename\" hidden by method
- Parse::RecDescent::$rulename",$line)
- and
- _hint("The rule named \"$rulename\" cannot be directly
- called through the Parse::RecDescent object
- for this grammar (although it may still
- be used as a subrule of other rules).
- It can't be directly called because
- Parse::RecDescent::$rulename is already defined (it
- is the standard method of all
- parsers).");
- }
- $rule = new Parse::RecDescent::Rule($rulename,$self,$line,$replace);
- $prod->check_pending($line) if $prod;
- $prod = $rule->addprod( new Parse::RecDescent::Production );
- $aftererror = 0;
- }
- elsif ($grammar =~ m/$UNCOMMITPROD/gco)
- {
- pos($grammar)-=9;
- _parseunneg("a new (uncommitted) production",
- 0, $lookahead, $line) or next;
-
- $prod->check_pending($line) if $prod;
- $prod = new Parse::RecDescent::Production($line,1);
- $rule and $rule->addprod($prod)
- or _no_rule("<uncommit>",$line);
- $aftererror = 0;
- }
- elsif ($grammar =~ m/$ERRORPROD/gco)
- {
- pos($grammar)-=6;
- _parseunneg("a new (error) production", $aftererror,
- $lookahead,$line) or next;
- $prod->check_pending($line) if $prod;
- $prod = new Parse::RecDescent::Production($line,0,1);
- $rule and $rule->addprod($prod)
- or _no_rule("<error>",$line);
- $aftererror = 0;
- }
- elsif ($grammar =~ m/$PROD/gco)
- {
- _parseunneg("a new production", 0,
- $lookahead,$line) or next;
- $rule
- and (!$prod || $prod->check_pending($line))
- and $prod = $rule->addprod(new Parse::RecDescent::Production($line))
- or _no_rule("production",$line);
- $aftererror = 0;
- }
- elsif ($grammar =~ m/$LITERAL/gco)
- {
- ($code = $1) =~ s/\\\\/\\/g;
- _parse("a literal terminal", $aftererror,$line,$1);
- $item = new Parse::RecDescent::Literal($code,$lookahead,$line);
- $prod and $prod->additem($item)
- or _no_rule("literal terminal",$line,"'$1'");
- }
- elsif ($grammar =~ m/$INTERPLIT/gco)
- {
- _parse("an interpolated literal terminal", $aftererror,$line);
- $item = new Parse::RecDescent::InterpLit($1,$lookahead,$line);
- $prod and $prod->additem($item)
- or _no_rule("interpolated literal terminal",$line,"'$1'");
- }
- elsif ($grammar =~ m/$TOKEN/gco)
- {
- _parse("a /../ pattern terminal", $aftererror,$line);
- $item = new Parse::RecDescent::Token($1,'/',$3?$3:'',$lookahead,$line);
- $prod and $prod->additem($item)
- or _no_rule("pattern terminal",$line,"/$1/");
- }
- elsif ($grammar =~ m/(?=$MTOKEN)/gco
- and do { ($code, undef, @components)
- = extract_quotelike($grammar);
- $code }
- )
-
- {
- _parse("an m/../ pattern terminal", $aftererror,$line,$code);
- $item = new Parse::RecDescent::Token(@components[3,2,8],
- $lookahead,$line);
- $prod and $prod->additem($item)
- or _no_rule("pattern terminal",$line,$code);
- }
- elsif ($grammar =~ m/(?=$MATCHRULE)/gco
- and do { ($code) = extract_bracketed($grammar,'<');
- $code
- }
- or $grammar =~ m/$SUBRULE/gco
- and $code = $1)
- {
- my $name = $code;
- my $matchrule = 0;
- if (substr($name,0,1) eq '<')
- {
- $name =~ s/$MATCHRULE\s*//;
- $name =~ s/\s*>\Z//;
- $matchrule = 1;
- }
-
- # EXTRACT TRAILING ARG LIST (IF ANY)
-
- my ($argcode) = extract_codeblock($grammar, "[]",'') || '';
-
- # EXTRACT TRAILING REPETITION SPECIFIER (IF ANY)
-
- if ($grammar =~ m/\G[(]/gc)
- {
- pos($grammar)--;
-
- if ($grammar =~ m/$OPTIONAL/gco)
- {
- _parse("an zero-or-one subrule match", $aftererror,$line,"$code$argcode($1)");
- $item = new Parse::RecDescent::Repetition($name,$1,0,1,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1)");
-
- !$matchrule and $rule and $rule->addcall($name);
- }
- elsif ($grammar =~ m/$ANY/gco)
- {
- _parse("a zero-or-more subrule match", $aftererror,$line,"$code$argcode($1)");
- if ($2)
- {
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name(s?)': $name $2 $name>(s?) ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,$1,0,$MAXREP,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1)");
-
- !$matchrule and $rule and $rule->addcall($name);
-
- _check_insatiable($name,$1,$grammar,$line) if $::RD_CHECK;
- }
- }
- elsif ($grammar =~ m/$MANY/gco)
- {
- _parse("a one-or-more subrule match", $aftererror,$line,"$code$argcode($1)");
- if ($2)
- {
- # $DB::single=1;
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name(s)': $name $2 $name> ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,$1,1,$MAXREP,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
-
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1)");
-
- !$matchrule and $rule and $rule->addcall($name);
-
- _check_insatiable($name,$1,$grammar,$line) if $::RD_CHECK;
- }
- }
- elsif ($grammar =~ m/$EXACTLY/gco)
- {
- _parse("an exactly-$1-times subrule match", $aftererror,$line,"$code$argcode($1)");
- if ($2)
- {
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name($1)': $name $2 $name>($1) ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,$1,$1,$1,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1)");
-
- !$matchrule and $rule and $rule->addcall($name);
- }
- }
- elsif ($grammar =~ m/$BETWEEN/gco)
- {
- _parse("a $1-to-$2 subrule match", $aftererror,$line,"$code$argcode($1..$2)");
- if ($3)
- {
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name($1..$2)': $name $3 $name>($1..$2) ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,"$1..$2",$1,$2,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1..$2)");
-
- !$matchrule and $rule and $rule->addcall($name);
- }
- }
- elsif ($grammar =~ m/$ATLEAST/gco)
- {
- _parse("a $1-or-more subrule match", $aftererror,$line,"$code$argcode($1..)");
- if ($2)
- {
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name($1..)': $name $2 $name>($1..) ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,"$1..",$1,$MAXREP,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode($1..)");
-
- !$matchrule and $rule and $rule->addcall($name);
- _check_insatiable($name,"$1..",$grammar,$line) if $::RD_CHECK;
- }
- }
- elsif ($grammar =~ m/$ATMOST/gco)
- {
- _parse("a one-to-$1 subrule match", $aftererror,$line,"$code$argcode(..$1)");
- if ($2)
- {
- my $pos = pos $grammar;
- substr($grammar,$pos,0,
- "<leftop='$name(..$1)': $name $2 $name>(..$1) ");
-
- pos $grammar = $pos;
- }
- else
- {
- $item = new Parse::RecDescent::Repetition($name,"..$1",1,$1,
- $lookahead,$line,
- $self,
- $matchrule,
- $argcode);
- $prod and $prod->additem($item)
- or _no_rule("repetition",$line,"$code$argcode(..$1)");
-
- !$matchrule and $rule and $rule->addcall($name);
- }
- }
- elsif ($grammar =~ m/$BADREP/gco)
- {
- _parse("an subrule match with invalid repetition specifier", 0,$line);
- _error("Incorrect specification of a repeated subrule",
- $line);
- _hint("Repeated subrules like \"$code$argcode$&\" cannot have
- a maximum repetition of zero, nor can they have
- negative components in their ranges.");
- }
- }
- else
- {
- _parse("a subrule match", $aftererror,$line,$code);
- my $desc;
- if ($name=~/\A_alternation_\d+_of_production_\d+_of_rule/)
- { $desc = $self->{"rules"}{$name}->expected }
- $item = new Parse::RecDescent::Subrule($name,
- $lookahead,
- $line,
- $desc,
- $matchrule,
- $argcode);
-
- $prod and $prod->additem($item)
- or _no_rule("(sub)rule",$line,$name);
-
- !$matchrule and $rule and $rule->addcall($name);
- }
- }
- elsif ($grammar =~ m/$LONECOLON/gco )
- {
- _error("Unexpected colon encountered", $line);
- _hint("Did you mean \"|\" (to start a new production)?
- Or perhaps you forgot that the colon
- in a rule definition must be
- on the same line as the rule name?");
- }
- elsif ($grammar =~ m/$ACTION/gco ) # BAD ACTION, ALREADY FAILED
- {
- _error("Malformed action encountered",
- $line);
- _hint("Did you forget the closing curly bracket
- or is there a syntax error in the action?");
- }
- elsif ($grammar =~ m/$OTHER/gco )
- {
- _error("Untranslatable item encountered: \"$1\"",
- $line);
- _hint("Did you misspell \"$1\"
- or forget to comment it out?");
- }
-
- if ($lookaheadspec =~ tr /././ > 3)
- {
- $lookaheadspec =~ s/\A\s+//;
- $lookahead = $lookahead<0
- ? 'a negative lookahead ("...!")'
- : 'a positive lookahead ("...")' ;
- _warn(1,"Found two or more lookahead specifiers in a
- row.",$line)
- and
- _hint("Multiple positive and/or negative lookaheads
- are simply multiplied together to produce a
- single positive or negative lookahead
- specification. In this case the sequence
- \"$lookaheadspec\" was reduced to $lookahead.
- Was this your intention?");
- }
- $lookahead = 0;
- $lookaheadspec = "";
-
- $grammar =~ m/\G\s+/gc;
- }
-
- unless ($ERRORS or $isimplicit or !$::RD_CHECK)
- {
- $self->_check_grammar();
- }
-
- unless ($ERRORS or $isimplicit or $Parse::RecDescent::compiling)
- {
- my $code = $self->_code();
- if (defined $::RD_TRACE)
- {
- print STDERR "printing code (", length($code),") to RD_TRACE\n";
- local *TRACE_FILE;
- open TRACE_FILE, ">RD_TRACE"
- and print TRACE_FILE "my \$ERRORS;\n$code"
- and close TRACE_FILE;
- }
-
- unless ( eval "$code 1" )
- {
- _error("Internal error in generated parser code!");
- $@ =~ s/at grammar/in grammar at/;
- _hint($@);
- }
- }
-
- if ($ERRORS and !_verbosity("HINT"))
- {
- local $::RD_HINT = 1;
- _hint('Set $::RD_HINT (or -RD_HINT if you\'re using "perl -s")
- for hints on fixing these problems.');
- }
- if ($ERRORS) { $ERRORS=0; return }
- return $self;
-}
-
-
-sub _addstartcode($$)
-{
- my ($self, $code) = @_;
- $code =~ s/\A\s*\{(.*)\}\Z/$1/s;
-
- $self->{"startcode"} .= "$code;\n";
-}
-
-# CHECK FOR GRAMMAR PROBLEMS....
-
-sub _check_insatiable($$$$)
-{
- my ($subrule,$repspec,$grammar,$line) = @_;
- pos($grammar)=pos($_[2]);
- return if $grammar =~ m/$OPTIONAL/gco || $grammar =~ m/$ANY/gco;
- my $min = 1;
- if ( $grammar =~ m/$MANY/gco
- || $grammar =~ m/$EXACTLY/gco
- || $grammar =~ m/$ATMOST/gco
- || $grammar =~ m/$BETWEEN/gco && do { $min=$2; 1 }
- || $grammar =~ m/$ATLEAST/gco && do { $min=$2; 1 }
- || $grammar =~ m/$SUBRULE(?!\s*:)/gco
- )
- {
- return unless $1 eq $subrule && $min > 0;
- _warn(3,"Subrule sequence \"$subrule($repspec) $&\" will
- (almost certainly) fail.",$line)
- and
- _hint("Unless subrule \"$subrule\" performs some cunning
- lookahead, the repetition \"$subrule($repspec)\" will
- insatiably consume as many matches of \"$subrule\" as it
- can, leaving none to match the \"$&\" that follows.");
- }
-}
-
-sub _check_grammar ($)
-{
- my $self = shift;
- my $rules = $self->{"rules"};
- my $rule;
- foreach $rule ( values %$rules )
- {
- next if ! $rule->{"changed"};
-
- # CHECK FOR UNDEFINED RULES
-
- my $call;
- foreach $call ( @{$rule->{"calls"}} )
- {
- if (!defined ${$rules}{$call}
- &&!defined &{"Parse::RecDescent::$call"})
- {
- if (!defined $::RD_AUTOSTUB)
- {
- _warn(3,"Undefined (sub)rule \"$call\"
- used in a production.")
- and
- _hint("Will you be providing this rule
- later, or did you perhaps
- misspell \"$call\"? Otherwise
- it will be treated as an
- immediate <reject>.");
- eval "sub $self->{namespace}::$call {undef}";
- }
- else # EXPERIMENTAL
- {
- my $rule = $::RD_AUTOSTUB || qq{'$call'};
- _warn(1,"Autogenerating rule: $call")
- and
- _hint("A call was made to a subrule
- named \"$call\", but no such
- rule was specified. However,
- since \$::RD_AUTOSTUB
- was defined, a rule stub
- ($call : $rule) was
- automatically created.");
-
- $self->_generate("$call : $rule",0,1);
- }
- }
- }
-
- # CHECK FOR LEFT RECURSION
-
- if ($rule->isleftrec($rules))
- {
- _error("Rule \"$rule->{name}\" is left-recursive.");
- _hint("Redesign the grammar so it's not left-recursive.
- That will probably mean you need to re-implement
- repetitions using the '(s)' notation.
- For example: \"$rule->{name}(s)\".");
- next;
- }
- }
-}
-
-# GENERATE ACTUAL PARSER CODE
-
-sub _code($)
-{
- my $self = shift;
- my $code = qq{
-package $self->{namespace};
-use strict;
-use vars qw(\$skip \$AUTOLOAD $self->{localvars} );
-\$skip = '$skip';
-$self->{startcode}
-
-{
-local \$SIG{__WARN__} = sub {0};
-# PRETEND TO BE IN Parse::RecDescent NAMESPACE
-*$self->{namespace}::AUTOLOAD = sub
-{
- no strict 'refs';
- \$AUTOLOAD =~ s/^$self->{namespace}/Parse::RecDescent/;
- goto &{\$AUTOLOAD};
-}
-}
-
-};
- $code .= "push \@$self->{namespace}\::ISA, 'Parse::RecDescent';";
- $self->{"startcode"} = '';
-
- my $rule;
- foreach $rule ( values %{$self->{"rules"}} )
- {
- if ($rule->{"changed"})
- {
- $code .= $rule->code($self->{"namespace"},$self);
- $rule->{"changed"} = 0;
- }
- }
-
- return $code;
-}
-
-
-# EXECUTING A PARSE....
-
-sub AUTOLOAD # ($parser, $text; $linenum, @args)
-{
- croak "Could not find method: $AUTOLOAD\n" unless ref $_[0];
- my $class = ref($_[0]) || $_[0];
- my $text = ref($_[1]) ? ${$_[1]} : $_[1];
- $_[0]->{lastlinenum} = $_[2]||_linecount($_[1]);
- $_[0]->{lastlinenum} = _linecount($_[1]);
- $_[0]->{lastlinenum} += $_[2] if @_ > 2;
- $_[0]->{offsetlinenum} = $_[0]->{lastlinenum};
- $_[0]->{fulltext} = $text;
- $_[0]->{fulltextlen} = length $text;
- $_[0]->{deferred} = [];
- $_[0]->{errors} = [];
- my @args = @_[3..$#_];
- my $args = sub { [ @args ] };
-
- $AUTOLOAD =~ s/$class/$_[0]->{namespace}/;
- no strict "refs";
-
- croak "Unknown starting rule ($AUTOLOAD) called\n"
- unless defined &$AUTOLOAD;
- my $retval = &{$AUTOLOAD}($_[0],$text,undef,undef,$args);
-
- if (defined $retval)
- {
- foreach ( @{$_[0]->{deferred}} ) { &$_; }
- }
- else
- {
- foreach ( @{$_[0]->{errors}} ) { _error(@$_); }
- }
-
- if (ref $_[1]) { ${$_[1]} = $text }
-
- $ERRORS = 0;
- return $retval;
-}
-
-sub _parserepeat($$$$$$$$$$) # RETURNS A REF TO AN ARRAY OF MATCHES
-{
- my ($parser, $text, $prod, $min, $max, $_noactions, $expectation, $argcode) = @_;
- my @tokens = ();
-
- my $reps;
- for ($reps=0; $reps<$max;)
- {
- $_[6]->at($text); # $_[6] IS $expectation FROM CALLER
- my $_savetext = $text;
- my $prevtextlen = length $text;
- my $_tok;
- if (! defined ($_tok = &$prod($parser,$text,1,$_noactions,$argcode)))
- {
- $text = $_savetext;
- last;
- }
- push @tokens, $_tok if defined $_tok;
- last if ++$reps >= $min and $prevtextlen == length $text;
- }
-
- do { $_[6]->failed(); return undef} if $reps<$min;
-
- $_[1] = $text;
- return [@tokens];
-}
-
-
-# ERROR REPORTING....
-
-my $errortext;
-my $errorprefix;
-
-open (ERROR, ">&STDERR");
-format ERROR =
-@>>>>>>>>>>>>>>>>>>>>: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-$errorprefix, $errortext
-~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
- $errortext
-.
-
-select ERROR;
-$| = 1;
-
-# TRACING
-
-my $tracemsg;
-my $tracecontext;
-my $tracerulename;
-use vars '$tracelevel';
-
-open (TRACE, ">&STDERR");
-format TRACE =
-@>|@|||||||||@^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<|
-$tracelevel, $tracerulename, '|', $tracemsg
- | ~~ |^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<|
- $tracemsg
-.
-
-select TRACE;
-$| = 1;
-
-open (TRACECONTEXT, ">&STDERR");
-format TRACECONTEXT =
-@>|@|||||||||@ |^<<<<<<<<<<<<<<<<<<<<<<<<<<<
-$tracelevel, $tracerulename, '|', $tracecontext
- | ~~ | |^<<<<<<<<<<<<<<<<<<<<<<<<<<<
- $tracecontext
-.
-
-
-select TRACECONTEXT;
-$| = 1;
-
-select STDOUT;
-
-sub _verbosity($)
-{
- defined $::RD_TRACE
- or defined $::RD_HINT and $_[0] =~ /ERRORS|WARN|HINT/
- or defined $::RD_WARN and $_[0] =~ /ERRORS|WARN/
- or defined $::RD_ERRORS and $_[0] =~ /ERRORS/
-}
-
-sub _error($;$)
-{
- $ERRORS++;
- return 0 if ! _verbosity("ERRORS");
- $errortext = $_[0];
- $errorprefix = "ERROR" . ($_[1] ? " (line $_[1])" : "");
- $errortext =~ s/\s+/ /g;
- print ERROR "\n" if _verbosity("WARN");
- write ERROR;
- return 1;
-}
-
-sub _warn($$;$)
-{
- return 0 unless _verbosity("WARN") && ($::RD_HINT || $_[0] >= ($::RD_WARN||1));
- $errortext = $_[1];
- $errorprefix = "Warning" . ($_[2] ? " (line $_[2])" : "");
- print ERROR "\n";
- $errortext =~ s/\s+/ /g;
- write ERROR;
- return 1;
-}
-
-sub _hint($)
-{
- return 0 unless defined $::RD_HINT;
- $errortext = "$_[0])";
- $errorprefix = "(Hint";
- $errortext =~ s/\s+/ /g;
- write ERROR;
- return 1;
-}
-
-sub _tracemax($)
-{
- if (defined $::RD_TRACE
- && $::RD_TRACE =~ /\d+/
- && $::RD_TRACE>1
- && $::RD_TRACE+10<length($_[0]))
- {
- my $count = length($_[0]) - $::RD_TRACE;
- return substr($_[0],0,$::RD_TRACE/2)
- . "...<$count>..."
- . substr($_[0],-$::RD_TRACE/2);
- }
- else
- {
- return $_[0];
- }
-}
-
-sub _tracefirst($)
-{
- if (defined $::RD_TRACE
- && $::RD_TRACE =~ /\d+/
- && $::RD_TRACE>1
- && $::RD_TRACE+10<length($_[0]))
- {
- my $count = length($_[0]) - $::RD_TRACE;
- return substr($_[0],0,$::RD_TRACE) . "...<+$count>";
- }
- else
- {
- return $_[0];
- }
-}
-
-my $lastcontext = '';
-my $lastrulename = '';
-my $lastlevel = '';
-
-sub _trace($;$$$)
-{
- $tracemsg = $_[0];
- $tracecontext = $_[1]||$lastcontext;
- $tracerulename = $_[2]||$lastrulename;
- $tracelevel = $_[3]||$lastlevel;
- if ($tracerulename) { $lastrulename = $tracerulename }
- if ($tracelevel) { $lastlevel = $tracelevel }
-
- $tracecontext =~ s/\n/\\n/g;
- $tracecontext =~ s/\s+/ /g;
- $tracerulename = qq{$tracerulename};
- write TRACE;
- if ($tracecontext ne $lastcontext)
- {
- if ($tracecontext)
- {
- $lastcontext = _tracefirst($tracecontext);
- $tracecontext = qq{"$tracecontext"};
- }
- else
- {
- $tracecontext = qq{<NO TEXT LEFT>};
- }
- write TRACECONTEXT;
- }
-}
-
-sub _parseunneg($$$$)
-{
- _parse($_[0],$_[1],$_[3]);
- if ($_[2]<0)
- {
- _error("Can't negate \"$&\".",$_[3]);
- _hint("You can't negate $_[0]. Remove the \"...!\" before
- \"$&\".");
- return 0;
- }
- return 1;
-}
-
-sub _parse($$$;$)
-{
- my $what = $_[3] || $&;
- $what =~ s/^\s+//;
- if ($_[1])
- {
- _warn(3,"Found $_[0] ($what) after an unconditional <error>",$_[2])
- and
- _hint("An unconditional <error> always causes the
- production containing it to immediately fail.
- \u$_[0] that follows an <error>
- will never be reached. Did you mean to use
- <error?> instead?");
- }
-
- return if ! _verbosity("TRACE");
- $errortext = "Treating \"$what\" as $_[0]";
- $errorprefix = "Parse::RecDescent";
- $errortext =~ s/\s+/ /g;
- write ERROR;
-}
-
-sub _linecount($) {
- scalar substr($_[0], pos $_[0]||0) =~ tr/\n//
-}
-
-
-package main;
-
-use vars qw ( $RD_ERRORS $RD_WARN $RD_HINT $RD_TRACE $RD_CHECK );
-$::RD_CHECK = 1;
-$::RD_ERRORS = 1;
-$::RD_WARN = 3;
-
-1;
-
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff