Benchmark-Perl-Formance-Cargo
view release on metacpan or search on metacpan
share/P6STD/CursorBase.pmc view on Meta::CPAN
# Cursor Accessors
#############################################################
sub _PARAMS {} # overridden in parametric role packages
sub from :lvalue { $_[0]->{_from} //= $_[0]->{_pos} }
sub to { $_[0]->{_pos} }
sub pos :lvalue { $_[0]->{_pos} }
sub chars { $_[0]->{_pos} - ($_[0]->{_from} // $_[0]->{_pos}) }
sub Str { no warnings; exists $_[0]->{_from} && defined $_[0]->{_pos} ? substr($::ORIG, $_[0]->{_from}, $_[0]->{_pos} - $_[0]->{_from})//'' : '' }
sub xact { $_[0]->{_xact} // die "internal error: cursor has no xact!!!" }
sub orig { $::ORIG }
sub WHAT { ref $_[0] || $_[0] }
sub item { $_[0] }
sub caps { $_[0] && $_[0]->{'~CAPS'} ? @{$_[0]->{'~CAPS'}} : () }
sub chunks { die "unimpl" }
sub ast { exists $_[0]->{'_ast'} ? $_[0]->{'_ast'} : $_[0]->Str }
sub make { $_[0]->{'_ast'} = $_[1]; $_[0] }
sub label_id {
share/P6STD/CursorBase.pmc view on Meta::CPAN
sub to { my $self = shift;
$self->{_t};
}
}
#############################################################
# Cursor transformations
#############################################################
sub cursor_xact {
if (DEBUG & DEBUG::cursors) {
my $self = shift;
my $name = shift;
my $pedigree = '';
for (my $x = $self->{_xact}; $x; $x = $x->[-1]) {
my $n = $x->[0];
$n =~ s/^RULE // or
$n =~ s/^ALT *//;
$pedigree .= ($x->[-2] ? " - " : " + ") . $n;
}
$self->deb("cursor_xact $name$pedigree");
$self->{_xact} = [$name,0,$self->{_xact}];
return $self;
}
# doing this in place is slightly dangerous, but seems to work
$_[0]->{_xact} = [$_[1],0,$_[0]->{_xact}];
return $_[0];
}
sub cursor_fresh { my $self = shift;
my %r;
my $lang = @_ && $_[0] ? shift() : ref $self;
$self->deb("cursor_fresh lang $lang") if DEBUG & DEBUG::cursors;
@r{'_pos','_fate','_xact'} = @$self{'_pos','_fate','_xact'};
$r{_herelang} = $self->{_herelang} if $self->{_herelang};
bless \%r, ref $lang || $lang;
}
sub cursor_herelang { my $self = shift;
$self->deb("cursor_herelang") if DEBUG & DEBUG::cursors;
my %r = %$self;
$r{_herelang} = $self;
bless \%r, 'STD::Q';
}
sub prepbind {
my $self = shift;
delete $self->{_fate};
delete $_->{_xact} for @_;
$self;
}
sub cursor_bind { my $self = shift; # this is parent's match cursor
my $bindings = shift;
my $submatch = shift; # this is the submatch's cursor
$self->prepbind($submatch);
$self->deb("cursor_bind @$bindings") if DEBUG & DEBUG::cursors;
my @caps;
@caps = @{$self->{'~CAPS'}} if $self->{'~CAPS'}; # must copy elems
my %r = %$self;
if ($bindings) {
for my $binding (@$bindings) {
if (ref $r{$binding} eq 'ARRAY') {
push(@{$r{$binding}}, $submatch);
}
else {
$r{$binding} = $submatch;
}
next if $binding eq 'PRE';
next if $binding eq 'POST';
push @caps, $binding, $submatch;
}
$r{'~CAPS'} = \@caps;
}
$submatch->{_from} = $r{_from} = $r{_pos};
$r{_pos} = $submatch->{_pos};
$r{_xact} = $self->{_xact};
bless \%r, ref $self; # return new match cursor for parent
}
sub cursor_bind_value { my $self = shift; # this is parent's match cursor
my $binding = shift;
my $value = shift;
delete $self->{_fate};
$self->deb("cursor_bind_value $binding") if DEBUG & DEBUG::cursors;
my @caps;
@caps = @{$self->{'~CAPS'}} if $self->{'~CAPS'}; # must copy elems
my %r = %$self;
if (ref $r{$binding} eq 'ARRAY') {
push(@{$r{$binding}}, $value);
}
else {
$r{$binding} = $value;
}
push @caps, $binding, $value
unless $binding eq 'PRE' or $binding eq 'POST';
$r{'~CAPS'} = \@caps;
$r{_xact} = $self->{_xact};
bless \%r, ref $self; # return new match cursor for parent
}
sub cursor_fate { my $self = shift;
my $pkg = shift;
my $name = shift;
my $retree = shift;
# $_[0] is now ref to a $trystate;
$self->deb("cursor_fate $pkg $name") if DEBUG & DEBUG::cursors;
my $key = refaddr($retree->{$name}) // $name;
my $lexer = $::LEXERS{ref $self}->{$key} // do {
local %::AUTOLEXED;
$self->_AUTOLEXpeek($name,$retree);
};
if ($self->{_pos} >= $::HIGHWATER) {
if ($self->{_pos} > $::HIGHWATER) {
%$::HIGHEXPECT = ();
$::HIGHMESS = '';
}
$::HIGHEXPECT->{$lexer->{DBA}}++;
$::HIGHWATER = $self->{_pos};
}
my $P = $self->{_pos};
if ($P > @::ORIG) {
return sub {};
}
$self->cursor_fate_dfa($pkg, $name, $lexer, $P);
}
sub cursor_fate_dfa {
my ($self, $pkg, $name, $lexer, $P) = @_;
my $state = $lexer->{S};
my $p = $P;
my @rfates;
print ::LOG "=" x 10,"\n$p DFA for ${pkg}::$name in ", ref $self, "\n" if DEBUG & DEBUG::autolexer;
CH: {
push @rfates, @{ $state->[0] // _jit_dfa_node($lexer, $state) };
if (DEBUG & DEBUG::autolexer) {
share/P6STD/CursorBase.pmc view on Meta::CPAN
print ::LOG " -> ", $$dt->[1]{ID}, "\n" if DEBUG & DEBUG::autolexer;
$state = $state->[1]{$chi} = $$dt;
redo CH;
}
}
}
sub { @rfates ? pop(@rfates) : () };
}
sub cursor_all { my $self = shift;
my $fpos = shift;
my $tpos = shift;
$self->deb("cursor_all from $fpos to $tpos") if DEBUG & DEBUG::cursors;
my %r = %$self;
@r{'_from','_pos'} = ($fpos,$tpos);
bless \%r, ref $self;
}
sub makestr { my $self = shift;
$self->deb("maketext @_") if DEBUG & DEBUG::cursors;
my %r = @_;
bless \%r, "Str";
}
sub cursor_tweak { my $self = shift;
my $tpos = shift;
if (DEBUG & DEBUG::cursors) {
my $peek = substr($::ORIG,$tpos,20);
$peek =~ s/\n/\\n/g;
$peek =~ s/\t/\\t/g;
$self->deb("cursor to $tpos --------->$GREEN$peek$CLEAR");
}
$self->{_pos} = $tpos;
return () if $tpos > @::ORIG;
$self;
}
sub cursor_incr { my $self = shift;
my $tpos = $self->{_pos} + 1;
$self->panic("Unexpected EOF") if $tpos > length($::ORIG);
if (DEBUG & DEBUG::cursors) {
my $peek = substr($::ORIG,$tpos,20);
$peek =~ s/\n/\\n/g;
$peek =~ s/\t/\\t/g;
$self->deb("cursor to $tpos --------->$GREEN$peek$CLEAR");
}
$self->{_pos} = $tpos;
return () if $tpos > @::ORIG;
$self;
}
sub cursor { my $self = shift;
my $tpos = shift;
$self->panic("Unexpected EOF") if $tpos > length($::ORIG);
if (DEBUG & DEBUG::cursors) {
my $peek = substr($::ORIG,$tpos,20);
$peek =~ s/\n/\\n/g;
$peek =~ s/\t/\\t/g;
$self->deb("cursor to $tpos --------->$GREEN$peek$CLEAR");
}
my %r = %$self;
# $r{_from} = $self->{_pos} // 0;
$r{_pos} = $tpos;
bless \%r, ref $self;
}
sub cursor_force { my $self = shift;
my $tpos = shift;
$self->panic("Unexpected EOF") if $tpos > length($::ORIG);
if (DEBUG & DEBUG::cursors) {
my $peek = substr($::ORIG,$tpos,20);
$peek =~ s/\n/\\n/g;
$peek =~ s/\t/\\t/g;
$self->deb("cursor to $tpos --------->$GREEN$peek$CLEAR");
}
my %r = %$self;
# $r{_from} = $self->{_pos} // 0;
$r{_pos} = $::HIGHWATER = $tpos;
bless \%r, ref $self;
}
sub cursor_rev { my $self = shift;
my $fpos = shift;
if (DEBUG & DEBUG::cursors) {
my $peek = substr($::ORIG,$fpos,20);
$peek =~ s/\n/\\n/g;
$peek =~ s/\t/\\t/g;
$self->deb("cursor_ref to $fpos --------->$GREEN$peek$CLEAR");
}
my %r = %$self;
$r{_pos} = $fpos;
bless \%r, ref $self;
}
#############################################################
# Regex service routines
#############################################################
share/P6STD/CursorBase.pmc view on Meta::CPAN
$var->{_xact} = $xact;
$var->_REDUCE($S, $name)->retm();
}
sub _SCANf { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $eos = @::ORIG;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("SCANf $pos");
my $xact = $C->xact;
lazymap( sub { $self->cursor($_[0])->retm() }, LazyRange->new($xact, $pos,$eos) );
}
sub _SCANg { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $eos = @::ORIG;
my $C = $self->cursor_xact("SCANg $pos");
my $xact = $C->xact;
lazymap( sub { $C->cursor($_[0])->retm() }, LazyRangeRev->new($xact, $eos,$pos) );
}
sub _STARf { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("SCANf $pos");
my $xact = $C->xact;
lazymap(sub { $_[0]->retm() },
$C->cursor($pos),
LazyMap->new(sub { $C->_PLUSf($_[0]) }, $block));
}
sub _STARg { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("STARg $pos");
# my $xact = $C->xact;
lazymap(sub { $_[0]->retm() }, reverse
eager(
$C->cursor($self->{_pos}),
$C->_PLUSf($block))
);
}
sub _STARr { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $prev = $self->cursor_xact("STARr $pos");
# my $xact = $prev->xact;
my $prev_pos = $prev->{_pos} // 0;
my @all;
my $eos = @::ORIG;
for (;;) {
last if $prev->{_pos} == $eos;
my @matches = $block->($prev); # XXX shouldn't read whole list
# say @matches.perl;
last unless @matches;
my $first = $matches[0]; # no backtracking into block on ratchet
last if $first->{_pos} == $prev_pos;
$prev_pos = $first->{_pos};
push @all, $first;
$prev = $first;
}
$self->cursor($prev_pos)->retm();
}
sub _PLUSf { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $x = $self->cursor_xact("PLUSf $pos");
my $xact = $x->xact;
# don't go beyond end of string
return () if $self->{_pos} == @::ORIG;
lazymap(
sub {
my $x = $_[0];
lazymap(
sub {
$self->cursor($_[0]->{_pos})->retm()
}, $x, LazyMap->new(sub { $x->_PLUSf($_[0]) }, $block)
);
}, $block->($self)
);
}
sub _PLUSg { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("PLUSg $pos");
# my $xact = $C->xact;
reverse eager($C->_PLUSf($block, @_));
}
sub _PLUSr { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my @all;
my $eos = @::ORIG;
my $pos = $self->{_pos};
my $to = $self->cursor_xact("PLUSr $pos");
# my $xact = $to->xact;
for (;;) {
last if $to->{_pos} == $eos;
my @matches = $block->($to); # XXX shouldn't read whole list
last unless @matches;
my $first = $matches[0]; # no backtracking into block on ratchet
#$first->deb($matches->perl) if DEBUG;
push @all, $first;
$to = $first;
}
return () unless @all;
$self->cursor($to->{_pos})->retm();
}
sub _REPSEPf { my $self = shift;
my $sep = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my @result;
# don't go beyond end of string
return () if $self->{_pos} == @::ORIG;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("REPSEPf $pos");
# my $xact = $C->xact;
do {
for my $x ($block->($C)) {
for my $s ($sep->($x)) {
push @result, lazymap(sub { $C->cursor($_[0]->{_pos}) }, $x, $s->_REPSEPf($sep,$block));
}
}
};
lazymap(sub { $_[0]->retm() }, @result);
}
sub _REPSEPg { my $self = shift;
my $sep = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("REPSEPg $pos");
# my $xact = $C->xact;
reverse eager($C->_REPSEPf($sep, $block, @_));
}
sub _REPSEPr { my $self = shift;
my $sep = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my @all;
my $eos = @::ORIG;
my $pos = $self->{_pos};
my $to = $self->cursor_xact("REPSEPr $pos");
# my $xact = $C->xact;
for (;;) {
last if $to->{_pos} == $eos;
my @matches = $block->($to); # XXX shouldn't read whole list
last unless @matches;
my $first = $matches[0]; # no backtracking into block on ratchet
#$first->deb($matches->perl) if DEBUG;
push @all, $first;
my @seps = $sep->($first);
last unless @seps;
my $sep = $seps[0];
$to = $sep;
}
return () unless @all;
$self->cursor($all[-1]->{_pos})->retm;
}
sub _OPTr { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("OPTr $pos");
my $xact = $C->xact;
my $x = ($block->($C))[0];
my $r = $x // $C->cursor_tweak($pos);
$r->{_xact} = $self->{_xact};
$r->retm();
}
sub _OPTg { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("OPTg $pos");
# my $xact = $C->xact;
my @x = $block->($C);
lazymap(sub { $_[0]->retm() },
$block->($C),
$self->cursor($pos));
}
sub _OPTf { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $pos = $self->{_pos};
my $C = $self->cursor_xact("OPTf $pos");
# my $xact = $C->xact;
lazymap(sub { $_[0]->retm() },
$C->cursor($C->{_pos}),
$block->($self));
}
sub _BRACKET { my $self = shift;
my $block = shift;
no warnings 'recursion';
my $oldlang = ref($self);
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
lazymap(sub { bless($_[0],$oldlang)->retm() },
share/P6STD/CursorBase.pmc view on Meta::CPAN
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
local $::HIGHEXPECT = {}; # don't count lookahead as expectation
local $::HIGHWATER = $::HIGHWATER;
my @caps;
@caps = @{$self->{'~CAPS'}} if $self->{'~CAPS'}; # must copy elems
my @all = $block->($self);
return () if @all;
$self->{'~CAPS'} = \@caps;
return $self->cursor($self->{_pos})->retm();
}
sub _NOTCHAR { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my @all = $block->($self);
return () if @all;
return $self->cursor($self->{_pos}+1)->retm();
}
sub before { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
local $::HIGHEXPECT = {}; # don't count lookahead as expectation
local $::HIGHWATER = $::HIGHWATER;
my @caps;
@caps = @{$self->{'~CAPS'}} if $self->{'~CAPS'}; # must copy elems
my @all = $block->($self);
if (@all and $all[0]) {
$all[0]->{'~CAPS'} = \@caps;
if ($self->{_ast}) {
$all[0]->{'_ast'} = $self->{_ast};
}
else {
delete $all[0]->{'_ast'};
}
return $all[0]->cursor_all(($self->{_pos}) x 2)->retm();
}
return ();
}
sub suppose { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
local $::FATALS = 0;
share/P6STD/CursorBase.pmc view on Meta::CPAN
};
lazymap( sub { $_[0]->retm() }, @all );
}
sub after { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
local $::HIGHEXPECT = {}; # don't count lookbehind as expectation
my $end = $self->cursor($self->{_pos});
my @caps;
@caps = @{$self->{'~CAPS'}} if $self->{'~CAPS'}; # must copy elems
my @all = $block->($end); # Make sure $_->{_from} == $_->{_pos}
if (@all and $all[0]) {
$all[0]->{'~CAPS'} = \@caps;
if ($self->{_ast}) {
$all[0]->{'_ast'} = $self->{_ast};
}
else {
delete $all[0]->{'_ast'};
}
return $all[0]->cursor_all(($self->{_pos}) x 2)->retm();
}
return ();
}
sub null { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
return $self->cursor($self->{_pos})->retm();
}
sub ws__PEEK { ''; }
sub ws {
my $self = shift;
local $CTX = $self->callm() if DEBUG & DEBUG::trace_call;
my @stub = return $self if exists $::MEMOS[$self->{_pos}]{ws};
my $S = $self->{_pos};
my $C = $self->cursor_xact("RULE ws $S");
# my $xact = $C->xact;
$::MEMOS[$S]{ws} = undef; # exists means we know, undef means no ws before here
$self->_MATCHIFY($S, 'ws',
$C->_BRACKET( sub { my $C=shift;
do { my @gather;
push @gather, (map { my $C=$_;
(map { my $C=$_;
(map { my $C=$_;
share/P6STD/CursorBase.pmc view on Meta::CPAN
);
}
sub _ASSERT { my $self = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my @all = $block->($self);
if ((@all and $all[0]->{_bool})) {
return $self->cursor($self->{_pos})->retm();
}
return ();
}
sub _BINDVAR { my $self = shift;
my $var = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
share/P6STD/CursorBase.pmc view on Meta::CPAN
$block->($self));
}
sub _SUBSUME { my $self = shift;
my $names = shift;
my $block = shift;
no warnings 'recursion';
no warnings 'recursion';
local $CTX = $self->callm($names ? "@$names" : "") if DEBUG & DEBUG::trace_call;
lazymap(sub { $self->cursor_bind($names, $_[0])->retm() },
$block->($self->cursor_fresh()));
}
sub _SUBSUMEr { my $self = shift;
my $names = shift;
my $block = shift;
no warnings 'recursion';
no warnings 'recursion';
local $CTX = $self->callm($names ? "@$names" : "") if DEBUG & DEBUG::trace_call;
my ($var) = $block->($self->cursor_fresh()) or return ();
$self->cursor_bind($names, $var)->retm();
}
sub _SUBSUMEblock { my $self = shift;
my $name = shift;
my $block = shift;
no warnings 'recursion';
local $CTX = $self->callm($name) if DEBUG & DEBUG::trace_call;
$self->cursor_bind_value($name, $block->($self))->retm();
}
sub _EXACT_rev { my $self = shift;
my $s = shift() // '';
my @ints = unpack("U*", $s);
local $CTX = $self->callm($s) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
while (@ints) {
return () unless ($::ORIG[--$P]//-1) == pop @ints;
}
return $self->cursor($P)->retm();
}
sub _EXACT { my $self = shift;
my $s = shift() // '';
my @ints = unpack("U*", $s);
local $CTX = $self->callm($s) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
while (@ints) {
return () unless ($::ORIG[$P++]//-1) == shift @ints;
}
return $self->cursor($P)->retm();
# if (substr($::ORIG, $P, $len) eq $s) {
# $self->deb("EXACT $s matched @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
# my $r = $self->cursor($P+$len);
# $r->retm();
# }
# else {
# $self->deb("EXACT $s didn't match @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
# return ();
# }
}
sub _PATTERN { my $self = shift;
my $qr = shift;
local $CTX = $self->callm($qr) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
pos($::ORIG) = $P;
if ($::ORIG =~ /$qr/gc) {
my $len = pos($::ORIG) - $P;
$self->deb("PATTERN $qr matched @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
my $r = $self->cursor($P+$len);
$r->retm();
}
else {
$self->deb("PATTERN $qr didn't match at $P") if DEBUG & DEBUG::matchers;
return ();
}
}
sub _BACKREFn { my $self = shift;
my $n = shift;
local $CTX = $self->callm($n) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
my $s = $self->{$n}->Str;
my $len = length($s);
if (substr($::ORIG, $P, $len) eq $s) {
$self->deb("EXACT $s matched @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
my $r = $self->cursor($P+$len);
$r->retm();
}
else {
$self->deb("EXACT $s didn't match @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
return ();
}
}
sub _SYM { my $self = shift;
my $s = shift;
share/P6STD/CursorBase.pmc view on Meta::CPAN
$s = $s->[0] if ref $s eq 'ARRAY';
local $CTX = $self->callm($s) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
my $len = length($s);
if ($i
? lc substr($::ORIG, $P, $len) eq lc $s
: substr($::ORIG, $P, $len) eq $s
) {
$self->deb("SYM $s matched @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
my $r = $self->cursor($P+$len);
$r->{sym} = $s;
$r->retm();
}
else {
$self->deb("SYM $s didn't match @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
return ();
}
}
#sub _EXACT_rev { my $self = shift;
# my $s = shift;
#
# local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
# my $len = length($s);
# my $from = $self->{_pos} - $len;
# if ($from >= 0 and substr($::ORIG, $from, $len) eq $s) {
# my $r = $self->cursor_rev($from);
# $r->retm();
# }
# else {
## say "EXACT_rev $s didn't match @{[substr($!orig,$from,$len)]} at $from $len";
# return ();
# }
#}
sub _ARRAY { my $self = shift;
local $CTX = $self->callm(0+@_) if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos} // 0;
my @array = sort { length($b) <=> length($a) } @_; # XXX suboptimal
my @result = ();
for my $s (@array) {
my $len = length($s);
if (substr($::ORIG, $P, $len) eq $s) {
$self->deb("ARRAY elem $s matched @{[substr($::ORIG,$P,$len)]} at $P $len") if DEBUG & DEBUG::matchers;
my $r = $self->cursor($P+$len);
push @result, $r->retm('');
}
}
return @result;
}
sub _ARRAY_rev { my $self = shift;
local $CTX = $self->callm(0+@_) if DEBUG & DEBUG::trace_call;
my @array = sort { length($b) <=> length($a) } @_; # XXX suboptimal
my @result = ();
for my $s (@array) {
my $len = length($s);
my $from = $self->{_pos} = $len;
if (substr($::ORIG, $from, $len) eq $s) {
$self->deb("ARRAY_rev elem $s matched @{[substr($::ORIG,$from,$len)]} at $from $len") if DEBUG & DEBUG::matchers;
my $r = $self->cursor_rev($from);
push @result, $r->retm('');
}
}
return @result;
}
sub _DIGIT { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /^\d$/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "DIGIT didn't match $char at $P";
return ();
}
}
sub _DIGIT_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "DIGIT_rev didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^\d$/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "DIGIT_rev didn't match $char at $from";
return ();
}
}
sub ww { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
return () unless $P;
my $chars = substr($::ORIG, $P-1, 2);
if ($chars =~ /^\w\w$/) {
my $r = $self->cursor($P);
return $r->retm();
}
else {
# say "ww didn't match $chars at $P";
return ();
}
}
sub _ALNUM { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /^\w$/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "ALNUM didn't match $char at $P";
return ();
}
}
sub _ALNUM_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "ALNUM_rev didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^\w$/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "ALNUM_rev didn't match $char at $from";
return ();
}
}
my $alpha;
BEGIN {
share/P6STD/CursorBase.pmc view on Meta::CPAN
vec($alpha,$ch,1) = 1 if $char =~ /\w/ and $char !~ /\d/;
}
}
sub alpha { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
# my $char = substr($::ORIG, $P, 1);
my $ch = $::ORIG[$P];
if (vec($alpha,$ch,1) or ($ch > 255 and chr($ch) =~ /\pL/)) {
# if ($char =~ /^[_[:alpha:]\pL]$/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "alpha didn't match $char at $P";
return ();
}
}
sub alpha_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^[_[:alpha:]\pL]$/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
return ();
}
}
sub _SPACE { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /^\s$/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "SPACE didn't match $char at $P";
return ();
}
}
sub _SPACE_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "SPACE_rev didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^\s$/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "SPACE_rev didn't match $char at $from";
return ();
}
}
sub _HSPACE { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /^[ \t\r]$/ or ($char =~ /^\s$/ and $char !~ /^[\n\f\0x0b\x{2028}\x{2029}]$/)) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "HSPACE didn't match $char at $P";
return ();
}
}
sub _HSPACE_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "HSPACE_rev didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^[ \t\r]$/ or ($char =~ /^\s$/ and $char !~ /^[\n\f\0x0b\x{2028}\x{2029}]$/)) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "HSPACE_rev didn't match $char at $from";
return ();
}
}
sub _VSPACE { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /^[\n\f\x0b\x{2028}\x{2029}]$/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "VSPACE didn't match $char at $P";
return ();
}
}
sub _VSPACE_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "VSPACE_rev didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /^[\n\f\x0b\x{2028}\x{2029}]$/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "VSPACE_rev didn't match $char at $from";
return ();
}
}
sub _CCLASS { my $self = shift;
my $cc = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
my $char = substr($::ORIG, $P, 1);
if ($char =~ /$cc/) {
my $r = $self->cursor($P+1);
return $r->retm();
}
else {
# say "CCLASS didn't match $char at $P";
return ();
}
}
sub _CCLASS_rev { my $self = shift;
my $cc = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
# say "CCLASS didn't match $char at $from";
return ();
}
my $char = substr($::ORIG, $from, 1);
if ($char =~ /$cc/) {
my $r = $self->cursor_rev($from);
return $r->retm();
}
else {
# say "CCLASS didn't match $char at $from";
return ();
}
}
sub _ANY { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
if ($P < @::ORIG) {
$self->cursor($P+1)->retm();
}
else {
# say "ANY didn't match anything at $P";
return ();
}
}
sub _ANY_rev { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $from = $self->{_pos} - 1;
if ($from < 0) {
return ();
}
return $self->cursor_rev($from)->retm();
}
sub _BOS { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
if ($P == 0) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _BOS_rev { $_[0]->_BOS }
sub _BOL { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
if ($P == 0 or substr($::ORIG, $P-1, 1) =~ /^[\n\f\x0b\x{2028}\x{2029}]$/) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _BOL_rev { $_[0]->_BOL }
sub _EOS { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
if ($P == @::ORIG) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _EOS_rev { $_[0]->_EOS }
sub _EOL { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
if ($P == @::ORIG or substr($::ORIG, $P, 1) =~ /^(?:\r\n|[\n\f\x0b\x{2028}\x{2029}])$/) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _EOL_rev { $_[0]->_EOL }
sub _RIGHTWB { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
pos($::ORIG) = $P - 1;
if ($::ORIG =~ /\w\b/) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _RIGHTWB_rev { $_[0]->_RIGHTWB }
sub _LEFTWB { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
pos($::ORIG) = $P;
if ($::ORIG =~ /\b(?=\w)/) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _LEFTWB_rev { $_[0]->_LEFTWB }
sub _LEFTRESULT { my $self = shift;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
pos($::ORIG) = $P;
if ($::ORIG =~ /\b(?=\w)/) {
$self->cursor($P)->retm();
}
else {
return ();
}
}
sub _LEFTRESULT_rev { $_[0]->_LEFTWB }
sub _REDUCE { my $self = shift;
my $S = shift;
my $meth = shift;
share/P6STD/CursorBase.pmc view on Meta::CPAN
}
sub _COMMITBRANCH { my $self = shift;
my $xact = $self->xact;
# $self->{LAST} = shift() if @_;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
while ($xact) {
$xact->[-2] = 1;
$self->deb("Commit $$xact[0] to $P") if DEBUG & DEBUG::matchers;
return $self->cursor_xact("CB") if $xact->[0] =~ /^ALT/;
$xact = $xact->[-1];
}
die "Not in an alternation, so can't commit to a branch";
}
sub _COMMITLTM { my $self = shift;
my $xact = $self->xact;
# $self->{LAST} = shift() if @_;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
while ($xact) {
$xact->[-2] = 1;
$self->deb("Commit $$xact[0] to $P") if DEBUG & DEBUG::matchers;
return $self->cursor_xact("CL") if $xact->[0] =~ /^ALTLTM/;
$xact = $xact->[-1];
}
die "Not in a longest token matcher, so can't commit to a longest token";
}
sub _COMMITRULE { my $self = shift;
my $xact = $self->xact;
# $self->{LAST} = shift() if @_;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
while ($xact) {
$xact->[-2] = 1;
$self->deb("Commit $$xact[0] to $P") if DEBUG & DEBUG::matchers;
return $self->cursor_xact("CR") if $xact->[0] =~ /^RULE/;
$xact = $xact->[-1];
}
die "Not in a rule, so can't commit to rule";
}
sub commit { my $self = shift;
my $xact = $self->xact;
# $self->{LAST} = shift() if @_;
local $CTX = $self->callm if DEBUG & DEBUG::trace_call;
my $P = $self->{_pos};
while ($xact) {
$xact->[-2] = 1;
$self->deb("Commit $$xact[0] to $P") if DEBUG & DEBUG::matchers;
return $self->cursor_xact("CM") if $xact->[0] =~ /^MATCH/;
$xact = $xact->[-1];
}
die "Not in a match, so can't commit to match";
}
sub fail { my $self = shift;
my $m = shift;
return ();
}
share/P6STD/CursorBase.pmc view on Meta::CPAN
+{ map { $_->name, 1 } ($lang->meta, $lang->meta->calculate_all_roles) }
};
# It doesn't make sense to float a lexer above Cursor, or (for 'has'
# regexes), the class of definition.
if ($ar->{$dic}) {
$self->deb("\tcannot reuse $key; at top") if DEBUG & DEBUG::autolexer;
last;
}
my $supercursor = $self->cursor_fresh($super);
my $superlexer = eval {
local %::AUTOLEXED;
$supercursor->_AUTOLEXpeek($key, $retree)
};
if (!$superlexer) {
$self->deb("\tcannot reuse $key; failed ($@)") if DEBUG & DEBUG::autolexer;
last;
}
my $ml = _scan_regexes($lang, 'ALL');
for my $meth (@$ml) {
share/P6STD/CursorBase.pmc view on Meta::CPAN
no strict 'refs';
if (not exists &{$NEWWHAT.'::meta'}) { # never composed this one yet?
# fake up mixin with MI, being sure to put "roles" in front
my $eval = "package $NEWWHAT; use Moose ':all' => { -prefix => 'moose_' }; moose_extends('$WHAT'); moose_with(" . join(',', map {"'$_'"} @newmix) . ");our \$CATEGORY = '.';\n";
$self->deb($eval) if DEBUG & DEBUG::mixins;
local $SIG{__WARN__} = sub { die $_[0] unless $_[0] =~ /^Deep recursion/ };
eval $eval;
warn $@ if $@;
}
return $self->cursor_fresh($NEWWHAT);
}
sub tweak {
my $self = shift;
my $class = ref $self;
no strict 'refs';
for (;;) {
my $retval = eval {
$self->deb("Calling $class" . '::multitweak') if DEBUG & DEBUG::mixins;
&{$class . '::multitweak'}($self,@_);
share/P6STD/CursorBase.pmc view on Meta::CPAN
sub $mangle {
my \$self = shift;
local \$CTX = \$self->callm() if \$::DEBUG & DEBUG::trace_call;
my %args = \@_;
my \$sym = \$args{sym} // $sym;
my \$xact = ['RULE $mangle', 0, \$::XACT];
local \$::XACT = \$xact;
my \$S = \$self->{_pos};
my \$C = \$self->cursor_xact("RULE $mangle \$S");
# my \$xact = \$C->xact;
\$C->{'sym'} = \$sym;
\$self->_MATCHIFY(\$S, '$mangle',
do {
if (my (\$C) = (\$C->_SYM(\$sym, 0))) {
\$C->_SUBSUMEr(['O'], sub {
my \$C = shift;
\$C->O(%STD::$coercion)
share/P6STD/CursorBase.pmc view on Meta::CPAN
sub ${mangle}__PEEK { \$_[0]->_AUTOLEXpeek('$mangle',\$retree) }
sub $mangle {
no warnings 'recursion';
my \$self = shift;
local \$::CTX = \$self->callm() if \$::DEBUG & DEBUG::trace_call;
my %args = \@_;
local \$::sym = \$args{sym} // $sym;
return () if \$::GOAL eq $starter;
my \$C = \$self->cursor_xact("RULE $mangle");
my \$xact = \$C->xact;
my \$S = \$C->{'_pos'};
\$C->{'sym'} = ref \$sym ? join(' ', \@\$sym) : \$sym;
\$self->_MATCHIFYr(\$S, "$mangle",
do {
if (my (\$C) = (\$C->_EXACT($starter))) {
do {
if (my (\$C) = (((local \$::GOAL = $stopper , my \$goalpos = \$C), \$C->unbalanced($stopper))[-1])) {
do {
if (my (\$C) = (\$C->_SUBSUMEr(['semilist'], sub {
my \$C = shift;
\$C->semilist
}))) {
do {
if (my (\$C) = (\$C->_BRACKETr(sub {
my \$C=shift;
do {
my \$C = \$C->cursor_xact('ALT ||');
my \$xact = \$C->xact;
my \@gather;
do {
push \@gather, \$C->_EXACT($stopper)
}
or \$xact->[-2] or
do {
push \@gather, \$C->FAILGOAL($stopper , '$category expression',\$goalpos)};
\@gather;
}
share/P6STD/CursorBase.pmc view on Meta::CPAN
}
}
);
}
1;
END
}
$lang->deb("derive $genpkg from $WHAT adding $mangle") if DEBUG & DEBUG::mixins;
eval $e or die "Cannot create $name: $@\n";
$::LANG{'MAIN'} = $lang->cursor_fresh($genpkg);
}
$lang;
}
sub add_enum { my $self = shift;
my $type = shift;
my $expr = shift;
return unless $type;
return unless $expr;
my $typename = $type->Str;
share/P6STD/DEBUG.pmc view on Meta::CPAN
package DEBUG;
our @EXPORTS = qw(
autolexer
symtab
fixed_length
fates
longest_token_pattern_generation
EXPR
matchers
trace_call
cursors
try_processing
mixins
callm_show_subnames
use_color
);
use constant {
autolexer => 1,
symtab => 2,
fixed_length => 4,
fates => 8,
longest_token_pattern_generation => 16,
EXPR => 32,
matchers => 64,
trace_call=> 128,
cursors => 256,
try_processing => 1024,
mixins => 2048,
callm_show_subnames => 16384,
use_color => 32768
};
share/P6STD/LazyMap.pm view on Meta::CPAN
# B: the function to call to transform each incoming value; it is called in
# list context and it should return multiple values to create a choice
# point. It can also return a lazy list, which is treated as a lazy
# choice point.
# C: The values which were generated by the last block call, if it returned
# >1 (since iter only removes one at a time, but they don't arrive that way)
# L: The values input to the map which have not yet been fed to the block
# N: Number of values so far returned - this is used to ignore cuts if we
# haven't delivered our first value yet (somewhat of a hack).
#
# Values returned by a LazyMap are expected to be cursors, or at least have
# an _xact field that can be checked for cutness.
# Construct a lazymap - block, then a list of inputs (concatenated if lazies)
sub new {
my $class = shift;
my $block = shift;
return bless { 'B' => $block, 'C' => [], 'L' => [@_], 'N' => 0 }, $class;
}
# The fundamental operation on lazies, sometimes spelled concatMap. In list
share/P6STD/LazyMap.pm view on Meta::CPAN
while (@$called and ref($$called[0]) =~ /^Lazy/) {
my $really = $$called[0]->iter;
if ($really) {
unshift @$called, $really;
}
else {
shift @$called;
}
}
# finally have at least one real cursor, grep for first with live transaction
while (@$called and ref($$called[0]) !~ /^Lazy/) {
my $candidate = shift @$called;
# make sure its transaction doesn't have a prior commitment
my $xact = $candidate->{_xact};
my $n = $self->{N}++;
return $candidate unless $xact->[-2] and $n;
}
}
return ();
}
share/P6STD/STD.pm6 view on Meta::CPAN
for disambiguating the name. However, if no $sym is set, the original
symbol will be used by default.
This grammar relies on transitive longest-token semantics.
=end notes
method p6class () { ::STD::P6 }
method TOP ($STOP = '') {
my $lang = self.cursor_fresh( self.p6class );
if $STOP {
my $*GOAL ::= $STOP;
$lang.unitstop($STOP).comp_unit;
}
else {
$lang.comp_unit;
}
}
share/P6STD/STD.pm6 view on Meta::CPAN
]
}
proto token backslash {*}
proto token escape {*}
token starter { <!> }
token escape:none { <!> }
# and this is what makes nibbler polymorphic...
method nibble ($lang) {
self.cursor_fresh($lang).nibbler;
}
# note: polymorphic over many quote languages, we hope
token nibbler {
:my $text = '';
:my $from = self.pos;
:my $to = $from;
:my @nibbles = ();
:my $multiline = 0;
{ $.from = self.pos; }
share/P6STD/STD.pm6 view on Meta::CPAN
my $lang = $herestub.lang.mixin( ::herestop );
my $doc;
if ($doc) = $here.nibble($lang) {
$here = $doc.trim_heredoc();
$herestub.orignode<doc> = $doc;
}
else {
self.panic("Ending delimiter $*DELIM not found");
}
}
return self.cursor($here.pos); # return to initial type
}
token quibble ($l) {
:my ($lang, $start, $stop);
<babble($l)>
{ my $B = $<babble><B>; ($lang,$start,$stop) = @$B; }
$start <nibble($lang)> [ $stop || <.panic: "Couldn't find terminator $stop"> ]
{
share/P6STD/STD.pm6 view on Meta::CPAN
[
|| <.unsp>? <?before '('> <circumfix> { $value = $<circumfix>; }
|| { $value = 1; }
]
| $<n>=(\d+) $<id>=(<[a..z]>+) [ <?before '('> <.sorry: "2nd argument not allowed on pair"> <circumfix> ]?
{ $key = $<id>.Str; $value = $<n>.Str; }
]
$<k> = {$key} $<v> = {$value}
}
token quote:sym<｢ ｣> { :dba('perfect quotes') "｢" ~ "｣" <nibble($¢.cursor_fresh( %*LANG<Q> ).unbalanced("｣"))> }
token quote:sym<' '> { :dba('single quotes') "'" ~ "'" <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q).unbalanced("'"))> }
token quote:sym<" "> { :dba('double quotes') '"' ~ '"' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).unbalanced('"'))> }
token circumfix:sym<« »> { :dba('shell-quote words') '«' ~ '»' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(:ww).balanced('«','»'))> }
token circumfix:sym«<< >>» { :dba('shell-quote words') '<<' ~ '>>' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(:ww).balanced('<<','>>'))> }
token circumfix:sym«< >» { :dba('quote words') '<' ~ '>'
[
[ <?before 'STDIN>' > <.obs('<STDIN>', '$' ~ '*IN.lines (or add whitespace to suppress warning)')> ]? # XXX fake out gimme5
[ <?before '>' > <.obs('<>', "lines() to read input,\n or ('') to represent the null string,\n or () to represent Nil")> ]?
<nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q).tweak(:w).balanced('<','>'))>
]
}
##################
# Lexer routines #
##################
token ws {
:temp $*STUB = return self if @*MEMOS[self.pos]<ws> :exists;
:my $startpos = self.pos;
share/P6STD/STD.pm6 view on Meta::CPAN
:dba('horizontal whitespace')
[
| \h+
| <?before \h* '=' [ \w | '\\'] > ^^ <.pod_comment>
| \h* <comment>
]+
}
token comment:sym<#`(...)> {
'#`' :: [ <?opener> || <.panic: "Opening bracket is required for #` comment"> ]
<.quibble($¢.cursor_fresh( %*LANG<Q> ))>
}
token comment:sym<#(...)> {
'#' <?opener>
<.suppose
<quibble($¢.cursor_fresh( %*LANG<Q> ))>
<!before <[,;:]>* \h* [ '#' | $$ ] > # extra stuff on line after closer?
>
<.worry: "Embedded comment seems to be missing backtick"> <!>
}
token comment:sym<#=(...)> {
'#=' <?opener> ::
<quibble($¢.cursor_fresh( %*LANG<Q> ))>
}
token comment:sym<#=> {
'#=' :: $<attachment> = [\N*]
}
token comment:sym<#> {
'#' {} \N*
}
share/P6STD/STD.pm6 view on Meta::CPAN
my $id = 'MY:file<' ~ $*FILE<name> ~ '>';
$*CURLEX = Stash.new(
'OUTER::' => [$oid],
'!file' => $*FILE, '!line' => 0,
'!id' => [$id],
);
$ALL.{$id} = $*CURLEX;
$*UNIT = $*CURLEX;
$ALL.<UNIT> = $*UNIT;
self.finishlex;
# $¢ = self.cursor_fresh($*CURLEX<$?LANGNAME>);
}
<.unitstart>
<statementlist>
[ <?unitstopper> || <.panic: "Confused"> ]
# "CHECK" time...
$<LEX> = { $*CURLEX }
{
$¢.explain_mystery();
if @*WORRIES {
note "Potential difficulties:\n " ~ join( "\n ", @*WORRIES) ~ "\n";
share/P6STD/STD.pm6 view on Meta::CPAN
# this is a hook for subclasses
token unitstart { <?> }
token lambda { '->' | '<->' }
# Look for an expression followed by a required lambda.
token xblock {
:my $*GOAL ::= '{';
:my $*BORG = {};
<.ws> # XXX
<EXPR>
{ $*BORG.<culprit> //= $<EXPR>.cursor(self.pos) }
<.ws>
<pblock>
}
token block () {
:temp $*CURLEX;
:dba('scoped block')
[ <?before '{' > || <.panic: "Missing block"> ]
<.newlex>
<blockoid>
share/P6STD/STD.pm6 view on Meta::CPAN
my $kv = $<quotepair>[*-1];
$lang = ($lang.tweak(|($kv.<k>.Str => $kv.<v>))
or $lang.panic("Unrecognized adverb :" ~ $kv.<k> ~ '(' ~ $kv.<v> ~ ')'));
}
]*
[
| '{*}' <?{ $*MULTINESS eq 'proto' }> $<onlystar> = {1}
| [
'{'
<nibble( $¢.cursor_fresh($lang).unbalanced('}') )>
[ '}' || <.panic: "Unable to parse regex; couldn't find right brace"> ]
]
]
<.curlycheck(1)>
}
# statement semantics
rule statementlist {
:my $*INVOCANT_OK = 0;
share/P6STD/STD.pm6 view on Meta::CPAN
|| $
|| <?stopper>
|| <?before <.suppose <statement_control> > > <.backup_ws> { $*HIGHWATER = -1; } <.panic: "Missing semicolon">
|| <.panic: "Confused">
]
}
# undo any line transition
method backup_ws () {
if @*MEMOS[self.pos]<ws> {
return self.cursor(@*MEMOS[self.pos]<ws>);
}
return self;
}
#####################
# statement control #
#####################
rule statement_control:need {
:my $longname;
share/P6STD/STD.pm6 view on Meta::CPAN
|| <?{ $start eq '{' }> [ :lang($lang) <block> ]
|| [ :lang($lang) <starter> <statementlist> [ <stopper> || <.panic: "Couldn't find terminator $stop"> ] ]
]
}
token quote:sym<//> {
'/'\s*'/' <.sorry: "Null regex not allowed">
}
token quote:sym</ /> {
'/' <nibble( $¢.cursor_fresh( %*LANG<Regex> ).unbalanced("/") )> [ '/' || <.panic: "Unable to parse regex; couldn't find final '/'"> ]
<.old_rx_mods>?
}
# handle composite forms like qww
token quote:qq {
:my $qm;
'qq'
[
| <quote_mod> » <!before '('> { $qm = $<quote_mod>.Str } <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(|($qm => 1)))>
| » <!before '('> <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq))>
]
}
token quote:q {
:my $qm;
'q'
[
| <quote_mod> » <!before '('> { $qm = $<quote_mod>.Str } <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q).tweak(|($qm => 1)))>
| » <!before '('> <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q))>
]
}
token quote:Q {
:my $qm;
'Q'
[
| <quote_mod> » <!before '('> { $qm = $<quote_mod>.Str } <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(|($qm => 1)))>
| » <!before '('> <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ))>
]
}
token quote_mod:w { <sym> }
token quote_mod:ww { <sym> }
token quote_mod:p { <sym> }
token quote_mod:x { <sym> }
token quote_mod:to { <sym> }
token quote_mod:s { <sym> }
token quote_mod:a { <sym> }
token quote_mod:h { <sym> }
token quote_mod:f { <sym> }
token quote_mod:c { <sym> }
token quote_mod:b { <sym> }
token quote:rx {
<sym> » <!before '('>
<quibble( $¢.cursor_fresh( %*LANG<Regex> ) )>
<!old_rx_mods>
}
token quote:m {
<sym> » <!before '('>
<quibble( $¢.cursor_fresh( %*LANG<Regex> ) )>
<!old_rx_mods>
}
token quote:ms {
<sym> » <!before '('>
<quibble( $¢.cursor_fresh( %*LANG<Regex> ).tweak(:s))>
<!old_rx_mods>
}
token quote:s {
<sym> » <!before '('>
<pat=.sibble( $¢.cursor_fresh( %*LANG<Regex> ), $¢.cursor_fresh( %*LANG<Q> ).tweak(:qq))>
<!old_rx_mods>
}
token quote:ss {
<sym> » <!before '('>
<pat=.sibble( $¢.cursor_fresh( %*LANG<Regex> ).tweak(:s), $¢.cursor_fresh( %*LANG<Q> ).tweak(:qq))>
<!old_rx_mods>
}
token quote:tr {
<sym> » <!before '('> <pat=.tribble( $¢.cursor_fresh( %*LANG<Q> ).tweak(:cc))>
<!old_tr_mods>
}
token old_rx_mods {
<!after \s>
(\w+)
{
given $0.Str {
$_ ~~ /i/ and $¢.worryobs('/i',':i');
$_ ~~ /g/ and $¢.worryobs('/g',':g');
share/P6STD/STD.pm6 view on Meta::CPAN
given $0.Str {
$_ ~~ /c/ and $¢.worryobs('/c',':c');
$_ ~~ /d/ and $¢.worryobs('/g',':d');
$_ ~~ /s/ and $¢.worryobs('/s',':s');
$¢.obs('suffix transliteration modifiers','prefix adverbs');
}
}
}
token quote:quasi {
<sym> » <!before '('> <quasiquibble($¢.cursor_fresh( %*LANG<Quasi> ))>
}
###########################
# Captures and Signatures #
###########################
token capterm {
'\\'
[
| '(' <capture>? ')'
share/P6STD/STD.pm6 view on Meta::CPAN
$needparens++ if $_ eq 'loop';
my $m = %*MYSTERY{$_};
next unless $m;
if $line - ($m.<line>//-123) < 5 {
if $m.<ctx> eq '(' {
$¢.panic("Word '$_' interpreted as '$_" ~ "()' function call; please use whitespace " ~
($needparens ?? 'around the parens' !! 'instead of parens') ~ $m<token>.locmess ~
"\nUnexpected block in infix position (two terms in a row)");
}
else {
$¢.panic("Word '$_' interpreted as a listop; please use 'do $_' to introduce the statement control word" ~ $m<token>.cursor($m<token>.from).locmess ~
"\nUnexpected block in infix position (two terms in a row)");
}
}
}
return () if $*IN_REDUCE;
my $endpos = $¢.pos;
my $startpos = @*MEMOS[$endpos]<ws> // $endpos;
if self.lineof($startpos) != self.lineof($endpos) {
$¢.panic("Unexpected block in infix position (previous line missing its semicolon?)");
}
elsif @*MEMOS[$startpos]<baremeth> {
$¢.cursor($startpos).panic("Unexpected block in infix position (method call with args needs colon or parens without whitespace)");
}
else {
$¢.panic("Unexpected block in infix position (two terms in a row, or previous statement missing semicolon?)");
}
}
<O(|%term)>
}
token circumfix:sigil
{ :dba('contextualizer') <sigil> '(' ~ ')' <semilist> { $*LEFTSIGIL ||= $<sigil>.Str } <O(|%term)> }
share/P6STD/STD.pm6 view on Meta::CPAN
'{' ~ '}' <semilist> <O(|%methodcall)>
<.checkyada>
<.curlycheck(0)>
}
token postcircumfix:sym«< >» {
:my $pos;
'<'
{ $pos = $¢.pos }
[
|| <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q).tweak(:w).balanced('<','>'))> '>'
|| <?before \h* [ \d | <sigil> | ':' ] >
{ $¢.cursor_force($pos).panic("Whitespace required before < operator") }
|| { $¢.cursor_force($pos).panic("Unable to parse quote-words subscript; couldn't find right angle quote") }
]
<O(|%methodcall)>
}
token postcircumfix:sym«<< >>»
{ '<<' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(:ww).balanced('<<','>>'))> [ '>>' || <.panic: "Unable to parse quote-words subscript; couldn't find right double-angle quote"> ] <O(|%methodcall)> }
token postcircumfix:sym<« »>
{ '«' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(:ww).balanced('«','»'))> [ '»' || <.panic: "Unable to parse quote-words subscript; couldn't find right double-angle quote"> ] <O(|%methodcall)> }
token postop {
| <postfix> $<O> = {$<postfix><O>} $<sym> = {$<postfix><sym>}
| <postcircumfix> $<O> = {$<postcircumfix><O>} $<sym> = {$<postcircumfix><sym>}
}
token methodop {
[
| <longname>
| <?before '$' | '@' | '&' > <variable> { $¢.check_variable($<variable>) }
share/P6STD/STD.pm6 view on Meta::CPAN
my $methop = self.<right><methodop>;
my $name = $methop.<longname>.Str;
if grep { $_ eq $name }, <new clone sort subst trans reverse uniq map samecase substr flip fmt pick> {
$ok = 1;
}
elsif not $methop.<args>[0] {
$ok = 1;
}
};
self.cursor_force(self.<infix>.pos).worryobs('.= as append operator', '~=') unless $ok;
self;
}
token infix:sym« => »
{ <sym> <O(|%item_assignment, fiddly => 0)> }
# Note, other assignment ops generated by infix_postfix_meta_operator rule
## loose unary
token prefix:sym<so>
share/P6STD/STD.pm6 view on Meta::CPAN
$name = $<identifier>.Str;
$pos = $¢.pos;
$isname = $¢.is_name($name);
$¢.check_nodecl($name) if $isname;
}
<args($isname)>
{ self.add_mystery($<identifier>,$pos,substr(self.orig,$pos,1)) unless $<args><invocant>; }
{
if $*BORG and $*BORG.<block> {
if not $*BORG.<name> {
$*BORG.<culprit> = $<identifier>.cursor($pos);
$*BORG.<name> = $name;
}
}
if %deftrap{$name} {
my $al = $<args><arglist>[0];
my $ok = 0;
$ok = 1 if $isname;
$ok = 1 if $al and $al.from != $al.to;
$ok = 1 if $<args><semiarglist>;
if not $ok {
share/P6STD/STD.pm6 view on Meta::CPAN
{ $¢.check_nodecl($name); }
# parametric type?
:dba('type parameter')
<.unsp>? [ <?before '['> <postcircumfix> ]?
:dba('namespace variable lookup')
[
<?after '::'>
<?before [ '«' | '<' | '{' | '<<' ] > <postcircumfix>
{ $*VAR = $¢.cursor_all(self.pos, $¢.pos) }
]?
# unrecognized names are assumed to be post-declared listops.
|| <args> { self.add_mystery($<longname>,$pos,'termish') unless $<args><invocant>; }
{
if $*BORG and $*BORG.<block> {
if not $*BORG.<name> {
$*BORG.<culprit> = $<longname>.cursor($pos);
$*BORG.<name> //= $name;
}
}
}
]
<O(|%term)>
}
method check_nodecl($name) {
if $name lt 'a' {
share/P6STD/STD.pm6 view on Meta::CPAN
| <?{ $*GOAL eq 'endargs' and @*MEMOS[@*MEMOS[$¢.pos]<ws>//$¢.pos]<endargs> }>
]
}
}
grammar Q is STD {
role b1 {
token escape:sym<\\> { <sym> {} <item=.backslash> }
token backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
token backslash:sym<\\> { <text=.sym> }
token backslash:stopper { <text=.stopper> }
token backslash:a { <sym> }
token backslash:b { <sym> }
token backslash:c { <sym> <charspec> }
token backslash:e { <sym> }
token backslash:f { <sym> }
token backslash:n { <sym> }
token backslash:o { :dba('octal character') <sym> [ <octint> | '[' ~ ']' <octints> ] }
token backslash:r { <sym> }
share/P6STD/STD.pm6 view on Meta::CPAN
role x0 {
method postprocessor () { 'null' }
}
role q {
token stopper { \' }
token escape:sym<\\> { <sym> <item=.backslash> }
token backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
token backslash:sym<\\> { <text=.sym> }
token backslash:stopper { <text=.stopper> }
# in single quotes, keep backslash on random character by default
token backslash:misc { {} (.) { $<text> = "\\" ~ $0.Str; } }
multi method tweak (:single(:$q)!) { self.panic("Too late for :q") }
multi method tweak (:double(:$qq)!) { self.panic("Too late for :qq") }
multi method tweak (:cclass(:$cc)!) { self.panic("Too late for :cc") }
}
share/P6STD/STD.pm6 view on Meta::CPAN
multi method tweak (:array(:$a)!) { self.mixin($a ?? ::a1 !! ::a0) }
multi method tweak (:hash(:$h)!) { self.mixin($h ?? ::h1 !! ::h0) }
multi method tweak (:function(:$f)!) { self.mixin($f ?? ::f1 !! ::f0) }
multi method tweak (:closure(:$c)!) { self.mixin($c ?? ::c1 !! ::c0) }
multi method tweak (:path(:$p)!) { self.mixin($p ?? ::p1 !! ::p0) }
multi method tweak (:exec(:$x)!) { self.mixin($x ?? ::x1 !! ::x0) }
multi method tweak (:words(:$w)!) { self.mixin($w ?? ::w1 !! ::w0) }
multi method tweak (:quotewords(:$ww)!) { self.mixin($ww ?? ::ww1 !! ::ww0) }
multi method tweak (:heredoc(:$to)!) { self.truly($to, ':to'); self.cursor_herelang; }
multi method tweak (:$regex!) {
return %*LANG<Regex>;
}
multi method tweak (*%x) {
my @k = keys(%x);
self.sorry("Unrecognized quote modifier: " ~ join('',@k));
}
}
grammar Quasi is STD::P6 {
token term:unquote {
:my $*QUASIMODO = 0;
<starter><starter><starter> <.ws>
[ <EXPR> <stopper><stopper><stopper> || <.panic: "Confused"> ]
}
multi method tweak (:$ast!) { self; } # XXX some transformer operating on the normal AST?
multi method tweak (:$lang!) { self.cursor_fresh( $lang ); }
multi method tweak (:$unquote!) { self; } # XXX needs to override unquote
multi method tweak (:$COMPILING!) { $*QUASIMODO = 1; self; } # XXX needs to lazify the lexical lookups somehow
multi method tweak (*%x) {
my @k = keys(%x);
self.sorry("Unrecognized quasiquote modifier: " ~ join('',@k));
}
}
##############################
share/P6STD/STD.pm6 view on Meta::CPAN
push @chain, $op;
while @opstack {
last if $op<O><prec> ne @opstack[*-1]<O><prec>;
push @chain, pop(@termstack);
push @chain, pop(@opstack);
}
push @chain, pop(@termstack);
my $endpos = @chain[0].pos;
@chain = reverse @chain if @chain > 1;
my $startpos = @chain[0].from;
my $nop = $op.cursor_fresh();
$nop.prepbind(@chain);
$nop<chain> = [@chain];
$nop<_arity> = 'CHAIN';
$nop.from = $startpos;
$nop.pos = $endpos;
my @caps;
my $i = 0;
for @chain {
push(@caps, $i++ % 2 ?? 'op' !! 'term' );
push(@caps, $_);
share/P6STD/STD.pm6 view on Meta::CPAN
if @termstack and defined @termstack[0] {
push @list, pop(@termstack);
}
else {
self.worry("Missing final term in '" ~ $sym ~ "' list");
}
my $endpos = @list[0].pos;
@list = reverse @list if @list > 1;
my $startpos = @list[0].from;
@delims = reverse @delims if @delims > 1;
my $nop = $op.cursor_fresh();
$nop.prepbind(@list,@delims);
$nop<sym> = $sym;
$nop<O> = $op<O>;
$nop<list> = [@list];
$nop<delims> = [@delims];
$nop<_arity> = 'LIST';
$nop.from = $startpos;
$nop.pos = $endpos;
if @list {
my @caps;
share/P6STD/STD.pm6 view on Meta::CPAN
@termstack[*-1].<PRE>:delete;
@termstack[*-1].<POST>:delete;
}
}
};
TERM:
loop {
self.deb("In loop, at ", $here.pos) if $*DEBUG +& DEBUG::EXPR;
my $oldpos = $here.pos;
$here = $here.cursor_fresh();
$*LEFTSIGIL = @opstack[*-1]<O><prec> gt $item_assignment_prec ?? '@' !! ''; # XXX P6
my @t = $here.$termish;
if not @t or not $here = @t[0] or ($here.pos == $oldpos and $termish eq 'termish') {
$here.panic("Bogus term") if @opstack > 1;
return ();
}
$termish = 'termish';
my $PRE = ($here.<PRE>:delete) // [];
my $POST = ($here.<POST>:delete) // [];
share/P6STD/STD.pm6 view on Meta::CPAN
push @termstack, $here.<term>;
@termstack[*-1].<POST>:delete;
self.deb("after push: " ~ (0+@termstack)) if $*DEBUG +& DEBUG::EXPR;
last TERM if $preclim eq $methodcall_prec; # in interpolation, probably # XXX P6
loop { # while we see adverbs
$oldpos = $here.pos;
last TERM if (@*MEMOS[$oldpos]<endstmt> // 0) == 2; # XXX P6
$here = $here.cursor_fresh.ws;
my @infix = $here.cursor_fresh.infixish();
last TERM unless @infix;
my $infix = @infix[0];
last TERM unless $infix.pos > $oldpos;
if not $infix<sym> {
die $infix.dump if $*DEBUG +& DEBUG::EXPR;
}
my $inO = $infix<O>;
my Str $inprec = $inO<prec>;
share/P6STD/STD.pm6 view on Meta::CPAN
if $inprec le $preclim {
if $preclim ne $LOOSEST {
my $dba = $preclvl.<dba>;
my $h = $*HIGHEXPECT;
%$h = ();
$h.{"an infix operator with precedence tighter than $dba"} = 1;
}
last TERM;
}
$here = $infix.cursor_fresh.ws();
# Does new infix (or terminator) force any reductions?
while @opstack[*-1]<O><prec> gt $inprec {
&reduce();
}
# Not much point in reducing the sentinels...
last if $inprec lt $LOOSEST;
if $infix<fake> {
share/P6STD/STD.pm6 view on Meta::CPAN
}
self._MATCHIFYr($S, "EXPR", @termstack);
}
##########
## Regex #
##########
grammar Regex is STD {
multi method tweak (:Perl5(:$P5)!) { self.require_P5; self.cursor_fresh( %*LANG<Q> ).mixin( ::q ).mixin( ::p5 ) }
multi method tweak (:overlap(:$ov)!) { %*RX<ov> = $ov; self; }
multi method tweak (:exhaustive(:$ex)!) { %*RX<ex> = $ex; self; }
multi method tweak (:continue(:$c)!) { %*RX<c> = $c; self; }
multi method tweak (:pos(:$p)!) { %*RX<p> = $p; self; }
multi method tweak (:sigspace(:$s)!) { %*RX<s> = $s; self; }
multi method tweak (:ratchet(:$r)!) { %*RX<r> = $r; self; }
multi method tweak (:global(:$g)!) { %*RX<g> = $g; self; }
multi method tweak (:ignorecase(:$i)!) { %*RX<i> = $i; self; }
multi method tweak (:ignoremark(:$m)!) { %*RX<m> = $m; self; }
multi method tweak (:samecase(:$ii)!) { %*RX<ii> = $ii; self; }
share/P6STD/STD.pm6 view on Meta::CPAN
token assertion:sym<|> { <sym> [ <?before '>'> | <?before \w> <assertion> ] } # assertion-like syntax, anyway
token assertion:sym<?> { <sym> [ <?before '>'> | <assertion> ] }
token assertion:sym<!> { <sym> [ <?before '>'> | <assertion> ] }
token assertion:sym<*> { <sym> [ <?before '>'> | <.ws> <nibbler> ] }
token assertion:sym<{ }> { <embeddedblock> }
token assertion:variable {
<?before <sigil>> # note: semantics must be determined per-sigil
[:lang($¢.cursor_fresh(%*LANG<MAIN>).unbalanced('>')) <variable=.EXPR(item %LOOSEST)>]
}
token assertion:method {
'.' [
| <?before <alpha> > <assertion>
| [ :lang($¢.cursor_fresh(%*LANG<MAIN>).unbalanced('>')) <dottyop> ]
]
}
token assertion:name { [ :lang($¢.cursor_fresh(%*LANG<MAIN>).unbalanced('>')) <longname> ]
[
| <?before '>' > {
my $n = $<longname>.Str;
if $n eq 'before' or $n eq 'after' {
$¢.panic("$n requires an argument");
}
}
| <.normspace>? <nibbler> <.ws>
| '=' <assertion>
| ':' [ :lang($¢.cursor_fresh(%*LANG<MAIN>).unbalanced('>')) <.ws> <arglist> ]
| '(' {}
[ :lang(%*LANG<MAIN>) <arglist> ]
[ ')' || <.panic: "Assertion call missing right parenthesis"> ]
]?
}
token assertion:sym<:> { <?before ':'> <cclass_expr> }
token assertion:sym<[> { <?before '['> <cclass_expr> }
token assertion:sym<+> { <?before '+'> <cclass_expr> }
token assertion:sym<-> { <?before '-'> <cclass_expr> }
share/P6STD/STD.pm6 view on Meta::CPAN
token cclass_elem:name {
:dba('character class element')
<name>
<.normspace>?
}
token cclass_elem:sym<[ ]> {
:my $*CCSTATE = '';
:dba('character class element')
"[" ~ "]" <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:cc).unbalanced("]"))>
<.normspace>?
}
token cclass_elem:sym<( )> {
:my $*CCSTATE = '';
:dba('character class element')
'(' ~ ')' <cclass_expr>
<.normspace>?
}
share/P6STD/STD.pm6 view on Meta::CPAN
token mod_internal:sym<:s> { ':s' 'igspace'? » { %*RX<s> = 1 } }
token mod_internal:sym<:!s> { ':!s' 'igspace'? » { %*RX<s> = 0 } }
token mod_internal:sym<:s( )> { ':s' 'igspace'? <mod_arg> { %*RX<s> = eval $<mod_arg>.Str } }
token mod_internal:sym<:0s> { ':' (\d+) 's' 'igspace'? » { %*RX<s> = $0 } }
token mod_internal:sym<:r> { ':r' 'atchet'? » { %*RX<r> = 1 } }
token mod_internal:sym<:!r> { ':!r' 'atchet'? » { %*RX<r> = 0 } }
token mod_internal:sym<:r( )> { ':r' 'atchet'? » <mod_arg> { %*RX<r> = eval $<mod_arg>.Str } }
token mod_internal:sym<:0r> { ':' (\d+) 'r' 'atchet'? » { %*RX<r> = $0 } }
token mod_internal:sym<:Perl5> { [':Perl5' | ':P5'] <.require_P5> [ :lang( $¢.cursor_fresh( %*LANG<P5Regex> ).unbalanced($*GOAL) ) <nibbler> ] }
token mod_internal:p6adv {
<?before ':' ['dba'|'lang'] » > [ :lang(%*LANG<MAIN>) <quotepair> ] $<sym> = {':' ~ $<quotepair><k>}
}
token mod_internal:oops { {} (':'\w+) <.sorry: "Unrecognized regex modifier " ~ $0.Str > }
token quantifier:sym<*> { <sym> <quantmod> }
token quantifier:sym<+> { <sym> <quantmod> }
token quantifier:sym<?> { <sym> <quantmod> }
share/P6STD/STD.pm6 view on Meta::CPAN
next unless $_ ~~ m/(\$|\@|\%|\&)\w/;
next if $_ eq '$_' or $_ eq '@_' or $_ eq '%_';
next if $desc<used>;
next if $desc<rebind>;
next if $desc<dynamic>;
my $scope = $desc<scope> // 'my';
next if $scope eq 'our';
next if $scope eq 'state';
next if $desc<stub>;
my $pos = $desc<declaredat> // self.pos;
self.cursor($pos).worry("$_ is declared but not used");
}
}
self;
}
method getdecl {
self.<decl> = $*DECLARAND;
self;
}
share/P6STD/STD.pm6 view on Meta::CPAN
return self.sorry("$varname has already been used as a non-placeholder in the surrounding$decl block,\n so you will confuse the reader if you suddenly declare $name here");
}
self.add_my_name($varname);
$*CURLEX{$varname}<used> = 1;
self;
}
method check_variable ($variable) {
my $name = $variable.Str;
my $here = self.cursor($variable.from);
self.deb("check_variable $name") if $*DEBUG +& DEBUG::symtab;
my ($sigil, $twigil, $first) = $name ~~ /(\$|\@|\%|\&)(\W*)(.?)/;
($first,$twigil) = ($twigil, '') if $first eq '';
given $twigil {
when '' {
my $ok = 0;
$ok ||= $*IN_DECL;
$ok ||= $first lt 'A';
$ok ||= $first eq '¢';
$ok ||= self.is_known($name);
share/P6STD/STD.pm6 view on Meta::CPAN
method panic (Str $s) {
die "Recursive panic" if $*IN_PANIC;
$*IN_PANIC++;
self.deb("panic $s") if $*DEBUG;
my $m;
my $here = self;
# Have we backed off recently?
my $highvalid = self.pos <= $*HIGHWATER;
$here = self.cursor($*HIGHWATER) if $highvalid;
my $first = $here.lineof($*LAST_NIBBLE.from);
my $last = $here.lineof($*LAST_NIBBLE.pos);
if $first != $last {
if $here.lineof($here.pos) == $last {
$m ~= "(Possible runaway string from line $first)\n";
}
else {
$first = $here.lineof($*LAST_NIBBLE_MULTILINE.from);
$last = $here.lineof($*LAST_NIBBLE_MULTILINE.pos);
share/P6STD/STD.pm6 view on Meta::CPAN
my $endpos = $here.pos;
my $startpos = @*MEMOS[$endpos]<ws> // $endpos;
if self.lineof($startpos) != self.lineof($endpos) {
$m ~~ s|Confused|Two terms in a row (previous line missing its semicolon?)|;
}
elsif @*MEMOS[$startpos]<listop> {
$m ~~ s|Confused|Two terms in a row (listop with args requires whitespace or parens)|;
}
elsif @*MEMOS[$startpos]<baremeth> {
$here = $here.cursor($startpos);
$m ~~ s|Confused|Two terms in a row (method call with args requires colon or parens without whitespace)|;
}
elsif @*MEMOS[$startpos]<arraycomp> {
$m ~~ s|Confused|Two terms in a row (preceding is not a valid reduce operator)|;
}
else {
$m ~~ s|Confused|Two terms in a row|;
}
}
elsif my $type = @*MEMOS[$here.pos - 1]<nodecl> {
share/P6STD/STD_P5.pm6 view on Meta::CPAN
[ <quotepair> <.ws>
{
my $kv = $<quotepair>[*-1];
$lang = $lang.tweak($kv.<k>, $kv.<v>)
or self.sorry("Unrecognized adverb :" ~ $kv.<k> ~ '(' ~ $kv.<v> ~ ')');
}
]*
'{'
<nibble( $¢.cursor_fresh($lang).unbalanced('}') )>
[ '}' || <.panic: "Unable to parse regex; couldn't find right brace"> ]
[
| <?before \h* $$> # (usual case without comments)
{ @*MEMOS[$¢.pos]<endstmt> = 2; }
| \h* <?before <[\\,:]>>
| <.unv>? $$
{ @*MEMOS[$¢.pos]<endstmt> = 2; }
| {} <.unsp>? { @*MEMOS[$¢.pos]<endargs> = 1; }
]
share/P6STD/STD_P5.pm6 view on Meta::CPAN
my $lang = $herestub.lang.mixin( ::herestop );
my $doc;
if ($doc) = $here.nibble($lang) {
$here = $doc.trim_heredoc();
$herestub.orignode<doc> = $doc;
}
else {
self.panic("Ending delimiter $*DELIM not found");
}
}
return self.cursor($here.pos); # return to initial type
}
proto token backslash { <...> }
proto token escape { <...> }
token starter { <!> }
token escape:none { <!> }
token babble ($l) {
:my $lang = $l;
:my $start;
share/P6STD/STD_P5.pm6 view on Meta::CPAN
$<escape> :delete;
$<starter> :delete;
$<stopper> :delete;
$*LAST_NIBBLE = $¢;
$*LAST_NIBBLE_MULTILINE = $¢ if $multiline;
}}
}
# and this is what makes nibbler polymorphic...
method nibble ($lang) {
self.cursor_fresh($lang).nibbler;
}
token p5quote:sym<' '> { "'" <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q).unbalanced("'"))> "'" }
token p5quote:sym<" "> { '"' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).unbalanced('"'))> '"' }
token p5circumfix:sym«< >» { '<'
<nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq).tweak(:w).balanced('<','>'))> '>' }
token p5quote:sym</ /> {
'/' <nibble( $¢.cursor_fresh( %*LANG<Regex> ).unbalanced("/") )> [ '/' || <.panic: "Unable to parse regex; couldn't find final '/'"> ]
<p5rx_mods>?
}
# handle composite forms like qww
token quote:qq {
'qq'
[
| » <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:qq))>
]
}
token quote:q {
'q'
[
| » <.ws> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q))>
]
}
token quote:qr {
<sym> » <!before '('>
<quibble( $¢.cursor_fresh( %*LANG<Regex> ) )>
<p5rx_mods>
}
token quote:m {
<sym> » <!before '('>
<quibble( $¢.cursor_fresh( %*LANG<Regex> ) )>
<p5rx_mods>
}
token quote:s {
<sym> » <!before '('>
<pat=sibble( $¢.cursor_fresh( %*LANG<Regex> ), $¢.cursor_fresh( %*LANG<Q> ).tweak(:qq))>
<p5rx_mods>
}
token quote:tr {
<sym> » <!before '('> <pat=tribble( $¢.cursor_fresh( %*LANG<Q> ).tweak(:q))>
<p5tr_mods>
}
token p5rx_mods {
<!after \s>
(< i g s m x c e >+)
}
token p5tr_mods {
(< c d s ] >+)
share/P6STD/STD_P5.pm6 view on Meta::CPAN
method truly ($bool,$opt) {
return self if $bool;
self.panic("Cannot negate $opt adverb");
}
grammar Q is STD {
role b1 {
token p5escape:sym<\\> { <sym> <item=p5backslash> }
token p5backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
token p5backslash:sym<\\> { <text=sym> }
token p5backslash:stopper { <text=stopper> }
token p5backslash:a { <sym> }
token p5backslash:b { <sym> }
token p5backslash:c { <sym> <charspec> }
token p5backslash:e { <sym> }
token p5backslash:f { <sym> }
token p5backslash:n { <sym> }
token p5backslash:o { :dba('octal character') <sym> [ <octint> | '[' ~ ']' <octints> ] }
token p5backslash:r { <sym> }
share/P6STD/STD_P5.pm6 view on Meta::CPAN
role x0 {
method postprocess ($s) { $s }
} # end role
role q {
token stopper { \' }
token p5escape:sym<\\> { <sym> <item=p5backslash> }
token p5backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
token p5backslash:sym<\\> { <text=sym> }
token p5backslash:stopper { <text=stopper> }
# in single quotes, keep backslash on random character by default
token p5backslash:misc { {} (.) { $<text> = "\\" ~ $0.Str; } }
# begin tweaks (DO NOT ERASE)
multi method tweak (:single(:$q)!) { self.panic("Too late for :q") }
multi method tweak (:double(:$qq)!) { self.panic("Too late for :qq") }
# end tweaks (DO NOT ERASE)
share/P6STD/STD_P5.pm6 view on Meta::CPAN
multi method tweak (:scalar(:$s)!) { self.mixin($s ?? ::s1 !! ::s0) }
multi method tweak (:array(:$a)!) { self.mixin($a ?? ::a1 !! ::a0) }
multi method tweak (:hash(:$h)!) { self.mixin($h ?? ::h1 !! ::h0) }
multi method tweak (:function(:$f)!) { self.mixin($f ?? ::f1 !! ::f0) }
multi method tweak (:closure(:$c)!) { self.mixin($c ?? ::c1 !! ::c0) }
multi method tweak (:exec(:$x)!) { self.mixin($x ?? ::x1 !! ::x0) }
multi method tweak (:words(:$w)!) { self.mixin($w ?? ::w1 !! ::w0) }
multi method tweak (:quotewords(:$ww)!) { self.mixin($ww ?? ::ww1 !! ::ww0) }
multi method tweak (:heredoc(:$to)!) { self.truly($to, ':to'); self.cursor_herelang; }
multi method tweak (:$regex!) {
return %*LANG<Regex>;
}
multi method tweak (:$trans!) {
return %*LANG<Trans>;
}
multi method tweak (*%x) {
share/P6STD/STD_P5.pm6 view on Meta::CPAN
proto token p5quantifier { <...> }
token category:p5mod_internal { <sym> }
proto token p5mod_internal { <...> }
proto token p5regex_infix { <...> }
# suppress fancy end-of-line checking
token codeblock {
:my $*GOAL ::= '}';
'{' :: [ :lang($¢.cursor_fresh(%*LANG<MAIN>)) <statementlist> ]
[ '}' || <.panic: "Unable to parse statement list; couldn't find right brace"> ]
}
token ws {
<?{ $*RX<s> }>
|| [ <?before \s | '#'> <.nextsame> ]? # still get all the pod goodness, hopefully
}
rule nibbler {
:temp $*ignorecase;
share/P6STD/STD_P5.pm6 view on Meta::CPAN
# sequence stoppers
token p5metachar:sym<|> { '|' :: <fail> }
token p5metachar:sym<)> { ')' :: <fail> }
token p5metachar:quant { <quantifier=p5quantifier> <.panic: "quantifier quantifies nothing"> }
# "normal" metachars
token p5metachar:sym<[ ]> {
<before '['> <quibble($¢.cursor_fresh( %*LANG<Q> ).tweak(:q))> # XXX parse as q[] for now
}
token p5metachar:sym«(? )» {
'(?' {} <assertion=p5assertion>
[ ')' || <.panic: "Perl 5 regex assertion not terminated by parenthesis"> ]
}
token p5metachar:sym<( )> {
'(' {} [:lang(self.unbalanced(')')) <nibbler>]?
[ ')' || <.panic: "Unable to parse Perl 5 regex; couldn't find right parenthesis"> ]
share/P6STD/boot/STD.pmc view on Meta::CPAN
## method p6class ()
sub p6class {
no warnings 'recursion';
my $self = shift;
'STD::P6' };
## method TOP ($STOP = '')
sub TOP {
no warnings 'recursion';
my $self = shift;
my $STOP = @_ ? shift() : '';
my $lang = $self->cursor_fresh( $self->p6class );
if ($STOP) {
local $::GOAL = $STOP;
$lang->unitstop($STOP)->comp_unit;
}
else {
$lang->comp_unit};
};
our %term = ('dba' => ('term') , 'prec' => 'z=');
our %methodcall = ('dba' => ('methodcall') , 'prec' => 'y=', 'assoc' => 'unary', 'uassoc' => 'left', 'fiddly' => 1, 'pure' => 0);
our %autoincrement = ('dba' => ('autoincrement') , 'prec' => 'x=', 'assoc' => 'unary', 'uassoc' => 'non', 'pure' => 0);
share/P6STD/boot/STD.pmc view on Meta::CPAN
local $::endsym = "null";
local $::endargs = -1;
## token category {*}
sub category__PEEK { $_[0]->_AUTOLEXpeek('category:*',$retree); }
sub category {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE category');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'category') {
$C->deb("Fate passed to category: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT category';
}
else {
$x = 'ALTLTM category';
}
}
else {
$x = 'ALTLTM category';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'category:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("category trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:category { <sym> }
sub category__S_000category__PEEK { $_[0]->_AUTOLEXpeek('category__S_000category', $retree) }
sub category__S_000category {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_000category");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "category";
$self->_MATCHIFYr($S, "category__S_000category", $C->_EXACT("category"));
}
;
## token category:sigil { <sym> }
sub category__S_001sigil__PEEK { $_[0]->_AUTOLEXpeek('category__S_001sigil', $retree) }
sub category__S_001sigil {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_001sigil");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sigil";
$self->_MATCHIFYr($S, "category__S_001sigil", $C->_EXACT("sigil"));
}
;
## token sigil {*}
sub sigil__PEEK { $_[0]->_AUTOLEXpeek('sigil:*',$retree); }
sub sigil {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE sigil');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'sigil') {
$C->deb("Fate passed to sigil: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT sigil';
}
else {
$x = 'ALTLTM sigil';
}
}
else {
$x = 'ALTLTM sigil';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'sigil:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("sigil trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:twigil { <sym> }
sub category__S_002twigil__PEEK { $_[0]->_AUTOLEXpeek('category__S_002twigil', $retree) }
sub category__S_002twigil {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_002twigil");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "twigil";
$self->_MATCHIFYr($S, "category__S_002twigil", $C->_EXACT("twigil"));
}
;
## token twigil is endsym<begid> {*}
sub twigil__PEEK { $_[0]->_AUTOLEXpeek('twigil:*',$retree); }
sub twigil {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE twigil');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'twigil') {
$C->deb("Fate passed to twigil: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT twigil';
}
else {
$x = 'ALTLTM twigil';
}
}
else {
$x = 'ALTLTM twigil';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'twigil:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("twigil trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:special_variable { <sym> }
sub category__S_003special_variable__PEEK { $_[0]->_AUTOLEXpeek('category__S_003special_variable', $retree) }
sub category__S_003special_variable {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_003special_variable");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "special_variable";
$self->_MATCHIFYr($S, "category__S_003special_variable", $C->_EXACT("special_variable"));
}
;
## token special_variable {*}
sub special_variable__PEEK { $_[0]->_AUTOLEXpeek('special_variable:*',$retree); }
sub special_variable {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE special_variable');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'special_variable') {
$C->deb("Fate passed to special_variable: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT special_variable';
}
else {
$x = 'ALTLTM special_variable';
}
}
else {
$x = 'ALTLTM special_variable';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'special_variable:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:comment { <sym> }
sub category__S_004comment__PEEK { $_[0]->_AUTOLEXpeek('category__S_004comment', $retree) }
sub category__S_004comment {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_004comment");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "comment";
$self->_MATCHIFYr($S, "category__S_004comment", $C->_EXACT("comment"));
}
;
## token comment {*}
sub comment__PEEK { $_[0]->_AUTOLEXpeek('comment:*',$retree); }
sub comment {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE comment');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'comment') {
$C->deb("Fate passed to comment: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT comment';
}
else {
$x = 'ALTLTM comment';
}
}
else {
$x = 'ALTLTM comment';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'comment:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("comment trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:version { <sym> }
sub category__S_005version__PEEK { $_[0]->_AUTOLEXpeek('category__S_005version', $retree) }
sub category__S_005version {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_005version");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "version";
$self->_MATCHIFYr($S, "category__S_005version", $C->_EXACT("version"));
}
;
## token version {*}
sub version__PEEK { $_[0]->_AUTOLEXpeek('version:*',$retree); }
sub version {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE version');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'version') {
$C->deb("Fate passed to version: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT version';
}
else {
$x = 'ALTLTM version';
}
}
else {
$x = 'ALTLTM version';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'version:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("version trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:module_name { <sym> }
sub category__S_006module_name__PEEK { $_[0]->_AUTOLEXpeek('category__S_006module_name', $retree) }
sub category__S_006module_name {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_006module_name");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "module_name";
$self->_MATCHIFYr($S, "category__S_006module_name", $C->_EXACT("module_name"));
}
;
## token module_name {*}
sub module_name__PEEK { $_[0]->_AUTOLEXpeek('module_name:*',$retree); }
sub module_name {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE module_name');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'module_name') {
$C->deb("Fate passed to module_name: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT module_name';
}
else {
$x = 'ALTLTM module_name';
}
}
else {
$x = 'ALTLTM module_name';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'module_name:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("module_name trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:value { <sym> }
sub category__S_007value__PEEK { $_[0]->_AUTOLEXpeek('category__S_007value', $retree) }
sub category__S_007value {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_007value");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "value";
$self->_MATCHIFYr($S, "category__S_007value", $C->_EXACT("value"));
}
;
## token value {*}
sub value__PEEK { $_[0]->_AUTOLEXpeek('value:*',$retree); }
sub value {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE value');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'value') {
$C->deb("Fate passed to value: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT value';
}
else {
$x = 'ALTLTM value';
}
}
else {
$x = 'ALTLTM value';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'value:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("value trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:term { <sym> }
sub category__S_008term__PEEK { $_[0]->_AUTOLEXpeek('category__S_008term', $retree) }
sub category__S_008term {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_008term");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "term";
$self->_MATCHIFYr($S, "category__S_008term", $C->_EXACT("term"));
}
;
## token term {*}
sub term__PEEK { $_[0]->_AUTOLEXpeek('term:*',$retree); }
sub term {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE term');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'term') {
$C->deb("Fate passed to term: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT term';
}
else {
$x = 'ALTLTM term';
}
}
else {
$x = 'ALTLTM term';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'term:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:numeric { <sym> }
sub category__S_009numeric__PEEK { $_[0]->_AUTOLEXpeek('category__S_009numeric', $retree) }
sub category__S_009numeric {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_009numeric");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "numeric";
$self->_MATCHIFYr($S, "category__S_009numeric", $C->_EXACT("numeric"));
}
;
## token numeric {*}
sub numeric__PEEK { $_[0]->_AUTOLEXpeek('numeric:*',$retree); }
sub numeric {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE numeric');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'numeric') {
$C->deb("Fate passed to numeric: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT numeric';
}
else {
$x = 'ALTLTM numeric';
}
}
else {
$x = 'ALTLTM numeric';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'numeric:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("numeric trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:quote { <sym> }
sub category__S_010quote__PEEK { $_[0]->_AUTOLEXpeek('category__S_010quote', $retree) }
sub category__S_010quote {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_010quote");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quote";
$self->_MATCHIFYr($S, "category__S_010quote", $C->_EXACT("quote"));
}
;
## token quote () {*}
sub quote__PEEK { $_[0]->_AUTOLEXpeek('quote:*',$retree); }
sub quote {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE quote');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'quote') {
$C->deb("Fate passed to quote: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT quote';
}
else {
$x = 'ALTLTM quote';
}
}
else {
$x = 'ALTLTM quote';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'quote:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quote trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:prefix { <sym> }
sub category__S_011prefix__PEEK { $_[0]->_AUTOLEXpeek('category__S_011prefix', $retree) }
sub category__S_011prefix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_011prefix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "prefix";
$self->_MATCHIFYr($S, "category__S_011prefix", $C->_EXACT("prefix"));
}
;
## token prefix is unary is defequiv(%symbolic_unary) {*}
sub prefix__PEEK { $_[0]->_AUTOLEXpeek('prefix:*',$retree); }
sub prefix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE prefix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'prefix') {
$C->deb("Fate passed to prefix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT prefix';
}
else {
$x = 'ALTLTM prefix';
}
}
else {
$x = 'ALTLTM prefix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'prefix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("prefix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:infix { <sym> }
sub category__S_012infix__PEEK { $_[0]->_AUTOLEXpeek('category__S_012infix', $retree) }
sub category__S_012infix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_012infix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "infix";
$self->_MATCHIFYr($S, "category__S_012infix", $C->_EXACT("infix"));
}
;
## token infix is binary is defequiv(%additive) {*}
sub infix__PEEK { $_[0]->_AUTOLEXpeek('infix:*',$retree); }
sub infix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE infix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'infix') {
$C->deb("Fate passed to infix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT infix';
}
else {
$x = 'ALTLTM infix';
}
}
else {
$x = 'ALTLTM infix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'infix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:postfix { <sym> }
sub category__S_013postfix__PEEK { $_[0]->_AUTOLEXpeek('category__S_013postfix', $retree) }
sub category__S_013postfix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_013postfix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "postfix";
$self->_MATCHIFYr($S, "category__S_013postfix", $C->_EXACT("postfix"));
}
;
## token postfix is unary is defequiv(%autoincrement) {*}
sub postfix__PEEK { $_[0]->_AUTOLEXpeek('postfix:*',$retree); }
sub postfix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE postfix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'postfix') {
$C->deb("Fate passed to postfix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT postfix';
}
else {
$x = 'ALTLTM postfix';
}
}
else {
$x = 'ALTLTM postfix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'postfix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postfix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:dotty { <sym> }
sub category__S_014dotty__PEEK { $_[0]->_AUTOLEXpeek('category__S_014dotty', $retree) }
sub category__S_014dotty {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_014dotty");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "dotty";
$self->_MATCHIFYr($S, "category__S_014dotty", $C->_EXACT("dotty"));
}
;
## token dotty is endsym<unspacey> {*}
sub dotty__PEEK { $_[0]->_AUTOLEXpeek('dotty:*',$retree); }
sub dotty {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE dotty');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'dotty') {
$C->deb("Fate passed to dotty: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT dotty';
}
else {
$x = 'ALTLTM dotty';
}
}
else {
$x = 'ALTLTM dotty';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'dotty:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("dotty trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:circumfix { <sym> }
sub category__S_015circumfix__PEEK { $_[0]->_AUTOLEXpeek('category__S_015circumfix', $retree) }
sub category__S_015circumfix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_015circumfix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "circumfix";
$self->_MATCHIFYr($S, "category__S_015circumfix", $C->_EXACT("circumfix"));
}
;
## token circumfix {*}
sub circumfix__PEEK { $_[0]->_AUTOLEXpeek('circumfix:*',$retree); }
sub circumfix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE circumfix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'circumfix') {
$C->deb("Fate passed to circumfix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT circumfix';
}
else {
$x = 'ALTLTM circumfix';
}
}
else {
$x = 'ALTLTM circumfix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'circumfix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("circumfix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:postcircumfix { <sym> }
sub category__S_016postcircumfix__PEEK { $_[0]->_AUTOLEXpeek('category__S_016postcircumfix', $retree) }
sub category__S_016postcircumfix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_016postcircumfix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "postcircumfix";
$self->_MATCHIFYr($S, "category__S_016postcircumfix", $C->_EXACT("postcircumfix"));
}
;
## token postcircumfix is unary {*} # unary as far as EXPR knows...
sub postcircumfix__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix:*',$retree); }
sub postcircumfix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE postcircumfix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'postcircumfix') {
$C->deb("Fate passed to postcircumfix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT postcircumfix';
}
else {
$x = 'ALTLTM postcircumfix';
}
}
else {
$x = 'ALTLTM postcircumfix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'postcircumfix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postcircumfix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:quote_mod { <sym> }
sub category__S_017quote_mod__PEEK { $_[0]->_AUTOLEXpeek('category__S_017quote_mod', $retree) }
sub category__S_017quote_mod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_017quote_mod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quote_mod";
$self->_MATCHIFYr($S, "category__S_017quote_mod", $C->_EXACT("quote_mod"));
}
;
## token quote_mod {*}
sub quote_mod__PEEK { $_[0]->_AUTOLEXpeek('quote_mod:*',$retree); }
sub quote_mod {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE quote_mod');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'quote_mod') {
$C->deb("Fate passed to quote_mod: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT quote_mod';
}
else {
$x = 'ALTLTM quote_mod';
}
}
else {
$x = 'ALTLTM quote_mod';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'quote_mod:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quote_mod trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:trait_mod { <sym> }
sub category__S_018trait_mod__PEEK { $_[0]->_AUTOLEXpeek('category__S_018trait_mod', $retree) }
sub category__S_018trait_mod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_018trait_mod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "trait_mod";
$self->_MATCHIFYr($S, "category__S_018trait_mod", $C->_EXACT("trait_mod"));
}
;
## token trait_mod is endsym<keyspace> {*}
sub trait_mod__PEEK { $_[0]->_AUTOLEXpeek('trait_mod:*',$retree); }
sub trait_mod {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE trait_mod');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'trait_mod') {
$C->deb("Fate passed to trait_mod: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT trait_mod';
}
else {
$x = 'ALTLTM trait_mod';
}
}
else {
$x = 'ALTLTM trait_mod';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'trait_mod:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("trait_mod trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:initializer { <sym> }
sub category__S_019initializer__PEEK { $_[0]->_AUTOLEXpeek('category__S_019initializer', $retree) }
sub category__S_019initializer {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_019initializer");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "initializer";
$self->_MATCHIFYr($S, "category__S_019initializer", $C->_EXACT("initializer"));
}
;
## token initializer is endsym<ws> {*}
sub initializer__PEEK { $_[0]->_AUTOLEXpeek('initializer:*',$retree); }
sub initializer {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE initializer');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'initializer') {
$C->deb("Fate passed to initializer: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT initializer';
}
else {
$x = 'ALTLTM initializer';
}
}
else {
$x = 'ALTLTM initializer';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'initializer:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("initializer trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:type_declarator { <sym> }
sub category__S_020type_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_020type_declarator', $retree) }
sub category__S_020type_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_020type_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "type_declarator";
$self->_MATCHIFYr($S, "category__S_020type_declarator", $C->_EXACT("type_declarator"));
}
;
## token type_declarator is endsym<keyspace> {*}
sub type_declarator__PEEK { $_[0]->_AUTOLEXpeek('type_declarator:*',$retree); }
sub type_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE type_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'type_declarator') {
$C->deb("Fate passed to type_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT type_declarator';
}
else {
$x = 'ALTLTM type_declarator';
}
}
else {
$x = 'ALTLTM type_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'type_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("type_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:scope_declarator { <sym> }
sub category__S_021scope_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_021scope_declarator', $retree) }
sub category__S_021scope_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_021scope_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "scope_declarator";
$self->_MATCHIFYr($S, "category__S_021scope_declarator", $C->_EXACT("scope_declarator"));
}
;
## token scope_declarator is endsym<nofun> {*}
sub scope_declarator__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator:*',$retree); }
sub scope_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE scope_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'scope_declarator') {
$C->deb("Fate passed to scope_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT scope_declarator';
}
else {
$x = 'ALTLTM scope_declarator';
}
}
else {
$x = 'ALTLTM scope_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'scope_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("scope_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:package_declarator { <sym> }
sub category__S_022package_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_022package_declarator', $retree) }
sub category__S_022package_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_022package_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "package_declarator";
$self->_MATCHIFYr($S, "category__S_022package_declarator", $C->_EXACT("package_declarator"));
}
;
## token package_declarator is endsym<keyspace> {*}
sub package_declarator__PEEK { $_[0]->_AUTOLEXpeek('package_declarator:*',$retree); }
sub package_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE package_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'package_declarator') {
$C->deb("Fate passed to package_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT package_declarator';
}
else {
$x = 'ALTLTM package_declarator';
}
}
else {
$x = 'ALTLTM package_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'package_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("package_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:multi_declarator { <sym> }
sub category__S_023multi_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_023multi_declarator', $retree) }
sub category__S_023multi_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_023multi_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "multi_declarator";
$self->_MATCHIFYr($S, "category__S_023multi_declarator", $C->_EXACT("multi_declarator"));
}
;
## token multi_declarator is endsym<keyspace> {*}
sub multi_declarator__PEEK { $_[0]->_AUTOLEXpeek('multi_declarator:*',$retree); }
sub multi_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE multi_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'multi_declarator') {
$C->deb("Fate passed to multi_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT multi_declarator';
}
else {
$x = 'ALTLTM multi_declarator';
}
}
else {
$x = 'ALTLTM multi_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'multi_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("multi_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:routine_declarator { <sym> }
sub category__S_024routine_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_024routine_declarator', $retree) }
sub category__S_024routine_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_024routine_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "routine_declarator";
$self->_MATCHIFYr($S, "category__S_024routine_declarator", $C->_EXACT("routine_declarator"));
}
;
## token routine_declarator is endsym<nofun> {*}
sub routine_declarator__PEEK { $_[0]->_AUTOLEXpeek('routine_declarator:*',$retree); }
sub routine_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE routine_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'routine_declarator') {
$C->deb("Fate passed to routine_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT routine_declarator';
}
else {
$x = 'ALTLTM routine_declarator';
}
}
else {
$x = 'ALTLTM routine_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'routine_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("routine_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:regex_declarator { <sym> }
sub category__S_025regex_declarator__PEEK { $_[0]->_AUTOLEXpeek('category__S_025regex_declarator', $retree) }
sub category__S_025regex_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_025regex_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "regex_declarator";
$self->_MATCHIFYr($S, "category__S_025regex_declarator", $C->_EXACT("regex_declarator"));
}
;
## token regex_declarator is endsym<keyspace> {*}
sub regex_declarator__PEEK { $_[0]->_AUTOLEXpeek('regex_declarator:*',$retree); }
sub regex_declarator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE regex_declarator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'regex_declarator') {
$C->deb("Fate passed to regex_declarator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT regex_declarator';
}
else {
$x = 'ALTLTM regex_declarator';
}
}
else {
$x = 'ALTLTM regex_declarator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'regex_declarator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("regex_declarator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:statement_prefix { <sym> }
sub category__S_026statement_prefix__PEEK { $_[0]->_AUTOLEXpeek('category__S_026statement_prefix', $retree) }
sub category__S_026statement_prefix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_026statement_prefix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "statement_prefix";
$self->_MATCHIFYr($S, "category__S_026statement_prefix", $C->_EXACT("statement_prefix"));
}
;
## rule statement_prefix () {*}
sub statement_prefix__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix:*',$retree); }
sub statement_prefix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE statement_prefix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'statement_prefix') {
$C->deb("Fate passed to statement_prefix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT statement_prefix';
}
else {
$x = 'ALTLTM statement_prefix';
}
}
else {
$x = 'ALTLTM statement_prefix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'statement_prefix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_prefix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:statement_control { <sym> }
sub category__S_027statement_control__PEEK { $_[0]->_AUTOLEXpeek('category__S_027statement_control', $retree) }
sub category__S_027statement_control {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_027statement_control");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "statement_control";
$self->_MATCHIFYr($S, "category__S_027statement_control", $C->_EXACT("statement_control"));
}
;
## rule statement_control is endsym<keyspace> {*}
sub statement_control__PEEK { $_[0]->_AUTOLEXpeek('statement_control:*',$retree); }
sub statement_control {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE statement_control');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'statement_control') {
$C->deb("Fate passed to statement_control: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT statement_control';
}
else {
$x = 'ALTLTM statement_control';
}
}
else {
$x = 'ALTLTM statement_control';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'statement_control:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:statement_mod_cond { <sym> }
sub category__S_028statement_mod_cond__PEEK { $_[0]->_AUTOLEXpeek('category__S_028statement_mod_cond', $retree) }
sub category__S_028statement_mod_cond {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_028statement_mod_cond");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "statement_mod_cond";
$self->_MATCHIFYr($S, "category__S_028statement_mod_cond", $C->_EXACT("statement_mod_cond"));
}
;
## rule statement_mod_cond is endsym<nofun> {*}
sub statement_mod_cond__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_cond:*',$retree); }
sub statement_mod_cond {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE statement_mod_cond');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'statement_mod_cond') {
$C->deb("Fate passed to statement_mod_cond: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT statement_mod_cond';
}
else {
$x = 'ALTLTM statement_mod_cond';
}
}
else {
$x = 'ALTLTM statement_mod_cond';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'statement_mod_cond:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_mod_cond trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:statement_mod_loop { <sym> }
sub category__S_029statement_mod_loop__PEEK { $_[0]->_AUTOLEXpeek('category__S_029statement_mod_loop', $retree) }
sub category__S_029statement_mod_loop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_029statement_mod_loop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "statement_mod_loop";
$self->_MATCHIFYr($S, "category__S_029statement_mod_loop", $C->_EXACT("statement_mod_loop"));
}
;
## rule statement_mod_loop is endsym<nofun> {*}
sub statement_mod_loop__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_loop:*',$retree); }
sub statement_mod_loop {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE statement_mod_loop');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'statement_mod_loop') {
$C->deb("Fate passed to statement_mod_loop: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT statement_mod_loop';
}
else {
$x = 'ALTLTM statement_mod_loop';
}
}
else {
$x = 'ALTLTM statement_mod_loop';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'statement_mod_loop:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_mod_loop trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:infix_prefix_meta_operator { <sym> }
sub category__S_030infix_prefix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_030infix_prefix_meta_operator', $retree) }
sub category__S_030infix_prefix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_030infix_prefix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "infix_prefix_meta_operator";
$self->_MATCHIFYr($S, "category__S_030infix_prefix_meta_operator", $C->_EXACT("infix_prefix_meta_operator"));
}
;
## token infix_prefix_meta_operator is binary {*}
sub infix_prefix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator:*',$retree); }
sub infix_prefix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE infix_prefix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'infix_prefix_meta_operator') {
$C->deb("Fate passed to infix_prefix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT infix_prefix_meta_operator';
}
else {
$x = 'ALTLTM infix_prefix_meta_operator';
}
}
else {
$x = 'ALTLTM infix_prefix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'infix_prefix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_prefix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:infix_postfix_meta_operator { <sym> }
sub category__S_031infix_postfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_031infix_postfix_meta_operator', $retree) }
sub category__S_031infix_postfix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_031infix_postfix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "infix_postfix_meta_operator";
$self->_MATCHIFYr($S, "category__S_031infix_postfix_meta_operator", $C->_EXACT("infix_postfix_meta_operator"));
}
;
## token infix_postfix_meta_operator ($op) is binary {*}
sub infix_postfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('infix_postfix_meta_operator:*',$retree); }
sub infix_postfix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE infix_postfix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'infix_postfix_meta_operator') {
$C->deb("Fate passed to infix_postfix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT infix_postfix_meta_operator';
}
else {
$x = 'ALTLTM infix_postfix_meta_operator';
}
}
else {
$x = 'ALTLTM infix_postfix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'infix_postfix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_postfix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:infix_circumfix_meta_operator { <sym> }
sub category__S_032infix_circumfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_032infix_circumfix_meta_operator', $retree) }
sub category__S_032infix_circumfix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_032infix_circumfix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "infix_circumfix_meta_operator";
$self->_MATCHIFYr($S, "category__S_032infix_circumfix_meta_operator", $C->_EXACT("infix_circumfix_meta_operator"));
}
;
## token infix_circumfix_meta_operator is binary {*}
sub infix_circumfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('infix_circumfix_meta_operator:*',$retree); }
sub infix_circumfix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE infix_circumfix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'infix_circumfix_meta_operator') {
$C->deb("Fate passed to infix_circumfix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT infix_circumfix_meta_operator';
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator';
}
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'infix_circumfix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_circumfix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:postfix_prefix_meta_operator { <sym> }
sub category__S_033postfix_prefix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_033postfix_prefix_meta_operator', $retree) }
sub category__S_033postfix_prefix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_033postfix_prefix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "postfix_prefix_meta_operator";
$self->_MATCHIFYr($S, "category__S_033postfix_prefix_meta_operator", $C->_EXACT("postfix_prefix_meta_operator"));
}
;
## token postfix_prefix_meta_operator is unary {*}
sub postfix_prefix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('postfix_prefix_meta_operator:*',$retree); }
sub postfix_prefix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE postfix_prefix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'postfix_prefix_meta_operator') {
$C->deb("Fate passed to postfix_prefix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT postfix_prefix_meta_operator';
}
else {
$x = 'ALTLTM postfix_prefix_meta_operator';
}
}
else {
$x = 'ALTLTM postfix_prefix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'postfix_prefix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postfix_prefix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:prefix_postfix_meta_operator { <sym> }
sub category__S_034prefix_postfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_034prefix_postfix_meta_operator', $retree) }
sub category__S_034prefix_postfix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_034prefix_postfix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "prefix_postfix_meta_operator";
$self->_MATCHIFYr($S, "category__S_034prefix_postfix_meta_operator", $C->_EXACT("prefix_postfix_meta_operator"));
}
;
## token prefix_postfix_meta_operator is unary {*}
sub prefix_postfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('prefix_postfix_meta_operator:*',$retree); }
sub prefix_postfix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE prefix_postfix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'prefix_postfix_meta_operator') {
$C->deb("Fate passed to prefix_postfix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT prefix_postfix_meta_operator';
}
else {
$x = 'ALTLTM prefix_postfix_meta_operator';
}
}
else {
$x = 'ALTLTM prefix_postfix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'prefix_postfix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("prefix_postfix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:prefix_circumfix_meta_operator { <sym> }
sub category__S_035prefix_circumfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('category__S_035prefix_circumfix_meta_operator', $retree) }
sub category__S_035prefix_circumfix_meta_operator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_035prefix_circumfix_meta_operator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "prefix_circumfix_meta_operator";
$self->_MATCHIFYr($S, "category__S_035prefix_circumfix_meta_operator", $C->_EXACT("prefix_circumfix_meta_operator"));
}
;
## token prefix_circumfix_meta_operator is unary {*}
sub prefix_circumfix_meta_operator__PEEK { $_[0]->_AUTOLEXpeek('prefix_circumfix_meta_operator:*',$retree); }
sub prefix_circumfix_meta_operator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE prefix_circumfix_meta_operator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'prefix_circumfix_meta_operator') {
$C->deb("Fate passed to prefix_circumfix_meta_operator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT prefix_circumfix_meta_operator';
}
else {
$x = 'ALTLTM prefix_circumfix_meta_operator';
}
}
else {
$x = 'ALTLTM prefix_circumfix_meta_operator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'prefix_circumfix_meta_operator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("prefix_circumfix_meta_operator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:terminator { <sym> }
sub category__S_036terminator__PEEK { $_[0]->_AUTOLEXpeek('category__S_036terminator', $retree) }
sub category__S_036terminator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_036terminator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "terminator";
$self->_MATCHIFYr($S, "category__S_036terminator", $C->_EXACT("terminator"));
}
;
## token terminator {*}
sub terminator__PEEK { $_[0]->_AUTOLEXpeek('terminator:*',$retree); }
sub terminator {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE terminator');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'terminator') {
$C->deb("Fate passed to terminator: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT terminator';
}
else {
$x = 'ALTLTM terminator';
}
}
else {
$x = 'ALTLTM terminator';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'terminator:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("terminator trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token unspacey { <.unsp>? }
sub unspacey__PEEK { $_[0]->_AUTOLEXpeek('unspacey', $retree) }
sub unspacey {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unspacey");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unspacey", $C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->unsp)) { ($C) } else { () }
}));
}
;
## token begid { <?before \w> }
sub begid__PEEK { $_[0]->_AUTOLEXpeek('begid', $retree) }
sub begid {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE begid");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "begid", $C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G\w/)
}))) { ($C) } else { () }
}));
}
;
## token endid { <?before <-[ \- \' \w ]> > }
sub endid__PEEK { $_[0]->_AUTOLEXpeek('endid', $retree) }
sub endid {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE endid");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "endid", $C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G[^\-\'\w]/)
}))) { ($C) } else { () }
}));
}
;
## token spacey { <?before <[ \s \# ]> > }
sub spacey__PEEK { $_[0]->_AUTOLEXpeek('spacey', $retree) }
sub spacey {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE spacey");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "spacey", $C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G[\s\#]/)
}))) { ($C) } else { () }
}));
}
;
## token keyspace { <!before '('> [ <?before <[ \s \# ]> > || <.panic: "Whitespace required after keywo
sub keyspace__PEEK { $_[0]->_AUTOLEXpeek('keyspace', $retree) }
sub keyspace {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE keyspace");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "keyspace", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G[\s\#]/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token nofun { <!before '(' | '.(' | '\\' | '\'' | '-' | "'" | \w > }
sub nofun__PEEK { $_[0]->_AUTOLEXpeek('nofun', $retree) }
sub nofun {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE nofun");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "nofun", $C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'nofun_0') {
$C->deb("Fate passed to nofun_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT nofun_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM nofun_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'nofun_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("nofun_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sigil:sym<$> { <sym> }
sub sigil__S_037Dollar__PEEK { $_[0]->_AUTOLEXpeek('sigil__S_037Dollar', $retree) }
sub sigil__S_037Dollar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigil__S_037Dollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$";
$self->_MATCHIFYr($S, "sigil__S_037Dollar", $C->_EXACT("\$"));
}
;
## token sigil:sym<@> { <sym> }
sub sigil__S_038At__PEEK { $_[0]->_AUTOLEXpeek('sigil__S_038At', $retree) }
sub sigil__S_038At {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigil__S_038At");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@";
$self->_MATCHIFYr($S, "sigil__S_038At", $C->_EXACT("\@"));
}
;
## token sigil:sym<%> { <sym> }
sub sigil__S_039Percent__PEEK { $_[0]->_AUTOLEXpeek('sigil__S_039Percent', $retree) }
sub sigil__S_039Percent {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigil__S_039Percent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%";
$self->_MATCHIFYr($S, "sigil__S_039Percent", $C->_EXACT("\%"));
}
;
## token sigil:sym<&> { <sym> }
sub sigil__S_040Amp__PEEK { $_[0]->_AUTOLEXpeek('sigil__S_040Amp', $retree) }
sub sigil__S_040Amp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigil__S_040Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "sigil__S_040Amp", $C->_EXACT("\&"));
}
;
## token twigil:sym<.> { <sym> }
sub twigil__S_041Dot__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_041Dot', $retree) }
sub twigil__S_041Dot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_041Dot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.";
$self->_MATCHIFYr($S, "twigil__S_041Dot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\."))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<!> { <sym> }
sub twigil__S_042Bang__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_042Bang', $retree) }
sub twigil__S_042Bang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_042Bang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!";
$self->_MATCHIFYr($S, "twigil__S_042Bang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<^> { <sym> }
sub twigil__S_043Caret__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_043Caret', $retree) }
sub twigil__S_043Caret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_043Caret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^";
$self->_MATCHIFYr($S, "twigil__S_043Caret", do {
my $C = $C;
if (($C) = ($C->_EXACT("\^"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<:> { <sym> }
sub twigil__S_044Colon__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_044Colon', $retree) }
sub twigil__S_044Colon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_044Colon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:";
$self->_MATCHIFYr($S, "twigil__S_044Colon", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<*> { <sym> }
sub twigil__S_045Star__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_045Star', $retree) }
sub twigil__S_045Star {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_045Star");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*";
$self->_MATCHIFYr($S, "twigil__S_045Star", do {
my $C = $C;
if (($C) = ($C->_EXACT("\*"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<?> { <sym> }
sub twigil__S_046Question__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_046Question', $retree) }
sub twigil__S_046Question {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_046Question");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?";
$self->_MATCHIFYr($S, "twigil__S_046Question", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<=> { <sym> }
sub twigil__S_047Equal__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_047Equal', $retree) }
sub twigil__S_047Equal {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_047Equal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=";
$self->_MATCHIFYr($S, "twigil__S_047Equal", do {
my $C = $C;
if (($C) = ($C->_EXACT("\="))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token twigil:sym<~> { <sym> }
sub twigil__S_048Tilde__PEEK { $_[0]->_AUTOLEXpeek('twigil__S_048Tilde', $retree) }
sub twigil__S_048Tilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE twigil__S_048Tilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~";
$self->_MATCHIFYr($S, "twigil__S_048Tilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~"))
and ($C) = ($C->begid)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token stopper { <!> }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
;
## regex liststopper {
sub liststopper__PEEK { $_[0]->_AUTOLEXpeek('liststopper', $retree) }
sub liststopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE liststopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFY($S, "liststopper", $C->_BRACKET(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'liststopper_0') {
$C->deb("Fate passed to liststopper_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT liststopper_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM liststopper_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'liststopper_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("liststopper_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## regex stdstopper {
sub stdstopper__PEEK { $_[0]->_AUTOLEXpeek('stdstopper', $retree) }
sub stdstopper {
no warnings 'recursion';
my $self = shift;
local $::STUB = $::STUB = return $self if exists $::MEMOS[$self->{'_pos'}]->{'endstmt'};
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stdstopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFY($S, "stdstopper", LazyMap::lazymap(sub {
my $C=shift;
scalar(do {
$::MEMOS[$C->{'_pos'}]->{'endstmt'} ||= 1}, $C)
},
$C->_BRACKET(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'stdstopper_0') {
$C->deb("Fate passed to stdstopper_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT stdstopper_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM stdstopper_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'stdstopper_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("stdstopper_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token longname {
sub longname__PEEK { $_[0]->_AUTOLEXpeek('longname', $retree) }
sub longname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE longname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'colonpair'} = [];
$self->_MATCHIFYr($S, "longname", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['name'], sub {
my $C = shift;
$C->name
}))
and ($C) = (scalar(do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token name {
sub name__PEEK { $_[0]->_AUTOLEXpeek('name', $retree) }
sub name {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE name");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'morename'} = [];
$self->_MATCHIFYr($S, "name", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'name_0') {
$C->deb("Fate passed to name_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT name_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM name_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'name_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("name_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token morename {
sub morename__PEEK { $_[0]->_AUTOLEXpeek('morename', $retree) }
sub morename {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE morename");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'EXPR'} = [];
$C->{'identifier'} = [];
$self->_MATCHIFYr($S, "morename", do {
if (my ($C) = ($C->_EXACT("\:\:"))) {
$C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'morename_0') {
$C->deb("Fate passed to morename_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT morename_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM morename_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'morename_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("morename_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'morename_1') {
$C->deb("Fate passed to morename_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT morename_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM morename_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'morename_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("morename_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'indirect name', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token starter { $start }
sub starter__PEEK { $_[0]->_AUTOLEXpeek('starter', $retree) }
sub starter {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE starter");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "starter", $C->_EXACT($start));
}
;
## token stopper { $stop }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_EXACT($stop));
}
;
};
eval $eval;
die $@ if $@;
return $mixin;
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token starter { <!> }
sub starter__PEEK { $_[0]->_AUTOLEXpeek('starter', $retree) }
sub starter {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE starter");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "starter", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
;
## token stopper { $stop }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_EXACT($stop));
}
;
};
eval $eval;
die $@ if $@;
return $mixin;
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token unitstopper { $stop }
sub unitstopper__PEEK { $_[0]->_AUTOLEXpeek('unitstopper', $retree) }
sub unitstopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unitstopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unitstopper", $C->_EXACT($stop));
}
};
eval $eval;
die $@ if $@;
return $mixin;
}
1; };
## token unitstopper { $ }
sub unitstopper__PEEK { $_[0]->_AUTOLEXpeek('unitstopper', $retree) }
sub unitstopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unitstopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unitstopper", $C->_PATTERN(qr/\G\z/));
}
;
## method balanced ($start,$stop)
sub balanced {
no warnings 'recursion';
my $self = shift;
die 'Required argument start omitted' unless @_;
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token charname {
sub charname__PEEK { $_[0]->_AUTOLEXpeek('charname', $retree) }
sub charname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE charname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "charname", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'charname_0') {
$C->deb("Fate passed to charname_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT charname_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM charname_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'charname_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("charname_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'charname_1') {
$C->deb("Fate passed to charname_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT charname_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM charname_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'charname_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("charname_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token charnames { \s* [<charname><.ws>] +% [','\s*] }
sub charnames__PEEK { $_[0]->_AUTOLEXpeek('charnames', $retree) }
sub charnames {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE charnames");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'charname'} = [];
$self->_MATCHIFYr($S, "charnames", do {
if (my ($C) = ($C->_PATTERN(qr/\G\s*+/))) {
$C->_REPSEPr( sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G\,\s*+/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token charspec {
sub charspec__PEEK { $_[0]->_AUTOLEXpeek('charspec', $retree) }
sub charspec {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE charspec");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "charspec", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'charspec_0') {
$C->deb("Fate passed to charspec_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT charspec_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM charspec_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'charspec_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("charspec_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['charnames'], sub {
my $C = shift;
$C->charnames
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'character name', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
$C->_PATTERN(qr/\G[?-Z\\-_]/)
},
sub {
my $C=shift;
if (($C) = ($C->before(sub {
my $C=shift;
$C
}))
and ($C) = ($C->sorry("Unrecognized \\c character"))) {
$C->cursor_incr()
} else { () }
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}));
}
;
## token backslash {*}
sub backslash__PEEK { $_[0]->_AUTOLEXpeek('backslash:*',$retree); }
sub backslash {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE backslash');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'backslash') {
$C->deb("Fate passed to backslash: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT backslash';
}
else {
$x = 'ALTLTM backslash';
}
}
else {
$x = 'ALTLTM backslash';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'backslash:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
;
## token escape {*}
sub escape__PEEK { $_[0]->_AUTOLEXpeek('escape:*',$retree); }
sub escape {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE escape');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'escape') {
$C->deb("Fate passed to escape: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT escape';
}
else {
$x = 'ALTLTM escape';
}
}
else {
$x = 'ALTLTM escape';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'escape:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("escape trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token starter { <!> }
sub starter__PEEK { $_[0]->_AUTOLEXpeek('starter', $retree) }
sub starter {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE starter");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "starter", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
;
## token escape:none { <!> }
sub escape__S_049none__PEEK { $_[0]->_AUTOLEXpeek('escape__S_049none', $retree) }
sub escape__S_049none {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_049none");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "none";
$self->_MATCHIFYr($S, "escape__S_049none", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
;
## method nibble ($lang)
sub nibble {
no warnings 'recursion';
my $self = shift;
die 'Required argument lang omitted' unless @_;
my $lang = @_ ? shift() : undef;
$self->cursor_fresh($lang)->nibbler};
## token nibbler {
sub nibbler__PEEK { $_[0]->_AUTOLEXpeek('nibbler', $retree) }
sub nibbler {
no warnings 'recursion';
my $self = shift;
my $text = '';my $from = $self->{'_pos'};my $to = $from;my @nibbles = ();my $multiline = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE nibbler");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'escape'} = [];
$C->{'nibbler'} = [];
$C->{'starter'} = [];
$C->{'stopper'} = [];
$self->_MATCHIFYr($S, "nibbler", do {
my $C = $C;
if (($C) = (scalar(do {
$self->from = $self->{'_pos'}}, $C))
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
$C->{'stopper'} = [];
$C->_SUBSUMEr(['stopper'], sub {
my $C = shift;
$C->stopper
})
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['starter'], sub {
my $C = shift;
$C->starter
}))
and ($C) = ($C->_SUBSUMEr(['nibbler'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
$text = '';
$to = $from = $C->{'_pos'};
}, $C)
} else { () }
}
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->cursor_incr())) {
scalar(do {
my $ch = substr($self->orig, $C->{'_pos'}-1, 1);
$text .= $ch;
$to = $C->{'_pos'};
if ($ch =~ "\n") {
$multiline++};
}, $C)
} else { () }
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub babble__PEEK { $_[0]->_AUTOLEXpeek('babble', $retree) }
sub babble {
no warnings 'recursion';
my $self = shift;
die 'Required argument l omitted' unless @_;
my $l = @_ ? shift() : undef;
my $lang = $l;my $start;my $stop;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE babble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'quotepair'} = [];
$self->_MATCHIFYr($S, "babble", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token stopper { ^^ {} $<ws>=(\h*?) $*DELIM \h* <.unv>?? $$ \v? }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?m:^)/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['ws'], sub {
my $C = shift;
$C->_PAREN( sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $lang = $herestub->lang->mixin( 'STD::herestop' );
my $doc;
if (($doc) = $here->nibble($lang)) {
$here = $doc->trim_heredoc();
$herestub->orignode->{'doc'} = $doc;
}
else {
$self->panic("Ending delimiter $::DELIM not found")};
}
;
return $self->cursor($here->{'_pos'});
};
## token quibble ($l) {
sub quibble__PEEK { $_[0]->_AUTOLEXpeek('quibble', $retree) }
sub quibble {
no warnings 'recursion';
my $self = shift;
die 'Required argument l omitted' unless @_;
my $l = @_ ? shift() : undef;
my ($lang, $start, $stop);
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quibble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "quibble", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['babble'], sub {
my $C = shift;
$C->babble($l)
}))
and ($C) = (scalar(do {
my $M = $C;
my $B = $M->{'babble'}->{'B'};
($lang,$start,$stop) = @$B;
}, $C))
and ($C) = ($C->_EXACT($start))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($lang)
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_EXACT($stop))) { ($C) } else { () }
}
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quotepair {
sub quotepair__PEEK { $_[0]->_AUTOLEXpeek('quotepair', $retree) }
sub quotepair {
no warnings 'recursion';
my $self = shift;
my $key;my $value;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quotepair");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'circumfix'} = [];
$self->_MATCHIFYr($S, "quotepair", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quotepair_0') {
$C->deb("Fate passed to quotepair_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quotepair_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quotepair_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'quotepair_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quotepair_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = (scalar(do {
my $M = $C;
$key = $M->{'identifier'}->Str}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->unsp)) { ($C) } else { () }
}))
and ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$key}))) {
$C->_SUBSUMEblock('v', sub {
my $C = shift;
$value})
} else { () }
});
}
;
## token quote:sym<' '> { :dba('single quotes') "'" ~ "'" <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(
sub quote__S_050Single_Single__PEEK { $_[0]->_AUTOLEXpeek('quote__S_050Single_Single', $retree) }
sub quote__S_050Single_Single {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_050Single_Single");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\'\ \'";
$self->_MATCHIFYr($S, "quote__S_050Single_Single", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\'";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("\'"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('q' => 1)->unbalanced("'"))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\'")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'single quotes', $goalpos))) { ($C) } else { () }
}
};
@gather;
}
}))) {
$C
} else { () }
}));
}
;
## token quote:sym<" "> { :dba('double quotes') '"' ~ '"' <nibble($¢.cursor_fresh( %*LANG<Q> ).tweak(
sub quote__S_051Double_Double__PEEK { $_[0]->_AUTOLEXpeek('quote__S_051Double_Double', $retree) }
sub quote__S_051Double_Double {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_051Double_Double");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\"\ \"";
$self->_MATCHIFYr($S, "quote__S_051Double_Double", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\"";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("\""))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->unbalanced('"'))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\"")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'double quotes', $goalpos))) { ($C) } else { () }
}
};
@gather;
}
}))) {
$C
} else { () }
}));
}
;
## token circumfix:sym<« »> { :dba('shell-quote words') '«' ~ '»' <nibble($¢.cursor_fresh( %*LANG<Q>
sub circumfix__S_052Fre_Nch__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_052Fre_Nch', $retree) }
sub circumfix__S_052Fre_Nch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_052Fre_Nch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "«\ »";
$self->_MATCHIFYr($S, "circumfix__S_052Fre_Nch", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "»";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("«"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->tweak('ww' => 1)->balanced('«','»'))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("»")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'shell-quote words', $goalpos))) { ($C) } else { () }
}
};
@gather;
}
}))) {
$C
} else { () }
}));
}
;
## token circumfix:sym«<< >>» { :dba('shell-quote words') '<<' ~ '>>' <nibble($¢.cursor_fresh( %*LANG<Q
sub circumfix__S_053LtLt_GtGt__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_053LtLt_GtGt', $retree) }
sub circumfix__S_053LtLt_GtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_053LtLt_GtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<\ \>\>";
$self->_MATCHIFYr($S, "circumfix__S_053LtLt_GtGt", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\>\>";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("\<\<"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->tweak('ww' => 1)->balanced('<<','>>'))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\>\>")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'shell-quote words', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token circumfix:sym«< >» { :dba('quote words') '<' ~ '>'
sub circumfix__S_054Lt_Gt__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_054Lt_Gt', $retree) }
sub circumfix__S_054Lt_Gt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_054Lt_Gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\ \>";
$self->_MATCHIFYr($S, "circumfix__S_054Lt_Gt", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\>";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("\<"))
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->_EXACT("\>")
}))) { ($C) } else { () }
}))
and ($C) = ($C->obs('<>', "lines() to read input,\n or ('') to represent the null string,\n or () to represent Nil"))) {
$C
} else { () }
}))) { ($C) } else { () }
}))) {
$C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('q' => 1)->tweak('w' => 1)->balanced('<','>'))
})
} else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\>")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'quote words', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token ws {
sub ws__PEEK { $_[0]->_AUTOLEXpeek('ws', $retree) }
sub ws {
no warnings 'recursion';
my $self = shift;
local $::STUB = $::STUB = return $self if exists $::MEMOS[$self->{'_pos'}]->{'ws'};my $startpos = $self->{'_pos'};local $::HIGHEXPECT = {
};
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE ws");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "ws", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'ws_0') {
$C->deb("Fate passed to ws_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT ws_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM ws_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'ws_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("ws_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'ws_1') {
$C->deb("Fate passed to ws_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT ws_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM ws_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'ws_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("ws_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token unsp {
sub unsp__PEEK { $_[0]->_AUTOLEXpeek('unsp', $retree) }
sub unsp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unsp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unsp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'unsp_0') {
$C->deb("Fate passed to unsp_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT unsp_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM unsp_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'unsp_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("unsp_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'unsp_1') {
$C->deb("Fate passed to unsp_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT unsp_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM unsp_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'unsp_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("unsp_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token vws {
sub vws__PEEK { $_[0]->_AUTOLEXpeek('vws', $retree) }
sub vws {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE vws");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "vws", $C->_PLUSr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'vws_0') {
$C->deb("Fate passed to vws_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT vws_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM vws_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'vws_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("vws_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token unv {
sub unv__PEEK { $_[0]->_AUTOLEXpeek('unv', $retree) }
sub unv {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unv");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'comment'} = [];
$self->_MATCHIFYr($S, "unv", $C->_PLUSr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'unv_0') {
$C->deb("Fate passed to unv_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT unv_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM unv_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'unv_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("unv_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'unv_1') {
$C->deb("Fate passed to unv_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT unv_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM unv_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'unv_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("unv_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token comment:sym<#`(...)> {
sub comment__S_055SharpGraveParenDotDotDotThesis__PEEK { $_[0]->_AUTOLEXpeek('comment__S_055SharpGraveParenDotDotDotThesis', $retree) }
sub comment__S_055SharpGraveParenDotDotDotThesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comment__S_055SharpGraveParenDotDotDotThesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#\`\(\.\.\.\)";
$self->_MATCHIFYr($S, "comment__S_055SharpGraveParenDotDotDotThesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#\`"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->opener)) { ($C) } else { () }
}))) { ($C) } else { () }
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Opening bracket is required for #` comment"))) { ($C) } else { () }
}
};
@gather;
}
}))
and ($C) = ($C->quibble($C->cursor_fresh( $::LANG{'Q'} )))) {
$C
} else { () }
});
}
;
## token comment:sym<#(...)> {
sub comment__S_056SharpParenDotDotDotThesis__PEEK { $_[0]->_AUTOLEXpeek('comment__S_056SharpParenDotDotDotThesis', $retree) }
sub comment__S_056SharpParenDotDotDotThesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comment__S_056SharpParenDotDotDotThesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#\(\.\.\.\)";
$self->_MATCHIFYr($S, "comment__S_056SharpParenDotDotDotThesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->opener)) { ($C) } else { () }
}))
and ($C) = ($C->suppose(sub {
my $C=shift;
do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} ))
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?:[,;:])*+[\x20\t\r]*+/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'comment__S_056SharpParenDotDotDotThesis_0') {
$C->deb("Fate passed to comment__S_056SharpParenDotDotDotThesis_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT comment__S_056SharpParenDotDotDotThesis_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM comment__S_056SharpParenDotDotDotThesis_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'comment__S_056SharpParenDotDotDotThesis_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("comment__S_056SharpParenDotDotDotThesis_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token comment:sym<#=(...)> {
sub comment__S_057SharpEqualParenDotDotDotThesis__PEEK { $_[0]->_AUTOLEXpeek('comment__S_057SharpEqualParenDotDotDotThesis', $retree) }
sub comment__S_057SharpEqualParenDotDotDotThesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comment__S_057SharpEqualParenDotDotDotThesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#\=\(\.\.\.\)";
$self->_MATCHIFYr($S, "comment__S_057SharpEqualParenDotDotDotThesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#\="))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->opener)) { ($C) } else { () }
}))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} ))
})
} else { () }
});
}
;
## token comment:sym<#=> {
sub comment__S_058SharpEqual__PEEK { $_[0]->_AUTOLEXpeek('comment__S_058SharpEqual', $retree) }
sub comment__S_058SharpEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comment__S_058SharpEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#\=";
$self->_MATCHIFYr($S, "comment__S_058SharpEqual", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#\="))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['attachment'], sub {
my $C = shift;
$C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token comment:sym<#> {
sub comment__S_059Sharp__PEEK { $_[0]->_AUTOLEXpeek('comment__S_059Sharp', $retree) }
sub comment__S_059Sharp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comment__S_059Sharp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#";
$self->_MATCHIFYr($S, "comment__S_059Sharp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#"))
and ($C) = (scalar(do {
}, $C))) {
$C->_STARr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token ident {
sub ident__PEEK { $_[0]->_AUTOLEXpeek('ident', $retree) }
sub ident {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE ident");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "ident", $C->_PATTERN(qr/\G[_[:alpha:]]\w*+/));
}
;
## token apostrophe {
sub apostrophe__PEEK { $_[0]->_AUTOLEXpeek('apostrophe', $retree) }
sub apostrophe {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE apostrophe");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "apostrophe", $C->_PATTERN(qr/\G['\-]/));
}
;
## token identifier {
sub identifier__PEEK { $_[0]->_AUTOLEXpeek('identifier', $retree) }
sub identifier {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE identifier");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "identifier", do {
if (my ($C) = ($C->ident)) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->apostrophe)
and ($C) = ($C->ident)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token pod_comment {
sub pod_comment__PEEK { $_[0]->_AUTOLEXpeek('pod_comment', $retree) }
sub pod_comment {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE pod_comment");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "pod_comment", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?m:^)[\x20\t\r]*+\=/))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->unsp)) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'pod_comment_0') {
$C->deb("Fate passed to pod_comment_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT pod_comment_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM pod_comment_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'pod_comment_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("pod_comment_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\Gbegin[\x20\t\r]++/))
and ($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (LazyMap::lazymap(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\n"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+\=/))
share/P6STD/boot/STD.pmc view on Meta::CPAN
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
my $M = $C;
$M->{'identifier'}->Str eq 'END'})
}))) {
$C->_STARr(sub {
my $C=shift;
$C->cursor_incr()
})
} else { () }
}
}
or $xact->[-2] or
do {
push @gather, scalar(do {
my $M = $C;
my $id = $M->{'identifier'}->Str;
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\Gbegin\b/))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G(?m:$)/)
}
or $xact->[-2] or
do {
push @gather, $C->_EXACT("\#")
}
or $xact->[-2] or
share/P6STD/boot/STD.pmc view on Meta::CPAN
})
} else { () }
}
};
@gather;
}
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (LazyMap::lazymap(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\n"))
and ($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+\=/))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\Gfor\b/))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
})
} else { () }
}
};
@gather;
}
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (LazyMap::lazymap(sub {
my $C=shift;
$C->_PATTERN(qr/\G(?m:^)[\x20\t\r]*+(?m:$)/)
},
$C->_SCANf()))) { ($C) } else { () }
}
}
or $xact->[-2] or
do {
push @gather, $C->_STARr(sub {
my $C=shift;
$C->cursor_incr()
})
};
@gather;
}
}))) {
$C
} else { () }
},
sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->_SCANf()))) { ($C) } else { () }
}))) { ($C) } else { () }
}))
and ($C) = ($C->panic("Obsolescent pod format, please use =begin/=end instead"))) {
$C
} else { () }
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G[_[:alpha:]]/)
}
or $xact->[-2] or
do {
push @gather, $C->_PATTERN(qr/\G\s/)
}
or $xact->[-2] or
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token embeddedblock {
sub embeddedblock__PEEK { $_[0]->_AUTOLEXpeek('embeddedblock', $retree) }
sub embeddedblock {
no warnings 'recursion';
my $self = shift;
local %::LANG = %::LANG;local $::SIGNUM;local $::GOAL = '}';local $::CURLEX = $::CURLEX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE embeddedblock");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "embeddedblock", do {
my $C = $C;
if (($C) = ($C->newlex)
and ($C) = ($C->finishlex)
and ($C) = ($C->_EXACT("\{"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($::LANG{'MAIN'});
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['statementlist'], sub {
my $C = shift;
$C->statementlist
})
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Unable to parse statement list; couldn't find right brace"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token binints { [<.ws><binint><.ws>] +% ',' }
sub binints__PEEK { $_[0]->_AUTOLEXpeek('binints', $retree) }
sub binints {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE binints");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'binint'} = [];
$self->_MATCHIFYr($S, "binints", $C->_REPSEPr( sub {
my $C=shift;
$C->_EXACT("\,")
}, sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token binint {
sub binint__PEEK { $_[0]->_AUTOLEXpeek('binint', $retree) }
sub binint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE binint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "binint", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?:[0-1])++/))) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G_(?:[0-1])++/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token octints { [<.ws><octint><.ws>] +% ',' }
sub octints__PEEK { $_[0]->_AUTOLEXpeek('octints', $retree) }
sub octints {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE octints");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'octint'} = [];
$self->_MATCHIFYr($S, "octints", $C->_REPSEPr( sub {
my $C=shift;
$C->_EXACT("\,")
}, sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token octint {
sub octint__PEEK { $_[0]->_AUTOLEXpeek('octint', $retree) }
sub octint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE octint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "octint", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?:[0-7])++/))) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G_(?:[0-7])++/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token hexints { [<.ws><hexint><.ws>] +% ',' }
sub hexints__PEEK { $_[0]->_AUTOLEXpeek('hexints', $retree) }
sub hexints {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE hexints");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'hexint'} = [];
$self->_MATCHIFYr($S, "hexints", $C->_REPSEPr( sub {
my $C=shift;
$C->_EXACT("\,")
}, sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token hexint {
sub hexint__PEEK { $_[0]->_AUTOLEXpeek('hexint', $retree) }
sub hexint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE hexint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "hexint", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?:[0-9a-fA-F])++/))) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G_(?:[0-9a-fA-F])++/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token decints { [<.ws><decint><.ws>] +% ',' }
sub decints__PEEK { $_[0]->_AUTOLEXpeek('decints', $retree) }
sub decints {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE decints");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'decint'} = [];
$self->_MATCHIFYr($S, "decints", $C->_REPSEPr( sub {
my $C=shift;
$C->_EXACT("\,")
}, sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token decint {
sub decint__PEEK { $_[0]->_AUTOLEXpeek('decint', $retree) }
sub decint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE decint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "decint", do {
if (my ($C) = ($C->_PATTERN(qr/\G\d++/))) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G_\d++/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token integer {
sub integer__PEEK { $_[0]->_AUTOLEXpeek('integer', $retree) }
sub integer {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE integer");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "integer", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'integer_0') {
$C->deb("Fate passed to integer_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT integer_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM integer_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'integer_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("integer_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'integer_1') {
$C->deb("Fate passed to integer_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT integer_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM integer_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'integer_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("integer_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'integer_2') {
$C->deb("Fate passed to integer_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT integer_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM integer_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'integer_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("integer_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token radint {
sub radint__PEEK { $_[0]->_AUTOLEXpeek('radint', $retree) }
sub radint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE radint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "radint", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'radint_0') {
$C->deb("Fate passed to radint_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT radint_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM radint_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'radint_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("radint_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escale {
sub escale__PEEK { $_[0]->_AUTOLEXpeek('escale', $retree) }
sub escale {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escale");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "escale", do {
if (my ($C) = ($C->_PATTERN(qr/\G[Ee](?:[+\-])?+/))) {
$C->_SUBSUMEr(['decint'], sub {
my $C = shift;
$C->decint
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token dec_number {
sub dec_number__PEEK { $_[0]->_AUTOLEXpeek('dec_number', $retree) }
sub dec_number {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dec_number");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'escale'} = [];
$self->_MATCHIFYr($S, "dec_number", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'dec_number_0') {
$C->deb("Fate passed to dec_number_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT dec_number_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM dec_number_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'dec_number_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("dec_number_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token alnumint {
sub alnumint__PEEK { $_[0]->_AUTOLEXpeek('alnumint', $retree) }
sub alnumint {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE alnumint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "alnumint", $C->_BRACKETr(sub {
my $C=shift;
if (my ($C) = ($C->_PATTERN(qr/\G(?:[0-9a-zA-Z])++/))) {
$C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G_(?:[0-9a-zA-Z])++/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token rad_number {
sub rad_number__PEEK { $_[0]->_AUTOLEXpeek('rad_number', $retree) }
sub rad_number {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE rad_number");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'base'} = [];
$C->{'exp'} = [];
$self->_MATCHIFYr($S, "rad_number", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_SUBSUMEr(['radix'], sub {
my $C = shift;
$C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
})
}))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->unsp)) { ($C) } else { () }
}))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\<"))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'rad_number_0') {
$C->deb("Fate passed to rad_number_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT rad_number_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM rad_number_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD', 'rad_number_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("rad_number_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
if (($C) = ($C->_EXACT("\*"))
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['base'], sub {
my $C = shift;
$C->radint
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\*\*"))
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['exp'], sub {
my $C = shift;
$C->radint
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<)>
sub terminator__S_060Thesis__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_060Thesis', $retree) }
sub terminator__S_060Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_060Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\)";
$self->_MATCHIFYr($S, "terminator__S_060Thesis", do {
if (my ($C) = ($C->_EXACT("\)"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<]>
sub terminator__S_061Ket__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_061Ket', $retree) }
sub terminator__S_061Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_061Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\]";
$self->_MATCHIFYr($S, "terminator__S_061Ket", do {
if (my ($C) = ($C->_EXACT("\]"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<}>
sub terminator__S_062Ly__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_062Ly', $retree) }
sub terminator__S_062Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_062Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\}";
$self->_MATCHIFYr($S, "terminator__S_062Ly", do {
if (my ($C) = ($C->_EXACT("\}"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
our %close2open = reverse %open2close;
## token opener {
sub opener__PEEK { $_[0]->_AUTOLEXpeek('opener', $retree) }
sub opener {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE opener");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "opener", $C->_PATTERN(qr/\G[\x{0028}\x{003C}\x{005B}\x{007B}\x{00AB}\x{0F3A}\x{0F3C}\x{169B}\x{2018}\x{201A}\x{201B}\x{201C}\x{201E}\x{201F}\x{2039}\x{2045}\x{207D}\x{208D}\x{2208}\x{2209}\x{220A}\x{2215}\x{223C}\x{2243}\x{2252...
}
;
{ package STD::P6;
use Moose ':all' => { -prefix => "moose_" };
use Encode;
moose_extends('STD');
our $ALLROLES = { 'STD::P6', 1 };
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## rule comp_unit {
sub comp_unit__PEEK { $_[0]->_AUTOLEXpeek('comp_unit', $retree) }
sub comp_unit {
no warnings 'recursion';
my $self = shift;
local $::begin_compunit = 1;local $::endargs = -1;local %::LANG;local $::PKGDECL = "";local $::IN_DECL = '';local $::HAS_SELF = '';local $::DECLARAND;local $::OFTYPE;local $::NEWPKG;local $::NEWLEX;local $::QSIGIL = '';local $::IN_META = '';local $::...
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE comp_unit");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "comp_unit", do {
my $C = $C;
if (($C) = (scalar(do {
$::LANG{'MAIN'} = 'STD::P6' ;
$::LANG{'Q'} = 'STD::Q' ;
$::LANG{'Quasi'} = 'STD::Quasi' ;
$::LANG{'Regex'} = 'STD::Regex' ;
$::LANG{'P5'} = 'STD::P5' ;
share/P6STD/boot/STD.pmc view on Meta::CPAN
}, $C))
and ($C) = ($C->unitstart)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['statementlist'], sub {
my $C = shift;
$C->statementlist
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->unitstopper)) { ($C) } else { () }
}))) { ($C) } else { () }
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token pblock () {
sub pblock__PEEK { $_[0]->_AUTOLEXpeek('pblock', $retree) }
sub pblock {
no warnings 'recursion';
my $self = shift;
local $::CURLEX = $::CURLEX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE pblock");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "pblock", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'pblock_0') {
$C->deb("Fate passed to pblock_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT pblock_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM pblock_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'pblock_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("pblock_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'pblock_1') {
$C->deb("Fate passed to pblock_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT pblock_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM pblock_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'pblock_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("pblock_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token unitstart { <?> }
sub unitstart__PEEK { $_[0]->_AUTOLEXpeek('unitstart', $retree) }
sub unitstart {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unitstart");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unitstart", $C->before(sub {
my $C=shift;
$C
}));
}
;
## token lambda { '->' | '<->' }
sub lambda__PEEK { $_[0]->_AUTOLEXpeek('lambda', $retree) }
sub lambda {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE lambda");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "lambda", do {
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'lambda_0') {
$C->deb("Fate passed to lambda_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT lambda_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM lambda_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'lambda_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("lambda_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token xblock {
sub xblock__PEEK { $_[0]->_AUTOLEXpeek('xblock', $retree) }
sub xblock {
no warnings 'recursion';
my $self = shift;
local $::GOAL = '{';local $::BORG = {
};
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE xblock");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "xblock", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = (scalar(do {
my $M = $C;
$::BORG->{'culprit'} //= $M->{'EXPR'}->cursor($self->{'_pos'}) }, $C))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['pblock'], sub {
my $C = shift;
$C->pblock
})
} else { () }
});
}
;
## token block () {
sub block__PEEK { $_[0]->_AUTOLEXpeek('block', $retree) }
sub block {
no warnings 'recursion';
my $self = shift;
local $::CURLEX = $::CURLEX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE block");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "block", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\{")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token blockoid {
sub blockoid__PEEK { $_[0]->_AUTOLEXpeek('blockoid', $retree) }
sub blockoid {
no warnings 'recursion';
my $self = shift;
local %::LANG = %::LANG;local $::SIGNUM;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE blockoid");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "blockoid", do {
my $C = $C;
if (($C) = ($C->finishlex)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'blockoid_0') {
$C->deb("Fate passed to blockoid_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT blockoid_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM blockoid_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'blockoid_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("blockoid_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\{"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['statementlist'], sub {
my $C = shift;
$C->statementlist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'block', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub curlycheck__PEEK { $_[0]->_AUTOLEXpeek('curlycheck', $retree) }
sub curlycheck {
no warnings 'recursion';
my $self = shift;
die 'Required argument code omitted' unless @_;
my $code = @_ ? shift() : undef;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE curlycheck");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "curlycheck", $C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G[\x20\t\r]*+(?m:$)/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token regex_block {
sub regex_block__PEEK { $_[0]->_AUTOLEXpeek('regex_block', $retree) }
sub regex_block {
no warnings 'recursion';
my $self = shift;
local %::LANG = %::LANG;local %::RX = %::RX;my $lang = $::LANG{'Regex'};local $::GOAL = '}';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_block");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'quotepair'} = [];
$self->_MATCHIFYr($S, "regex_block", do {
my $C = $C;
if (($C) = ($C->_STARr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['quotepair'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'regex_block_0') {
$C->deb("Fate passed to regex_block_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT regex_block_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM regex_block_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'regex_block_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("regex_block_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
1})
} else { () }
},
sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\{"))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble( $C->cursor_fresh($lang)->unbalanced('}') )
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Unable to parse regex; couldn't find right brace"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statementlist {
sub statementlist__PEEK { $_[0]->_AUTOLEXpeek('statementlist', $retree) }
sub statementlist {
no warnings 'recursion';
my $self = shift;
local $::INVOCANT_OK = 0;local $::MONKEY_TYPING = $::MONKEY_TYPING;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statementlist");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'eat_terminator'} = [];
$C->{'statement'} = [];
$self->_MATCHIFYr($S, "statementlist", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statementlist_0') {
$C->deb("Fate passed to statementlist_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statementlist_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statementlist_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statementlist_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statementlist_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule semilist {
sub semilist__PEEK { $_[0]->_AUTOLEXpeek('semilist', $retree) }
sub semilist {
no warnings 'recursion';
my $self = shift;
local $::INVOCANT_OK = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE semilist");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'eat_terminator'} = [];
$C->{'statement'} = [];
$self->_MATCHIFYr($S, "semilist", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'semilist_0') {
$C->deb("Fate passed to semilist_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT semilist_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM semilist_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'semilist_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("semilist_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token label {
sub label__PEEK { $_[0]->_AUTOLEXpeek('label', $retree) }
sub label {
no warnings 'recursion';
my $self = shift;
my $label;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE label");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "label", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->_EXACT("\:"))
and ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement {
sub statement__PEEK { $_[0]->_AUTOLEXpeek('statement', $retree) }
sub statement {
no warnings 'recursion';
my $self = shift;
local $::endargs = -1;local $::QSIGIL = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'statement_mod_cond'} = [];
$C->{'statement_mod_loop'} = [];
$self->_MATCHIFYr($S, "statement", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_0') {
$C->deb("Fate passed to statement_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
})
},
sub {
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
($::MEMOS[$C->{'_pos'}]->{'endstmt'} // 0) == 2 })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_1') {
$C->deb("Fate passed to statement_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['statement_mod_cond'], sub {
my $C = shift;
$C->statement_mod_cond
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
($::MEMOS[$C->{'_pos'}]->{'endstmt'} // 0) == 2 })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_2') {
$C->deb("Fate passed to statement_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token eat_terminator {
sub eat_terminator__PEEK { $_[0]->_AUTOLEXpeek('eat_terminator', $retree) }
sub eat_terminator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE eat_terminator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "eat_terminator", $C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\;")
}
or $xact->[-2] or
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'eat_terminator_0') {
$C->deb("Fate passed to eat_terminator_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT eat_terminator_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM eat_terminator_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'eat_terminator_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("eat_terminator_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
@gather;
}
}));
}
;
## method backup_ws ()
sub backup_ws {
no warnings 'recursion';
my $self = shift;
if ($::MEMOS[$self->{'_pos'}]->{'ws'}) {
return $self->cursor($::MEMOS[$self->{'_pos'}]->{'ws'})};
return $self;
};
## rule statement_control:need {
sub statement_control__S_000need__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_000need', $retree) }
sub statement_control__S_000need {
no warnings 'recursion';
my $self = shift;
my $longname;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_000need");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'module_name'} = [];
$C->{'version'} = [];
$C->{sym} = "need";
$self->_MATCHIFYr($S, "statement_control__S_000need", do {
my $C = $C;
if (($C) = ($C->_EXACT("need"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_000need_0') {
$C->deb("Fate passed to statement_control__S_000need_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_000need_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_000need_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_000need_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_000need_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_control:import {
sub statement_control__S_001import__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_001import', $retree) }
sub statement_control__S_001import {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 'use';local $::HAS_SELF = '';local $::SCOPE = 'use';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_001import");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "import";
$self->_MATCHIFYr($S, "statement_control__S_001import", do {
my $C = $C;
if (($C) = ($C->_EXACT("import"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['term'], sub {
my $C = shift;
$C->term
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->spacey)
and ($C) = ($C->_SUBSUMEr(['arglist'], sub {
my $C = shift;
$C->arglist
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_control:use {
sub statement_control__S_002use__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_002use', $retree) }
sub statement_control__S_002use {
no warnings 'recursion';
my $self = shift;
my $longname;local $::IN_DECL = 'use';local $::SCOPE = 'use';local $::HAS_SELF = '';local %::MYSTERY;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_002use");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "use";
$self->_MATCHIFYr($S, "statement_control__S_002use", do {
my $C = $C;
if (($C) = ($C->_EXACT("use"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_002use_0') {
$C->deb("Fate passed to statement_control__S_002use_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_002use_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_002use_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_002use_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_002use_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->module_name
}))
and ($C) = (scalar(do {
my $M = $C;
$longname = $M->{'module_name'}->{'longname'};
if ($longname->Str eq 'MONKEY_TYPING') {
$::MONKEY_TYPING = 1};
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->spacey)
and ($C) = ($C->_SUBSUMEr(['arglist'], sub {
my $C = shift;
$C->arglist
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:no {
sub statement_control__S_003no__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_003no', $retree) }
sub statement_control__S_003no {
no warnings 'recursion';
my $self = shift;
local %::MYSTERY;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_003no");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$C->{sym} = "no";
$self->_MATCHIFYr($S, "statement_control__S_003no", do {
my $C = $C;
if (($C) = ($C->_EXACT("no"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['module_name'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:if {
sub statement_control__S_004if__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_004if', $retree) }
sub statement_control__S_004if {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_004if");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'else'} = [];
$C->{'elsif'} = [];
$C->{sym} = "if";
$self->_MATCHIFYr($S, "statement_control__S_004if", do {
my $C = $C;
if (($C) = ($C->_EXACT("if"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_004if_0') {
$C->deb("Fate passed to statement_control__S_004if_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_004if_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_004if_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_004if_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_004if_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:unless {
sub statement_control__S_005unless__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_005unless', $retree) }
sub statement_control__S_005unless {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_005unless");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "unless";
$self->_MATCHIFYr($S, "statement_control__S_005unless", do {
my $C = $C;
if (($C) = ($C->_EXACT("unless"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['xblock'], sub {
my $C = shift;
$C->xblock
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("else")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:while {
sub statement_control__S_006while__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_006while', $retree) }
sub statement_control__S_006while {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_006while");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "while";
$self->_MATCHIFYr($S, "statement_control__S_006while", do {
my $C = $C;
if (($C) = ($C->_EXACT("while"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:until {
sub statement_control__S_007until__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_007until', $retree) }
sub statement_control__S_007until {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_007until");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "until";
$self->_MATCHIFYr($S, "statement_control__S_007until", do {
my $C = $C;
if (($C) = ($C->_EXACT("until"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['xblock'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:repeat {
sub statement_control__S_008repeat__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_008repeat', $retree) }
sub statement_control__S_008repeat {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_008repeat");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "repeat";
$self->_MATCHIFYr($S, "statement_control__S_008repeat", do {
my $C = $C;
if (($C) = ($C->_EXACT("repeat"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_008repeat_0') {
$C->deb("Fate passed to statement_control__S_008repeat_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_008repeat_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_008repeat_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_008repeat_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_008repeat_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_008repeat_1') {
$C->deb("Fate passed to statement_control__S_008repeat_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_008repeat_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_008repeat_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_008repeat_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_008repeat_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
},
sub {
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['pblock'], sub {
my $C = shift;
$C->pblock
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['wu'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'statement_control__S_008repeat_2') {
$C->deb("Fate passed to statement_control__S_008repeat_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT statement_control__S_008repeat_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM statement_control__S_008repeat_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'statement_control__S_008repeat_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("statement_control__S_008repeat_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:loop {
sub statement_control__S_009loop__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_009loop', $retree) }
sub statement_control__S_009loop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_009loop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "loop";
$self->_MATCHIFYr($S, "statement_control__S_009loop", do {
my $C = $C;
if (($C) = ($C->_EXACT("loop"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['eee'], sub {
my $C = shift;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_PAREN( sub {
my $C=shift;
do {
my $C = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
$C->_SUBSUMEr(['e1'], sub {
my $C = shift;
$C->EXPR
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:for {
sub statement_control__S_010for__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_010for', $retree) }
sub statement_control__S_010for {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_010for");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "for";
$self->_MATCHIFYr($S, "statement_control__S_010for", do {
my $C = $C;
if (($C) = ($C->_EXACT("for"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:given {
sub statement_control__S_011given__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_011given', $retree) }
sub statement_control__S_011given {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_011given");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "given";
$self->_MATCHIFYr($S, "statement_control__S_011given", do {
my $C = $C;
if (($C) = ($C->_EXACT("given"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['xblock'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:when {
sub statement_control__S_012when__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_012when', $retree) }
sub statement_control__S_012when {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_012when");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "when";
$self->_MATCHIFYr($S, "statement_control__S_012when", do {
my $C = $C;
if (($C) = ($C->_EXACT("when"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:default {<sym> <block> }
sub statement_control__S_013default__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_013default', $retree) }
sub statement_control__S_013default {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_013default");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "default";
$self->_MATCHIFYr($S, "statement_control__S_013default", do {
my $C = $C;
if (($C) = ($C->_EXACT("default"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['block'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:BEGIN { :my %*MYSTERY; <sym> <blast> <.explain_mystery> }
sub statement_prefix__S_014BEGIN__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_014BEGIN', $retree) }
sub statement_prefix__S_014BEGIN {
no warnings 'recursion';
my $self = shift;
local %::MYSTERY;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_014BEGIN");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "BEGIN";
$self->_MATCHIFYr($S, "statement_prefix__S_014BEGIN", do {
my $C = $C;
if (($C) = ($C->_EXACT("BEGIN"))
and ($C) = ($C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:CHECK { <sym> <blast> }
sub statement_prefix__S_015CHECK__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_015CHECK', $retree) }
sub statement_prefix__S_015CHECK {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_015CHECK");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "CHECK";
$self->_MATCHIFYr($S, "statement_prefix__S_015CHECK", do {
if (my ($C) = ($C->_EXACT("CHECK"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:INIT { <sym> <blast> }
sub statement_prefix__S_016INIT__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_016INIT', $retree) }
sub statement_prefix__S_016INIT {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_016INIT");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "INIT";
$self->_MATCHIFYr($S, "statement_prefix__S_016INIT", do {
if (my ($C) = ($C->_EXACT("INIT"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:START { <sym> <blast> }
sub statement_prefix__S_017START__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_017START', $retree) }
sub statement_prefix__S_017START {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_017START");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "START";
$self->_MATCHIFYr($S, "statement_prefix__S_017START", do {
if (my ($C) = ($C->_EXACT("START"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:ENTER { <sym> <blast> }
sub statement_prefix__S_018ENTER__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_018ENTER', $retree) }
sub statement_prefix__S_018ENTER {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_018ENTER");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ENTER";
$self->_MATCHIFYr($S, "statement_prefix__S_018ENTER", do {
if (my ($C) = ($C->_EXACT("ENTER"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:FIRST { <sym> <blast> }
sub statement_prefix__S_019FIRST__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_019FIRST', $retree) }
sub statement_prefix__S_019FIRST {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_019FIRST");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "FIRST";
$self->_MATCHIFYr($S, "statement_prefix__S_019FIRST", do {
if (my ($C) = ($C->_EXACT("FIRST"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:END { <sym> <blast> }
sub statement_prefix__S_020END__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_020END', $retree) }
sub statement_prefix__S_020END {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_020END");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "END";
$self->_MATCHIFYr($S, "statement_prefix__S_020END", do {
if (my ($C) = ($C->_EXACT("END"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:LEAVE { <sym> <blast> }
sub statement_prefix__S_021LEAVE__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_021LEAVE', $retree) }
sub statement_prefix__S_021LEAVE {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_021LEAVE");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "LEAVE";
$self->_MATCHIFYr($S, "statement_prefix__S_021LEAVE", do {
if (my ($C) = ($C->_EXACT("LEAVE"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:KEEP { <sym> <blast> }
sub statement_prefix__S_022KEEP__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_022KEEP', $retree) }
sub statement_prefix__S_022KEEP {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_022KEEP");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "KEEP";
$self->_MATCHIFYr($S, "statement_prefix__S_022KEEP", do {
if (my ($C) = ($C->_EXACT("KEEP"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:UNDO { <sym> <blast> }
sub statement_prefix__S_023UNDO__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_023UNDO', $retree) }
sub statement_prefix__S_023UNDO {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_023UNDO");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "UNDO";
$self->_MATCHIFYr($S, "statement_prefix__S_023UNDO", do {
if (my ($C) = ($C->_EXACT("UNDO"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:NEXT { <sym> <blast> }
sub statement_prefix__S_024NEXT__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_024NEXT', $retree) }
sub statement_prefix__S_024NEXT {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_024NEXT");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "NEXT";
$self->_MATCHIFYr($S, "statement_prefix__S_024NEXT", do {
if (my ($C) = ($C->_EXACT("NEXT"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:LAST { <sym> <blast> }
sub statement_prefix__S_025LAST__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_025LAST', $retree) }
sub statement_prefix__S_025LAST {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_025LAST");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "LAST";
$self->_MATCHIFYr($S, "statement_prefix__S_025LAST", do {
if (my ($C) = ($C->_EXACT("LAST"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:PRE { <sym> <blast> }
sub statement_prefix__S_026PRE__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_026PRE', $retree) }
sub statement_prefix__S_026PRE {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_026PRE");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "PRE";
$self->_MATCHIFYr($S, "statement_prefix__S_026PRE", do {
if (my ($C) = ($C->_EXACT("PRE"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:POST { <sym> <blast> }
sub statement_prefix__S_027POST__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_027POST', $retree) }
sub statement_prefix__S_027POST {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_027POST");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "POST";
$self->_MATCHIFYr($S, "statement_prefix__S_027POST", do {
if (my ($C) = ($C->_EXACT("POST"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:CATCH {<sym> <block> }
sub statement_control__S_028CATCH__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_028CATCH', $retree) }
sub statement_control__S_028CATCH {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_028CATCH");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "CATCH";
$self->_MATCHIFYr($S, "statement_control__S_028CATCH", do {
my $C = $C;
if (($C) = ($C->_EXACT("CATCH"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['block'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:CONTROL {<sym> <block> }
sub statement_control__S_029CONTROL__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_029CONTROL', $retree) }
sub statement_control__S_029CONTROL {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_029CONTROL");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "CONTROL";
$self->_MATCHIFYr($S, "statement_control__S_029CONTROL", do {
my $C = $C;
if (($C) = ($C->_EXACT("CONTROL"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['block'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_control:TEMP {<sym> <block> }
sub statement_control__S_030TEMP__PEEK { $_[0]->_AUTOLEXpeek('statement_control__S_030TEMP', $retree) }
sub statement_control__S_030TEMP {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_control__S_030TEMP");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "TEMP";
$self->_MATCHIFYr($S, "statement_control__S_030TEMP", do {
my $C = $C;
if (($C) = ($C->_EXACT("TEMP"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['block'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule modifier_expr { <EXPR> }
sub modifier_expr__PEEK { $_[0]->_AUTOLEXpeek('modifier_expr', $retree) }
sub modifier_expr {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE modifier_expr");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "modifier_expr", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->ws)) {
$C
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_cond:if {<sym> <modifier_expr> }
sub statement_mod_cond__S_031if__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_cond__S_031if', $retree) }
sub statement_mod_cond__S_031if {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_cond__S_031if");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "if";
$self->_MATCHIFYr($S, "statement_mod_cond__S_031if", do {
my $C = $C;
if (($C) = ($C->_EXACT("if"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_cond:unless {<sym> <modifier_expr> }
sub statement_mod_cond__S_032unless__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_cond__S_032unless', $retree) }
sub statement_mod_cond__S_032unless {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_cond__S_032unless");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "unless";
$self->_MATCHIFYr($S, "statement_mod_cond__S_032unless", do {
my $C = $C;
if (($C) = ($C->_EXACT("unless"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_cond:when {<sym> <?dumbsmart> <modifier_expr> }
sub statement_mod_cond__S_033when__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_cond__S_033when', $retree) }
sub statement_mod_cond__S_033when {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_cond__S_033when");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "when";
$self->_MATCHIFYr($S, "statement_mod_cond__S_033when", do {
my $C = $C;
if (($C) = ($C->_EXACT("when"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_loop:while {<sym> <modifier_expr> }
sub statement_mod_loop__S_034while__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_loop__S_034while', $retree) }
sub statement_mod_loop__S_034while {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_loop__S_034while");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "while";
$self->_MATCHIFYr($S, "statement_mod_loop__S_034while", do {
my $C = $C;
if (($C) = ($C->_EXACT("while"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_loop:until {<sym> <modifier_expr> }
sub statement_mod_loop__S_035until__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_loop__S_035until', $retree) }
sub statement_mod_loop__S_035until {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_loop__S_035until");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "until";
$self->_MATCHIFYr($S, "statement_mod_loop__S_035until", do {
my $C = $C;
if (($C) = ($C->_EXACT("until"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_loop:for {<sym> <modifier_expr> }
sub statement_mod_loop__S_036for__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_loop__S_036for', $retree) }
sub statement_mod_loop__S_036for {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_loop__S_036for");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "for";
$self->_MATCHIFYr($S, "statement_mod_loop__S_036for", do {
my $C = $C;
if (($C) = ($C->_EXACT("for"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule statement_mod_loop:given {<sym> <modifier_expr> }
sub statement_mod_loop__S_037given__PEEK { $_[0]->_AUTOLEXpeek('statement_mod_loop__S_037given', $retree) }
sub statement_mod_loop__S_037given {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_mod_loop__S_037given");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "given";
$self->_MATCHIFYr($S, "statement_mod_loop__S_037given", do {
my $C = $C;
if (($C) = ($C->_EXACT("given"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['modifier_expr'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token module_name:normal {
sub module_name__S_038normal__PEEK { $_[0]->_AUTOLEXpeek('module_name__S_038normal', $retree) }
sub module_name__S_038normal {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE module_name__S_038normal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$C->{sym} = "normal";
$self->_MATCHIFYr($S, "module_name__S_038normal", do {
if (my ($C) = ($C->_SUBSUMEr(['longname'], sub {
my $C = shift;
$C->longname
}))) {
$C->_OPTr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['arglist'], sub {
my $C = shift;
$C->arglist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'generic role', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token vnum {
sub vnum__PEEK { $_[0]->_AUTOLEXpeek('vnum', $retree) }
sub vnum {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE vnum");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "vnum", do {
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'vnum_0') {
$C->deb("Fate passed to vnum_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT vnum_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM vnum_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'vnum_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("vnum_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token version:sym<v> {
sub version__S_039v__PEEK { $_[0]->_AUTOLEXpeek('version__S_039v', $retree) }
sub version__S_039v {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE version__S_039v");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'vnum'} = [];
$C->{sym} = "v";
$self->_MATCHIFYr($S, "version__S_039v", do {
my $C = $C;
if (($C) = ($C->_EXACT("v"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token variable_declarator {
sub variable_declarator__PEEK { $_[0]->_AUTOLEXpeek('variable_declarator', $retree) }
sub variable_declarator {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 'variable';local $::DECLARAND;my $var;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE variable_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'post_constraint'} = [];
$C->{'postcircumfix'} = [];
$C->{'semilist'} = [];
$C->{'shape'} = [];
$C->{'signature'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "variable_declarator", do {
my $C = $C;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'variable_declarator_0') {
$C->deb("Fate passed to variable_declarator_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT variable_declarator_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM variable_declarator_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'variable_declarator_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("variable_declarator_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'variable_declarator', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'shape definition', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\{"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'shape definition', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub scoped__PEEK { $_[0]->_AUTOLEXpeek('scoped', $retree) }
sub scoped {
no warnings 'recursion';
my $self = shift;
die 'Required argument SCOPE omitted' unless @_;
local $::SCOPE = @_ ? shift() : undef;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scoped");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'typename'} = [];
$self->_MATCHIFYr($S, "scoped", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'scoped_0') {
$C->deb("Fate passed to scoped_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT scoped_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM scoped_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'scoped_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("scoped_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:my { <sym> <scoped('my')> }
sub scope_declarator__S_040my__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_040my', $retree) }
sub scope_declarator__S_040my {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_040my");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "my";
$self->_MATCHIFYr($S, "scope_declarator__S_040my", do {
my $C = $C;
if (($C) = ($C->_EXACT("my"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('my')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:our { <sym> <scoped('our')> }
sub scope_declarator__S_041our__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_041our', $retree) }
sub scope_declarator__S_041our {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_041our");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "our";
$self->_MATCHIFYr($S, "scope_declarator__S_041our", do {
my $C = $C;
if (($C) = ($C->_EXACT("our"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('our')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:anon { <sym> <scoped('anon')> }
sub scope_declarator__S_042anon__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_042anon', $retree) }
sub scope_declarator__S_042anon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_042anon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "anon";
$self->_MATCHIFYr($S, "scope_declarator__S_042anon", do {
my $C = $C;
if (($C) = ($C->_EXACT("anon"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('anon')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:state { <sym> <scoped('state')> }
sub scope_declarator__S_043state__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_043state', $retree) }
sub scope_declarator__S_043state {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_043state");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "state";
$self->_MATCHIFYr($S, "scope_declarator__S_043state", do {
my $C = $C;
if (($C) = ($C->_EXACT("state"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('state')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:augment { <sym> <scoped('augment')> }
sub scope_declarator__S_044augment__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_044augment', $retree) }
sub scope_declarator__S_044augment {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_044augment");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "augment";
$self->_MATCHIFYr($S, "scope_declarator__S_044augment", do {
my $C = $C;
if (($C) = ($C->_EXACT("augment"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('augment')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:supersede { <sym> <scoped('supersede')> }
sub scope_declarator__S_045supersede__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_045supersede', $retree) }
sub scope_declarator__S_045supersede {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_045supersede");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "supersede";
$self->_MATCHIFYr($S, "scope_declarator__S_045supersede", do {
my $C = $C;
if (($C) = ($C->_EXACT("supersede"))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['scoped'], sub {
my $C = shift;
$C->scoped('supersede')
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token scope_declarator:has {
sub scope_declarator__S_046has__PEEK { $_[0]->_AUTOLEXpeek('scope_declarator__S_046has', $retree) }
sub scope_declarator__S_046has {
no warnings 'recursion';
my $self = shift;
local $::HAS_SELF = 'partial';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE scope_declarator__S_046has");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "has";
$self->_MATCHIFYr($S, "scope_declarator__S_046has", do {
my $C = $C;
if (($C) = ($C->_EXACT("has"))
and ($C) = ($C->nofun)
and ($C) = (scalar(do {
given ($::PKGDECL) {
when ('class') {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:class {
sub package_declarator__S_047class__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_047class', $retree) }
sub package_declarator__S_047class {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'class';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_047class");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "class";
$self->_MATCHIFYr($S, "package_declarator__S_047class", do {
my $C = $C;
if (($C) = ($C->_EXACT("class"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:grammar {
sub package_declarator__S_048grammar__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_048grammar', $retree) }
sub package_declarator__S_048grammar {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'grammar';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_048grammar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "grammar";
$self->_MATCHIFYr($S, "package_declarator__S_048grammar", do {
my $C = $C;
if (($C) = ($C->_EXACT("grammar"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:module {
sub package_declarator__S_049module__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_049module', $retree) }
sub package_declarator__S_049module {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'module';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_049module");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "module";
$self->_MATCHIFYr($S, "package_declarator__S_049module", do {
my $C = $C;
if (($C) = ($C->_EXACT("module"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:package {
sub package_declarator__S_050package__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_050package', $retree) }
sub package_declarator__S_050package {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'package';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_050package");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "package";
$self->_MATCHIFYr($S, "package_declarator__S_050package", do {
my $C = $C;
if (($C) = ($C->_EXACT("package"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:role {
sub package_declarator__S_051role__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_051role', $retree) }
sub package_declarator__S_051role {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'role';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_051role");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "role";
$self->_MATCHIFYr($S, "package_declarator__S_051role", do {
my $C = $C;
if (($C) = ($C->_EXACT("role"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:knowhow {
sub package_declarator__S_052knowhow__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_052knowhow', $retree) }
sub package_declarator__S_052knowhow {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'knowhow';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_052knowhow");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "knowhow";
$self->_MATCHIFYr($S, "package_declarator__S_052knowhow", do {
my $C = $C;
if (($C) = ($C->_EXACT("knowhow"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:slang {
sub package_declarator__S_053slang__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_053slang', $retree) }
sub package_declarator__S_053slang {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'slang';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_053slang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "slang";
$self->_MATCHIFYr($S, "package_declarator__S_053slang", do {
my $C = $C;
if (($C) = ($C->_EXACT("slang"))
and ($C) = ($C->keyspace)) {
$C->_SUBSUMEr(['package_def'], sub {
my $C = shift;
$C->package_def
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token package_declarator:require { # here because of declarational aspects
sub package_declarator__S_054require__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_054require', $retree) }
sub package_declarator__S_054require {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_054require");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'EXPR'} = [];
$C->{sym} = "require";
$self->_MATCHIFYr($S, "package_declarator__S_054require", do {
my $C = $C;
if (($C) = ($C->_EXACT("require"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['module_name'], sub {
my $C = shift;
$C->module_name
}))
and ($C) = ($C->ws)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule package_declarator:trusts {
sub package_declarator__S_055trusts__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_055trusts', $retree) }
sub package_declarator__S_055trusts {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_055trusts");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "trusts";
$self->_MATCHIFYr($S, "package_declarator__S_055trusts", do {
my $C = $C;
if (($C) = ($C->_EXACT("trusts"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['module_name'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule package_declarator:sym<also> {
sub package_declarator__S_056also__PEEK { $_[0]->_AUTOLEXpeek('package_declarator__S_056also', $retree) }
sub package_declarator__S_056also {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_declarator__S_056also");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'trait'} = [];
$C->{sym} = "also";
$self->_MATCHIFYr($S, "package_declarator__S_056also", do {
my $C = $C;
if (($C) = ($C->_EXACT("also"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_PLUSr(sub {
my $C=shift;
$C->_SUBSUMEr(['trait'], sub {
my $C = shift;
$C->trait
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule package_def {
sub package_def__PEEK { $_[0]->_AUTOLEXpeek('package_def', $retree) }
sub package_def {
no warnings 'recursion';
my $self = shift;
my $longname;local $::IN_DECL = 'package';local $::HAS_SELF = '';local $::DECLARAND;local $::NEWPKG;local $::NEWLEX;my $outer = $::CURLEX;local $::CURPKG = $::CURPKG;local $::CURLEX = $::CURLEX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE package_def");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'longname'} = [];
$C->{'signature'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "package_def", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = (scalar(do {
$::SCOPE ||= 'our'}, $C))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'generic role', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->_SUBSUMEr(['trait'], sub {
my $C = shift;
$C->trait
})
}))
and ($C) = ($C->ws)
and ($C) = ($C->getdecl)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\{")
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\;")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::begin_compunit })
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token declarator {
sub declarator__PEEK { $_[0]->_AUTOLEXpeek('declarator', $retree) }
sub declarator {
no warnings 'recursion';
my $self = shift;
local $::LEFTSIGIL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'initializer'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "declarator", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'declarator_0') {
$C->deb("Fate passed to declarator_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT declarator_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM declarator_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'declarator_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("declarator_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
sub {
my $C=shift;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->_SUBSUMEr(['defterm'], sub {
my $C = shift;
$C->defterm
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['initializer'], sub {
my $C = shift;
$C->initializer
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'declarator', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule multi_declarator:multi {
sub multi_declarator__S_057multi__PEEK { $_[0]->_AUTOLEXpeek('multi_declarator__S_057multi', $retree) }
sub multi_declarator__S_057multi {
no warnings 'recursion';
my $self = shift;
local $::MULTINESS = 'multi';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE multi_declarator__S_057multi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "multi";
$self->_MATCHIFYr($S, "multi_declarator__S_057multi", do {
my $C = $C;
if (($C) = ($C->_EXACT("multi"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['declarator'], sub {
my $C = shift;
$C->declarator
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule multi_declarator:proto {
sub multi_declarator__S_058proto__PEEK { $_[0]->_AUTOLEXpeek('multi_declarator__S_058proto', $retree) }
sub multi_declarator__S_058proto {
no warnings 'recursion';
my $self = shift;
local $::MULTINESS = 'proto';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE multi_declarator__S_058proto");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "proto";
$self->_MATCHIFYr($S, "multi_declarator__S_058proto", do {
my $C = $C;
if (($C) = ($C->_EXACT("proto"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['declarator'], sub {
my $C = shift;
$C->declarator
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule multi_declarator:only {
sub multi_declarator__S_059only__PEEK { $_[0]->_AUTOLEXpeek('multi_declarator__S_059only', $retree) }
sub multi_declarator__S_059only {
no warnings 'recursion';
my $self = shift;
local $::MULTINESS = 'only';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE multi_declarator__S_059only");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "only";
$self->_MATCHIFYr($S, "multi_declarator__S_059only", do {
my $C = $C;
if (($C) = ($C->_EXACT("only"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['declarator'], sub {
my $C = shift;
$C->declarator
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule multi_declarator:null {
sub multi_declarator__S_060null__PEEK { $_[0]->_AUTOLEXpeek('multi_declarator__S_060null', $retree) }
sub multi_declarator__S_060null {
no warnings 'recursion';
my $self = shift;
local $::MULTINESS = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE multi_declarator__S_060null");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "null";
$self->_MATCHIFYr($S, "multi_declarator__S_060null", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['declarator'], sub {
my $C = shift;
$C->declarator
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule routine_declarator:sub { <sym> <routine_def('sub')> }
sub routine_declarator__S_061sub__PEEK { $_[0]->_AUTOLEXpeek('routine_declarator__S_061sub', $retree) }
sub routine_declarator__S_061sub {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE routine_declarator__S_061sub");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sub";
$self->_MATCHIFYr($S, "routine_declarator__S_061sub", do {
my $C = $C;
if (($C) = ($C->_EXACT("sub"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['routine_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule routine_declarator:method { <sym> <method_def('method')> }
sub routine_declarator__S_062method__PEEK { $_[0]->_AUTOLEXpeek('routine_declarator__S_062method', $retree) }
sub routine_declarator__S_062method {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE routine_declarator__S_062method");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "method";
$self->_MATCHIFYr($S, "routine_declarator__S_062method", do {
my $C = $C;
if (($C) = ($C->_EXACT("method"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['method_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule routine_declarator:submethod { <sym> <method_def('submethod')> }
sub routine_declarator__S_063submethod__PEEK { $_[0]->_AUTOLEXpeek('routine_declarator__S_063submethod', $retree) }
sub routine_declarator__S_063submethod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE routine_declarator__S_063submethod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "submethod";
$self->_MATCHIFYr($S, "routine_declarator__S_063submethod", do {
my $C = $C;
if (($C) = ($C->_EXACT("submethod"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['method_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule routine_declarator:macro { <sym> <macro_def> }
sub routine_declarator__S_064macro__PEEK { $_[0]->_AUTOLEXpeek('routine_declarator__S_064macro', $retree) }
sub routine_declarator__S_064macro {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE routine_declarator__S_064macro");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "macro";
$self->_MATCHIFYr($S, "routine_declarator__S_064macro", do {
my $C = $C;
if (($C) = ($C->_EXACT("macro"))
and ($C) = ($C->nofun)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['macro_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule regex_declarator:regex { <sym> <regex_def('regex', :!r,:!s)> }
sub regex_declarator__S_065regex__PEEK { $_[0]->_AUTOLEXpeek('regex_declarator__S_065regex', $retree) }
sub regex_declarator__S_065regex {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_declarator__S_065regex");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "regex";
$self->_MATCHIFYr($S, "regex_declarator__S_065regex", do {
my $C = $C;
if (($C) = ($C->_EXACT("regex"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['regex_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule regex_declarator:token { <sym> <regex_def('token', :r,:!s)> }
sub regex_declarator__S_066token__PEEK { $_[0]->_AUTOLEXpeek('regex_declarator__S_066token', $retree) }
sub regex_declarator__S_066token {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_declarator__S_066token");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "token";
$self->_MATCHIFYr($S, "regex_declarator__S_066token", do {
my $C = $C;
if (($C) = ($C->_EXACT("token"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['regex_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule regex_declarator:rule { <sym> <regex_def('rule', :r,:s)> }
sub regex_declarator__S_067rule__PEEK { $_[0]->_AUTOLEXpeek('regex_declarator__S_067rule', $retree) }
sub regex_declarator__S_067rule {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_declarator__S_067rule");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "rule";
$self->_MATCHIFYr($S, "regex_declarator__S_067rule", do {
my $C = $C;
if (($C) = ($C->_EXACT("rule"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['regex_def'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule multisig {
sub multisig__PEEK { $_[0]->_AUTOLEXpeek('multisig', $retree) }
sub multisig {
no warnings 'recursion';
my $self = shift;
my $signum = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE multisig");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'signature'} = [];
$self->_MATCHIFYr($S, "multisig", $C->_REPSEPr( sub {
my $C=shift;
if (($C) = ($C->_EXACT("\|"))
and ($C) = ($C->ws)) {
$C
} else { () }
}, sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature(++$signum)
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub routine_def__PEEK { $_[0]->_AUTOLEXpeek('routine_def', $retree) }
sub routine_def {
no warnings 'recursion';
my $self = shift;
die 'Required argument d omitted' unless @_;
my $d = @_ ? shift() : undef;
local $::CURLEX = $::CURLEX;local $::IN_DECL = $d;local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE routine_def");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'deflongname'} = [];
$C->{'multisig'} = [];
$C->{'sigil'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "routine_def", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'routine_def_0') {
$C->deb("Fate passed to routine_def_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT routine_def_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM routine_def_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'routine_def_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("routine_def_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'routine_def_1') {
$C->deb("Fate passed to routine_def_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT routine_def_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM routine_def_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'routine_def_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("routine_def_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub method_def__PEEK { $_[0]->_AUTOLEXpeek('method_def', $retree) }
sub method_def {
no warnings 'recursion';
my $self = shift;
die 'Required argument d omitted' unless @_;
my $d = @_ ? shift() : undef;
local $::CURLEX = $::CURLEX;local $::IN_DECL = $d;local $::DECLARAND;local $::HAS_SELF = $d eq 'submethod' ? 'partial' : 'complete';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE method_def");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'multisig'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "method_def", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->newlex(1))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'method_def_0') {
$C->deb("Fate passed to method_def_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT method_def_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM method_def_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'method_def_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("method_def_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'method_def_1') {
$C->deb("Fate passed to method_def_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT method_def_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM method_def_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'method_def_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("method_def_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'method_def_2') {
$C->deb("Fate passed to method_def_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT method_def_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM method_def_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'method_def_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("method_def_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'subscript signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'subscript signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\{"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'subscript signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $self = shift;
die 'Required argument d omitted' unless @_;
my $d = @_ ? shift() : undef;
my %args = @_;
my $r = exists $args{r} ? delete $args{r} : undef;
my $s = exists $args{s} ? delete $args{s} : undef;
local $::CURLEX = $::CURLEX;local $::IN_DECL = $d;local %::RX = %::RX;local $::DECLARAND;local $::HAS_SELF = 'complete';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_def");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'deflongname'} = [];
$C->{'signature'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "regex_def", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = (scalar(do {
$::RX{'s'} = $s;
$::RX{'r'} = $r;
}, $C))
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'regex_def_0') {
$C->deb("Fate passed to regex_def_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT regex_def_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM regex_def_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'regex_def_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("regex_def_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'regex_def_1') {
$C->deb("Fate passed to regex_def_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT regex_def_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM regex_def_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'regex_def_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("regex_def_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule macro_def () {
sub macro_def__PEEK { $_[0]->_AUTOLEXpeek('macro_def', $retree) }
sub macro_def {
no warnings 'recursion';
my $self = shift;
local $::CURLEX = $::CURLEX;local $::IN_DECL = 'macro';local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE macro_def");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'deflongname'} = [];
$C->{'multisig'} = [];
$C->{'trait'} = [];
$self->_MATCHIFYr($S, "macro_def", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'macro_def_0') {
$C->deb("Fate passed to macro_def_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT macro_def_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM macro_def_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'macro_def_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("macro_def_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'macro_def_1') {
$C->deb("Fate passed to macro_def_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT macro_def_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM macro_def_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'macro_def_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("macro_def_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait {
sub trait__PEEK { $_[0]->_AUTOLEXpeek('trait', $retree) }
sub trait {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "trait", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'trait_0') {
$C->deb("Fate passed to trait_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT trait_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM trait_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'trait_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("trait_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:is {
sub trait_mod__S_068is__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_068is', $retree) }
sub trait_mod__S_068is {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_068is");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'circumfix'} = [];
$C->{sym} = "is";
$self->_MATCHIFYr($S, "trait_mod__S_068is", do {
my $C = $C;
if (($C) = ($C->_EXACT("is"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['longname'], sub {
my $C = shift;
$C->longname
}))
and ($C) = ($C->_OPTr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:hides {
sub trait_mod__S_069hides__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_069hides', $retree) }
sub trait_mod__S_069hides {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_069hides");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "hides";
$self->_MATCHIFYr($S, "trait_mod__S_069hides", do {
my $C = $C;
if (($C) = ($C->_EXACT("hides"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['typename'], sub {
my $C = shift;
$C->typename
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:does {
sub trait_mod__S_070does__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_070does', $retree) }
sub trait_mod__S_070does {
no warnings 'recursion';
my $self = shift;
local $::PKGDECL = 'role';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_070does");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "does";
$self->_MATCHIFYr($S, "trait_mod__S_070does", do {
my $C = $C;
if (($C) = ($C->_EXACT("does"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['typename'], sub {
my $C = shift;
$C->typename
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:will {
sub trait_mod__S_071will__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_071will', $retree) }
sub trait_mod__S_071will {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_071will");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "will";
$self->_MATCHIFYr($S, "trait_mod__S_071will", do {
my $C = $C;
if (($C) = ($C->_EXACT("will"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->ws)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:of {
sub trait_mod__S_072of__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_072of', $retree) }
sub trait_mod__S_072of {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_072of");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "of";
$self->_MATCHIFYr($S, "trait_mod__S_072of", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'trait_mod__S_072of_0') {
$C->deb("Fate passed to trait_mod__S_072of_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT trait_mod__S_072of_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM trait_mod__S_072of_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'trait_mod__S_072of_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("trait_mod__S_072of_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['typename'], sub {
my $C = shift;
$C->typename
}))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule trait_mod:handles { <sym> <term> }
sub trait_mod__S_073handles__PEEK { $_[0]->_AUTOLEXpeek('trait_mod__S_073handles', $retree) }
sub trait_mod__S_073handles {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE trait_mod__S_073handles");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "handles";
$self->_MATCHIFYr($S, "trait_mod__S_073handles", do {
my $C = $C;
if (($C) = ($C->_EXACT("handles"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['term'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token nullterm {
sub nullterm__PEEK { $_[0]->_AUTOLEXpeek('nullterm', $retree) }
sub nullterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE nullterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "nullterm", $C->before(sub {
my $C=shift;
$C
}));
}
;
## token nulltermish {
sub nulltermish__PEEK { $_[0]->_AUTOLEXpeek('nulltermish', $retree) }
sub nulltermish {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE nulltermish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "nulltermish", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'nulltermish_0') {
$C->deb("Fate passed to nulltermish_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT nulltermish_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM nulltermish_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'nulltermish_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("nulltermish_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token termish {
sub termish__PEEK { $_[0]->_AUTOLEXpeek('termish', $retree) }
sub termish {
no warnings 'recursion';
my $self = shift;
local $::SCOPE = "";local $::MULTINESS = "";local $::OFTYPE;local $::VAR;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE termish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'POST'} = [];
$C->{'PRE'} = [];
$self->_MATCHIFYr($S, "termish", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'termish_0') {
$C->deb("Fate passed to termish_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT termish_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM termish_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'termish_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("termish_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
}))) {
$C->_SUBSUMEr(['PRE'], sub {
my $C = shift;
$C->PRE
})
} else { () }
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
my $M = $C;
$M->{'term'} })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::QSIGIL })
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::QSIGIL eq '$' })
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (LazyMap::lazymap(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->after(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:fatarrow { <fatarrow> }
sub term__S_074fatarrow__PEEK { $_[0]->_AUTOLEXpeek('term__S_074fatarrow', $retree) }
sub term__S_074fatarrow {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_074fatarrow");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "fatarrow";
$self->_MATCHIFYr($S, "term__S_074fatarrow", $C->_SUBSUMEr(['fatarrow'], sub {
my $C = shift;
$C->fatarrow
}));
}
;
## token term:variable { <variable> { $*VAR = $<variable> } }
sub term__S_075variable__PEEK { $_[0]->_AUTOLEXpeek('term__S_075variable', $retree) }
sub term__S_075variable {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_075variable");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "variable";
$self->_MATCHIFYr($S, "term__S_075variable", do {
if (my ($C) = ($C->_SUBSUMEr(['variable'], sub {
my $C = shift;
$C->variable
}))) {
scalar(do {
my $M = $C;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:package_declarator { <package_declarator> }
sub term__S_076package_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_076package_declarator', $retree) }
sub term__S_076package_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_076package_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "package_declarator";
$self->_MATCHIFYr($S, "term__S_076package_declarator", $C->_SUBSUMEr(['package_declarator'], sub {
my $C = shift;
$C->package_declarator
}));
}
;
## token term:scope_declarator { <scope_declarator> }
sub term__S_077scope_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_077scope_declarator', $retree) }
sub term__S_077scope_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_077scope_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "scope_declarator";
$self->_MATCHIFYr($S, "term__S_077scope_declarator", $C->_SUBSUMEr(['scope_declarator'], sub {
my $C = shift;
$C->scope_declarator
}));
}
;
## token term:multi_declarator { <?before 'multi'|'proto'|'only'> <multi_declarator> }
sub term__S_078multi_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_078multi_declarator', $retree) }
sub term__S_078multi_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_078multi_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "multi_declarator";
$self->_MATCHIFYr($S, "term__S_078multi_declarator", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'term__S_078multi_declarator_0') {
$C->deb("Fate passed to term__S_078multi_declarator_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT term__S_078multi_declarator_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM term__S_078multi_declarator_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'term__S_078multi_declarator_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term__S_078multi_declarator_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:routine_declarator { <routine_declarator> }
sub term__S_079routine_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_079routine_declarator', $retree) }
sub term__S_079routine_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_079routine_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "routine_declarator";
$self->_MATCHIFYr($S, "term__S_079routine_declarator", $C->_SUBSUMEr(['routine_declarator'], sub {
my $C = shift;
$C->routine_declarator
}));
}
;
## token term:regex_declarator { <regex_declarator> }
sub term__S_080regex_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_080regex_declarator', $retree) }
sub term__S_080regex_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_080regex_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "regex_declarator";
$self->_MATCHIFYr($S, "term__S_080regex_declarator", $C->_SUBSUMEr(['regex_declarator'], sub {
my $C = shift;
$C->regex_declarator
}));
}
;
## token term:type_declarator { <type_declarator> }
sub term__S_081type_declarator__PEEK { $_[0]->_AUTOLEXpeek('term__S_081type_declarator', $retree) }
sub term__S_081type_declarator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_081type_declarator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "type_declarator";
$self->_MATCHIFYr($S, "term__S_081type_declarator", $C->_SUBSUMEr(['type_declarator'], sub {
my $C = shift;
$C->type_declarator
}));
}
;
## token term:circumfix { <circumfix> }
sub term__S_082circumfix__PEEK { $_[0]->_AUTOLEXpeek('term__S_082circumfix', $retree) }
sub term__S_082circumfix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_082circumfix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "circumfix";
$self->_MATCHIFYr($S, "term__S_082circumfix", $C->_SUBSUMEr(['circumfix'], sub {
my $C = shift;
$C->circumfix
}));
}
;
## token term:dotty { <dotty> }
sub term__S_083dotty__PEEK { $_[0]->_AUTOLEXpeek('term__S_083dotty', $retree) }
sub term__S_083dotty {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_083dotty");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "dotty";
$self->_MATCHIFYr($S, "term__S_083dotty", $C->_SUBSUMEr(['dotty'], sub {
my $C = shift;
$C->dotty
}));
}
;
## token term:value { <value> }
sub term__S_084value__PEEK { $_[0]->_AUTOLEXpeek('term__S_084value', $retree) }
sub term__S_084value {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_084value");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "value";
$self->_MATCHIFYr($S, "term__S_084value", $C->_SUBSUMEr(['value'], sub {
my $C = shift;
$C->value
}));
}
;
## token term:capterm { <capterm> }
sub term__S_085capterm__PEEK { $_[0]->_AUTOLEXpeek('term__S_085capterm', $retree) }
sub term__S_085capterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_085capterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "capterm";
$self->_MATCHIFYr($S, "term__S_085capterm", $C->_SUBSUMEr(['capterm'], sub {
my $C = shift;
$C->capterm
}));
}
;
## token term:sigterm { <sigterm> }
sub term__S_086sigterm__PEEK { $_[0]->_AUTOLEXpeek('term__S_086sigterm', $retree) }
sub term__S_086sigterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_086sigterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sigterm";
$self->_MATCHIFYr($S, "term__S_086sigterm", $C->_SUBSUMEr(['sigterm'], sub {
my $C = shift;
$C->sigterm
}));
}
;
## token term:statement_prefix { <statement_prefix> }
sub term__S_087statement_prefix__PEEK { $_[0]->_AUTOLEXpeek('term__S_087statement_prefix', $retree) }
sub term__S_087statement_prefix {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_087statement_prefix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "statement_prefix";
$self->_MATCHIFYr($S, "term__S_087statement_prefix", $C->_SUBSUMEr(['statement_prefix'], sub {
my $C = shift;
$C->statement_prefix
}));
}
;
## token term:colonpair { [ <colonpair> <.ws> ]+ }
sub term__S_088colonpair__PEEK { $_[0]->_AUTOLEXpeek('term__S_088colonpair', $retree) }
sub term__S_088colonpair {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_088colonpair");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'colonpair'} = [];
$C->{sym} = "colonpair";
$self->_MATCHIFYr($S, "term__S_088colonpair", $C->_PLUSr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['colonpair'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token fatarrow {
sub fatarrow__PEEK { $_[0]->_AUTOLEXpeek('fatarrow', $retree) }
sub fatarrow {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE fatarrow");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "fatarrow", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['key'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+\=\>/))
and ($C) = ($C->ws)) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub coloncircumfix__PEEK { $_[0]->_AUTOLEXpeek('coloncircumfix', $retree) }
sub coloncircumfix {
no warnings 'recursion';
my $self = shift;
die 'Required argument front omitted' unless @_;
my $front = @_ ? shift() : undef;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE coloncircumfix");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "coloncircumfix", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'coloncircumfix_0') {
$C->deb("Fate passed to coloncircumfix_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT coloncircumfix_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM coloncircumfix_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'coloncircumfix_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("coloncircumfix_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token colonpair {
sub colonpair__PEEK { $_[0]->_AUTOLEXpeek('colonpair', $retree) }
sub colonpair {
no warnings 'recursion';
my $self = shift;
my $key;my $value;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE colonpair");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "colonpair", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'colonpair_0') {
$C->deb("Fate passed to colonpair_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT colonpair_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM colonpair_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'colonpair_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("colonpair_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
sub {
my $C=shift;
if (($C) = ($C->_EXACT("\!"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = (scalar(do {
my $M = $C;
$key = $M->{'identifier'}->Str}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->unsp)) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['coloncircumfix'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['fakesignature'], sub {
my $C = shift;
$C->fakesignature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'colonpair_1') {
$C->deb("Fate passed to colonpair_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT colonpair_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM colonpair_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'colonpair_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("colonpair_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$¢> { <sym> }
sub special_variable__S_089Dollar_a2___PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_089Dollar_a2_', $retree) }
sub special_variable__S_089Dollar_a2_ {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_089Dollar_a2_");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$¢";
$self->_MATCHIFYr($S, "special_variable__S_089Dollar_a2_", $C->_EXACT("\$¢"));
}
;
## token special_variable:sym<$!> { <sym> <!before \w> }
sub special_variable__S_090DollarBang__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_090DollarBang', $retree) }
sub special_variable__S_090DollarBang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_090DollarBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\!";
$self->_MATCHIFYr($S, "special_variable__S_090DollarBang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\!"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$!{ }> {
sub special_variable__S_091DollarBangCur_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_091DollarBangCur_Ly', $retree) }
sub special_variable__S_091DollarBangCur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_091DollarBangCur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\!\{\ \}";
$self->_MATCHIFYr($S, "special_variable__S_091DollarBangCur_Ly", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\!"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\}";
my $goalpos = $C;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_091DollarBangCur_Ly_0') {
$C->deb("Fate passed to special_variable__S_091DollarBangCur_Ly_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_091DollarBangCur_Ly_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_091DollarBangCur_Ly_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_091DollarBangCur_Ly_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_091DollarBangCur_Ly_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'special_variable', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$/> {
sub special_variable__S_092DollarSlash__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_092DollarSlash', $retree) }
sub special_variable__S_092DollarSlash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_092DollarSlash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\/";
$self->_MATCHIFYr($S, "special_variable__S_092DollarSlash", do {
if (my ($C) = ($C->_EXACT("\$\/"))) {
$C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$~> {
sub special_variable__S_093DollarTilde__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_093DollarTilde', $retree) }
sub special_variable__S_093DollarTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_093DollarTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\~";
$self->_MATCHIFYr($S, "special_variable__S_093DollarTilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\~"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_093DollarTilde_0') {
$C->deb("Fate passed to special_variable__S_093DollarTilde_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_093DollarTilde_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_093DollarTilde_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_093DollarTilde_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_093DollarTilde_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$`> {
sub special_variable__S_094DollarGrave__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_094DollarGrave', $retree) }
sub special_variable__S_094DollarGrave {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_094DollarGrave");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\`";
$self->_MATCHIFYr($S, "special_variable__S_094DollarGrave", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\`"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_094DollarGrave_0') {
$C->deb("Fate passed to special_variable__S_094DollarGrave_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_094DollarGrave_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_094DollarGrave_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_094DollarGrave_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_094DollarGrave_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$@> {
sub special_variable__S_095DollarAt__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_095DollarAt', $retree) }
sub special_variable__S_095DollarAt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_095DollarAt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\@";
$self->_MATCHIFYr($S, "special_variable__S_095DollarAt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\@"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$#> {
sub special_variable__S_096DollarSharp__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_096DollarSharp', $retree) }
sub special_variable__S_096DollarSharp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_096DollarSharp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\#";
$self->_MATCHIFYr($S, "special_variable__S_096DollarSharp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\#"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->_PATTERN(qr/\G\w++/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$$> {
sub special_variable__S_097DollarDollar__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_097DollarDollar', $retree) }
sub special_variable__S_097DollarDollar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_097DollarDollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\$";
$self->_MATCHIFYr($S, "special_variable__S_097DollarDollar", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\$"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
$C->_PATTERN(qr/\G[_[:alpha:]]/)
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_097DollarDollar_0') {
$C->deb("Fate passed to special_variable__S_097DollarDollar_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_097DollarDollar_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_097DollarDollar_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_097DollarDollar_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_097DollarDollar_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$%> {
sub special_variable__S_098DollarPercent__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_098DollarPercent', $retree) }
sub special_variable__S_098DollarPercent {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_098DollarPercent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\%";
$self->_MATCHIFYr($S, "special_variable__S_098DollarPercent", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\%"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$^X> {
sub special_variable__S_099DollarCaretX__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_099DollarCaretX', $retree) }
sub special_variable__S_099DollarCaretX {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_099DollarCaretX");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\^X";
$self->_MATCHIFYr($S, "special_variable__S_099DollarCaretX", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sigil'], sub {
my $C = shift;
$C->sigil
}))
and ($C) = ($C->_EXACT("\^"))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$^> {
sub special_variable__S_100DollarCaret__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_100DollarCaret', $retree) }
sub special_variable__S_100DollarCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_100DollarCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\^";
$self->_MATCHIFYr($S, "special_variable__S_100DollarCaret", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\^"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_100DollarCaret_0') {
$C->deb("Fate passed to special_variable__S_100DollarCaret_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_100DollarCaret_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_100DollarCaret_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_100DollarCaret_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_100DollarCaret_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$&> {
sub special_variable__S_101DollarAmp__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_101DollarAmp', $retree) }
sub special_variable__S_101DollarAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_101DollarAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\&";
$self->_MATCHIFYr($S, "special_variable__S_101DollarAmp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\&"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_101DollarAmp_0') {
$C->deb("Fate passed to special_variable__S_101DollarAmp_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_101DollarAmp_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_101DollarAmp_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_101DollarAmp_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_101DollarAmp_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$*> {
sub special_variable__S_102DollarStar__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_102DollarStar', $retree) }
sub special_variable__S_102DollarStar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_102DollarStar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\*";
$self->_MATCHIFYr($S, "special_variable__S_102DollarStar", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\*"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_102DollarStar_0') {
$C->deb("Fate passed to special_variable__S_102DollarStar_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_102DollarStar_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_102DollarStar_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_102DollarStar_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_102DollarStar_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$)> {
sub special_variable__S_103DollarThesis__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_103DollarThesis', $retree) }
sub special_variable__S_103DollarThesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_103DollarThesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\)";
$self->_MATCHIFYr($S, "special_variable__S_103DollarThesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\)"))
and ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::GOAL ne ')' })
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_103DollarThesis_0') {
$C->deb("Fate passed to special_variable__S_103DollarThesis_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_103DollarThesis_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_103DollarThesis_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_103DollarThesis_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_103DollarThesis_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$-> {
sub special_variable__S_104DollarMinus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_104DollarMinus', $retree) }
sub special_variable__S_104DollarMinus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_104DollarMinus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\-";
$self->_MATCHIFYr($S, "special_variable__S_104DollarMinus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\-"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_104DollarMinus_0') {
$C->deb("Fate passed to special_variable__S_104DollarMinus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_104DollarMinus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_104DollarMinus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_104DollarMinus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_104DollarMinus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$=> {
sub special_variable__S_105DollarEqual__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_105DollarEqual', $retree) }
sub special_variable__S_105DollarEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_105DollarEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\=";
$self->_MATCHIFYr($S, "special_variable__S_105DollarEqual", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\="))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_105DollarEqual_0') {
$C->deb("Fate passed to special_variable__S_105DollarEqual_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_105DollarEqual_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_105DollarEqual_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_105DollarEqual_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_105DollarEqual_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<@+> {
sub special_variable__S_106AtPlus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_106AtPlus', $retree) }
sub special_variable__S_106AtPlus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_106AtPlus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@\+";
$self->_MATCHIFYr($S, "special_variable__S_106AtPlus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\+"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_106AtPlus_0') {
$C->deb("Fate passed to special_variable__S_106AtPlus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_106AtPlus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_106AtPlus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_106AtPlus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_106AtPlus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<%+> {
sub special_variable__S_107PercentPlus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_107PercentPlus', $retree) }
sub special_variable__S_107PercentPlus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_107PercentPlus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%\+";
$self->_MATCHIFYr($S, "special_variable__S_107PercentPlus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\%\+"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_107PercentPlus_0') {
$C->deb("Fate passed to special_variable__S_107PercentPlus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_107PercentPlus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_107PercentPlus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_107PercentPlus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_107PercentPlus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$+[ ]> {
sub special_variable__S_108DollarPlusBra_Ket__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_108DollarPlusBra_Ket', $retree) }
sub special_variable__S_108DollarPlusBra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_108DollarPlusBra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\+\[\ \]";
$self->_MATCHIFYr($S, "special_variable__S_108DollarPlusBra_Ket", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\+\["))
and ($C) = ($C->obs('@+ variable', '.to method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<@+[ ]> {
sub special_variable__S_109AtPlusBra_Ket__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_109AtPlusBra_Ket', $retree) }
sub special_variable__S_109AtPlusBra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_109AtPlusBra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@\+\[\ \]";
$self->_MATCHIFYr($S, "special_variable__S_109AtPlusBra_Ket", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\+\["))
and ($C) = ($C->obs('@+ variable', '.to method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<@+{ }> {
sub special_variable__S_110AtPlusCur_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_110AtPlusCur_Ly', $retree) }
sub special_variable__S_110AtPlusCur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_110AtPlusCur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@\+\{\ \}";
$self->_MATCHIFYr($S, "special_variable__S_110AtPlusCur_Ly", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\+\{"))
and ($C) = ($C->obs('%+ variable', '.to method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<@-> {
sub special_variable__S_111AtMinus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_111AtMinus', $retree) }
sub special_variable__S_111AtMinus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_111AtMinus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@\-";
$self->_MATCHIFYr($S, "special_variable__S_111AtMinus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\-"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_111AtMinus_0') {
$C->deb("Fate passed to special_variable__S_111AtMinus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_111AtMinus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_111AtMinus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_111AtMinus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_111AtMinus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<%-> {
sub special_variable__S_112PercentMinus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_112PercentMinus', $retree) }
sub special_variable__S_112PercentMinus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_112PercentMinus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%\-";
$self->_MATCHIFYr($S, "special_variable__S_112PercentMinus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\%\-"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_112PercentMinus_0') {
$C->deb("Fate passed to special_variable__S_112PercentMinus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_112PercentMinus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_112PercentMinus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_112PercentMinus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_112PercentMinus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$-[ ]> {
sub special_variable__S_113DollarMinusBra_Ket__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_113DollarMinusBra_Ket', $retree) }
sub special_variable__S_113DollarMinusBra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_113DollarMinusBra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\-\[\ \]";
$self->_MATCHIFYr($S, "special_variable__S_113DollarMinusBra_Ket", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\-\["))
and ($C) = ($C->obs('@- variable', '.from method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<@-[ ]> {
sub special_variable__S_114AtMinusBra_Ket__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_114AtMinusBra_Ket', $retree) }
sub special_variable__S_114AtMinusBra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_114AtMinusBra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@\-\[\ \]";
$self->_MATCHIFYr($S, "special_variable__S_114AtMinusBra_Ket", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\-\["))
and ($C) = ($C->obs('@- variable', '.from method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<%-{ }> {
sub special_variable__S_115PercentMinusCur_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_115PercentMinusCur_Ly', $retree) }
sub special_variable__S_115PercentMinusCur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_115PercentMinusCur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%\-\{\ \}";
$self->_MATCHIFYr($S, "special_variable__S_115PercentMinusCur_Ly", do {
my $C = $C;
if (($C) = ($C->_EXACT("\@\-\{"))
and ($C) = ($C->obs('%- variable', '.from method'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$+> {
sub special_variable__S_116DollarPlus__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_116DollarPlus', $retree) }
sub special_variable__S_116DollarPlus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_116DollarPlus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\+";
$self->_MATCHIFYr($S, "special_variable__S_116DollarPlus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\+"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_116DollarPlus_0') {
$C->deb("Fate passed to special_variable__S_116DollarPlus_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_116DollarPlus_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_116DollarPlus_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_116DollarPlus_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_116DollarPlus_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<${^ }> {
sub special_variable__S_117DollarCurCaret_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_117DollarCurCaret_Ly', $retree) }
sub special_variable__S_117DollarCurCaret_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_117DollarCurCaret_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\{\^\ \}";
$self->_MATCHIFYr($S, "special_variable__S_117DollarCurCaret_Ly", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sigil'], sub {
my $C = shift;
$C->sigil
}))
and ($C) = ($C->_EXACT("\{\^"))
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token special_variable:sym<::{ }> {
sub special_variable__S_118ColonColonCur_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_118ColonColonCur_Ly', $retree) }
sub special_variable__S_118ColonColonCur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_118ColonColonCur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\{\ \}";
$self->_MATCHIFYr($S, "special_variable__S_118ColonColonCur_Ly", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:\:"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## regex special_variable:sym<${ }> {
sub special_variable__S_119DollarCur_Ly__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_119DollarCur_Ly', $retree) }
sub special_variable__S_119DollarCur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_119DollarCur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\{\ \}";
$self->_MATCHIFY($S, "special_variable__S_119DollarCur_Ly", LazyMap::lazymap(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\{"))
and ($C) = (scalar(do {
}, $C))) {
LazyMap::lazymap(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$[> {
sub special_variable__S_120DollarBra__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_120DollarBra', $retree) }
sub special_variable__S_120DollarBra {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_120DollarBra");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\[";
$self->_MATCHIFYr($S, "special_variable__S_120DollarBra", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\["))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_120DollarBra_0') {
$C->deb("Fate passed to special_variable__S_120DollarBra_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_120DollarBra_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_120DollarBra_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_120DollarBra_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_120DollarBra_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$]> {
sub special_variable__S_121DollarKet__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_121DollarKet', $retree) }
sub special_variable__S_121DollarKet {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_121DollarKet");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\]";
$self->_MATCHIFYr($S, "special_variable__S_121DollarKet", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\]"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_121DollarKet_0') {
$C->deb("Fate passed to special_variable__S_121DollarKet_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_121DollarKet_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_121DollarKet_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_121DollarKet_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_121DollarKet_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$\\> {
sub special_variable__S_122DollarBack__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_122DollarBack', $retree) }
sub special_variable__S_122DollarBack {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_122DollarBack");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\\";
$self->_MATCHIFYr($S, "special_variable__S_122DollarBack", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\\"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_122DollarBack_0') {
$C->deb("Fate passed to special_variable__S_122DollarBack_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_122DollarBack_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_122DollarBack_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_122DollarBack_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_122DollarBack_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$|> {
sub special_variable__S_123DollarVert__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_123DollarVert', $retree) }
sub special_variable__S_123DollarVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_123DollarVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\|";
$self->_MATCHIFYr($S, "special_variable__S_123DollarVert", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\|"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_123DollarVert_0') {
$C->deb("Fate passed to special_variable__S_123DollarVert_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_123DollarVert_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_123DollarVert_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_123DollarVert_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_123DollarVert_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$:> {
sub special_variable__S_124DollarColon__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_124DollarColon', $retree) }
sub special_variable__S_124DollarColon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_124DollarColon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\:";
$self->_MATCHIFYr($S, "special_variable__S_124DollarColon", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\:"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$;> {
sub special_variable__S_125DollarSemi__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_125DollarSemi', $retree) }
sub special_variable__S_125DollarSemi {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_125DollarSemi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\;";
$self->_MATCHIFYr($S, "special_variable__S_125DollarSemi", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\;"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_125DollarSemi_0') {
$C->deb("Fate passed to special_variable__S_125DollarSemi_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_125DollarSemi_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_125DollarSemi_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_125DollarSemi_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_125DollarSemi_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$'> { #'
sub special_variable__S_126DollarSingle__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_126DollarSingle', $retree) }
sub special_variable__S_126DollarSingle {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_126DollarSingle");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\'";
$self->_MATCHIFYr($S, "special_variable__S_126DollarSingle", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\'"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_126DollarSingle_0') {
$C->deb("Fate passed to special_variable__S_126DollarSingle_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_126DollarSingle_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_126DollarSingle_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_126DollarSingle_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_126DollarSingle_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$"> {
sub special_variable__S_127DollarDouble__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_127DollarDouble', $retree) }
sub special_variable__S_127DollarDouble {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_127DollarDouble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\"";
$self->_MATCHIFYr($S, "special_variable__S_127DollarDouble", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\""))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::QSIGIL })
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_127DollarDouble_0') {
$C->deb("Fate passed to special_variable__S_127DollarDouble_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_127DollarDouble_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_127DollarDouble_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_127DollarDouble_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_127DollarDouble_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$,> {
sub special_variable__S_128DollarComma__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_128DollarComma', $retree) }
sub special_variable__S_128DollarComma {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_128DollarComma");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\,";
$self->_MATCHIFYr($S, "special_variable__S_128DollarComma", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\,"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_128DollarComma_0') {
$C->deb("Fate passed to special_variable__S_128DollarComma_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_128DollarComma_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_128DollarComma_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_128DollarComma_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_128DollarComma_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym['$<'] {
sub special_variable__S_129DollarLt__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_129DollarLt', $retree) }
sub special_variable__S_129DollarLt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_129DollarLt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\<";
$self->_MATCHIFYr($S, "special_variable__S_129DollarLt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\<"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym«\$>» {
sub special_variable__S_130DollarGt__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_130DollarGt', $retree) }
sub special_variable__S_130DollarGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_130DollarGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\>";
$self->_MATCHIFYr($S, "special_variable__S_130DollarGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\>"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_130DollarGt_0') {
$C->deb("Fate passed to special_variable__S_130DollarGt_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_130DollarGt_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_130DollarGt_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_130DollarGt_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_130DollarGt_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$.> {
sub special_variable__S_131DollarDot__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_131DollarDot', $retree) }
sub special_variable__S_131DollarDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_131DollarDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\.";
$self->_MATCHIFYr($S, "special_variable__S_131DollarDot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\."))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_131DollarDot_0') {
$C->deb("Fate passed to special_variable__S_131DollarDot_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_131DollarDot_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_131DollarDot_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_131DollarDot_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_131DollarDot_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token special_variable:sym<$?> {
sub special_variable__S_132DollarQuestion__PEEK { $_[0]->_AUTOLEXpeek('special_variable__S_132DollarQuestion', $retree) }
sub special_variable__S_132DollarQuestion {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE special_variable__S_132DollarQuestion");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$\?";
$self->_MATCHIFYr($S, "special_variable__S_132DollarQuestion", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\?"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'special_variable__S_132DollarQuestion_0') {
$C->deb("Fate passed to special_variable__S_132DollarQuestion_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT special_variable__S_132DollarQuestion_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM special_variable__S_132DollarQuestion_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'special_variable__S_132DollarQuestion_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("special_variable__S_132DollarQuestion_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token desigilname {
sub desigilname__PEEK { $_[0]->_AUTOLEXpeek('desigilname', $retree) }
sub desigilname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE desigilname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "desigilname", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'desigilname_0') {
$C->deb("Fate passed to desigilname_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT desigilname_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM desigilname_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'desigilname_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("desigilname_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token variable {
sub variable__PEEK { $_[0]->_AUTOLEXpeek('variable', $retree) }
sub variable {
no warnings 'recursion';
my $self = shift;
local $::IN_META = '';my $sigil = '';my $twigil = '';my $name;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE variable");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'name'} = [];
$C->{'postcircumfix'} = [];
$C->{'twigil'} = [];
$self->_MATCHIFYr($S, "variable", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
$sigil = $M->{'sigil'}->Str;
$::LEFTSIGIL ||= $sigil;
}, $C)
} else { () }
}))) { ($C) } else { () }
}))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sigil'], sub {
my $C = shift;
$C->sigil
}))
and ($C) = ($C->_OPTr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'variable_0') {
$C->deb("Fate passed to variable_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT variable_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM variable_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'variable_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("variable_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'variable_1') {
$C->deb("Fate passed to variable_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT variable_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM variable_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'variable_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("variable_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish('[]')
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'infix noun', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'variable_2') {
$C->deb("Fate passed to variable_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT variable_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM variable_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'variable_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("variable_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'variable_3') {
$C->deb("Fate passed to variable_3: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT variable_3'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM variable_3'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'variable_3', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("variable_3 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token defterm { # XXX this is probably too general
sub defterm__PEEK { $_[0]->_AUTOLEXpeek('defterm', $retree) }
sub defterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE defterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'colonpair'} = [];
$self->_MATCHIFYr($S, "defterm", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'defterm_0') {
$C->deb("Fate passed to defterm_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT defterm_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM defterm_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'defterm_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("defterm_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token deflongname {
sub deflongname__PEEK { $_[0]->_AUTOLEXpeek('deflongname', $retree) }
sub deflongname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE deflongname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'colonpair'} = [];
$self->_MATCHIFYr($S, "deflongname", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['name'], sub {
my $C = shift;
$C->name
}))
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'deflongname_0') {
$C->deb("Fate passed to deflongname_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT deflongname_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM deflongname_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'deflongname_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("deflongname_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token subshortname {
sub subshortname__PEEK { $_[0]->_AUTOLEXpeek('subshortname', $retree) }
sub subshortname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE subshortname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'colonpair'} = [];
$self->_MATCHIFYr($S, "subshortname", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'subshortname_0') {
$C->deb("Fate passed to subshortname_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT subshortname_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM subshortname_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'subshortname_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("subshortname_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sublongname {
sub sublongname__PEEK { $_[0]->_AUTOLEXpeek('sublongname', $retree) }
sub sublongname {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sublongname");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'sigterm'} = [];
$self->_MATCHIFYr($S, "sublongname", do {
if (my ($C) = ($C->_SUBSUMEr(['subshortname'], sub {
my $C = shift;
$C->subshortname
}))) {
$C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token value:quote { <quote> }
sub value__S_133quote__PEEK { $_[0]->_AUTOLEXpeek('value__S_133quote', $retree) }
sub value__S_133quote {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE value__S_133quote");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quote";
$self->_MATCHIFYr($S, "value__S_133quote", $C->_SUBSUMEr(['quote'], sub {
my $C = shift;
$C->quote
}));
}
;
## token value:number { <number> }
sub value__S_134number__PEEK { $_[0]->_AUTOLEXpeek('value__S_134number', $retree) }
sub value__S_134number {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE value__S_134number");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "number";
$self->_MATCHIFYr($S, "value__S_134number", $C->_SUBSUMEr(['number'], sub {
my $C = shift;
$C->number
}));
}
;
## token value:version { <version> }
sub value__S_135version__PEEK { $_[0]->_AUTOLEXpeek('value__S_135version', $retree) }
sub value__S_135version {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE value__S_135version");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "version";
$self->_MATCHIFYr($S, "value__S_135version", $C->_SUBSUMEr(['version'], sub {
my $C = shift;
$C->version
}));
}
;
## token typename {
sub typename__PEEK { $_[0]->_AUTOLEXpeek('typename', $retree) }
sub typename {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE typename");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'accept'} = [];
$C->{'param'} = [];
$C->{'typename'} = [];
$C->{'whence'} = [];
$self->_MATCHIFYr($S, "typename", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'typename_0') {
$C->deb("Fate passed to typename_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT typename_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM typename_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'typename_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("typename_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token number {
sub number__PEEK { $_[0]->_AUTOLEXpeek('number', $retree) }
sub number {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE number");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "number", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'number_0') {
$C->deb("Fate passed to number_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT number_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM number_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'number_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("number_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token numeric:rational { <[+\-]>?<nu=.integer>'/'<de=.integer> }
sub numeric__S_136rational__PEEK { $_[0]->_AUTOLEXpeek('numeric__S_136rational', $retree) }
sub numeric__S_136rational {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE numeric__S_136rational");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "rational";
$self->_MATCHIFYr($S, "numeric__S_136rational", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?:[+\-])?+/))
and ($C) = ($C->_SUBSUMEr(['nu'], sub {
my $C = shift;
$C->integer
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token numeric:complex { [<[+\-]>?<re=.number>]? <[+\-]><im=.number>'\\'?'i' }
sub numeric__S_137complex__PEEK { $_[0]->_AUTOLEXpeek('numeric__S_137complex', $retree) }
sub numeric__S_137complex {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE numeric__S_137complex");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'re'} = [];
$C->{sym} = "complex";
$self->_MATCHIFYr($S, "numeric__S_137complex", do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token numeric:number { <[+\-]>?<number> }
sub numeric__S_138number__PEEK { $_[0]->_AUTOLEXpeek('numeric__S_138number', $retree) }
sub numeric__S_138number {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE numeric__S_138number");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "number";
$self->_MATCHIFYr($S, "numeric__S_138number", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?:[+\-])?+/))) {
$C->_SUBSUMEr(['number'], sub {
my $C = shift;
$C->number
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
no warnings 'recursion';
my $self = shift;
die 'Required argument l omitted' unless @_;
my $l = @_ ? shift() : undef;
die 'Required argument lang2 omitted' unless @_;
my $lang2 = @_ ? shift() : undef;
my ($lang, $start, $stop);
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sibble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "sibble", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['babble'], sub {
my $C = shift;
$C->babble($l)
}))
and ($C) = (scalar(do {
my $M = $C;
my $B = $M->{'babble'}->{'B'};
($lang,$start,$stop) = @$B;
}, $C))
and ($C) = ($C->_EXACT($start))
and ($C) = ($C->_SUBSUMEr(['left'], sub {
my $C = shift;
$C->nibble($lang)
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_EXACT($stop))) { ($C) } else { () }
}
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Couldn't find terminator $stop"))) { ($C) } else { () }
}
};
@gather;
}
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$start ne $stop })
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
$C->_PATTERN(qr/\G[\[\{\(\<]/)
}))
and ($C) = ($C->obs('brackets around replacement', 'assignment syntax'))) {
$C
} else { () }
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish
})
}
or $xact->[-2] or
do {
push @gather, $C->_SUBSUMEr(['panic'], sub {
my $C = shift;
$C->panic("Missing assignment operator")
})
};
@gather;
}
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
my $M = $C;
$M->{'infixish'}->Str eq '=' || $M->{'infixish'}->{'infix_postfix_meta_operator'} })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub tribble {
no warnings 'recursion';
my $self = shift;
die 'Required argument l omitted' unless @_;
my $l = @_ ? shift() : undef;
my $lang2 = @_ ? shift() : $l;
my ($lang, $start, $stop);local $::CCSTATE = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE tribble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "tribble", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['babble'], sub {
my $C = shift;
$C->babble($l)
}))
and ($C) = (scalar(do {
my $M = $C;
my $B = $M->{'babble'}->{'B'};
($lang,$start,$stop) = @$B;
}, $C))
and ($C) = ($C->_EXACT($start))
and ($C) = ($C->_SUBSUMEr(['left'], sub {
my $C = shift;
$C->nibble($lang)
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_EXACT($stop))) { ($C) } else { () }
}
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
};
@gather;
}
}))
and ($C) = (scalar(do {
$::CCSTATE = ''}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$start ne $stop })
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub quasiquibble__PEEK { $_[0]->_AUTOLEXpeek('quasiquibble', $retree) }
sub quasiquibble {
no warnings 'recursion';
my $self = shift;
die 'Required argument l omitted' unless @_;
my $l = @_ ? shift() : undef;
local %::LANG = %::LANG;my ($lang, $start, $stop);local $::QUASIMODO = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quasiquibble");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "quasiquibble", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['babble'], sub {
my $C = shift;
$C->babble($l)
}))
and ($C) = (scalar(do {
my $M = $C;
my $B = $M->{'babble'}->{'B'};
($lang,$start,$stop) = @$B;
$::LANG{'MAIN'} = $lang;
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$start eq '{' })
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (($C) = ($C->_SUBSUMEr(['starter'], sub {
my $C = shift;
$C->starter
}))
and ($C) = ($C->_SUBSUMEr(['statementlist'], sub {
my $C = shift;
$C->statementlist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['stopper'], sub {
my $C = shift;
$C->stopper
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:sym<//> {
sub quote__S_139SlashSlash__PEEK { $_[0]->_AUTOLEXpeek('quote__S_139SlashSlash', $retree) }
sub quote__S_139SlashSlash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_139SlashSlash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\/\/";
$self->_MATCHIFYr($S, "quote__S_139SlashSlash", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G\/\s*+\//))
and ($C) = ($C->sorry("Null regex not allowed"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:sym</ /> {
sub quote__S_140Slash_Slash__PEEK { $_[0]->_AUTOLEXpeek('quote__S_140Slash_Slash', $retree) }
sub quote__S_140Slash_Slash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_140Slash_Slash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\/\ \/";
$self->_MATCHIFYr($S, "quote__S_140Slash_Slash", do {
my $C = $C;
if (($C) = ($C->_EXACT("\/"))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble( $C->cursor_fresh( $::LANG{'Regex'} )->unbalanced("/") )
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\/")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Unable to parse regex; couldn't find final '/'"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:qq {
sub quote__S_141qq__PEEK { $_[0]->_AUTOLEXpeek('quote__S_141qq', $retree) }
sub quote__S_141qq {
no warnings 'recursion';
my $self = shift;
my $qm;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_141qq");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "qq";
$self->_MATCHIFYr($S, "quote__S_141qq", do {
my $C = $C;
if (($C) = ($C->_EXACT("qq"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quote__S_141qq_0') {
$C->deb("Fate passed to quote__S_141qq_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quote__S_141qq_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quote__S_141qq_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'quote__S_141qq_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quote__S_141qq_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = (scalar(do {
my $M = $C;
$qm = $M->{'quote_mod'}->Str }, $C))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->tweak(($qm => 1)))
})
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\G\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1))
})
} else { () }
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:q {
sub quote__S_142q__PEEK { $_[0]->_AUTOLEXpeek('quote__S_142q', $retree) }
sub quote__S_142q {
no warnings 'recursion';
my $self = shift;
my $qm;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_142q");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "q";
$self->_MATCHIFYr($S, "quote__S_142q", do {
my $C = $C;
if (($C) = ($C->_EXACT("q"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quote__S_142q_0') {
$C->deb("Fate passed to quote__S_142q_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quote__S_142q_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quote__S_142q_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'quote__S_142q_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quote__S_142q_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = (scalar(do {
my $M = $C;
$qm = $M->{'quote_mod'}->Str }, $C))) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('q' => 1)->tweak(($qm => 1)))
})
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\G\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('q' => 1))
})
} else { () }
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:Q {
sub quote__S_143Q__PEEK { $_[0]->_AUTOLEXpeek('quote__S_143Q', $retree) }
sub quote__S_143Q {
no warnings 'recursion';
my $self = shift;
my $qm;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_143Q");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "Q";
$self->_MATCHIFYr($S, "quote__S_143Q", do {
my $C = $C;
if (($C) = ($C->_EXACT("Q"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quote__S_143Q_0') {
$C->deb("Fate passed to quote__S_143Q_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quote__S_143Q_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quote__S_143Q_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'quote__S_143Q_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quote__S_143Q_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = (scalar(do {
my $M = $C;
$qm = $M->{'quote_mod'}->Str }, $C))) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} )->tweak(($qm => 1)))
})
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\G\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble($C->cursor_fresh( $::LANG{'Q'} ))
})
} else { () }
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote_mod:w { <sym> }
sub quote_mod__S_144w__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_144w', $retree) }
sub quote_mod__S_144w {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_144w");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "w";
$self->_MATCHIFYr($S, "quote_mod__S_144w", $C->_EXACT("w"));
}
;
## token quote_mod:ww { <sym> }
sub quote_mod__S_145ww__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_145ww', $retree) }
sub quote_mod__S_145ww {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_145ww");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ww";
$self->_MATCHIFYr($S, "quote_mod__S_145ww", $C->_EXACT("ww"));
}
;
## token quote_mod:p { <sym> }
sub quote_mod__S_146p__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_146p', $retree) }
sub quote_mod__S_146p {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_146p");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "p";
$self->_MATCHIFYr($S, "quote_mod__S_146p", $C->_EXACT("p"));
}
;
## token quote_mod:x { <sym> }
sub quote_mod__S_147x__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_147x', $retree) }
sub quote_mod__S_147x {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_147x");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "x";
$self->_MATCHIFYr($S, "quote_mod__S_147x", $C->_EXACT("x"));
}
;
## token quote_mod:to { <sym> }
sub quote_mod__S_148to__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_148to', $retree) }
sub quote_mod__S_148to {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_148to");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "to";
$self->_MATCHIFYr($S, "quote_mod__S_148to", $C->_EXACT("to"));
}
;
## token quote_mod:s { <sym> }
sub quote_mod__S_149s__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_149s', $retree) }
sub quote_mod__S_149s {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_149s");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "s";
$self->_MATCHIFYr($S, "quote_mod__S_149s", $C->_EXACT("s"));
}
;
## token quote_mod:a { <sym> }
sub quote_mod__S_150a__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_150a', $retree) }
sub quote_mod__S_150a {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_150a");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "a";
$self->_MATCHIFYr($S, "quote_mod__S_150a", $C->_EXACT("a"));
}
;
## token quote_mod:h { <sym> }
sub quote_mod__S_151h__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_151h', $retree) }
sub quote_mod__S_151h {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_151h");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "h";
$self->_MATCHIFYr($S, "quote_mod__S_151h", $C->_EXACT("h"));
}
;
## token quote_mod:f { <sym> }
sub quote_mod__S_152f__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_152f', $retree) }
sub quote_mod__S_152f {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_152f");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "f";
$self->_MATCHIFYr($S, "quote_mod__S_152f", $C->_EXACT("f"));
}
;
## token quote_mod:c { <sym> }
sub quote_mod__S_153c__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_153c', $retree) }
sub quote_mod__S_153c {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_153c");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "c";
$self->_MATCHIFYr($S, "quote_mod__S_153c", $C->_EXACT("c"));
}
;
## token quote_mod:b { <sym> }
sub quote_mod__S_154b__PEEK { $_[0]->_AUTOLEXpeek('quote_mod__S_154b', $retree) }
sub quote_mod__S_154b {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote_mod__S_154b");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "b";
$self->_MATCHIFYr($S, "quote_mod__S_154b", $C->_EXACT("b"));
}
;
## token quote:rx {
sub quote__S_155rx__PEEK { $_[0]->_AUTOLEXpeek('quote__S_155rx', $retree) }
sub quote__S_155rx {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_155rx");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "rx";
$self->_MATCHIFYr($S, "quote__S_155rx", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Grx\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble( $C->cursor_fresh( $::LANG{'Regex'} ) )
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_rx_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token quote:m {
sub quote__S_156m__PEEK { $_[0]->_AUTOLEXpeek('quote__S_156m', $retree) }
sub quote__S_156m {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_156m");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "m";
$self->_MATCHIFYr($S, "quote__S_156m", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gm\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble( $C->cursor_fresh( $::LANG{'Regex'} ) )
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_rx_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token quote:ms {
sub quote__S_157ms__PEEK { $_[0]->_AUTOLEXpeek('quote__S_157ms', $retree) }
sub quote__S_157ms {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_157ms");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ms";
$self->_MATCHIFYr($S, "quote__S_157ms", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gms\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['quibble'], sub {
my $C = shift;
$C->quibble( $C->cursor_fresh( $::LANG{'Regex'} )->tweak('s' => 1))
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_rx_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token quote:s {
sub quote__S_158s__PEEK { $_[0]->_AUTOLEXpeek('quote__S_158s', $retree) }
sub quote__S_158s {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_158s");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "s";
$self->_MATCHIFYr($S, "quote__S_158s", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gs\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['pat'], sub {
my $C = shift;
$C->sibble( $C->cursor_fresh( $::LANG{'Regex'} ), $C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1))
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_rx_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token quote:ss {
sub quote__S_159ss__PEEK { $_[0]->_AUTOLEXpeek('quote__S_159ss', $retree) }
sub quote__S_159ss {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_159ss");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ss";
$self->_MATCHIFYr($S, "quote__S_159ss", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gss\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['pat'], sub {
my $C = shift;
$C->sibble( $C->cursor_fresh( $::LANG{'Regex'} )->tweak('s' => 1), $C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1))
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_rx_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token quote:tr {
sub quote__S_160tr__PEEK { $_[0]->_AUTOLEXpeek('quote__S_160tr', $retree) }
sub quote__S_160tr {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_160tr");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "tr";
$self->_MATCHIFYr($S, "quote__S_160tr", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gtr\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['pat'], sub {
my $C = shift;
$C->tribble( $C->cursor_fresh( $::LANG{'Q'} )->tweak('cc' => 1))
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->old_tr_mods)) { ($C) } else { () }
}))) {
$C
} else { () }
});
}
;
## token old_rx_mods {
sub old_rx_mods__PEEK { $_[0]->_AUTOLEXpeek('old_rx_mods', $retree) }
sub old_rx_mods {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE old_rx_mods");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "old_rx_mods", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->after(sub {
my $C=shift;
$C->_PATTERN(qr/\G(?<=\w)/)
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token old_tr_mods {
sub old_tr_mods__PEEK { $_[0]->_AUTOLEXpeek('old_tr_mods', $retree) }
sub old_tr_mods {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE old_tr_mods");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "old_tr_mods", do {
if (my ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->_PLUSr(sub {
my $C=shift;
if (my ($C) = ($C->_ARRAY( qw< c d s ] > ))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quote:quasi {
sub quote__S_161quasi__PEEK { $_[0]->_AUTOLEXpeek('quote__S_161quasi', $retree) }
sub quote__S_161quasi {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quote__S_161quasi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quasi";
$self->_MATCHIFYr($S, "quote__S_161quasi", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gquasi\b/))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\(")
}))) { ($C) } else { () }
}))) {
$C->_SUBSUMEr(['quasiquibble'], sub {
my $C = shift;
$C->quasiquibble($C->cursor_fresh( $::LANG{'Quasi'} ))
})
} else { () }
});
}
;
## token capterm {
sub capterm__PEEK { $_[0]->_AUTOLEXpeek('capterm', $retree) }
sub capterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE capterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'capture'} = [];
$self->_MATCHIFYr($S, "capterm", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'capterm_0') {
$C->deb("Fate passed to capterm_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT capterm_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM capterm_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'capterm_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("capterm_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule capture {
sub capture__PEEK { $_[0]->_AUTOLEXpeek('capture', $retree) }
sub capture {
no warnings 'recursion';
my $self = shift;
local $::INVOCANT_OK = 1;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE capture");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "capture", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->ws)) {
$C
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sigterm {
sub sigterm__PEEK { $_[0]->_AUTOLEXpeek('sigterm', $retree) }
sub sigterm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigterm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "sigterm", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\:\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['fakesignature'], sub {
my $C = shift;
$C->fakesignature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'signature', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule param_sep {'' [','|':'|';'|';;'] }
sub param_sep__PEEK { $_[0]->_AUTOLEXpeek('param_sep', $retree) }
sub param_sep {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE param_sep");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "param_sep", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'param_sep_0') {
$C->deb("Fate passed to param_sep_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT param_sep_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM param_sep_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'param_sep_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("param_sep_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token fakesignature() {
sub fakesignature__PEEK { $_[0]->_AUTOLEXpeek('fakesignature', $retree) }
sub fakesignature {
no warnings 'recursion';
my $self = shift;
local $::CURLEX = $::CURLEX;local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE fakesignature");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "fakesignature", do {
if (my ($C) = ($C->newlex)) {
$C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token signature ($lexsig = 0) {
sub signature__PEEK { $_[0]->_AUTOLEXpeek('signature', $retree) }
sub signature {
no warnings 'recursion';
my $self = shift;
my $lexsig = @_ ? shift() : 0;
local $::IN_DECL = 'sig';local $::zone = 'posreq';my $startpos = $self->{'_pos'};local $::MULTINESS = 'only';local $::SIGNUM = $lexsig;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE signature");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'longname'} = [];
$C->{'param_sep'} = [];
$C->{'parameter'} = [];
$C->{'type_constraint'} = [];
$self->_MATCHIFYr($S, "signature", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'signature_0') {
$C->deb("Fate passed to signature_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT signature_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM signature_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'signature_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("signature_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
sub {
my $C=shift;
if (($C) = ($C->_EXACT("\\\|"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['defterm'], sub {
my $C = shift;
$C->defterm
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (my ($C) = ($C->panic("\\| signature must contain one identifier"))) { ($C) } else { () }
}
};
@gather;
}
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'signature_1') {
$C->deb("Fate passed to signature_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT signature_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM signature_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'signature_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("signature_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'signature_2') {
$C->deb("Fate passed to signature_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT signature_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM signature_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'signature_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("signature_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'signature_3') {
$C->deb("Fate passed to signature_3: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT signature_3'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM signature_3'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'signature_3', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("signature_3 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
})) { ($C) } else { () }
}))) { ($C) } else { () }
}))) { ($C) } else { () }
},
sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['parameter'], sub {
my $C = shift;
$C->parameter
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
and ($C) = (scalar(do {
$::IN_DECL = ''}, $C))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\-\-\>"))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['type_constraint'], sub {
my $C = shift;
$C->type_constraint
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule type_declarator:subset {
sub type_declarator__S_162subset__PEEK { $_[0]->_AUTOLEXpeek('type_declarator__S_162subset', $retree) }
sub type_declarator__S_162subset {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 'subset';local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE type_declarator__S_162subset");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'EXPR'} = [];
$C->{'longname'} = [];
$C->{'trait'} = [];
$C->{sym} = "subset";
$self->_MATCHIFYr($S, "type_declarator__S_162subset", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("subset"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token type_declarator:enum {
sub type_declarator__S_163enum__PEEK { $_[0]->_AUTOLEXpeek('type_declarator__S_163enum', $retree) }
sub type_declarator__S_163enum {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 'enum';local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE type_declarator__S_163enum");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'trait'} = [];
$C->{sym} = "enum";
$self->_MATCHIFYr($S, "type_declarator__S_163enum", do {
my $C = $C;
if (($C) = ($C->_EXACT("enum"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'type_declarator__S_163enum_0') {
$C->deb("Fate passed to type_declarator__S_163enum_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT type_declarator__S_163enum_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM type_declarator__S_163enum_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'type_declarator__S_163enum_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("type_declarator__S_163enum_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token type_declarator:constant {
sub type_declarator__S_164constant__PEEK { $_[0]->_AUTOLEXpeek('type_declarator__S_164constant', $retree) }
sub type_declarator__S_164constant {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = 'constant';local $::DECLARAND;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE type_declarator__S_164constant");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'trait'} = [];
$C->{sym} = "constant";
$self->_MATCHIFYr($S, "type_declarator__S_164constant", do {
my $C = $C;
if (($C) = ($C->_EXACT("constant"))
and ($C) = ($C->keyspace)
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'type_declarator__S_164constant_0') {
$C->deb("Fate passed to type_declarator__S_164constant_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT type_declarator__S_164constant_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM type_declarator__S_164constant_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'type_declarator__S_164constant_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("type_declarator__S_164constant_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
and ($C) = ($C->ws)
and ($C) = ($C->_STARr(sub {
my $C=shift;
$C->_SUBSUMEr(['trait'], sub {
my $C = shift;
$C->trait
})
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['initializer'], sub {
my $C = shift;
$C->initializer
})
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token initializer:sym<=> {
sub initializer__S_165Equal__PEEK { $_[0]->_AUTOLEXpeek('initializer__S_165Equal', $retree) }
sub initializer__S_165Equal {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE initializer__S_165Equal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=";
$self->_MATCHIFYr($S, "initializer__S_165Equal", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\="))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR(($::LEFTSIGIL eq '$' ? (\%item_assignment) : (\%list_prefix) ))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token initializer:sym<:=> {
sub initializer__S_166ColonEqual__PEEK { $_[0]->_AUTOLEXpeek('initializer__S_166ColonEqual', $retree) }
sub initializer__S_166ColonEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE initializer__S_166ColonEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\=";
$self->_MATCHIFYr($S, "initializer__S_166ColonEqual", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\:\="))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR(\%list_prefix)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token initializer:sym<::=> {
sub initializer__S_167ColonColonEqual__PEEK { $_[0]->_AUTOLEXpeek('initializer__S_167ColonColonEqual', $retree) }
sub initializer__S_167ColonColonEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE initializer__S_167ColonColonEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\=";
$self->_MATCHIFYr($S, "initializer__S_167ColonColonEqual", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\:\:\="))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR(\%list_prefix)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token initializer:sym<.=> {
sub initializer__S_168DotEqual__PEEK { $_[0]->_AUTOLEXpeek('initializer__S_168DotEqual', $retree) }
sub initializer__S_168DotEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE initializer__S_168DotEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\=";
$self->_MATCHIFYr($S, "initializer__S_168DotEqual", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_EXACT("\.\="))
and ($C) = ($C->ws)) {
$C->_SUBSUMEr(['dottyopish'], sub {
my $C = shift;
$C->dottyopish
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token type_constraint {
sub type_constraint__PEEK { $_[0]->_AUTOLEXpeek('type_constraint', $retree) }
sub type_constraint {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE type_constraint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "type_constraint", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'type_constraint_0') {
$C->deb("Fate passed to type_constraint_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT type_constraint_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM type_constraint_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'type_constraint_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("type_constraint_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule post_constraint {
sub post_constraint__PEEK { $_[0]->_AUTOLEXpeek('post_constraint', $retree) }
sub post_constraint {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE post_constraint");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "post_constraint", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'post_constraint_0') {
$C->deb("Fate passed to post_constraint_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT post_constraint_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM post_constraint_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'post_constraint_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("post_constraint_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'constraint', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'constraint', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token named_param {
sub named_param__PEEK { $_[0]->_AUTOLEXpeek('named_param', $retree) }
sub named_param {
no warnings 'recursion';
my $self = shift;
local $::GOAL = ')';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE named_param");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "named_param", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'named_param_0') {
$C->deb("Fate passed to named_param_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT named_param_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM named_param_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'named_param_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("named_param_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['named_param_term'], sub {
my $C = shift;
$C->named_param_term
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'named parameter', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token named_param_term {
sub named_param_term__PEEK { $_[0]->_AUTOLEXpeek('named_param_term', $retree) }
sub named_param_term {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE named_param_term");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "named_param_term", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'named_param_term_0') {
$C->deb("Fate passed to named_param_term_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT named_param_term_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM named_param_term_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'named_param_term_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("named_param_term_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token param_var($named = 0) {
sub param_var__PEEK { $_[0]->_AUTOLEXpeek('param_var', $retree) }
sub param_var {
no warnings 'recursion';
my $self = shift;
my $named = @_ ? shift() : 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE param_var");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'name'} = [];
$C->{'postcircumfix'} = [];
$C->{'twigil'} = [];
$self->_MATCHIFYr($S, "param_var", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'param_var_0') {
$C->deb("Fate passed to param_var_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT param_var_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM param_var_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'param_var_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("param_var_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'formal parameter', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['signature'], sub {
my $C = shift;
$C->signature
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'formal parameter', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
$C->_SUBSUMEr(['twigil'], sub {
my $C = shift;
$C->twigil
})
}))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
my $M = $C;
$M->{'sigil'}->Str eq '&' })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token parameter {
sub parameter__PEEK { $_[0]->_AUTOLEXpeek('parameter', $retree) }
sub parameter {
no warnings 'recursion';
my $self = shift;
my $kind;my $quant = '';local $::DECLARAND;local $::OFTYPE;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE parameter");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'default_value'} = [];
$C->{'defterm'} = [];
$C->{'post_constraint'} = [];
$C->{'trait'} = [];
$C->{'type_constraint'} = [];
$self->_MATCHIFYr($S, "parameter", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_0') {
$C->deb("Fate passed to parameter_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_1') {
$C->deb("Fate passed to parameter_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_2') {
$C->deb("Fate passed to parameter_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_3') {
$C->deb("Fate passed to parameter_3: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_3'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_3'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_3', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_3 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_4') {
$C->deb("Fate passed to parameter_4: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_4'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_4'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_4', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_4 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'parameter_5') {
$C->deb("Fate passed to parameter_5: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT parameter_5'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM parameter_5'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'parameter_5', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("parameter_5 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule default_value {
sub default_value__PEEK { $_[0]->_AUTOLEXpeek('default_value', $retree) }
sub default_value {
no warnings 'recursion';
my $self = shift;
local $::IN_DECL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE default_value");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "default_value", do {
my $C = $C;
if (($C) = ($C->_EXACT("\="))
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR(\%item_assignment)
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:sink { <sym> <blast> }
sub statement_prefix__S_169sink__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_169sink', $retree) }
sub statement_prefix__S_169sink {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_169sink");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sink";
$self->_MATCHIFYr($S, "statement_prefix__S_169sink", do {
if (my ($C) = ($C->_EXACT("sink"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:try { <sym> <blast> }
sub statement_prefix__S_170try__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_170try', $retree) }
sub statement_prefix__S_170try {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_170try");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "try";
$self->_MATCHIFYr($S, "statement_prefix__S_170try", do {
if (my ($C) = ($C->_EXACT("try"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:quietly { <sym> <blast> }
sub statement_prefix__S_171quietly__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_171quietly', $retree) }
sub statement_prefix__S_171quietly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_171quietly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quietly";
$self->_MATCHIFYr($S, "statement_prefix__S_171quietly", do {
if (my ($C) = ($C->_EXACT("quietly"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:gather { <sym> <blast> }
sub statement_prefix__S_172gather__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_172gather', $retree) }
sub statement_prefix__S_172gather {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_172gather");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "gather";
$self->_MATCHIFYr($S, "statement_prefix__S_172gather", do {
if (my ($C) = ($C->_EXACT("gather"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:contend { <sym> <blast> }
sub statement_prefix__S_173contend__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_173contend', $retree) }
sub statement_prefix__S_173contend {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_173contend");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "contend";
$self->_MATCHIFYr($S, "statement_prefix__S_173contend", do {
if (my ($C) = ($C->_EXACT("contend"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:async { <sym> <blast> }
sub statement_prefix__S_174async__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_174async', $retree) }
sub statement_prefix__S_174async {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_174async");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "async";
$self->_MATCHIFYr($S, "statement_prefix__S_174async", do {
if (my ($C) = ($C->_EXACT("async"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:maybe { <sym> <blast> }
sub statement_prefix__S_175maybe__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_175maybe', $retree) }
sub statement_prefix__S_175maybe {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_175maybe");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "maybe";
$self->_MATCHIFYr($S, "statement_prefix__S_175maybe", do {
if (my ($C) = ($C->_EXACT("maybe"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:lazy { <sym> <blast> }
sub statement_prefix__S_176lazy__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_176lazy', $retree) }
sub statement_prefix__S_176lazy {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_176lazy");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lazy";
$self->_MATCHIFYr($S, "statement_prefix__S_176lazy", do {
if (my ($C) = ($C->_EXACT("lazy"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:do { <sym> <blast> }
sub statement_prefix__S_177do__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_177do', $retree) }
sub statement_prefix__S_177do {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_177do");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "do";
$self->_MATCHIFYr($S, "statement_prefix__S_177do", do {
if (my ($C) = ($C->_EXACT("do"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token statement_prefix:lift {
sub statement_prefix__S_178lift__PEEK { $_[0]->_AUTOLEXpeek('statement_prefix__S_178lift', $retree) }
sub statement_prefix__S_178lift {
no warnings 'recursion';
my $self = shift;
local $::QUASIMODO = 1;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE statement_prefix__S_178lift");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lift";
$self->_MATCHIFYr($S, "statement_prefix__S_178lift", do {
if (my ($C) = ($C->_EXACT("lift"))) {
$C->_SUBSUMEr(['blast'], sub {
my $C = shift;
$C->blast
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token blast {
sub blast__PEEK { $_[0]->_AUTOLEXpeek('blast', $retree) }
sub blast {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE blast");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "blast", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'blast_0') {
$C->deb("Fate passed to blast_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT blast_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM blast_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'blast_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("blast_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'blast_1') {
$C->deb("Fate passed to blast_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT blast_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM blast_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'blast_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("blast_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:new {
sub term__S_179new__PEEK { $_[0]->_AUTOLEXpeek('term__S_179new', $retree) }
sub term__S_179new {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_179new");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "new";
$self->_MATCHIFYr($S, "term__S_179new", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gnew[\x20\t\r]++/))
and ($C) = ($C->_SUBSUMEr(['longname'], sub {
my $C = shift;
$C->longname
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<::?IDENT> {
sub term__S_180ColonColonQuestionIDENT__PEEK { $_[0]->_AUTOLEXpeek('term__S_180ColonColonQuestionIDENT', $retree) }
sub term__S_180ColonColonQuestionIDENT {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_180ColonColonQuestionIDENT");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\?IDENT";
$self->_MATCHIFYr($S, "term__S_180ColonColonQuestionIDENT", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
if (my ($C) = ($C->_EXACT("\:\:\?"))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<undef> {
sub term__S_181undef__PEEK { $_[0]->_AUTOLEXpeek('term__S_181undef', $retree) }
sub term__S_181undef {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_181undef");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "undef";
$self->_MATCHIFYr($S, "term__S_181undef", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gundef\b/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->{'sigil'} = [];
$C->{'twigil'} = [];
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\(")
}
or $xact->[-2] or
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+/))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<proceed>
sub term__S_182proceed__PEEK { $_[0]->_AUTOLEXpeek('term__S_182proceed', $retree) }
sub term__S_182proceed {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_182proceed");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "proceed";
$self->_MATCHIFYr($S, "term__S_182proceed", do {
if (my ($C) = ($C->_PATTERN(qr/\Gproceed\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<time>
sub term__S_183time__PEEK { $_[0]->_AUTOLEXpeek('term__S_183time', $retree) }
sub term__S_183time {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_183time");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "time";
$self->_MATCHIFYr($S, "term__S_183time", do {
if (my ($C) = ($C->_PATTERN(qr/\Gtime\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<now>
sub term__S_184now__PEEK { $_[0]->_AUTOLEXpeek('term__S_184now', $retree) }
sub term__S_184now {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_184now");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "now";
$self->_MATCHIFYr($S, "term__S_184now", do {
if (my ($C) = ($C->_PATTERN(qr/\Gnow\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<self> {
sub term__S_185self__PEEK { $_[0]->_AUTOLEXpeek('term__S_185self', $retree) }
sub term__S_185self {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_185self");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "self";
$self->_MATCHIFYr($S, "term__S_185self", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gself\b/))
and ($C) = (scalar(do {
$::HAS_SELF || $C->sorry("'self' used where no object is available") }, $C))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<defer>
sub term__S_186defer__PEEK { $_[0]->_AUTOLEXpeek('term__S_186defer', $retree) }
sub term__S_186defer {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_186defer");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "defer";
$self->_MATCHIFYr($S, "term__S_186defer", do {
if (my ($C) = ($C->_PATTERN(qr/\Gdefer\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:rand {
sub term__S_187rand__PEEK { $_[0]->_AUTOLEXpeek('term__S_187rand', $retree) }
sub term__S_187rand {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_187rand");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "rand";
$self->_MATCHIFYr($S, "term__S_187rand", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Grand\b/))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'term__S_187rand_0') {
$C->deb("Fate passed to term__S_187rand_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT term__S_187rand_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM term__S_187rand_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'term__S_187rand_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term__S_187rand_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<*>
sub term__S_188Star__PEEK { $_[0]->_AUTOLEXpeek('term__S_188Star', $retree) }
sub term__S_188Star {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_188Star");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*";
$self->_MATCHIFYr($S, "term__S_188Star", do {
if (my ($C) = ($C->_EXACT("\*"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<**>
sub term__S_189StarStar__PEEK { $_[0]->_AUTOLEXpeek('term__S_189StarStar', $retree) }
sub term__S_189StarStar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_189StarStar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*\*";
$self->_MATCHIFYr($S, "term__S_189StarStar", do {
if (my ($C) = ($C->_EXACT("\*\*"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:lambda {
sub infix__S_190lambda__PEEK { $_[0]->_AUTOLEXpeek('infix__S_190lambda', $retree) }
sub infix__S_190lambda {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_190lambda");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lambda";
$self->_MATCHIFYr($S, "infix__S_190lambda", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix__S_190lambda_0') {
$C->deb("Fate passed to infix__S_190lambda_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix__S_190lambda_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix__S_190lambda_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix__S_190lambda_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix__S_190lambda_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
for ('if', 'unless', 'while', 'until', 'for', 'given', 'when', 'loop', 'sub', 'method') {
$needparens++ if $_ eq 'loop';
my $m = $::MYSTERY{$_};
next unless $m;
if ($line - ($m->{'line'}//-123) < 5) {
if ($m->{'ctx'} eq '(') {
$C->panic("Word '$_' interpreted as '$_" . "()' function call; please use whitespace " .
($needparens ? 'around the parens' : 'instead of parens') . $m->{'token'}->locmess .
"\nUnexpected block in infix position (two terms in a row)")}
else {
$C->panic("Word '$_' interpreted as a listop; please use 'do $_' to introduce the statement control word" . $m->{'token'}->cursor($m->{'token'}->from)->locmess .
"\nUnexpected block in infix position (two terms in a row)")}};
}
;
return () if $::IN_REDUCE;
my $endpos = $C->{'_pos'};
my $startpos = $::MEMOS[$endpos]->{'ws'} // $endpos;
if ($self->lineof($startpos) != $self->lineof($endpos)) {
$C->panic("Unexpected block in infix position (previous line missing its semicolon?)")}
elsif ($::MEMOS[$startpos]->{'baremeth'}) {
$C->cursor($startpos)->panic("Unexpected block in infix position (method call with args needs colon or parens without whitespace)")}
else {
$C->panic("Unexpected block in infix position (two terms in a row, or previous statement missing semicolon?)")};
}, $C))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%term)
})
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token circumfix:sigil
sub circumfix__S_191sigil__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_191sigil', $retree) }
sub circumfix__S_191sigil {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_191sigil");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sigil";
$self->_MATCHIFYr($S, "circumfix__S_191sigil", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sigil'], sub {
my $C = shift;
$C->sigil
}))
and ($C) = ($C->_BRACKETr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'contextualizer', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token circumfix:sym<( )>
sub circumfix__S_192Paren_Thesis__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_192Paren_Thesis', $retree) }
sub circumfix__S_192Paren_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_192Paren_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\ \)";
$self->_MATCHIFYr($S, "circumfix__S_192Paren_Thesis", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'parenthesized expression', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token circumfix:sym<[ ]>
sub circumfix__S_193Bra_Ket__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_193Bra_Ket', $retree) }
sub circumfix__S_193Bra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_193Bra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\[\ \]";
$self->_MATCHIFYr($S, "circumfix__S_193Bra_Ket", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\]";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'array composer', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token PRE {
sub PRE__PEEK { $_[0]->_AUTOLEXpeek('PRE', $retree) }
sub PRE {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE PRE");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'prefix_postfix_meta_operator'} = [];
$self->_MATCHIFYr($S, "PRE", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'PRE_0') {
$C->deb("Fate passed to PRE_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT PRE_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM PRE_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'PRE_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("PRE_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token infixish ($in_meta = $*IN_META) {
sub infixish__PEEK { $_[0]->_AUTOLEXpeek('infixish', $retree) }
sub infixish {
no warnings 'recursion';
my $self = shift;
my $in_meta = @_ ? shift() : $::IN_META;
my $infix;local $::IN_META = $in_meta;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infixish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'infix_postfix_meta_operator'} = [];
$self->_MATCHIFYr($S, "infixish", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->stdstopper)) { ($C) } else { () }
}))
and ($C) = ($C->_NOTBEFORE(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixish_0') {
$C->deb("Fate passed to infixish_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixish_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixish_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infixish_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixish_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixish_1') {
$C->deb("Fate passed to infixish_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixish_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixish_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infixish_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixish_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infix'], sub {
my $C = shift;
$C->infixish('[]')
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'bracketed infix', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixish_2') {
$C->deb("Fate passed to infixish_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixish_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixish_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infixish_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixish_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infix'], sub {
my $C = shift;
$C->variable
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'infixed function', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token dotty:sym<.*> {
sub dotty__S_194DotStar__PEEK { $_[0]->_AUTOLEXpeek('dotty__S_194DotStar', $retree) }
sub dotty__S_194DotStar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dotty__S_194DotStar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\*";
$self->_MATCHIFYr($S, "dotty__S_194DotStar", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'dotty__S_194DotStar_0') {
$C->deb("Fate passed to dotty__S_194DotStar_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT dotty__S_194DotStar_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM dotty__S_194DotStar_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'dotty__S_194DotStar_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("dotty__S_194DotStar_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token dotty:sym<.> {
sub dotty__S_195Dot__PEEK { $_[0]->_AUTOLEXpeek('dotty__S_195Dot', $retree) }
sub dotty__S_195Dot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dotty__S_195Dot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.";
$self->_MATCHIFYr($S, "dotty__S_195Dot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\."))
and ($C) = ($C->unspacey)
and ($C) = ($C->_SUBSUMEr(['dottyop'], sub {
my $C = shift;
$C->dottyop
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token privop {
sub privop__PEEK { $_[0]->_AUTOLEXpeek('privop', $retree) }
sub privop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE privop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "privop", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!"))
and ($C) = ($C->_SUBSUMEr(['methodop'], sub {
my $C = shift;
$C->methodop
}))) {
$C->_SUBSUMEr(['O'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token dottyopish {
sub dottyopish__PEEK { $_[0]->_AUTOLEXpeek('dottyopish', $retree) }
sub dottyopish {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dottyopish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "dottyopish", $C->_SUBSUMEr(['term'], sub {
my $C = shift;
$C->dottyop
}));
}
;
## token dottyop {
sub dottyop__PEEK { $_[0]->_AUTOLEXpeek('dottyop', $retree) }
sub dottyop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dottyop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "dottyop", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'dottyop_0') {
$C->deb("Fate passed to dottyop_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT dottyop_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM dottyop_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'dottyop_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("dottyop_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token POST {
sub POST__PEEK { $_[0]->_AUTOLEXpeek('POST', $retree) }
sub POST {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE POST");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'postfix_prefix_meta_operator'} = [];
$self->_MATCHIFYr($S, "POST", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->stdstopper)) { ($C) } else { () }
}))
and ($C) = ($C->_NOTBEFORE(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'POST_0') {
$C->deb("Fate passed to POST_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT POST_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM POST_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'POST_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("POST_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'POST_1') {
$C->deb("Fate passed to POST_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT POST_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM POST_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'POST_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("POST_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## regex term:reduce {
sub term__S_196reduce__PEEK { $_[0]->_AUTOLEXpeek('term__S_196reduce', $retree) }
sub term__S_196reduce {
no warnings 'recursion';
my $self = shift;
local $::IN_REDUCE = 1;my $op;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_196reduce");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "reduce";
$self->_MATCHIFY($S, "term__S_196reduce", LazyMap::lazymap(sub {
my $C=shift;
LazyMap::lazymap(sub {
my $C=shift;
if (my ($C) = (scalar(do {
my $M = $C;
$op = $M->{'s'}->{'op'};
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->O(%term)
}))
},
$C->_SUBSUME(['args'], sub {
my $C = shift;
$C->args(0)
}))
},
$C->_BRACKET(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$op->{'O'}->{'diffy'} })
})
}
or $xact->[-2] or
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'term__S_196reduce_0') {
$C->deb("Fate passed to term__S_196reduce_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT term__S_196reduce_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM term__S_196reduce_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'term__S_196reduce_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term__S_196reduce_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
})
} else { () }
},
$C->_BRACKET(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, LazyMap::lazymap(sub {
my $C=shift;
$C->before(sub {
my $C=shift;
$C->_EXACT("\]")
})
},
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix_postfix_meta_operator:sym< « > { <sym> | '<<' }
sub prefix_postfix_meta_operator__S_197Fre__PEEK { $_[0]->_AUTOLEXpeek('prefix_postfix_meta_operator__S_197Fre', $retree) }
sub prefix_postfix_meta_operator__S_197Fre {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix_postfix_meta_operator__S_197Fre");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "«";
$self->_MATCHIFYr($S, "prefix_postfix_meta_operator__S_197Fre", do {
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'prefix_postfix_meta_operator__S_197Fre_0') {
$C->deb("Fate passed to prefix_postfix_meta_operator__S_197Fre_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT prefix_postfix_meta_operator__S_197Fre_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM prefix_postfix_meta_operator__S_197Fre_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'prefix_postfix_meta_operator__S_197Fre_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("prefix_postfix_meta_operator__S_197Fre_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postfix_prefix_meta_operator:sym< » > {
sub postfix_prefix_meta_operator__S_198Nch__PEEK { $_[0]->_AUTOLEXpeek('postfix_prefix_meta_operator__S_198Nch', $retree) }
sub postfix_prefix_meta_operator__S_198Nch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postfix_prefix_meta_operator__S_198Nch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "»";
$self->_MATCHIFYr($S, "postfix_prefix_meta_operator__S_198Nch", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'postfix_prefix_meta_operator__S_198Nch_0') {
$C->deb("Fate passed to postfix_prefix_meta_operator__S_198Nch_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT postfix_prefix_meta_operator__S_198Nch_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM postfix_prefix_meta_operator__S_198Nch_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'postfix_prefix_meta_operator__S_198Nch_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postfix_prefix_meta_operator__S_198Nch_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::QSIGIL })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_prefix_meta_operator:sym<!> {
sub infix_prefix_meta_operator__S_199Bang__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator__S_199Bang', $retree) }
sub infix_prefix_meta_operator__S_199Bang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_prefix_meta_operator__S_199Bang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!";
$self->_MATCHIFYr($S, "infix_prefix_meta_operator__S_199Bang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\!")
}))) { ($C) } else { () }
}))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish('neg')
})
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Negation metaoperator not followed by valid infix"))) { ($C) } else { () }
}
};
@gather;
}
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
my $M = $C;
$M->{'infixish'}->Str eq '=' })
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_prefix_meta_operator:sym<R> {
sub infix_prefix_meta_operator__S_200R__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator__S_200R', $retree) }
sub infix_prefix_meta_operator__S_200R {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_prefix_meta_operator__S_200R");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "R";
$self->_MATCHIFYr($S, "infix_prefix_meta_operator__S_200R", do {
my $C = $C;
if (($C) = ($C->_EXACT("R"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_prefix_meta_operator:sym<S> {
sub infix_prefix_meta_operator__S_201S__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator__S_201S', $retree) }
sub infix_prefix_meta_operator__S_201S {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_prefix_meta_operator__S_201S");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "S";
$self->_MATCHIFYr($S, "infix_prefix_meta_operator__S_201S", do {
my $C = $C;
if (($C) = ($C->_EXACT("S"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_prefix_meta_operator:sym<X> {
sub infix_prefix_meta_operator__S_202X__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator__S_202X', $retree) }
sub infix_prefix_meta_operator__S_202X {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_prefix_meta_operator__S_202X");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'infixish'} = [];
$C->{sym} = "X";
$self->_MATCHIFYr($S, "infix_prefix_meta_operator__S_202X", do {
my $C = $C;
if (($C) = ($C->_EXACT("X"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_prefix_meta_operator:sym<Z> {
sub infix_prefix_meta_operator__S_203Z__PEEK { $_[0]->_AUTOLEXpeek('infix_prefix_meta_operator__S_203Z', $retree) }
sub infix_prefix_meta_operator__S_203Z {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_prefix_meta_operator__S_203Z");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'infixish'} = [];
$C->{sym} = "Z";
$self->_MATCHIFYr($S, "infix_prefix_meta_operator__S_203Z", do {
my $C = $C;
if (($C) = ($C->_EXACT("Z"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_circumfix_meta_operator:sym<« »> {
sub infix_circumfix_meta_operator__S_204Fre_Nch__PEEK { $_[0]->_AUTOLEXpeek('infix_circumfix_meta_operator__S_204Fre_Nch', $retree) }
sub infix_circumfix_meta_operator__S_204Fre_Nch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_circumfix_meta_operator__S_204Fre_Nch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "«\ »";
$self->_MATCHIFYr($S, "infix_circumfix_meta_operator__S_204Fre_Nch", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix_circumfix_meta_operator__S_204Fre_Nch_0') {
$C->deb("Fate passed to infix_circumfix_meta_operator__S_204Fre_Nch_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix_circumfix_meta_operator__S_204Fre_Nch_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator__S_204Fre_Nch_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix_circumfix_meta_operator__S_204Fre_Nch_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_circumfix_meta_operator__S_204Fre_Nch_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
}))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish('hyper')
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (do {
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix_circumfix_meta_operator__S_204Fre_Nch_1') {
$C->deb("Fate passed to infix_circumfix_meta_operator__S_204Fre_Nch_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix_circumfix_meta_operator__S_204Fre_Nch_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator__S_204Fre_Nch_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix_circumfix_meta_operator__S_204Fre_Nch_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_circumfix_meta_operator__S_204Fre_Nch_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix_circumfix_meta_operator:sym«<< >>» {
sub infix_circumfix_meta_operator__S_205LtLt_GtGt__PEEK { $_[0]->_AUTOLEXpeek('infix_circumfix_meta_operator__S_205LtLt_GtGt', $retree) }
sub infix_circumfix_meta_operator__S_205LtLt_GtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_circumfix_meta_operator__S_205LtLt_GtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<\ \>\>";
$self->_MATCHIFYr($S, "infix_circumfix_meta_operator__S_205LtLt_GtGt", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix_circumfix_meta_operator__S_205LtLt_GtGt_0') {
$C->deb("Fate passed to infix_circumfix_meta_operator__S_205LtLt_GtGt_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix_circumfix_meta_operator__S_205LtLt_GtGt_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator__S_205LtLt_GtGt_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix_circumfix_meta_operator__S_205LtLt_GtGt_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_circumfix_meta_operator__S_205LtLt_GtGt_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
}))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish('HYPER')
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = (do {
do {
my ($tag, $try);
my @try;
my $relex;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix_circumfix_meta_operator__S_205LtLt_GtGt_1') {
$C->deb("Fate passed to infix_circumfix_meta_operator__S_205LtLt_GtGt_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix_circumfix_meta_operator__S_205LtLt_GtGt_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix_circumfix_meta_operator__S_205LtLt_GtGt_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix_circumfix_meta_operator__S_205LtLt_GtGt_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix_circumfix_meta_operator__S_205LtLt_GtGt_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
sub infix_postfix_meta_operator__S_206Equal__PEEK { $_[0]->_AUTOLEXpeek('infix_postfix_meta_operator__S_206Equal', $retree) }
sub infix_postfix_meta_operator__S_206Equal {
no warnings 'recursion';
my $self = shift;
die 'Required argument op omitted' unless @_;
my $op = @_ ? shift() : undef;
my %prec;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix_postfix_meta_operator__S_206Equal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=";
$self->_MATCHIFYr($S, "infix_postfix_meta_operator__S_206Equal", do {
my $C = $C;
if (($C) = ($C->_EXACT("\="))
and ($C) = ($C->can_meta($op, "make assignment out of"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$op->{'O'}->{'diffy'} })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym<( )>
sub postcircumfix__S_207Paren_Thesis__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_207Paren_Thesis', $retree) }
sub postcircumfix__S_207Paren_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_207Paren_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\ \)";
$self->_MATCHIFYr($S, "postcircumfix__S_207Paren_Thesis", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semiarglist'], sub {
my $C = shift;
$C->semiarglist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'argument list', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym<[ ]> { :dba('subscript') '[' ~ ']' <semilist> <O(|%methodcall)>
sub postcircumfix__S_208Bra_Ket__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_208Bra_Ket', $retree) }
sub postcircumfix__S_208Bra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_208Bra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\[\ \]";
$self->_MATCHIFYr($S, "postcircumfix__S_208Bra_Ket", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\]";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'subscript', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym<{ }> {
sub postcircumfix__S_209Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_209Cur_Ly', $retree) }
sub postcircumfix__S_209Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CURLEX = $::CURLEX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_209Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "postcircumfix__S_209Cur_Ly", do {
my $C = $C;
if (($C) = ($C->newlex)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\}";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\{"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\}")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'subscript', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym«< >» {
sub postcircumfix__S_210Lt_Gt__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_210Lt_Gt', $retree) }
sub postcircumfix__S_210Lt_Gt {
no warnings 'recursion';
my $self = shift;
my $pos;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_210Lt_Gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\ \>";
$self->_MATCHIFYr($S, "postcircumfix__S_210Lt_Gt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<"))
and ($C) = (scalar(do {
$pos = $C->{'_pos'} }, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('q' => 1)->tweak('w' => 1)->balanced('<','>'))
}))) {
$C->_EXACT("\>")
} else { () }
}
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'postcircumfix__S_210Lt_Gt_0') {
$C->deb("Fate passed to postcircumfix__S_210Lt_Gt_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT postcircumfix__S_210Lt_Gt_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM postcircumfix__S_210Lt_Gt_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'postcircumfix__S_210Lt_Gt_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postcircumfix__S_210Lt_Gt_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
@gather;
};
}))) {
$C
} else { () }
};
}))) { ($C) } else { () }
}))) {
scalar(do {
$C->cursor_force($pos)->panic("Whitespace required before < operator") }, $C)
} else { () }
}
}
or $xact->[-2] or
do {
push @gather, scalar(do {
$C->cursor_force($pos)->panic("Unable to parse quote-words subscript; couldn't find right angle quote") }, $C)
};
@gather;
}
}))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%methodcall)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym«<< >>»
sub postcircumfix__S_211LtLt_GtGt__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_211LtLt_GtGt', $retree) }
sub postcircumfix__S_211LtLt_GtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_211LtLt_GtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<\ \>\>";
$self->_MATCHIFYr($S, "postcircumfix__S_211LtLt_GtGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<\<"))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->tweak('ww' => 1)->balanced('<<','>>'))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\>\>")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Unable to parse quote-words subscript; couldn't find right double-angle quote"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postcircumfix:sym<« »>
sub postcircumfix__S_212Fre_Nch__PEEK { $_[0]->_AUTOLEXpeek('postcircumfix__S_212Fre_Nch', $retree) }
sub postcircumfix__S_212Fre_Nch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postcircumfix__S_212Fre_Nch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "«\ »";
$self->_MATCHIFYr($S, "postcircumfix__S_212Fre_Nch", do {
my $C = $C;
if (($C) = ($C->_EXACT("«"))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('qq' => 1)->tweak('ww' => 1)->balanced('«','»'))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("»")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Unable to parse quote-words subscript; couldn't find right double-angle quote"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postop {
sub postop__PEEK { $_[0]->_AUTOLEXpeek('postop', $retree) }
sub postop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "postop", do {
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'postop_0') {
$C->deb("Fate passed to postop_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT postop_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM postop_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'postop_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postop_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token methodop {
sub methodop__PEEK { $_[0]->_AUTOLEXpeek('methodop', $retree) }
sub methodop {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE methodop");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$C->{'args'} = [];
$self->_MATCHIFYr($S, "methodop", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'methodop_0') {
$C->deb("Fate passed to methodop_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT methodop_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM methodop_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'methodop_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("methodop_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'methodop_1') {
$C->deb("Fate passed to methodop_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT methodop_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM methodop_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'methodop_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("methodop_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G['"]/)
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::QSIGIL})
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
@gather;
}
}))
and ($C) = ($C->_SUBSUMEr(['quote'], sub {
my $C = shift;
$C->quote
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'methodop_2') {
$C->deb("Fate passed to methodop_2: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT methodop_2'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM methodop_2'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'methodop_2', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("methodop_2 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'methodop_3') {
$C->deb("Fate passed to methodop_3: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT methodop_3'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM methodop_3'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'methodop_3', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("methodop_3 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'methodop_4') {
$C->deb("Fate passed to methodop_4: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT methodop_4'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM methodop_4'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'methodop_4', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("methodop_4 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token semiarglist {
sub semiarglist__PEEK { $_[0]->_AUTOLEXpeek('semiarglist', $retree) }
sub semiarglist {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE semiarglist");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$self->_MATCHIFYr($S, "semiarglist", do {
my $C = $C;
if (($C) = ($C->_REPSEPr( sub {
my $C=shift;
$C->_EXACT("\;")
}, sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token arglist {
sub arglist__PEEK { $_[0]->_AUTOLEXpeek('arglist', $retree) }
sub arglist {
no warnings 'recursion';
my $self = shift;
my $inv_ok = $::INVOCANT_OK;local $::endargs = 0;local $::GOAL = 'endargs';local $::QSIGIL = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE arglist");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "arglist", do {
my $C = $C;
if (($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'arglist_0') {
$C->deb("Fate passed to arglist_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT arglist_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM arglist_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'arglist_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("arglist_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:lambda {
sub term__S_213lambda__PEEK { $_[0]->_AUTOLEXpeek('term__S_213lambda', $retree) }
sub term__S_213lambda {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_213lambda");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lambda";
$self->_MATCHIFYr($S, "term__S_213lambda", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->lambda)) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token circumfix:sym<{ }> {
sub circumfix__S_214Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('circumfix__S_214Cur_Ly', $retree) }
sub circumfix__S_214Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE circumfix__S_214Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "circumfix__S_214Cur_Ly", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\{")
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postfix:sym<i>
sub postfix__S_215i__PEEK { $_[0]->_AUTOLEXpeek('postfix__S_215i', $retree) }
sub postfix__S_215i {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postfix__S_215i");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "i";
$self->_MATCHIFYr($S, "postfix__S_215i", do {
if (my ($C) = ($C->_PATTERN(qr/\Gi\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%methodcall)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<.> ()
sub infix__S_216Dot__PEEK { $_[0]->_AUTOLEXpeek('infix__S_216Dot', $retree) }
sub infix__S_216Dot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_216Dot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.";
$self->_MATCHIFYr($S, "infix__S_216Dot", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G\.[\]\)\},:\s\$"']/))
and ($C) = ($C->obs('. to concatenate strings', '~'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postfix:sym['->'] () {
sub postfix__S_217MinusGt__PEEK { $_[0]->_AUTOLEXpeek('postfix__S_217MinusGt', $retree) }
sub postfix__S_217MinusGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postfix__S_217MinusGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-\>";
$self->_MATCHIFYr($S, "postfix__S_217MinusGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\-\>"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'postfix__S_217MinusGt_0') {
$C->deb("Fate passed to postfix__S_217MinusGt_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT postfix__S_217MinusGt_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM postfix__S_217MinusGt_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'postfix__S_217MinusGt_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("postfix__S_217MinusGt_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postfix:sym<++>
sub postfix__S_218PlusPlus__PEEK { $_[0]->_AUTOLEXpeek('postfix__S_218PlusPlus', $retree) }
sub postfix__S_218PlusPlus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postfix__S_218PlusPlus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\+";
$self->_MATCHIFYr($S, "postfix__S_218PlusPlus", do {
if (my ($C) = ($C->_EXACT("\+\+"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%autoincrement)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token postfix:sym«--» ()
sub postfix__S_219MinusMinus__PEEK { $_[0]->_AUTOLEXpeek('postfix__S_219MinusMinus', $retree) }
sub postfix__S_219MinusMinus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE postfix__S_219MinusMinus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-\-";
$self->_MATCHIFYr($S, "postfix__S_219MinusMinus", do {
if (my ($C) = ($C->_EXACT("\-\-"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%autoincrement)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<++>
sub prefix__S_220PlusPlus__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_220PlusPlus', $retree) }
sub prefix__S_220PlusPlus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_220PlusPlus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\+";
$self->_MATCHIFYr($S, "prefix__S_220PlusPlus", do {
if (my ($C) = ($C->_EXACT("\+\+"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%autoincrement)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym«--» ()
sub prefix__S_221MinusMinus__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_221MinusMinus', $retree) }
sub prefix__S_221MinusMinus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_221MinusMinus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-\-";
$self->_MATCHIFYr($S, "prefix__S_221MinusMinus", do {
if (my ($C) = ($C->_EXACT("\-\-"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%autoincrement)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<**>
sub infix__S_222StarStar__PEEK { $_[0]->_AUTOLEXpeek('infix__S_222StarStar', $retree) }
sub infix__S_222StarStar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_222StarStar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*\*";
$self->_MATCHIFYr($S, "infix__S_222StarStar", do {
if (my ($C) = ($C->_EXACT("\*\*"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%exponentiation)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<!>
sub prefix__S_223Bang__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_223Bang', $retree) }
sub prefix__S_223Bang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_223Bang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!";
$self->_MATCHIFYr($S, "prefix__S_223Bang", do {
if (my ($C) = ($C->_EXACT("\!"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<+>
sub prefix__S_224Plus__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_224Plus', $retree) }
sub prefix__S_224Plus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_224Plus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+";
$self->_MATCHIFYr($S, "prefix__S_224Plus", do {
if (my ($C) = ($C->_EXACT("\+"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<->
sub prefix__S_225Minus__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_225Minus', $retree) }
sub prefix__S_225Minus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_225Minus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-";
$self->_MATCHIFYr($S, "prefix__S_225Minus", do {
if (my ($C) = ($C->_EXACT("\-"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<~~>
sub prefix__S_226TildeTilde__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_226TildeTilde', $retree) }
sub prefix__S_226TildeTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_226TildeTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\~";
$self->_MATCHIFYr($S, "prefix__S_226TildeTilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~\~"))
and ($C) = ($C->dupprefix('~~'))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<~>
sub prefix__S_227Tilde__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_227Tilde', $retree) }
sub prefix__S_227Tilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_227Tilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~";
$self->_MATCHIFYr($S, "prefix__S_227Tilde", do {
if (my ($C) = ($C->_EXACT("\~"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<??>
sub prefix__S_228QuestionQuestion__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_228QuestionQuestion', $retree) }
sub prefix__S_228QuestionQuestion {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_228QuestionQuestion");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\?";
$self->_MATCHIFYr($S, "prefix__S_228QuestionQuestion", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?\?"))
and ($C) = ($C->dupprefix('??'))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<?>
sub prefix__S_229Question__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_229Question', $retree) }
sub prefix__S_229Question {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_229Question");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?";
$self->_MATCHIFYr($S, "prefix__S_229Question", do {
if (my ($C) = ($C->_EXACT("\?"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<~^>
sub prefix__S_230TildeCaret__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_230TildeCaret', $retree) }
sub prefix__S_230TildeCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_230TildeCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\^";
$self->_MATCHIFYr($S, "prefix__S_230TildeCaret", do {
if (my ($C) = ($C->_EXACT("\~\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<+^>
sub prefix__S_231PlusCaret__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_231PlusCaret', $retree) }
sub prefix__S_231PlusCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_231PlusCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\^";
$self->_MATCHIFYr($S, "prefix__S_231PlusCaret", do {
if (my ($C) = ($C->_EXACT("\+\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<?^>
sub prefix__S_232QuestionCaret__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_232QuestionCaret', $retree) }
sub prefix__S_232QuestionCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_232QuestionCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\^";
$self->_MATCHIFYr($S, "prefix__S_232QuestionCaret", do {
if (my ($C) = ($C->_EXACT("\?\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<^^>
sub prefix__S_233CaretCaret__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_233CaretCaret', $retree) }
sub prefix__S_233CaretCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_233CaretCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^\^";
$self->_MATCHIFYr($S, "prefix__S_233CaretCaret", do {
my $C = $C;
if (($C) = ($C->_EXACT("\^\^"))
and ($C) = ($C->dupprefix('^^'))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<^>
sub prefix__S_234Caret__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_234Caret', $retree) }
sub prefix__S_234Caret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_234Caret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^";
$self->_MATCHIFYr($S, "prefix__S_234Caret", do {
if (my ($C) = ($C->_EXACT("\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<||>
sub prefix__S_235VertVert__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_235VertVert', $retree) }
sub prefix__S_235VertVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_235VertVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|\|";
$self->_MATCHIFYr($S, "prefix__S_235VertVert", do {
if (my ($C) = ($C->_EXACT("\|\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<|>
sub prefix__S_236Vert__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_236Vert', $retree) }
sub prefix__S_236Vert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_236Vert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|";
$self->_MATCHIFYr($S, "prefix__S_236Vert", do {
if (my ($C) = ($C->_EXACT("\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%symbolic_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<*>
sub infix__S_237Star__PEEK { $_[0]->_AUTOLEXpeek('infix__S_237Star', $retree) }
sub infix__S_237Star {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_237Star");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*";
$self->_MATCHIFYr($S, "infix__S_237Star", do {
if (my ($C) = ($C->_EXACT("\*"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym</>
sub infix__S_238Slash__PEEK { $_[0]->_AUTOLEXpeek('infix__S_238Slash', $retree) }
sub infix__S_238Slash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_238Slash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\/";
$self->_MATCHIFYr($S, "infix__S_238Slash", do {
if (my ($C) = ($C->_EXACT("\/"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<div>
sub infix__S_239div__PEEK { $_[0]->_AUTOLEXpeek('infix__S_239div', $retree) }
sub infix__S_239div {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_239div");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "div";
$self->_MATCHIFYr($S, "infix__S_239div", do {
if (my ($C) = ($C->_EXACT("div"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<%>
sub infix__S_240Percent__PEEK { $_[0]->_AUTOLEXpeek('infix__S_240Percent', $retree) }
sub infix__S_240Percent {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_240Percent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%";
$self->_MATCHIFYr($S, "infix__S_240Percent", do {
if (my ($C) = ($C->_EXACT("\%"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<%%>
sub infix__S_241PercentPercent__PEEK { $_[0]->_AUTOLEXpeek('infix__S_241PercentPercent', $retree) }
sub infix__S_241PercentPercent {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_241PercentPercent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%\%";
$self->_MATCHIFYr($S, "infix__S_241PercentPercent", do {
if (my ($C) = ($C->_EXACT("\%\%"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<mod>
sub infix__S_242mod__PEEK { $_[0]->_AUTOLEXpeek('infix__S_242mod', $retree) }
sub infix__S_242mod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_242mod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "mod";
$self->_MATCHIFYr($S, "infix__S_242mod", do {
if (my ($C) = ($C->_EXACT("mod"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<gcd>
sub infix__S_243gcd__PEEK { $_[0]->_AUTOLEXpeek('infix__S_243gcd', $retree) }
sub infix__S_243gcd {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_243gcd");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "gcd";
$self->_MATCHIFYr($S, "infix__S_243gcd", do {
if (my ($C) = ($C->_EXACT("gcd"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<lcm>
sub infix__S_244lcm__PEEK { $_[0]->_AUTOLEXpeek('infix__S_244lcm', $retree) }
sub infix__S_244lcm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_244lcm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lcm";
$self->_MATCHIFYr($S, "infix__S_244lcm", do {
if (my ($C) = ($C->_EXACT("lcm"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<+&>
sub infix__S_245PlusAmp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_245PlusAmp', $retree) }
sub infix__S_245PlusAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_245PlusAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\&";
$self->_MATCHIFYr($S, "infix__S_245PlusAmp", do {
if (my ($C) = ($C->_EXACT("\+\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« << »
sub infix__S_246LtLt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_246LtLt', $retree) }
sub infix__S_246LtLt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_246LtLt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<";
$self->_MATCHIFYr($S, "infix__S_246LtLt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<\<"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« >> »
sub infix__S_247GtGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_247GtGt', $retree) }
sub infix__S_247GtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_247GtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\>\>";
$self->_MATCHIFYr($S, "infix__S_247GtGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\>\>"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<~&>
sub infix__S_248TildeAmp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_248TildeAmp', $retree) }
sub infix__S_248TildeAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_248TildeAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\&";
$self->_MATCHIFYr($S, "infix__S_248TildeAmp", do {
if (my ($C) = ($C->_EXACT("\~\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<?&>
sub infix__S_249QuestionAmp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_249QuestionAmp', $retree) }
sub infix__S_249QuestionAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_249QuestionAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\&";
$self->_MATCHIFYr($S, "infix__S_249QuestionAmp", do {
if (my ($C) = ($C->_EXACT("\?\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%multiplicative, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« ~< »
sub infix__S_250TildeLt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_250TildeLt', $retree) }
sub infix__S_250TildeLt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_250TildeLt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\<";
$self->_MATCHIFYr($S, "infix__S_250TildeLt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~\<"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« ~> »
sub infix__S_251TildeGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_251TildeGt', $retree) }
sub infix__S_251TildeGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_251TildeGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\>";
$self->_MATCHIFYr($S, "infix__S_251TildeGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~\>"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« +< »
sub infix__S_252PlusLt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_252PlusLt', $retree) }
sub infix__S_252PlusLt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_252PlusLt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\<";
$self->_MATCHIFYr($S, "infix__S_252PlusLt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\+\<"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« +> »
sub infix__S_253PlusGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_253PlusGt', $retree) }
sub infix__S_253PlusGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_253PlusGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\>";
$self->_MATCHIFYr($S, "infix__S_253PlusGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\+\>"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::IN_META })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<+>
sub infix__S_254Plus__PEEK { $_[0]->_AUTOLEXpeek('infix__S_254Plus', $retree) }
sub infix__S_254Plus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_254Plus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+";
$self->_MATCHIFYr($S, "infix__S_254Plus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\+"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<->
sub infix__S_255Minus__PEEK { $_[0]->_AUTOLEXpeek('infix__S_255Minus', $retree) }
sub infix__S_255Minus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_255Minus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-";
$self->_MATCHIFYr($S, "infix__S_255Minus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\-"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<+|>
sub infix__S_256PlusVert__PEEK { $_[0]->_AUTOLEXpeek('infix__S_256PlusVert', $retree) }
sub infix__S_256PlusVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_256PlusVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\|";
$self->_MATCHIFYr($S, "infix__S_256PlusVert", do {
if (my ($C) = ($C->_EXACT("\+\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<+^>
sub infix__S_257PlusCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_257PlusCaret', $retree) }
sub infix__S_257PlusCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_257PlusCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+\^";
$self->_MATCHIFYr($S, "infix__S_257PlusCaret", do {
if (my ($C) = ($C->_EXACT("\+\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<~|>
sub infix__S_258TildeVert__PEEK { $_[0]->_AUTOLEXpeek('infix__S_258TildeVert', $retree) }
sub infix__S_258TildeVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_258TildeVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\|";
$self->_MATCHIFYr($S, "infix__S_258TildeVert", do {
if (my ($C) = ($C->_EXACT("\~\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<~^>
sub infix__S_259TildeCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_259TildeCaret', $retree) }
sub infix__S_259TildeCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_259TildeCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\^";
$self->_MATCHIFYr($S, "infix__S_259TildeCaret", do {
if (my ($C) = ($C->_EXACT("\~\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<?|>
sub infix__S_260QuestionVert__PEEK { $_[0]->_AUTOLEXpeek('infix__S_260QuestionVert', $retree) }
sub infix__S_260QuestionVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_260QuestionVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\|";
$self->_MATCHIFYr($S, "infix__S_260QuestionVert", do {
if (my ($C) = ($C->_EXACT("\?\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<?^>
sub infix__S_261QuestionCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_261QuestionCaret', $retree) }
sub infix__S_261QuestionCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_261QuestionCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\^";
$self->_MATCHIFYr($S, "infix__S_261QuestionCaret", do {
if (my ($C) = ($C->_EXACT("\?\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%additive)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<x>
sub infix__S_262x__PEEK { $_[0]->_AUTOLEXpeek('infix__S_262x', $retree) }
sub infix__S_262x {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_262x");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "x";
$self->_MATCHIFYr($S, "infix__S_262x", do {
if (my ($C) = ($C->_EXACT("x"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%replication)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<xx>
sub infix__S_263xx__PEEK { $_[0]->_AUTOLEXpeek('infix__S_263xx', $retree) }
sub infix__S_263xx {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_263xx");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "xx";
$self->_MATCHIFYr($S, "infix__S_263xx", do {
if (my ($C) = ($C->_EXACT("xx"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%replication)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<~>
sub infix__S_264Tilde__PEEK { $_[0]->_AUTOLEXpeek('infix__S_264Tilde', $retree) }
sub infix__S_264Tilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_264Tilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~";
$self->_MATCHIFYr($S, "infix__S_264Tilde", do {
if (my ($C) = ($C->_EXACT("\~"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%concatenation)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<&>
sub infix__S_265Amp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_265Amp', $retree) }
sub infix__S_265Amp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_265Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "infix__S_265Amp", do {
if (my ($C) = ($C->_EXACT("\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%junctive_and, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<|>
sub infix__S_266Vert__PEEK { $_[0]->_AUTOLEXpeek('infix__S_266Vert', $retree) }
sub infix__S_266Vert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_266Vert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|";
$self->_MATCHIFYr($S, "infix__S_266Vert", do {
if (my ($C) = ($C->_EXACT("\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%junctive_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^>
sub infix__S_267Caret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_267Caret', $retree) }
sub infix__S_267Caret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_267Caret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^";
$self->_MATCHIFYr($S, "infix__S_267Caret", do {
if (my ($C) = ($C->_EXACT("\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%junctive_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sleep
sub prefix__S_268sleep__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_268sleep', $retree) }
sub prefix__S_268sleep {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_268sleep");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sleep";
$self->_MATCHIFYr($S, "prefix__S_268sleep", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gsleep\b/))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:abs
sub prefix__S_269abs__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_269abs', $retree) }
sub prefix__S_269abs {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_269abs");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "abs";
$self->_MATCHIFYr($S, "prefix__S_269abs", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gabs\b/))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:let
sub prefix__S_270let__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_270let', $retree) }
sub prefix__S_270let {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_270let");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "let";
$self->_MATCHIFYr($S, "prefix__S_270let", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Glet\b/))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:temp
sub prefix__S_271temp__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_271temp', $retree) }
sub prefix__S_271temp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_271temp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "temp";
$self->_MATCHIFYr($S, "prefix__S_271temp", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gtemp\b/))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« <=> »
sub infix__S_272LtEqualGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_272LtEqualGt', $retree) }
sub infix__S_272LtEqualGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_272LtEqualGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\=\>";
$self->_MATCHIFYr($S, "infix__S_272LtEqualGt", do {
if (my ($C) = ($C->_EXACT("\<\=\>"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural, returns => 'Order')
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:cmp
sub infix__S_273cmp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_273cmp', $retree) }
sub infix__S_273cmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_273cmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "cmp";
$self->_MATCHIFYr($S, "infix__S_273cmp", do {
if (my ($C) = ($C->_EXACT("cmp"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural, returns => 'Order')
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:leg
sub infix__S_274leg__PEEK { $_[0]->_AUTOLEXpeek('infix__S_274leg', $retree) }
sub infix__S_274leg {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_274leg");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "leg";
$self->_MATCHIFYr($S, "infix__S_274leg", do {
if (my ($C) = ($C->_EXACT("leg"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural, returns => 'Order')
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:but
sub infix__S_275but__PEEK { $_[0]->_AUTOLEXpeek('infix__S_275but', $retree) }
sub infix__S_275but {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_275but");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "but";
$self->_MATCHIFYr($S, "infix__S_275but", do {
if (my ($C) = ($C->_EXACT("but"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:does
sub infix__S_276does__PEEK { $_[0]->_AUTOLEXpeek('infix__S_276does', $retree) }
sub infix__S_276does {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_276does");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "does";
$self->_MATCHIFYr($S, "infix__S_276does", do {
if (my ($C) = ($C->_EXACT("does"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<..>
sub infix__S_277DotDot__PEEK { $_[0]->_AUTOLEXpeek('infix__S_277DotDot', $retree) }
sub infix__S_277DotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_277DotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\.";
$self->_MATCHIFYr($S, "infix__S_277DotDot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\.\."))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix__S_277DotDot_0') {
$C->deb("Fate passed to infix__S_277DotDot_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix__S_277DotDot_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix__S_277DotDot_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix__S_277DotDot_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix__S_277DotDot_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^..>
sub infix__S_278CaretDotDot__PEEK { $_[0]->_AUTOLEXpeek('infix__S_278CaretDotDot', $retree) }
sub infix__S_278CaretDotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_278CaretDotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^\.\.";
$self->_MATCHIFYr($S, "infix__S_278CaretDotDot", do {
if (my ($C) = ($C->_EXACT("\^\.\."))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<..^>
sub infix__S_279DotDotCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_279DotDotCaret', $retree) }
sub infix__S_279DotDotCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_279DotDotCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\.\^";
$self->_MATCHIFYr($S, "infix__S_279DotDotCaret", do {
if (my ($C) = ($C->_EXACT("\.\.\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^..^>
sub infix__S_280CaretDotDotCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_280CaretDotDotCaret', $retree) }
sub infix__S_280CaretDotDotCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_280CaretDotDotCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^\.\.\^";
$self->_MATCHIFYr($S, "infix__S_280CaretDotDotCaret", do {
if (my ($C) = ($C->_EXACT("\^\.\.\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%structural)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<==>
sub infix__S_281EqualEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_281EqualEqual', $retree) }
sub infix__S_281EqualEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_281EqualEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\=";
$self->_MATCHIFYr($S, "infix__S_281EqualEqual", do {
my $C = $C;
if (($C) = ($C->_EXACT("\=\="))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<!=>
sub infix__S_282BangEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_282BangEqual', $retree) }
sub infix__S_282BangEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_282BangEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!\=";
$self->_MATCHIFYr($S, "infix__S_282BangEqual", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!\="))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« < »
sub infix__S_283Lt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_283Lt', $retree) }
sub infix__S_283Lt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_283Lt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<";
$self->_MATCHIFYr($S, "infix__S_283Lt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« <= »
sub infix__S_284LtEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_284LtEqual', $retree) }
sub infix__S_284LtEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_284LtEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\=";
$self->_MATCHIFYr($S, "infix__S_284LtEqual", do {
if (my ($C) = ($C->_EXACT("\<\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« > »
sub infix__S_285Gt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_285Gt', $retree) }
sub infix__S_285Gt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_285Gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\>";
$self->_MATCHIFYr($S, "infix__S_285Gt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\>"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« >= »
sub infix__S_286GtEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_286GtEqual', $retree) }
sub infix__S_286GtEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_286GtEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\>\=";
$self->_MATCHIFYr($S, "infix__S_286GtEqual", do {
if (my ($C) = ($C->_EXACT("\>\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<~~>
sub infix__S_287TildeTilde__PEEK { $_[0]->_AUTOLEXpeek('infix__S_287TildeTilde', $retree) }
sub infix__S_287TildeTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_287TildeTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\~";
$self->_MATCHIFYr($S, "infix__S_287TildeTilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~\~"))
and ($C) = ($C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token dumbsmart {
sub dumbsmart__PEEK { $_[0]->_AUTOLEXpeek('dumbsmart', $retree) }
sub dumbsmart {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE dumbsmart");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'0'} = [];
$self->_MATCHIFYr($S, "dumbsmart", $C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_PATTERN(qr/\G[\x20\t\r]*+/))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'dumbsmart_0') {
$C->deb("Fate passed to dumbsmart_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT dumbsmart_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM dumbsmart_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'dumbsmart_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("dumbsmart_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<!~>
sub infix__S_288BangTilde__PEEK { $_[0]->_AUTOLEXpeek('infix__S_288BangTilde', $retree) }
sub infix__S_288BangTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_288BangTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!\~";
$self->_MATCHIFYr($S, "infix__S_288BangTilde", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G\!\~\s/))
and ($C) = ($C->obs('!~ to do negated pattern matching', '!~~'))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<=~>
sub infix__S_289EqualTilde__PEEK { $_[0]->_AUTOLEXpeek('infix__S_289EqualTilde', $retree) }
sub infix__S_289EqualTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_289EqualTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\~";
$self->_MATCHIFYr($S, "infix__S_289EqualTilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\=\~"))
and ($C) = ($C->obs('=~ to do pattern matching', '~~'))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<eq>
sub infix__S_290eq__PEEK { $_[0]->_AUTOLEXpeek('infix__S_290eq', $retree) }
sub infix__S_290eq {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_290eq");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "eq";
$self->_MATCHIFYr($S, "infix__S_290eq", do {
if (my ($C) = ($C->_EXACT("eq"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<ne>
sub infix__S_291ne__PEEK { $_[0]->_AUTOLEXpeek('infix__S_291ne', $retree) }
sub infix__S_291ne {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_291ne");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ne";
$self->_MATCHIFYr($S, "infix__S_291ne", do {
if (my ($C) = ($C->_EXACT("ne"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<lt>
sub infix__S_292lt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_292lt', $retree) }
sub infix__S_292lt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_292lt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "lt";
$self->_MATCHIFYr($S, "infix__S_292lt", do {
if (my ($C) = ($C->_EXACT("lt"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<le>
sub infix__S_293le__PEEK { $_[0]->_AUTOLEXpeek('infix__S_293le', $retree) }
sub infix__S_293le {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_293le");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "le";
$self->_MATCHIFYr($S, "infix__S_293le", do {
if (my ($C) = ($C->_EXACT("le"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<gt>
sub infix__S_294gt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_294gt', $retree) }
sub infix__S_294gt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_294gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "gt";
$self->_MATCHIFYr($S, "infix__S_294gt", do {
if (my ($C) = ($C->_EXACT("gt"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<ge>
sub infix__S_295ge__PEEK { $_[0]->_AUTOLEXpeek('infix__S_295ge', $retree) }
sub infix__S_295ge {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_295ge");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ge";
$self->_MATCHIFYr($S, "infix__S_295ge", do {
if (my ($C) = ($C->_EXACT("ge"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<=:=>
sub infix__S_296EqualColonEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_296EqualColonEqual', $retree) }
sub infix__S_296EqualColonEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_296EqualColonEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\:\=";
$self->_MATCHIFYr($S, "infix__S_296EqualColonEqual", do {
if (my ($C) = ($C->_EXACT("\=\:\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<===>
sub infix__S_297EqualEqualEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_297EqualEqualEqual', $retree) }
sub infix__S_297EqualEqualEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_297EqualEqualEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\=\=";
$self->_MATCHIFYr($S, "infix__S_297EqualEqualEqual", do {
if (my ($C) = ($C->_EXACT("\=\=\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<eqv>
sub infix__S_298eqv__PEEK { $_[0]->_AUTOLEXpeek('infix__S_298eqv', $retree) }
sub infix__S_298eqv {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_298eqv");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "eqv";
$self->_MATCHIFYr($S, "infix__S_298eqv", do {
if (my ($C) = ($C->_EXACT("eqv"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<before>
sub infix__S_299before__PEEK { $_[0]->_AUTOLEXpeek('infix__S_299before', $retree) }
sub infix__S_299before {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_299before");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "before";
$self->_MATCHIFYr($S, "infix__S_299before", do {
if (my ($C) = ($C->_EXACT("before"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<after>
sub infix__S_300after__PEEK { $_[0]->_AUTOLEXpeek('infix__S_300after', $retree) }
sub infix__S_300after {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_300after");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "after";
$self->_MATCHIFYr($S, "infix__S_300after", do {
if (my ($C) = ($C->_EXACT("after"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%chaining)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<&&>
sub infix__S_301AmpAmp__PEEK { $_[0]->_AUTOLEXpeek('infix__S_301AmpAmp', $retree) }
sub infix__S_301AmpAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_301AmpAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&\&";
$self->_MATCHIFYr($S, "infix__S_301AmpAmp", do {
if (my ($C) = ($C->_EXACT("\&\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_and, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<||>
sub infix__S_302VertVert__PEEK { $_[0]->_AUTOLEXpeek('infix__S_302VertVert', $retree) }
sub infix__S_302VertVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_302VertVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|\|";
$self->_MATCHIFYr($S, "infix__S_302VertVert", do {
if (my ($C) = ($C->_EXACT("\|\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^^>
sub infix__S_303CaretCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_303CaretCaret', $retree) }
sub infix__S_303CaretCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_303CaretCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^\^";
$self->_MATCHIFYr($S, "infix__S_303CaretCaret", do {
if (my ($C) = ($C->_EXACT("\^\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<//>
sub infix__S_304SlashSlash__PEEK { $_[0]->_AUTOLEXpeek('infix__S_304SlashSlash', $retree) }
sub infix__S_304SlashSlash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_304SlashSlash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\/\/";
$self->_MATCHIFYr($S, "infix__S_304SlashSlash", do {
if (my ($C) = ($C->_EXACT("\/\/"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<min>
sub infix__S_305min__PEEK { $_[0]->_AUTOLEXpeek('infix__S_305min', $retree) }
sub infix__S_305min {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_305min");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "min";
$self->_MATCHIFYr($S, "infix__S_305min", do {
if (my ($C) = ($C->_EXACT("min"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<max>
sub infix__S_306max__PEEK { $_[0]->_AUTOLEXpeek('infix__S_306max', $retree) }
sub infix__S_306max {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_306max");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "max";
$self->_MATCHIFYr($S, "infix__S_306max", do {
if (my ($C) = ($C->_EXACT("max"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<?? !!> {
sub infix__S_307QuestionQuestion_BangBang__PEEK { $_[0]->_AUTOLEXpeek('infix__S_307QuestionQuestion_BangBang', $retree) }
sub infix__S_307QuestionQuestion_BangBang {
no warnings 'recursion';
my $self = shift;
local $::GOAL = '!!';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_307QuestionQuestion_BangBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\?\ \!\!";
$self->_MATCHIFYr($S, "infix__S_307QuestionQuestion_BangBang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?\?"))
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR(\%item_assignment)
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\!\!")
}
or $xact->[-2] or
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<!!> {
sub infix__S_308BangBang__PEEK { $_[0]->_AUTOLEXpeek('infix__S_308BangBang', $retree) }
sub infix__S_308BangBang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_308BangBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!\!";
$self->_MATCHIFYr($S, "infix__S_308BangBang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!\!"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->suppose(sub {
my $C=shift;
$C->_SUBSUMEr(['infixish'], sub {
my $C = shift;
$C->infixish
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token infix:sym<?>
sub infix__S_309Question__PEEK { $_[0]->_AUTOLEXpeek('infix__S_309Question', $retree) }
sub infix__S_309Question {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_309Question");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?";
$self->_MATCHIFYr($S, "infix__S_309Question", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<ff>
sub infix__S_310ff__PEEK { $_[0]->_AUTOLEXpeek('infix__S_310ff', $retree) }
sub infix__S_310ff {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_310ff");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ff";
$self->_MATCHIFYr($S, "infix__S_310ff", do {
if (my ($C) = ($C->_EXACT("ff"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^ff>
sub infix__S_311Caretff__PEEK { $_[0]->_AUTOLEXpeek('infix__S_311Caretff', $retree) }
sub infix__S_311Caretff {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_311Caretff");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^ff";
$self->_MATCHIFYr($S, "infix__S_311Caretff", do {
if (my ($C) = ($C->_EXACT("\^ff"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<ff^>
sub infix__S_312ffCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_312ffCaret', $retree) }
sub infix__S_312ffCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_312ffCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ff\^";
$self->_MATCHIFYr($S, "infix__S_312ffCaret", do {
if (my ($C) = ($C->_EXACT("ff\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^ff^>
sub infix__S_313CaretffCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_313CaretffCaret', $retree) }
sub infix__S_313CaretffCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_313CaretffCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^ff\^";
$self->_MATCHIFYr($S, "infix__S_313CaretffCaret", do {
if (my ($C) = ($C->_EXACT("\^ff\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<fff>
sub infix__S_314fff__PEEK { $_[0]->_AUTOLEXpeek('infix__S_314fff', $retree) }
sub infix__S_314fff {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_314fff");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "fff";
$self->_MATCHIFYr($S, "infix__S_314fff", do {
if (my ($C) = ($C->_EXACT("fff"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^fff>
sub infix__S_315Caretfff__PEEK { $_[0]->_AUTOLEXpeek('infix__S_315Caretfff', $retree) }
sub infix__S_315Caretfff {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_315Caretfff");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^fff";
$self->_MATCHIFYr($S, "infix__S_315Caretfff", do {
if (my ($C) = ($C->_EXACT("\^fff"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<fff^>
sub infix__S_316fffCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_316fffCaret', $retree) }
sub infix__S_316fffCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_316fffCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "fff\^";
$self->_MATCHIFYr($S, "infix__S_316fffCaret", do {
if (my ($C) = ($C->_EXACT("fff\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<^fff^>
sub infix__S_317CaretfffCaret__PEEK { $_[0]->_AUTOLEXpeek('infix__S_317CaretfffCaret', $retree) }
sub infix__S_317CaretfffCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_317CaretfffCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^fff\^";
$self->_MATCHIFYr($S, "infix__S_317CaretfffCaret", do {
if (my ($C) = ($C->_EXACT("\^fff\^"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%conditional)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<=> ()
sub infix__S_318Equal__PEEK { $_[0]->_AUTOLEXpeek('infix__S_318Equal', $retree) }
sub infix__S_318Equal {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_318Equal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=";
$self->_MATCHIFYr($S, "infix__S_318Equal", do {
my $C = $C;
if (($C) = ($C->_EXACT("\="))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::LEFTSIGIL eq '$' })
}))) {
$C->_SUBSUMEr(['O'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<:=>
sub infix__S_319ColonEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_319ColonEqual', $retree) }
sub infix__S_319ColonEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_319ColonEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\=";
$self->_MATCHIFYr($S, "infix__S_319ColonEqual", do {
if (my ($C) = ($C->_EXACT("\:\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_assignment)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<::=>
sub infix__S_320ColonColonEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_320ColonColonEqual', $retree) }
sub infix__S_320ColonColonEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_320ColonColonEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\=";
$self->_MATCHIFYr($S, "infix__S_320ColonColonEqual", do {
if (my ($C) = ($C->_EXACT("\:\:\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_assignment)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<.=> {
sub infix__S_321DotEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_321DotEqual', $retree) }
sub infix__S_321DotEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_321DotEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\=";
$self->_MATCHIFYr($S, "infix__S_321DotEqual", do {
if (my ($C) = ($C->_EXACT("\.\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%item_assignment,
nextterm => 'dottyopish',
_reducecheck => 'check_doteq'
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $ok = 0;
eval {
my $methop = $self->{'right'}->{'methodop'};
my $name = $methop->{'longname'}->Str;
if (grep {
$_ eq $name } <new clone sort subst trans reverse uniq map samecase substr flip fmt pick>) {
$ok = 1}
elsif (not $methop->{'args'}->[0]) {
$ok = 1};
};
$self->cursor_force($self->{'infix'}->{'_pos'})->worryobs('.= as append operator', '~=') unless $ok;
$self;
};
## token infix:sym« => »
sub infix__S_322EqualGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_322EqualGt', $retree) }
sub infix__S_322EqualGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_322EqualGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\>";
$self->_MATCHIFYr($S, "infix__S_322EqualGt", do {
if (my ($C) = ($C->_EXACT("\=\>"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%item_assignment, fiddly => 0)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<so>
sub prefix__S_323so__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_323so', $retree) }
sub prefix__S_323so {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_323so");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "so";
$self->_MATCHIFYr($S, "prefix__S_323so", do {
if (my ($C) = ($C->_PATTERN(qr/\Gso\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token prefix:sym<not>
sub prefix__S_324not__PEEK { $_[0]->_AUTOLEXpeek('prefix__S_324not', $retree) }
sub prefix__S_324not {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE prefix__S_324not");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "not";
$self->_MATCHIFYr($S, "prefix__S_324not", do {
if (my ($C) = ($C->_PATTERN(qr/\Gnot\b/))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_unary)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<,> {
sub infix__S_325Comma__PEEK { $_[0]->_AUTOLEXpeek('infix__S_325Comma', $retree) }
sub infix__S_325Comma {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_325Comma");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\,";
$self->_MATCHIFYr($S, "infix__S_325Comma", do {
my $C = $C;
if (($C) = ($C->_EXACT("\,"))
and ($C) = ($C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%comma, fiddly => 0)
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<:> {
sub infix__S_326Colon__PEEK { $_[0]->_AUTOLEXpeek('infix__S_326Colon', $retree) }
sub infix__S_326Colon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_326Colon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:";
$self->_MATCHIFYr($S, "infix__S_326Colon", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infix__S_326Colon_0') {
$C->deb("Fate passed to infix__S_326Colon_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infix__S_326Colon_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infix__S_326Colon_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infix__S_326Colon_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infix__S_326Colon_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<X>
sub infix__S_327X__PEEK { $_[0]->_AUTOLEXpeek('infix__S_327X', $retree) }
sub infix__S_327X {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_327X");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "X";
$self->_MATCHIFYr($S, "infix__S_327X", do {
if (my ($C) = ($C->_EXACT("X"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_infix)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<Z>
sub infix__S_328Z__PEEK { $_[0]->_AUTOLEXpeek('infix__S_328Z', $retree) }
sub infix__S_328Z {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_328Z");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "Z";
$self->_MATCHIFYr($S, "infix__S_328Z", do {
if (my ($C) = ($C->_EXACT("Z"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_infix)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<minmax>
sub infix__S_329minmax__PEEK { $_[0]->_AUTOLEXpeek('infix__S_329minmax', $retree) }
sub infix__S_329minmax {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_329minmax");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "minmax";
$self->_MATCHIFYr($S, "infix__S_329minmax", do {
if (my ($C) = ($C->_EXACT("minmax"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_infix)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<...>
sub infix__S_330DotDotDot__PEEK { $_[0]->_AUTOLEXpeek('infix__S_330DotDotDot', $retree) }
sub infix__S_330DotDotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_330DotDotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\.\.";
$self->_MATCHIFYr($S, "infix__S_330DotDotDot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\.\.\."))
and ($C) = ($C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%list_infix)
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<...>
sub term__S_331DotDotDot__PEEK { $_[0]->_AUTOLEXpeek('term__S_331DotDotDot', $retree) }
sub term__S_331DotDotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_331DotDotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'args'} = [];
$C->{sym} = "\.\.\.";
$self->_MATCHIFYr($S, "term__S_331DotDotDot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\.\.\."))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
$C->_SUBSUMEr(['args'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<???>
sub term__S_332QuestionQuestionQuestion__PEEK { $_[0]->_AUTOLEXpeek('term__S_332QuestionQuestionQuestion', $retree) }
sub term__S_332QuestionQuestionQuestion {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_332QuestionQuestionQuestion");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'args'} = [];
$C->{sym} = "\?\?\?";
$self->_MATCHIFYr($S, "term__S_332QuestionQuestionQuestion", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?\?\?"))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
$C->_SUBSUMEr(['args'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:sym<!!!>
sub term__S_333BangBangBang__PEEK { $_[0]->_AUTOLEXpeek('term__S_333BangBangBang', $retree) }
sub term__S_333BangBangBang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_333BangBangBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'args'} = [];
$C->{sym} = "\!\!\!";
$self->_MATCHIFYr($S, "term__S_333BangBangBang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!\!\!"))
and ($C) = ($C->_OPTr(sub {
my $C=shift;
$C->_SUBSUMEr(['args'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
);
## token term:identifier
sub term__S_334identifier__PEEK { $_[0]->_AUTOLEXpeek('term__S_334identifier', $retree) }
sub term__S_334identifier {
no warnings 'recursion';
my $self = shift;
my $name;my $pos;my $isname = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_334identifier");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "identifier";
$self->_MATCHIFYr($S, "term__S_334identifier", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['identifier'], sub {
my $C = shift;
$C->identifier
}))
and ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'term__S_334identifier_0') {
$C->deb("Fate passed to term__S_334identifier_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT term__S_334identifier_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM term__S_334identifier_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'term__S_334identifier_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term__S_334identifier_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$C->args($isname)
}))
and ($C) = (scalar(do {
my $M = $C;
$self->add_mystery($M->{'identifier'},$pos,substr($self->orig,$pos,1)) unless $M->{'args'}->{'invocant'}}, $C))
and ($C) = (scalar(do {
my $M = $C;
if ($::BORG and $::BORG->{'block'}) {
if (not $::BORG->{'name'}) {
$::BORG->{'culprit'} = $M->{'identifier'}->cursor($pos);
$::BORG->{'name'} = $name;
}};
if ($deftrap{$name}) {
my $al = $M->{'args'}->{'arglist'}->[0];
my $ok = 0;
$ok = 1 if $isname;
$ok = 1 if $al and $al->from != $al->to;
$ok = 1 if $M->{'args'}->{'semiarglist'};
if (not $ok) {
given (0+$deftrap{$name}) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
## token args ($istype = 0) {
sub args__PEEK { $_[0]->_AUTOLEXpeek('args', $retree) }
sub args {
no warnings 'recursion';
my $self = shift;
my $istype = @_ ? shift() : 0;
my $listopish = 0;local $::GOAL = '';local $::INVOCANT_OK = 1;local $::INVOCANT_IS;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE args");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$self->_MATCHIFYr($S, "args", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'args_0') {
$C->deb("Fate passed to args_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT args_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM args_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'args_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("args_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semiarglist'], sub {
my $C = shift;
$C->semiarglist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'argument list', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['semiarglist'], sub {
my $C = shift;
$C->semiarglist
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'argument list', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->_SUBSUMEblock('invocant', sub {
my $C = shift;
$::INVOCANT_IS}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$listopish })
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token term:name
sub term__S_335name__PEEK { $_[0]->_AUTOLEXpeek('term__S_335name', $retree) }
sub term__S_335name {
no warnings 'recursion';
my $self = shift;
my $name;my $pos;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_335name");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'postcircumfix'} = [];
$C->{sym} = "name";
$self->_MATCHIFYr($S, "term__S_335name", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['longname'], sub {
my $C = shift;
$C->longname
}))
and ($C) = (scalar(do {
my $M = $C;
$name = $M->{'longname'}->Str;
$pos = $C->{'_pos'};
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$C->is_name($name) or substr($name,0,2) eq '::'
})
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'term__S_335name_0') {
$C->deb("Fate passed to term__S_335name_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT term__S_335name_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM term__S_335name_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'term__S_335name_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("term__S_335name_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
@gather;
};
}))) { ($C) } else { () }
}))) { ($C) } else { () }
}))
and ($C) = ($C->_SUBSUMEr(['postcircumfix'], sub {
my $C = shift;
$C->postcircumfix
}))) {
scalar(do {
$::VAR = $C->cursor_all($self->{'_pos'}, $C->{'_pos'}) }, $C)
} else { () }
}))) { ($C) } else { () }
})
} else { () }
}
}
or $xact->[-2] or
do {
push @gather, do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$C->args
}))
and ($C) = (scalar(do {
my $M = $C;
$self->add_mystery($M->{'longname'},$pos,'termish') unless $M->{'args'}->{'invocant'}}, $C))) {
scalar(do {
my $M = $C;
if ($::BORG and $::BORG->{'block'}) {
if (not $::BORG->{'name'}) {
$::BORG->{'culprit'} = $M->{'longname'}->cursor($pos);
$::BORG->{'name'} //= $name;
}}}, $C)
} else { () }
}
};
@gather;
}
}))) {
$C->_SUBSUMEr(['O'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
$::MEMOS[$self->{'_pos'}]->{'nodecl'} = $name}};
## token infix:sym<and>
sub infix__S_336and__PEEK { $_[0]->_AUTOLEXpeek('infix__S_336and', $retree) }
sub infix__S_336and {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_336and");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "and";
$self->_MATCHIFYr($S, "infix__S_336and", do {
if (my ($C) = ($C->_EXACT("and"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_and, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<andthen>
sub infix__S_337andthen__PEEK { $_[0]->_AUTOLEXpeek('infix__S_337andthen', $retree) }
sub infix__S_337andthen {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_337andthen");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "andthen";
$self->_MATCHIFYr($S, "infix__S_337andthen", do {
if (my ($C) = ($C->_EXACT("andthen"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_and)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<or>
sub infix__S_338or__PEEK { $_[0]->_AUTOLEXpeek('infix__S_338or', $retree) }
sub infix__S_338or {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_338or");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "or";
$self->_MATCHIFYr($S, "infix__S_338or", do {
if (my ($C) = ($C->_EXACT("or"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<orelse>
sub infix__S_339orelse__PEEK { $_[0]->_AUTOLEXpeek('infix__S_339orelse', $retree) }
sub infix__S_339orelse {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_339orelse");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "orelse";
$self->_MATCHIFYr($S, "infix__S_339orelse", do {
if (my ($C) = ($C->_EXACT("orelse"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym<xor>
sub infix__S_340xor__PEEK { $_[0]->_AUTOLEXpeek('infix__S_340xor', $retree) }
sub infix__S_340xor {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_340xor");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "xor";
$self->_MATCHIFYr($S, "infix__S_340xor", do {
if (my ($C) = ($C->_EXACT("xor"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%loose_or, iffy => 1)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« <== »
sub infix__S_341LtEqualEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_341LtEqualEqual', $retree) }
sub infix__S_341LtEqualEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_341LtEqualEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\=\=";
$self->_MATCHIFYr($S, "infix__S_341LtEqualEqual", do {
if (my ($C) = ($C->_EXACT("\<\=\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%sequencer)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« ==> »
sub infix__S_342EqualEqualGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_342EqualEqualGt', $retree) }
sub infix__S_342EqualEqualGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_342EqualEqualGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\=\>";
$self->_MATCHIFYr($S, "infix__S_342EqualEqualGt", do {
if (my ($C) = ($C->_EXACT("\=\=\>"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%sequencer)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« <<== »
sub infix__S_343LtLtEqualEqual__PEEK { $_[0]->_AUTOLEXpeek('infix__S_343LtLtEqualEqual', $retree) }
sub infix__S_343LtLtEqualEqual {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_343LtLtEqualEqual");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<\=\=";
$self->_MATCHIFYr($S, "infix__S_343LtLtEqualEqual", do {
if (my ($C) = ($C->_EXACT("\<\<\=\="))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%sequencer)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infix:sym« ==>> »
sub infix__S_344EqualEqualGtGt__PEEK { $_[0]->_AUTOLEXpeek('infix__S_344EqualEqualGtGt', $retree) }
sub infix__S_344EqualEqualGtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infix__S_344EqualEqualGtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\=\=\>\>";
$self->_MATCHIFYr($S, "infix__S_344EqualEqualGtGt", do {
if (my ($C) = ($C->_EXACT("\=\=\>\>"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%sequencer)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<;>
sub terminator__S_345Semi__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_345Semi', $retree) }
sub terminator__S_345Semi {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_345Semi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\;";
$self->_MATCHIFYr($S, "terminator__S_345Semi", do {
if (my ($C) = ($C->_EXACT("\;"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<if>
sub terminator__S_346if__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_346if', $retree) }
sub terminator__S_346if {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_346if");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "if";
$self->_MATCHIFYr($S, "terminator__S_346if", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gif\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<unless>
sub terminator__S_347unless__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_347unless', $retree) }
sub terminator__S_347unless {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_347unless");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "unless";
$self->_MATCHIFYr($S, "terminator__S_347unless", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gunless\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<while>
sub terminator__S_348while__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_348while', $retree) }
sub terminator__S_348while {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_348while");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "while";
$self->_MATCHIFYr($S, "terminator__S_348while", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gwhile\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<until>
sub terminator__S_349until__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_349until', $retree) }
sub terminator__S_349until {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_349until");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "until";
$self->_MATCHIFYr($S, "terminator__S_349until", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Guntil\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<for>
sub terminator__S_350for__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_350for', $retree) }
sub terminator__S_350for {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_350for");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "for";
$self->_MATCHIFYr($S, "terminator__S_350for", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gfor\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<given>
sub terminator__S_351given__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_351given', $retree) }
sub terminator__S_351given {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_351given");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "given";
$self->_MATCHIFYr($S, "terminator__S_351given", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Ggiven\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<when>
sub terminator__S_352when__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_352when', $retree) }
sub terminator__S_352when {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_352when");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "when";
$self->_MATCHIFYr($S, "terminator__S_352when", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\Gwhen\b/))
and ($C) = ($C->nofun)) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym« --> »
sub terminator__S_353MinusMinusGt__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_353MinusMinusGt', $retree) }
sub terminator__S_353MinusMinusGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_353MinusMinusGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-\-\>";
$self->_MATCHIFYr($S, "terminator__S_353MinusMinusGt", do {
if (my ($C) = ($C->_EXACT("\-\-\>"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%terminator)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token terminator:sym<!!>
sub terminator__S_354BangBang__PEEK { $_[0]->_AUTOLEXpeek('terminator__S_354BangBang', $retree) }
sub terminator__S_354BangBang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE terminator__S_354BangBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!\!";
$self->_MATCHIFYr($S, "terminator__S_354BangBang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!\!"))
and ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::GOAL eq '!!' })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## regex infixstopper {
sub infixstopper__PEEK { $_[0]->_AUTOLEXpeek('infixstopper', $retree) }
sub infixstopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infixstopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFY($S, "infixstopper", $C->_BRACKET(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixstopper_0') {
$C->deb("Fate passed to infixstopper_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixstopper_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixstopper_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infixstopper_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixstopper_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixstopper_1') {
$C->deb("Fate passed to infixstopper_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixstopper_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixstopper_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::P6', 'infixstopper_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixstopper_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<\\> { <sym> {} <item=.backslash> }
sub escape__S_000Back__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Back', $retree) }
sub escape__S_000Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "escape__S_000Back", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = (scalar(do {
}, $C))) {
$C->_SUBSUMEr(['item'], sub {
my $C = shift;
$C->backslash
})
} else { () }
});
}
;
## token backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
sub backslash__S_001qq__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_001qq', $retree) }
sub backslash__S_001qq {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_001qq");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "qq";
$self->_MATCHIFYr($S, "backslash__S_001qq", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("q")
}))) { ($C) } else { () }
}))) {
scalar(do {
my $M = $C;
$M->{'quote'} = $C->cursor_fresh($::LANG{'MAIN'})->quote()}, $C)
} else { () }
});
}
;
## token backslash:sym<\\> { <text=.sym> }
sub backslash__S_002Back__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_002Back', $retree) }
sub backslash__S_002Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_002Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "backslash__S_002Back", $C->_SUBSUMEr(['text'], sub {
my $C = shift;
$C->_EXACT("\\")
}));
}
;
## token backslash:stopper { <text=.stopper> }
sub backslash__S_003stopper__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_003stopper', $retree) }
sub backslash__S_003stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_003stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "stopper";
$self->_MATCHIFYr($S, "backslash__S_003stopper", $C->_SUBSUMEr(['text'], sub {
my $C = shift;
$C->stopper
}));
}
;
## token backslash:a { <sym> }
sub backslash__S_004a__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_004a', $retree) }
sub backslash__S_004a {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_004a");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "a";
$self->_MATCHIFYr($S, "backslash__S_004a", $C->_EXACT("a"));
}
;
## token backslash:b { <sym> }
sub backslash__S_005b__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_005b', $retree) }
sub backslash__S_005b {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_005b");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "b";
$self->_MATCHIFYr($S, "backslash__S_005b", $C->_EXACT("b"));
}
;
## token backslash:c { <sym> <charspec> }
sub backslash__S_006c__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_006c', $retree) }
sub backslash__S_006c {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_006c");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "c";
$self->_MATCHIFYr($S, "backslash__S_006c", do {
if (my ($C) = ($C->_EXACT("c"))) {
$C->_SUBSUMEr(['charspec'], sub {
my $C = shift;
$C->charspec
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:e { <sym> }
sub backslash__S_007e__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_007e', $retree) }
sub backslash__S_007e {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_007e");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "e";
$self->_MATCHIFYr($S, "backslash__S_007e", $C->_EXACT("e"));
}
;
## token backslash:f { <sym> }
sub backslash__S_008f__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_008f', $retree) }
sub backslash__S_008f {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_008f");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "f";
$self->_MATCHIFYr($S, "backslash__S_008f", $C->_EXACT("f"));
}
;
## token backslash:n { <sym> }
sub backslash__S_009n__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_009n', $retree) }
sub backslash__S_009n {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_009n");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "n";
$self->_MATCHIFYr($S, "backslash__S_009n", $C->_EXACT("n"));
}
;
## token backslash:o { :dba('octal character') <sym> [ <octint> | '[' ~ ']' <octints> ] }
sub backslash__S_010o__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_010o', $retree) }
sub backslash__S_010o {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_010o");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "o";
$self->_MATCHIFYr($S, "backslash__S_010o", do {
my $C = $C;
if (($C) = ($C->_EXACT("o"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_010o_0') {
$C->deb("Fate passed to backslash__S_010o_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_010o_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_010o_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::b1', 'backslash__S_010o_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_010o_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['octints'], sub {
my $C = shift;
$C->octints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'octal character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:r { <sym> }
sub backslash__S_011r__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_011r', $retree) }
sub backslash__S_011r {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_011r");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "r";
$self->_MATCHIFYr($S, "backslash__S_011r", $C->_EXACT("r"));
}
;
## token backslash:t { <sym> }
sub backslash__S_012t__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_012t', $retree) }
sub backslash__S_012t {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_012t");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "t";
$self->_MATCHIFYr($S, "backslash__S_012t", $C->_EXACT("t"));
}
;
## token backslash:x { :dba('hex character') <sym> [ <hexint> | '[' ~ ']' <hexints> ] }
sub backslash__S_013x__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_013x', $retree) }
sub backslash__S_013x {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_013x");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "x";
$self->_MATCHIFYr($S, "backslash__S_013x", do {
my $C = $C;
if (($C) = ($C->_EXACT("x"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_013x_0') {
$C->deb("Fate passed to backslash__S_013x_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_013x_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_013x_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::b1', 'backslash__S_013x_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_013x_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['hexints'], sub {
my $C = shift;
$C->hexints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'hex character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:sym<0> { <sym> }
sub backslash__S_0140__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_0140', $retree) }
sub backslash__S_0140 {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_0140");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "backslash__S_0140", $C->_EXACT("0"));
}
;
1; };
{ package STD::Q::b0;
use Moose::Role ':all' => { -prefix => "moose_" };
use Encode;
our $ALLROLES = { 'STD::Q::b0', 1 };
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<\\> { <!> }
sub escape__S_000Back__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Back', $retree) }
sub escape__S_000Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "escape__S_000Back", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::c1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<{ }> { <?before '{'> [ :lang(%*LANG<MAIN>) <embeddedblock> ] }
sub escape__S_000Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Cur_Ly', $retree) }
sub escape__S_000Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "escape__S_000Cur_Ly", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\{")
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<{ }> { <!> }
sub escape__S_000Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Cur_Ly', $retree) }
sub escape__S_000Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "escape__S_000Cur_Ly", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::s1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<$> {
sub escape__S_000Dollar__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Dollar', $retree) }
sub escape__S_000Dollar {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = '$';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Dollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$";
$self->_MATCHIFYr($S, "escape__S_000Dollar", do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\$")
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<$> { <!> }
sub escape__S_000Dollar__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Dollar', $retree) }
sub escape__S_000Dollar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Dollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$";
$self->_MATCHIFYr($S, "escape__S_000Dollar", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::a1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<@> {
sub escape__S_000At__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000At', $retree) }
sub escape__S_000At {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = '@';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000At");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@";
$self->_MATCHIFYr($S, "escape__S_000At", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\@")
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'escape__S_000At_0') {
$C->deb("Fate passed to escape__S_000At_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT escape__S_000At_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM escape__S_000At_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::a1', 'escape__S_000At_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("escape__S_000At_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<@> { <!> }
sub escape__S_000At__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000At', $retree) }
sub escape__S_000At {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000At");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\@";
$self->_MATCHIFYr($S, "escape__S_000At", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::h1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<%> {
sub escape__S_000Percent__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Percent', $retree) }
sub escape__S_000Percent {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = '%';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Percent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%";
$self->_MATCHIFYr($S, "escape__S_000Percent", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\%")
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'escape__S_000Percent_0') {
$C->deb("Fate passed to escape__S_000Percent_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT escape__S_000Percent_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM escape__S_000Percent_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::h1', 'escape__S_000Percent_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("escape__S_000Percent_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<%> { <!> }
sub escape__S_000Percent__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Percent', $retree) }
sub escape__S_000Percent {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Percent");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\%";
$self->_MATCHIFYr($S, "escape__S_000Percent", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::f1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<&> {
sub escape__S_000Amp__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Amp', $retree) }
sub escape__S_000Amp {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = '&';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "escape__S_000Amp", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\&")
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'escape__S_000Amp_0') {
$C->deb("Fate passed to escape__S_000Amp_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT escape__S_000Amp_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM escape__S_000Amp_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::f1', 'escape__S_000Amp_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("escape__S_000Amp_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token escape:sym<&> { <!> }
sub escape__S_000Amp__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Amp', $retree) }
sub escape__S_000Amp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "escape__S_000Amp", $C->_NOTBEFORE(sub {
my $C=shift;
$C
}));
}
1; };
{ package STD::Q::p1;
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token stopper { \' }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_EXACT("\'"));
}
;
## token escape:sym<\\> { <sym> <item=.backslash> }
sub escape__S_000Back__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000Back', $retree) }
sub escape__S_000Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "escape__S_000Back", do {
if (my ($C) = ($C->_EXACT("\\"))) {
$C->_SUBSUMEr(['item'], sub {
my $C = shift;
$C->backslash
})
} else { () }
});
}
;
## token backslash:qq { <?before 'q'> { $<quote> = $¢.cursor_fresh(%*LANG<MAIN>).quote(); } }
sub backslash__S_001qq__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_001qq', $retree) }
sub backslash__S_001qq {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_001qq");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "qq";
$self->_MATCHIFYr($S, "backslash__S_001qq", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("q")
}))) { ($C) } else { () }
}))) {
scalar(do {
my $M = $C;
$M->{'quote'} = $C->cursor_fresh($::LANG{'MAIN'})->quote()}, $C)
} else { () }
});
}
;
## token backslash:sym<\\> { <text=.sym> }
sub backslash__S_002Back__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_002Back', $retree) }
sub backslash__S_002Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_002Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "backslash__S_002Back", $C->_SUBSUMEr(['text'], sub {
my $C = shift;
$C->_EXACT("\\")
}));
}
;
## token backslash:stopper { <text=.stopper> }
sub backslash__S_003stopper__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_003stopper', $retree) }
sub backslash__S_003stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_003stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "stopper";
$self->_MATCHIFYr($S, "backslash__S_003stopper", $C->_SUBSUMEr(['text'], sub {
my $C = shift;
$C->stopper
}));
}
;
## token backslash:misc { {} (.) { $<text> = "\\" ~ $0.Str; } }
sub backslash__S_004misc__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_004misc', $retree) }
sub backslash__S_004misc {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_004misc");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "misc";
$self->_MATCHIFYr($S, "backslash__S_004misc", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->cursor_incr()
})
}))) {
scalar(do {
my $M = $C;
$M->{'text'} = "\\" . $M->{0}->Str}, $C)
} else { () }
});
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token stopper { \" }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_EXACT("\""));
}
;
## token backslash:misc { {} [ (\W) { $<text> = $0.Str; } | $<x>=(\w) <.sorry("Unrecognized backslash s
sub backslash__S_000misc__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_000misc', $retree) }
sub backslash__S_000misc {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_000misc");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "misc";
$self->_MATCHIFYr($S, "backslash__S_000misc", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_000misc_0') {
$C->deb("Fate passed to backslash__S_000misc_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_000misc_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_000misc_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::qq', 'backslash__S_000misc_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_000misc_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token stopper { \' }
sub stopper__PEEK { $_[0]->_AUTOLEXpeek('stopper', $retree) }
sub stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "stopper", $C->_EXACT("\'"));
}
;
## method ccstate ($s)
sub ccstate {
no warnings 'recursion';
my $self = shift;
die 'Required argument s omitted' unless @_;
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token escape:ws { \s+ [ <?before '#'> <.ws> ]? }
sub escape__S_000ws__PEEK { $_[0]->_AUTOLEXpeek('escape__S_000ws', $retree) }
sub escape__S_000ws {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_000ws");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ws";
$self->_MATCHIFYr($S, "escape__S_000ws", do {
if (my ($C) = ($C->_PATTERN(qr/\G\s++/))) {
$C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escape:sym<#> { '#' <.panic: "Please backslash # for literal char or put whitespace in front f
sub escape__S_001Sharp__PEEK { $_[0]->_AUTOLEXpeek('escape__S_001Sharp', $retree) }
sub escape__S_001Sharp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_001Sharp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\#";
$self->_MATCHIFYr($S, "escape__S_001Sharp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\#"))
and ($C) = ($C->panic("Please backslash # for literal char or put whitespace in front for comment"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escape:sym<\\> { <sym> <item=.backslash> <.ccstate('\\' ~ $<item>.Str)> }
sub escape__S_002Back__PEEK { $_[0]->_AUTOLEXpeek('escape__S_002Back', $retree) }
sub escape__S_002Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_002Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "escape__S_002Back", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->_SUBSUMEr(['item'], sub {
my $C = shift;
$C->backslash
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escape:sym<..> { <sym>
sub escape__S_003DotDot__PEEK { $_[0]->_AUTOLEXpeek('escape__S_003DotDot', $retree) }
sub escape__S_003DotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_003DotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\.";
$self->_MATCHIFYr($S, "escape__S_003DotDot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\.\."))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::CCSTATE eq '' or $::CCSTATE eq '..' })
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escape:sym<-> { '-' <?{ $*CCSTATE ne '' }> \s* <!stopper> \S <.obs('- as character range','..'
sub escape__S_004Minus__PEEK { $_[0]->_AUTOLEXpeek('escape__S_004Minus', $retree) }
sub escape__S_004Minus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_004Minus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-";
$self->_MATCHIFYr($S, "escape__S_004Minus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\-"))
and ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::CCSTATE ne '' })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token escape:ch { $<ch> = [\S] <.ccstate($<ch>.Str)> }
sub escape__S_005ch__PEEK { $_[0]->_AUTOLEXpeek('escape__S_005ch', $retree) }
sub escape__S_005ch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE escape__S_005ch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "ch";
$self->_MATCHIFYr($S, "escape__S_005ch", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['ch'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
$C->_PATTERN(qr/\G\S/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:stopper { <text=.stopper> }
sub backslash__S_006stopper__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_006stopper', $retree) }
sub backslash__S_006stopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_006stopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "stopper";
$self->_MATCHIFYr($S, "backslash__S_006stopper", $C->_SUBSUMEr(['text'], sub {
my $C = shift;
$C->stopper
}));
}
;
## token backslash:a { :i <sym> }
sub backslash__S_007a__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_007a', $retree) }
sub backslash__S_007a {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_007a");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "a";
$self->_MATCHIFYr($S, "backslash__S_007a", $C->_PATTERN(qr/\G(?i:a)/));
}
;
## token backslash:b { :i <sym> }
sub backslash__S_008b__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_008b', $retree) }
sub backslash__S_008b {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_008b");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "b";
$self->_MATCHIFYr($S, "backslash__S_008b", $C->_PATTERN(qr/\G(?i:b)/));
}
;
## token backslash:c { :i <sym> <charspec> }
sub backslash__S_009c__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_009c', $retree) }
sub backslash__S_009c {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_009c");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "c";
$self->_MATCHIFYr($S, "backslash__S_009c", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:c)/))) {
$C->_SUBSUMEr(['charspec'], sub {
my $C = shift;
$C->charspec
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:d { :i <sym> { $*CCSTATE = '' } }
sub backslash__S_010d__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_010d', $retree) }
sub backslash__S_010d {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_010d");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "d";
$self->_MATCHIFYr($S, "backslash__S_010d", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:d)/))) {
scalar(do {
$::CCSTATE = '' }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:e { :i <sym> }
sub backslash__S_011e__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_011e', $retree) }
sub backslash__S_011e {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_011e");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "e";
$self->_MATCHIFYr($S, "backslash__S_011e", $C->_PATTERN(qr/\G(?i:e)/));
}
;
## token backslash:f { :i <sym> }
sub backslash__S_012f__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_012f', $retree) }
sub backslash__S_012f {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_012f");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "f";
$self->_MATCHIFYr($S, "backslash__S_012f", $C->_PATTERN(qr/\G(?i:f)/));
}
;
## token backslash:h { :i <sym> { $*CCSTATE = '' } }
sub backslash__S_013h__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_013h', $retree) }
sub backslash__S_013h {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_013h");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "h";
$self->_MATCHIFYr($S, "backslash__S_013h", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:h)/))) {
scalar(do {
$::CCSTATE = '' }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:n { :i <sym> }
sub backslash__S_014n__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_014n', $retree) }
sub backslash__S_014n {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_014n");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "n";
$self->_MATCHIFYr($S, "backslash__S_014n", $C->_PATTERN(qr/\G(?i:n)/));
}
;
## token backslash:o { :i :dba('octal character') <sym> [ <octint> | '[' ~ ']' <octints> ] }
sub backslash__S_015o__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_015o', $retree) }
sub backslash__S_015o {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_015o");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "o";
$self->_MATCHIFYr($S, "backslash__S_015o", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:o)/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_015o_0') {
$C->deb("Fate passed to backslash__S_015o_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_015o_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_015o_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::cc', 'backslash__S_015o_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_015o_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:\[)/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['octints'], sub {
my $C = shift;
$C->octints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G(?i:\])/)
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'octal character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:r { :i <sym> }
sub backslash__S_016r__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_016r', $retree) }
sub backslash__S_016r {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_016r");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "r";
$self->_MATCHIFYr($S, "backslash__S_016r", $C->_PATTERN(qr/\G(?i:r)/));
}
;
## token backslash:s { :i <sym> { $*CCSTATE = '' } }
sub backslash__S_017s__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_017s', $retree) }
sub backslash__S_017s {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_017s");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "s";
$self->_MATCHIFYr($S, "backslash__S_017s", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:s)/))) {
scalar(do {
$::CCSTATE = '' }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:t { :i <sym> }
sub backslash__S_018t__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_018t', $retree) }
sub backslash__S_018t {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_018t");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "t";
$self->_MATCHIFYr($S, "backslash__S_018t", $C->_PATTERN(qr/\G(?i:t)/));
}
;
## token backslash:v { :i <sym> { $*CCSTATE = '' } }
sub backslash__S_019v__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_019v', $retree) }
sub backslash__S_019v {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_019v");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "v";
$self->_MATCHIFYr($S, "backslash__S_019v", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:v)/))) {
scalar(do {
$::CCSTATE = '' }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:w { :i <sym> { $*CCSTATE = '' } }
sub backslash__S_020w__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_020w', $retree) }
sub backslash__S_020w {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_020w");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "w";
$self->_MATCHIFYr($S, "backslash__S_020w", do {
if (my ($C) = ($C->_PATTERN(qr/\G(?i:w)/))) {
scalar(do {
$::CCSTATE = '' }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:x { :i :dba('hex character') <sym> [ <hexint> | '[' ~ ']' <hexints> ] }
sub backslash__S_021x__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_021x', $retree) }
sub backslash__S_021x {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_021x");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "x";
$self->_MATCHIFYr($S, "backslash__S_021x", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:x)/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_021x_0') {
$C->deb("Fate passed to backslash__S_021x_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_021x_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_021x_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::cc', 'backslash__S_021x_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_021x_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:\[)/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['hexints'], sub {
my $C = shift;
$C->hexints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G(?i:\])/)
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'hex character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:sym<0> { <sym> }
sub backslash__S_0220__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_0220', $retree) }
sub backslash__S_0220 {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_0220");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "backslash__S_0220", $C->_EXACT("0"));
}
;
## token backslash:misc { {} [ (\W) { $<text> = $0.Str; } | $<x>=(\w) <.sorry("Unrecognized backslash s
sub backslash__S_023misc__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_023misc', $retree) }
sub backslash__S_023misc {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_023misc");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "misc";
$self->_MATCHIFYr($S, "backslash__S_023misc", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_023misc_0') {
$C->deb("Fate passed to backslash__S_023misc_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_023misc_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_023misc_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Q::cc', 'backslash__S_023misc_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_023misc_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
$self->mixin($ww ? 'STD::Q::ww1' : 'STD::Q::ww0') };
}
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{heredoc} || exists $args{to};
my $to = exists $args{heredoc} ? delete $args{heredoc} : exists $args{to} ? delete $args{to} : undef;
$self->truly($to, ':to');
$self->cursor_herelang;
};
}
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{regex};
my $regex = exists $args{regex} ? delete $args{regex} : undef;
return $::LANG{'Regex'} };
share/P6STD/boot/STD.pmc view on Meta::CPAN
RETREE_END
## token term:unquote {
sub term__S_000unquote__PEEK { $_[0]->_AUTOLEXpeek('term__S_000unquote', $retree) }
sub term__S_000unquote {
no warnings 'recursion';
my $self = shift;
local $::QUASIMODO = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_000unquote");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'starter'} = [];
$C->{'stopper'} = [];
$C->{sym} = "unquote";
$self->_MATCHIFYr($S, "term__S_000unquote", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['starter'], sub {
my $C = shift;
$C->starter
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$C->starter
}))
and ($C) = ($C->_SUBSUMEr(['starter'], sub {
my $C = shift;
$C->starter
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->_SUBSUMEr(['stopper'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $ast = exists $args{ast} ? delete $args{ast} : undef;
$self };
}
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{lang};
my $lang = exists $args{lang} ? delete $args{lang} : undef;
$self->cursor_fresh( $lang ) };
}
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{unquote};
my $unquote = exists $args{unquote} ? delete $args{unquote} : undef;
$self };
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
while (@opstack) {
last if $op->{'O'}->{'prec'} ne $opstack[-1]->{'O'}->{'prec'};
push @chain, pop(@termstack);
push @chain, pop(@opstack);
}
;
push @chain, pop(@termstack);
my $endpos = $chain[0]->{'_pos'};
@chain = reverse @chain if @chain > 1;
my $startpos = $chain[0]->from;
my $nop = $op->cursor_fresh();
$nop->prepbind(@chain);
$nop->{'chain'} = [@chain];
$nop->{'_arity'} = 'CHAIN';
$nop->from = $startpos;
$nop->{'_pos'} = $endpos;
my @caps;
my $i = 0;
for (@chain) {
push(@caps, $i++ % 2 ? 'op' : 'term' );
push(@caps, $_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
;
if (@termstack and defined $termstack[0]) {
push @list, pop(@termstack)}
else {
$self->worry("Missing final term in '" . $sym . "' list")};
my $endpos = $list[0]->{'_pos'};
@list = reverse @list if @list > 1;
my $startpos = $list[0]->from;
@delims = reverse @delims if @delims > 1;
my $nop = $op->cursor_fresh();
$nop->prepbind(@list,@delims);
$nop->{'sym'} = $sym;
$nop->{'O'} = $op->{'O'};
$nop->{'list'} = [@list];
$nop->{'delims'} = [@delims];
$nop->{'_arity'} = 'LIST';
$nop->from = $startpos;
$nop->{'_pos'} = $endpos;
if (@list) {
my @caps;
share/P6STD/boot/STD.pmc view on Meta::CPAN
delete $termstack[-1]->{'POST'};
}
;
}
;
};
TERM:
for (;;) {
$self->deb("In loop, at ", $here->{'_pos'}) if $::DEBUG & DEBUG::EXPR;
my $oldpos = $here->{'_pos'};
$here = $here->cursor_fresh();
$::LEFTSIGIL = $opstack[-1]->{'O'}->{'prec'} gt $item_assignment_prec ? '@' : '';
my @t = $here->$termish;
if (not @t or not $here = $t[0] or ($here->{'_pos'} == $oldpos and $termish eq 'termish')) {
$here->panic("Bogus term") if @opstack > 1;
return ();
};
$termish = 'termish';
my $PRE = (delete $here->{'PRE'}) // [];
my $POST = (delete $here->{'POST'}) // [];
my @PRE = @$PRE;
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
;
push @opstack, @PRE,@POST;
push @termstack, $here->{'term'};
delete $termstack[-1]->{'POST'};
$self->deb("after push: " . (0+@termstack)) if $::DEBUG & DEBUG::EXPR;
last TERM if $preclim eq $methodcall_prec;
for (;;) {
$oldpos = $here->{'_pos'};
last TERM if ($::MEMOS[$oldpos]->{'endstmt'} // 0) == 2;
$here = $here->cursor_fresh->ws;
my @infix = $here->cursor_fresh->infixish();
last TERM unless @infix;
my $infix = $infix[0];
last TERM unless $infix->{'_pos'} > $oldpos;
if (not $infix->{'sym'}) {
die $infix->dump if $::DEBUG & DEBUG::EXPR};
my $inO = $infix->{'O'};
my $inprec = $inO->{'prec'};
if (not defined $inprec) {
$self->deb("No prec given in infix!") if $::DEBUG & DEBUG::EXPR;
die $infix->dump if $::DEBUG & DEBUG::EXPR;
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
if ($inprec le $preclim) {
if ($preclim ne $LOOSEST) {
my $dba = $preclvl->{'dba'};
my $h = $::HIGHEXPECT;
%$h = ();
$h->{"an infix operator with precedence tighter than $dba"} = 1;
};
last TERM;
};
$here = $infix->cursor_fresh->ws();
while ($opstack[-1]->{'O'}->{'prec'} gt $inprec) {
$reduce->()}
# Not much point in reducing the sentinels...
;
last if $inprec lt $LOOSEST;
if ($infix->{'fake'}) {
push @opstack, $infix;
$reduce->();
next;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:metachar { <sym> }
sub category__S_000metachar__PEEK { $_[0]->_AUTOLEXpeek('category__S_000metachar', $retree) }
sub category__S_000metachar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_000metachar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "metachar";
$self->_MATCHIFYr($S, "category__S_000metachar", $C->_EXACT("metachar"));
}
;
## token metachar {*}
sub metachar__PEEK { $_[0]->_AUTOLEXpeek('metachar:*',$retree); }
sub metachar {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE metachar');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'metachar') {
$C->deb("Fate passed to metachar: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT metachar';
}
else {
$x = 'ALTLTM metachar';
}
}
else {
$x = 'ALTLTM metachar';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'metachar:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("metachar trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:sigmaybe { <sym> }
sub category__S_001sigmaybe__PEEK { $_[0]->_AUTOLEXpeek('category__S_001sigmaybe', $retree) }
sub category__S_001sigmaybe {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_001sigmaybe");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sigmaybe";
$self->_MATCHIFYr($S, "category__S_001sigmaybe", $C->_EXACT("sigmaybe"));
}
;
## token sigmaybe {*}
sub sigmaybe__PEEK { $_[0]->_AUTOLEXpeek('sigmaybe:*',$retree); }
sub sigmaybe {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE sigmaybe');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'sigmaybe') {
$C->deb("Fate passed to sigmaybe: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT sigmaybe';
}
else {
$x = 'ALTLTM sigmaybe';
}
}
else {
$x = 'ALTLTM sigmaybe';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'sigmaybe:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("sigmaybe trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:backslash { <sym> }
sub category__S_002backslash__PEEK { $_[0]->_AUTOLEXpeek('category__S_002backslash', $retree) }
sub category__S_002backslash {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_002backslash");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "backslash";
$self->_MATCHIFYr($S, "category__S_002backslash", $C->_EXACT("backslash"));
}
;
## token backslash {*}
sub backslash__PEEK { $_[0]->_AUTOLEXpeek('backslash:*',$retree); }
sub backslash {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE backslash');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'backslash') {
$C->deb("Fate passed to backslash: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT backslash';
}
else {
$x = 'ALTLTM backslash';
}
}
else {
$x = 'ALTLTM backslash';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'backslash:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:assertion { <sym> }
sub category__S_003assertion__PEEK { $_[0]->_AUTOLEXpeek('category__S_003assertion', $retree) }
sub category__S_003assertion {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_003assertion");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "assertion";
$self->_MATCHIFYr($S, "category__S_003assertion", $C->_EXACT("assertion"));
}
;
## token assertion {*}
sub assertion__PEEK { $_[0]->_AUTOLEXpeek('assertion:*',$retree); }
sub assertion {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE assertion');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'assertion') {
$C->deb("Fate passed to assertion: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT assertion';
}
else {
$x = 'ALTLTM assertion';
}
}
else {
$x = 'ALTLTM assertion';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:quantifier { <sym> }
sub category__S_004quantifier__PEEK { $_[0]->_AUTOLEXpeek('category__S_004quantifier', $retree) }
sub category__S_004quantifier {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_004quantifier");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quantifier";
$self->_MATCHIFYr($S, "category__S_004quantifier", $C->_EXACT("quantifier"));
}
;
## token quantifier {*}
sub quantifier__PEEK { $_[0]->_AUTOLEXpeek('quantifier:*',$retree); }
sub quantifier {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE quantifier');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'quantifier') {
$C->deb("Fate passed to quantifier: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT quantifier';
}
else {
$x = 'ALTLTM quantifier';
}
}
else {
$x = 'ALTLTM quantifier';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'quantifier:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quantifier trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:cclass_elem { <sym> }
sub category__S_005cclass_elem__PEEK { $_[0]->_AUTOLEXpeek('category__S_005cclass_elem', $retree) }
sub category__S_005cclass_elem {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_005cclass_elem");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "cclass_elem";
$self->_MATCHIFYr($S, "category__S_005cclass_elem", $C->_EXACT("cclass_elem"));
}
;
## token cclass_elem {*}
sub cclass_elem__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem:*',$retree); }
sub cclass_elem {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE cclass_elem');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'cclass_elem') {
$C->deb("Fate passed to cclass_elem: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT cclass_elem';
}
else {
$x = 'ALTLTM cclass_elem';
}
}
else {
$x = 'ALTLTM cclass_elem';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'cclass_elem:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("cclass_elem trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token category:mod_internal { <sym> }
sub category__S_006mod_internal__PEEK { $_[0]->_AUTOLEXpeek('category__S_006mod_internal', $retree) }
sub category__S_006mod_internal {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE category__S_006mod_internal");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "mod_internal";
$self->_MATCHIFYr($S, "category__S_006mod_internal", $C->_EXACT("mod_internal"));
}
;
## token mod_internal {*}
sub mod_internal__PEEK { $_[0]->_AUTOLEXpeek('mod_internal:*',$retree); }
sub mod_internal {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE mod_internal');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'mod_internal') {
$C->deb("Fate passed to mod_internal: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT mod_internal';
}
else {
$x = 'ALTLTM mod_internal';
}
}
else {
$x = 'ALTLTM mod_internal';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
;
## token regex_infix {*}
sub regex_infix__PEEK { $_[0]->_AUTOLEXpeek('regex_infix:*',$retree); }
sub regex_infix {
my $self = shift;
my $subs;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact('RULE regex_infix');
my $S = $C->{'_pos'};
my @result = do {
my ($tag, $try);
my @try;
my $relex;
my $x;
if (my $fate = $C->{'_fate'}) {
if ($fate->[1] eq 'regex_infix') {
$C->deb("Fate passed to regex_infix: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
share/P6STD/boot/STD.pmc view on Meta::CPAN
@try = ($try);
$x = 'ALT regex_infix';
}
else {
$x = 'ALTLTM regex_infix';
}
}
else {
$x = 'ALTLTM regex_infix';
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'regex_infix:*', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("regex_infix trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, $C->$try(@_);
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token normspace {
sub normspace__PEEK { $_[0]->_AUTOLEXpeek('normspace', $retree) }
sub normspace {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE normspace");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "normspace", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'normspace_0') {
$C->deb("Fate passed to normspace_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT normspace_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM normspace_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'normspace_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("normspace_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token unsp { '\\' <?before \s | '#'> <.panic: "No unspace allowed in regex; if you meant to match th
sub unsp__PEEK { $_[0]->_AUTOLEXpeek('unsp', $retree) }
sub unsp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE unsp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "unsp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'unsp_0') {
$C->deb("Fate passed to unsp_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT unsp_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM unsp_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'unsp_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("unsp_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## rule nibbler {
sub nibbler__PEEK { $_[0]->_AUTOLEXpeek('nibbler', $retree) }
sub nibbler {
no warnings 'recursion';
my $self = shift;
local %::RX = %::RX;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE nibbler");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "nibbler", do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
}))) { ($C) } else { () }
}))
and ($C) = ($C->ws)
and ($C) = ($C->_SUBSUMEr(['EXPR'], sub {
my $C = shift;
$C->EXPR
}))
and ($C) = ($C->ws)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->infixstopper)) { ($C) } else { () }
}))) { ($C) } else { () }
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token termish {
sub termish__PEEK { $_[0]->_AUTOLEXpeek('termish', $retree) }
sub termish {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE termish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "termish", do {
my $C = $C;
if (($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->normspace)) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['term'], sub {
my $C = shift;
$C->quant_atom_list
}))
and ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'termish_0') {
$C->deb("Fate passed to termish_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT termish_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM termish_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'termish_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("termish_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quant_atom_list {
sub quant_atom_list__PEEK { $_[0]->_AUTOLEXpeek('quant_atom_list', $retree) }
sub quant_atom_list {
no warnings 'recursion';
my $self = shift;
local $::SIGOK = 0;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quant_atom_list");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'quantified_atom'} = [];
$self->_MATCHIFYr($S, "quant_atom_list", $C->_PLUSr(sub {
my $C=shift;
$C->_SUBSUMEr(['quantified_atom'], sub {
my $C = shift;
$C->quantified_atom
})
}));
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token infixish {
sub infixish__PEEK { $_[0]->_AUTOLEXpeek('infixish', $retree) }
sub infixish {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infixish");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "infixish", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->infixstopper)) { ($C) } else { () }
}))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## regex infixstopper {
sub infixstopper__PEEK { $_[0]->_AUTOLEXpeek('infixstopper', $retree) }
sub infixstopper {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE infixstopper");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFY($S, "infixstopper", $C->_BRACKET(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'infixstopper_0') {
$C->deb("Fate passed to infixstopper_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT infixstopper_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM infixstopper_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'infixstopper_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("infixstopper_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token regex_infix:sym<||> { <sym> <O(|%tight_or)> }
sub regex_infix__S_007VertVert__PEEK { $_[0]->_AUTOLEXpeek('regex_infix__S_007VertVert', $retree) }
sub regex_infix__S_007VertVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_infix__S_007VertVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|\|";
$self->_MATCHIFYr($S, "regex_infix__S_007VertVert", do {
if (my ($C) = ($C->_EXACT("\|\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token regex_infix:sym<&&> { <sym> <O(|%tight_and)> }
sub regex_infix__S_008AmpAmp__PEEK { $_[0]->_AUTOLEXpeek('regex_infix__S_008AmpAmp', $retree) }
sub regex_infix__S_008AmpAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_infix__S_008AmpAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&\&";
$self->_MATCHIFYr($S, "regex_infix__S_008AmpAmp", do {
if (my ($C) = ($C->_EXACT("\&\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%tight_and)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token regex_infix:sym<|> { <sym> <O(|%junctive_or)> }
sub regex_infix__S_009Vert__PEEK { $_[0]->_AUTOLEXpeek('regex_infix__S_009Vert', $retree) }
sub regex_infix__S_009Vert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_infix__S_009Vert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|";
$self->_MATCHIFYr($S, "regex_infix__S_009Vert", do {
if (my ($C) = ($C->_EXACT("\|"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%junctive_or)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token regex_infix:sym<&> { <sym> <O(|%junctive_and)> }
sub regex_infix__S_010Amp__PEEK { $_[0]->_AUTOLEXpeek('regex_infix__S_010Amp', $retree) }
sub regex_infix__S_010Amp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE regex_infix__S_010Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "regex_infix__S_010Amp", do {
if (my ($C) = ($C->_EXACT("\&"))) {
$C->_SUBSUMEr(['O'], sub {
my $C = shift;
$C->O(%junctive_and)
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantified_atom {
sub quantified_atom__PEEK { $_[0]->_AUTOLEXpeek('quantified_atom', $retree) }
sub quantified_atom {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantified_atom");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'quantifier'} = [];
$C->{'separator'} = [];
$C->{'sigfinal'} = [];
$C->{'sigmaybe'} = [];
$self->_MATCHIFYr($S, "quantified_atom", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token separator {
sub separator__PEEK { $_[0]->_AUTOLEXpeek('separator', $retree) }
sub separator {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE separator");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'normspace'} = [];
$self->_MATCHIFYr($S, "separator", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['how'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
if (($C) = ($C->_EXACT("\%"))
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'separator_0') {
$C->deb("Fate passed to separator_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT separator_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM separator_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'separator_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("separator_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'separator_1') {
$C->deb("Fate passed to separator_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT separator_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM separator_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'separator_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("separator_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sigmaybe:normspace {
sub sigmaybe__S_011normspace__PEEK { $_[0]->_AUTOLEXpeek('sigmaybe__S_011normspace', $retree) }
sub sigmaybe__S_011normspace {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigmaybe__S_011normspace");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "normspace";
$self->_MATCHIFYr($S, "sigmaybe__S_011normspace", do {
if (my ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
$::SIGOK})
}))) {
$C->_SUBSUMEr(['normspace'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sigmaybe:sigwhite {
sub sigmaybe__S_012sigwhite__PEEK { $_[0]->_AUTOLEXpeek('sigmaybe__S_012sigwhite', $retree) }
sub sigmaybe__S_012sigwhite {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigmaybe__S_012sigwhite");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "sigwhite";
$self->_MATCHIFYr($S, "sigmaybe__S_012sigwhite", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::SIGOK})
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token sigmaybe:unsp { <unsp> }
sub sigmaybe__S_013unsp__PEEK { $_[0]->_AUTOLEXpeek('sigmaybe__S_013unsp', $retree) }
sub sigmaybe__S_013unsp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigmaybe__S_013unsp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "unsp";
$self->_MATCHIFYr($S, "sigmaybe__S_013unsp", $C->_SUBSUMEr(['unsp'], sub {
my $C = shift;
$C->unsp
}));
}
;
## token sigmaybe:nosp { <?before \S> }
sub sigmaybe__S_014nosp__PEEK { $_[0]->_AUTOLEXpeek('sigmaybe__S_014nosp', $retree) }
sub sigmaybe__S_014nosp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sigmaybe__S_014nosp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "nosp";
$self->_MATCHIFYr($S, "sigmaybe__S_014nosp", $C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G\S/)
}))) { ($C) } else { () }
}));
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## token atom {
sub atom__PEEK { $_[0]->_AUTOLEXpeek('atom', $retree) }
sub atom {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE atom");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "atom", $C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'atom_0') {
$C->deb("Fate passed to atom_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT atom_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM atom_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'atom_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("atom_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym« > » { '>'<!before '>'> :: <fail> }
sub metachar__S_015Gt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_015Gt', $retree) }
sub metachar__S_015Gt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_015Gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\>";
$self->_MATCHIFYr($S, "metachar__S_015Gt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\>"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<&&> { '&&' :: <fail> }
sub metachar__S_016AmpAmp__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_016AmpAmp', $retree) }
sub metachar__S_016AmpAmp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_016AmpAmp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&\&";
$self->_MATCHIFYr($S, "metachar__S_016AmpAmp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\&\&"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<&> { '&' :: <fail> }
sub metachar__S_017Amp__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_017Amp', $retree) }
sub metachar__S_017Amp {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_017Amp");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\&";
$self->_MATCHIFYr($S, "metachar__S_017Amp", do {
my $C = $C;
if (($C) = ($C->_EXACT("\&"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<||> { '||' :: <fail> }
sub metachar__S_018VertVert__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_018VertVert', $retree) }
sub metachar__S_018VertVert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_018VertVert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|\|";
$self->_MATCHIFYr($S, "metachar__S_018VertVert", do {
my $C = $C;
if (($C) = ($C->_EXACT("\|\|"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<|> { '|' :: <fail> }
sub metachar__S_019Vert__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_019Vert', $retree) }
sub metachar__S_019Vert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_019Vert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|";
$self->_MATCHIFYr($S, "metachar__S_019Vert", do {
my $C = $C;
if (($C) = ($C->_EXACT("\|"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<]> { ']' :: <fail> }
sub metachar__S_020Ket__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_020Ket', $retree) }
sub metachar__S_020Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_020Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\]";
$self->_MATCHIFYr($S, "metachar__S_020Ket", do {
my $C = $C;
if (($C) = ($C->_EXACT("\]"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<)> { ')' :: <fail> }
sub metachar__S_021Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_021Thesis', $retree) }
sub metachar__S_021Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_021Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\)";
$self->_MATCHIFYr($S, "metachar__S_021Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\)"))
and ($C) = ($C->_COMMITLTM())) {
$C->_SUBSUMEr(['fail'], sub {
my $C = shift;
$C->fail
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<;> {
sub metachar__S_022Semi__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_022Semi', $retree) }
sub metachar__S_022Semi {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_022Semi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\;";
$self->_MATCHIFYr($S, "metachar__S_022Semi", do {
my $C = $C;
if (($C) = ($C->_EXACT("\;"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (LazyMap::lazymap(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
}
}
or $xact->[-2] or
do {
push @gather, do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->cursor_incr()
}))) { ($C) } else { () }
}))
and ($C) = ($C->panic("Regex missing terminator (or semicolon must be quoted?)"))) {
$C
} else { () }
}
}
or $xact->[-2] or
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<{*}> { <onlystar=.sym> <?{ $*MULTINESS eq 'proto' }> }
sub metachar__S_023CurStarLy__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_023CurStarLy', $retree) }
sub metachar__S_023CurStarLy {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_023CurStarLy");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\*\}";
$self->_MATCHIFYr($S, "metachar__S_023CurStarLy", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['onlystar'], sub {
my $C = shift;
$C->_EXACT("\{\*\}")
}))
and ($C) = ($C->before(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:quant { <quantifier> <.sorry: "Quantifier quantifies nothing"> }
sub metachar__S_024quant__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_024quant', $retree) }
sub metachar__S_024quant {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_024quant");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quant";
$self->_MATCHIFYr($S, "metachar__S_024quant", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['quantifier'], sub {
my $C = shift;
$C->quantifier
}))
and ($C) = ($C->sorry("Quantifier quantifies nothing"))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<{ }> {
sub metachar__S_025Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_025Cur_Ly', $retree) }
sub metachar__S_025Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_025Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "metachar__S_025Cur_Ly", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\{")
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:mod {
sub metachar__S_026mod__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_026mod', $retree) }
sub metachar__S_026mod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_026mod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "mod";
$self->_MATCHIFYr($S, "metachar__S_026mod", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\:")
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<-> {
sub metachar__S_027Minus__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_027Minus', $retree) }
sub metachar__S_027Minus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_027Minus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-";
$self->_MATCHIFYr($S, "metachar__S_027Minus", do {
my $C = $C;
if (($C) = ($C->_EXACT("\-"))
and ($C) = ($C->before(sub {
my $C=shift;
(($C) x !!do {
$::GOAL eq ']' })
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<:> {
sub metachar__S_028Colon__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_028Colon', $retree) }
sub metachar__S_028Colon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_028Colon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:";
$self->_MATCHIFYr($S, "metachar__S_028Colon", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<::> {
sub metachar__S_029ColonColon__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_029ColonColon', $retree) }
sub metachar__S_029ColonColon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_029ColonColon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:";
$self->_MATCHIFYr($S, "metachar__S_029ColonColon", $C->_EXACT("\:\:"));
}
;
## token metachar:sym«::>» {
sub metachar__S_030ColonColonGt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_030ColonColonGt', $retree) }
sub metachar__S_030ColonColonGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_030ColonColonGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\>";
$self->_MATCHIFYr($S, "metachar__S_030ColonColonGt", $C->_EXACT("\:\:\>"));
}
;
## token metachar:sym<:::> {
sub metachar__S_031ColonColonColon__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_031ColonColonColon', $retree) }
sub metachar__S_031ColonColonColon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_031ColonColonColon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\:\:";
$self->_MATCHIFYr($S, "metachar__S_031ColonColonColon", $C->_EXACT("\:\:\:"));
}
;
## token metachar:sym<[ ]> {
sub metachar__S_032Bra_Ket__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_032Bra_Ket', $retree) }
sub metachar__S_032Bra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_032Bra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\[\ \]";
$self->_MATCHIFYr($S, "metachar__S_032Bra_Ket", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\]";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibbler'], sub {
my $C = shift;
$C->nibbler
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'bracketed regex', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<(?: )> { '(?:' <.obs("(?: ... ) for grouping", "[ ... ]")> }
sub metachar__S_033ParenQuestionColon_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_033ParenQuestionColon_Thesis', $retree) }
sub metachar__S_033ParenQuestionColon_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_033ParenQuestionColon_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\?\:\ \)";
$self->_MATCHIFYr($S, "metachar__S_033ParenQuestionColon_Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\(\?\:"))
and ($C) = ($C->obs("(?: ... ) for grouping", "[ ... ]"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<(?= )> { '(?=' <.obs("(?= ... ) for lookahead", "<?before ... >")> }
sub metachar__S_034ParenQuestionEqual_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_034ParenQuestionEqual_Thesis', $retree) }
sub metachar__S_034ParenQuestionEqual_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_034ParenQuestionEqual_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\?\=\ \)";
$self->_MATCHIFYr($S, "metachar__S_034ParenQuestionEqual_Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\(\?\="))
and ($C) = ($C->obs("(?= ... ) for lookahead", "<?before ... >"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<(?! )> { '(?!' <.obs("(?! ... ) for lookahead", "<!before ... >")> }
sub metachar__S_035ParenQuestionBang_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_035ParenQuestionBang_Thesis', $retree) }
sub metachar__S_035ParenQuestionBang_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_035ParenQuestionBang_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\?\!\ \)";
$self->_MATCHIFYr($S, "metachar__S_035ParenQuestionBang_Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\(\?\!"))
and ($C) = ($C->obs("(?! ... ) for lookahead", "<!before ... >"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<(?\<= )> { '(?<=' <.obs("(?<= ... ) for lookbehind", "<?after ... >")> }
sub metachar__S_036ParenQuestionBackLtEqual_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_036ParenQuestionBackLtEqual_Thesis', $retree) }
sub metachar__S_036ParenQuestionBackLtEqual_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_036ParenQuestionBackLtEqual_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\?\\\<\=\ \)";
$self->_MATCHIFYr($S, "metachar__S_036ParenQuestionBackLtEqual_Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\(\?\<\="))
and ($C) = ($C->obs("(?<= ... ) for lookbehind", "<?after ... >"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<(?\<! )> { '(?<!' <.obs("(?<! ... ) for lookbehind", "<!after ... >")> }
sub metachar__S_037ParenQuestionBackLtBang_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_037ParenQuestionBackLtBang_Thesis', $retree) }
sub metachar__S_037ParenQuestionBackLtBang_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_037ParenQuestionBackLtBang_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\?\\\<\!\ \)";
$self->_MATCHIFYr($S, "metachar__S_037ParenQuestionBackLtBang_Thesis", do {
my $C = $C;
if (($C) = ($C->_EXACT("\(\?\<\!"))
and ($C) = ($C->obs("(?<! ... ) for lookbehind", "<!after ... >"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<( )> {
sub metachar__S_038Paren_Thesis__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_038Paren_Thesis', $retree) }
sub metachar__S_038Paren_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_038Paren_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\ \)";
$self->_MATCHIFYr($S, "metachar__S_038Paren_Thesis", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibbler'], sub {
my $C = shift;
$C->nibbler
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'capture parens', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym« <( » { '<(' <.SIGOK> }
sub metachar__S_039LtParen__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_039LtParen', $retree) }
sub metachar__S_039LtParen {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_039LtParen");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\(";
$self->_MATCHIFYr($S, "metachar__S_039LtParen", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<\("))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym« )> » { ')>' <.SIGOK> }
sub metachar__S_040ThesisGt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_040ThesisGt', $retree) }
sub metachar__S_040ThesisGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_040ThesisGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\)\>";
$self->_MATCHIFYr($S, "metachar__S_040ThesisGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\)\>"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym« << » { '<<' <.SIGOK> }
sub metachar__S_041LtLt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_041LtLt', $retree) }
sub metachar__S_041LtLt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_041LtLt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\<";
$self->_MATCHIFYr($S, "metachar__S_041LtLt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\<\<"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym« >> » { '>>' <.SIGOK> }
sub metachar__S_042GtGt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_042GtGt', $retree) }
sub metachar__S_042GtGt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_042GtGt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\>\>";
$self->_MATCHIFYr($S, "metachar__S_042GtGt", do {
my $C = $C;
if (($C) = ($C->_EXACT("\>\>"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym< « > { '«' <.SIGOK> }
sub metachar__S_043Fre__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_043Fre', $retree) }
sub metachar__S_043Fre {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_043Fre");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "«";
$self->_MATCHIFYr($S, "metachar__S_043Fre", do {
my $C = $C;
if (($C) = ($C->_EXACT("«"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym< » > { '»' <.SIGOK> }
sub metachar__S_044Nch__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_044Nch', $retree) }
sub metachar__S_044Nch {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_044Nch");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "»";
$self->_MATCHIFYr($S, "metachar__S_044Nch", do {
my $C = $C;
if (($C) = ($C->_EXACT("»"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:qw {
sub metachar__S_045qw__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_045qw', $retree) }
sub metachar__S_045qw {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_045qw");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "qw";
$self->_MATCHIFYr($S, "metachar__S_045qw", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G\<\s/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym«< >» {
sub metachar__S_046Lt_Gt__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_046Lt_Gt', $retree) }
sub metachar__S_046Lt_Gt {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_046Lt_Gt");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\<\ \>";
$self->_MATCHIFYr($S, "metachar__S_046Lt_Gt", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\>";
my $goalpos = $C;
my $newlang = $C->unbalanced($::GOAL);
$C = bless($C, (ref($newlang) || $newlang));
if (($C) = ($C->_EXACT("\<"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['assertion'], sub {
my $C = shift;
$C->assertion
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\>")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'metachar', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<\\> { <sym> <backslash> <.SIGOK> }
sub metachar__S_047Back__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_047Back', $retree) }
sub metachar__S_047Back {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_047Back");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\\";
$self->_MATCHIFYr($S, "metachar__S_047Back", do {
my $C = $C;
if (($C) = ($C->_EXACT("\\"))
and ($C) = ($C->_SUBSUMEr(['backslash'], sub {
my $C = shift;
$C->backslash
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<.> { <sym> <.SIGOK> }
sub metachar__S_048Dot__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_048Dot', $retree) }
sub metachar__S_048Dot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_048Dot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.";
$self->_MATCHIFYr($S, "metachar__S_048Dot", do {
my $C = $C;
if (($C) = ($C->_EXACT("\."))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<^^> { <sym> <.SIGOK> }
sub metachar__S_049CaretCaret__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_049CaretCaret', $retree) }
sub metachar__S_049CaretCaret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_049CaretCaret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^\^";
$self->_MATCHIFYr($S, "metachar__S_049CaretCaret", do {
my $C = $C;
if (($C) = ($C->_EXACT("\^\^"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<^> { <sym> <.SIGOK> }
sub metachar__S_050Caret__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_050Caret', $retree) }
sub metachar__S_050Caret {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_050Caret");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\^";
$self->_MATCHIFYr($S, "metachar__S_050Caret", do {
my $C = $C;
if (($C) = ($C->_EXACT("\^"))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<$$> {
sub metachar__S_051DollarDollar__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_051DollarDollar', $retree) }
sub metachar__S_051DollarDollar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_051DollarDollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'0'} = [];
$C->{sym} = "\$\$";
$self->_MATCHIFYr($S, "metachar__S_051DollarDollar", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$\$"))
and ($C) = ($C->SIGOK)) {
$C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<$> {
sub metachar__S_052Dollar__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_052Dollar', $retree) }
sub metachar__S_052Dollar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_052Dollar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\$";
$self->_MATCHIFYr($S, "metachar__S_052Dollar", do {
my $C = $C;
if (($C) = ($C->_EXACT("\$"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'metachar__S_052Dollar_0') {
$C->deb("Fate passed to metachar__S_052Dollar_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT metachar__S_052Dollar_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM metachar__S_052Dollar_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'metachar__S_052Dollar_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("metachar__S_052Dollar_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<' '> { <?before "'"> [:lang(%*LANG<MAIN>) <quote>] <.SIGOK> }
sub metachar__S_053Single_Single__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_053Single_Single', $retree) }
sub metachar__S_053Single_Single {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_053Single_Single");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\'\ \'";
$self->_MATCHIFYr($S, "metachar__S_053Single_Single", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\'")
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:sym<" "> { <?before '"'> [:lang(%*LANG<MAIN>) <quote>] <.SIGOK> }
sub metachar__S_054Double_Double__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_054Double_Double', $retree) }
sub metachar__S_054Double_Double {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_054Double_Double");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\"\ \"";
$self->_MATCHIFYr($S, "metachar__S_054Double_Double", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\"")
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token metachar:var {
sub metachar__S_055var__PEEK { $_[0]->_AUTOLEXpeek('metachar__S_055var', $retree) }
sub metachar__S_055var {
no warnings 'recursion';
my $self = shift;
local $::QSIGIL = substr($self->orig,$self->{'_pos'},1);
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE metachar__S_055var");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "var";
$self->_MATCHIFYr($S, "metachar__S_055var", do {
my $C = $C;
if (($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\$\$")
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$C->variable
})
}))
and ($C) = ($C->_SUBSUMEblock('sym', sub {
my $C = shift;
my $M = $C;
$M->{'variable'}->Str}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_SUBSUMEr(['binding'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
if (my ($C) = ($C->_PATTERN(qr/\G\s*+\=\s*+/))) {
$C->_SUBSUMEr(['quantified_atom'], sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:unspace { <?before \s> [ :lang( %*LANG<MAIN> ) <.ws> ] }
sub backslash__S_056unspace__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_056unspace', $retree) }
sub backslash__S_056unspace {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_056unspace");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "unspace";
$self->_MATCHIFYr($S, "backslash__S_056unspace", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G\s/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:sym<0> { '0' <!before <[0..7]> > <.SIGOK> }
sub backslash__S_0570__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_0570', $retree) }
sub backslash__S_0570 {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_0570");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "backslash__S_0570", do {
my $C = $C;
if (($C) = ($C->_EXACT("0"))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_PATTERN(qr/\G[0-7]/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:A { <sym> <.obs('\\A as beginning-of-string matcher', '^')> }
sub backslash__S_058A__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_058A', $retree) }
sub backslash__S_058A {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_058A");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "A";
$self->_MATCHIFYr($S, "backslash__S_058A", do {
my $C = $C;
if (($C) = ($C->_EXACT("A"))
and ($C) = ($C->obs('\\A as beginning-of-string matcher', '^'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:a { <sym> <.sorry: "\\a is allowed only in strings, not regexes"> }
sub backslash__S_059a__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_059a', $retree) }
sub backslash__S_059a {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_059a");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "a";
$self->_MATCHIFYr($S, "backslash__S_059a", do {
my $C = $C;
if (($C) = ($C->_EXACT("a"))
and ($C) = ($C->sorry("\\a is allowed only in strings, not regexes"))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:B { <sym> <.obs('\\B as word non-boundary', '<!wb>')> }
sub backslash__S_060B__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_060B', $retree) }
sub backslash__S_060B {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_060B");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "B";
$self->_MATCHIFYr($S, "backslash__S_060B", do {
my $C = $C;
if (($C) = ($C->_EXACT("B"))
and ($C) = ($C->obs('\\B as word non-boundary', '<!wb>'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:b { <sym> <.obs('\\b as word boundary', '<?wb> (or either of « or »)')> }
sub backslash__S_061b__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_061b', $retree) }
sub backslash__S_061b {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_061b");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "b";
$self->_MATCHIFYr($S, "backslash__S_061b", do {
my $C = $C;
if (($C) = ($C->_EXACT("b"))
and ($C) = ($C->obs('\\b as word boundary', '<?wb> (or either of « or »)'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:c { :i <sym> <charspec> <.SIGOK> }
sub backslash__S_062c__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_062c', $retree) }
sub backslash__S_062c {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_062c");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "c";
$self->_MATCHIFYr($S, "backslash__S_062c", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:c)/))
and ($C) = ($C->_SUBSUMEr(['charspec'], sub {
my $C = shift;
$C->charspec
}))
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:d { :i <sym> <.SIGOK> }
sub backslash__S_063d__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_063d', $retree) }
sub backslash__S_063d {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_063d");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "d";
$self->_MATCHIFYr($S, "backslash__S_063d", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:d)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:e { :i <sym> <.SIGOK> }
sub backslash__S_064e__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_064e', $retree) }
sub backslash__S_064e {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_064e");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "e";
$self->_MATCHIFYr($S, "backslash__S_064e", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:e)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:f { :i <sym> <.SIGOK> }
sub backslash__S_065f__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_065f', $retree) }
sub backslash__S_065f {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_065f");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "f";
$self->_MATCHIFYr($S, "backslash__S_065f", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:f)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:h { :i <sym> <.SIGOK> }
sub backslash__S_066h__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_066h', $retree) }
sub backslash__S_066h {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_066h");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "h";
$self->_MATCHIFYr($S, "backslash__S_066h", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:h)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:n { :i <sym> <.SIGOK> }
sub backslash__S_067n__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_067n', $retree) }
sub backslash__S_067n {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_067n");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "n";
$self->_MATCHIFYr($S, "backslash__S_067n", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:n)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:o { :i :dba('octal character') <sym> [ <octint> | '[' ~ ']' <octints> ] <.SIGOK> }
sub backslash__S_068o__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_068o', $retree) }
sub backslash__S_068o {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_068o");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "o";
$self->_MATCHIFYr($S, "backslash__S_068o", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:o)/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_068o_0') {
$C->deb("Fate passed to backslash__S_068o_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_068o_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_068o_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'backslash__S_068o_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_068o_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:\[)/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['octints'], sub {
my $C = shift;
$C->octints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G(?i:\])/)
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'octal character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:p {
sub backslash__S_069p__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_069p', $retree) }
sub backslash__S_069p {
no warnings 'recursion';
my $self = shift;
my $s;my $m;my $p;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_069p");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "p";
$self->_MATCHIFYr($S, "backslash__S_069p", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_PATTERN(qr/\G[pP]/)
}))
and ($C) = (scalar(do {
my $M = $C;
$s = $M->{'sym'}->Str;
$m = $s lt 'a' ? '-' : '';
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, do {
if (my ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->_PATTERN(qr/\G\w/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:Q { <sym> <.obs('\\Q as quotemeta', 'quotes or literal variable match')> }
sub backslash__S_070Q__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_070Q', $retree) }
sub backslash__S_070Q {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_070Q");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "Q";
$self->_MATCHIFYr($S, "backslash__S_070Q", do {
my $C = $C;
if (($C) = ($C->_EXACT("Q"))
and ($C) = ($C->obs('\\Q as quotemeta', 'quotes or literal variable match'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:r { :i <sym> <.SIGOK> }
sub backslash__S_071r__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_071r', $retree) }
sub backslash__S_071r {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_071r");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "r";
$self->_MATCHIFYr($S, "backslash__S_071r", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:r)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:s { :i <sym> <.SIGOK> }
sub backslash__S_072s__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_072s', $retree) }
sub backslash__S_072s {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_072s");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "s";
$self->_MATCHIFYr($S, "backslash__S_072s", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:s)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:t { :i <sym> <.SIGOK> }
sub backslash__S_073t__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_073t', $retree) }
sub backslash__S_073t {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_073t");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "t";
$self->_MATCHIFYr($S, "backslash__S_073t", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:t)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:v { :i <sym> <.SIGOK> }
sub backslash__S_074v__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_074v', $retree) }
sub backslash__S_074v {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_074v");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "v";
$self->_MATCHIFYr($S, "backslash__S_074v", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:v)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:w { :i <sym> <.SIGOK> }
sub backslash__S_075w__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_075w', $retree) }
sub backslash__S_075w {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_075w");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "w";
$self->_MATCHIFYr($S, "backslash__S_075w", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:w)/))
and ($C) = ($C->SIGOK)) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:x { :i :dba('hex character') <sym> [ <hexint> | '[' ~ ']' <hexints> ] <.SIGOK> }
sub backslash__S_076x__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_076x', $retree) }
sub backslash__S_076x {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_076x");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "x";
$self->_MATCHIFYr($S, "backslash__S_076x", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:x)/))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'backslash__S_076x_0') {
$C->deb("Fate passed to backslash__S_076x_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT backslash__S_076x_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM backslash__S_076x_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'backslash__S_076x_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("backslash__S_076x_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $goalpos = $C;
if (($C) = ($C->_PATTERN(qr/\G(?i:\[)/))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['hexints'], sub {
my $C = shift;
$C->hexints
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_PATTERN(qr/\G(?i:\])/)
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'hex character', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:z { <sym> <.obs('\\z as end-of-string matcher', '$')> }
sub backslash__S_077z__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_077z', $retree) }
sub backslash__S_077z {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_077z");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "z";
$self->_MATCHIFYr($S, "backslash__S_077z", do {
my $C = $C;
if (($C) = ($C->_EXACT("z"))
and ($C) = ($C->obs('\\z as end-of-string matcher', '$'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:Z { <sym> <.obs('\\Z as end-of-string matcher', '\\n?$')> }
sub backslash__S_078Z__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_078Z', $retree) }
sub backslash__S_078Z {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_078Z");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "Z";
$self->_MATCHIFYr($S, "backslash__S_078Z", do {
my $C = $C;
if (($C) = ($C->_EXACT("Z"))
and ($C) = ($C->obs('\\Z as end-of-string matcher', '\\n?$'))) {
$C
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:misc { $<litchar>=(\W) <.SIGOK> }
sub backslash__S_079misc__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_079misc', $retree) }
sub backslash__S_079misc {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_079misc");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "misc";
$self->_MATCHIFYr($S, "backslash__S_079misc", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['litchar'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->_PATTERN(qr/\G\W/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:oldbackref { (<[1..9]>\d*) { my $d = $0.Str; $¢.sorryobs("the 1-based special form '
sub backslash__S_080oldbackref__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_080oldbackref', $retree) }
sub backslash__S_080oldbackref {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_080oldbackref");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "oldbackref";
$self->_MATCHIFYr($S, "backslash__S_080oldbackref", do {
if (my ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
$C->_PATTERN(qr/\G[1-9]\d*+/)
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token backslash:oops { <.sorry: "Unrecognized regex backslash sequence"> . }
sub backslash__S_081oops__PEEK { $_[0]->_AUTOLEXpeek('backslash__S_081oops', $retree) }
sub backslash__S_081oops {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE backslash__S_081oops");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "oops";
$self->_MATCHIFYr($S, "backslash__S_081oops", do {
if (my ($C) = ($C->sorry("Unrecognized regex backslash sequence"))) {
$C->cursor_incr()
} else { () }
});
}
;
## token assertion:sym<...> { <sym> }
sub assertion__S_082DotDotDot__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_082DotDotDot', $retree) }
sub assertion__S_082DotDotDot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_082DotDotDot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.\.\.";
$self->_MATCHIFYr($S, "assertion__S_082DotDotDot", $C->_EXACT("\.\.\."));
}
;
## token assertion:sym<???> { <sym> }
sub assertion__S_083QuestionQuestionQuestion__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_083QuestionQuestionQuestion', $retree) }
sub assertion__S_083QuestionQuestionQuestion {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_083QuestionQuestionQuestion");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?\?\?";
$self->_MATCHIFYr($S, "assertion__S_083QuestionQuestionQuestion", $C->_EXACT("\?\?\?"));
}
;
## token assertion:sym<!!!> { <sym> }
sub assertion__S_084BangBangBang__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_084BangBangBang', $retree) }
sub assertion__S_084BangBangBang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_084BangBangBang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!\!\!";
$self->_MATCHIFYr($S, "assertion__S_084BangBangBang", $C->_EXACT("\!\!\!"));
}
;
## token assertion:sym<|> { <sym> [ <?before '>'> | <?before \w> <assertion> ] } # assertion-like synt
sub assertion__S_085Vert__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_085Vert', $retree) }
sub assertion__S_085Vert {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_085Vert");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\|";
$self->_MATCHIFYr($S, "assertion__S_085Vert", do {
my $C = $C;
if (($C) = ($C->_EXACT("\|"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_085Vert_0') {
$C->deb("Fate passed to assertion__S_085Vert_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_085Vert_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_085Vert_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_085Vert_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_085Vert_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<?> { <sym> [ <?before '>'> | <assertion> ] }
sub assertion__S_086Question__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_086Question', $retree) }
sub assertion__S_086Question {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_086Question");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?";
$self->_MATCHIFYr($S, "assertion__S_086Question", do {
my $C = $C;
if (($C) = ($C->_EXACT("\?"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_086Question_0') {
$C->deb("Fate passed to assertion__S_086Question_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_086Question_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_086Question_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_086Question_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_086Question_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<!> { <sym> [ <?before '>'> | <assertion> ] }
sub assertion__S_087Bang__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_087Bang', $retree) }
sub assertion__S_087Bang {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_087Bang");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\!";
$self->_MATCHIFYr($S, "assertion__S_087Bang", do {
my $C = $C;
if (($C) = ($C->_EXACT("\!"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_087Bang_0') {
$C->deb("Fate passed to assertion__S_087Bang_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_087Bang_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_087Bang_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_087Bang_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_087Bang_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<*> { <sym> [ <?before '>'> | <.ws> <nibbler> ] }
sub assertion__S_088Star__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_088Star', $retree) }
sub assertion__S_088Star {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_088Star");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*";
$self->_MATCHIFYr($S, "assertion__S_088Star", do {
my $C = $C;
if (($C) = ($C->_EXACT("\*"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_088Star_0') {
$C->deb("Fate passed to assertion__S_088Star_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_088Star_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_088Star_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_088Star_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_088Star_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<{ }> { <embeddedblock> }
sub assertion__S_089Cur_Ly__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_089Cur_Ly', $retree) }
sub assertion__S_089Cur_Ly {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_089Cur_Ly");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{\ \}";
$self->_MATCHIFYr($S, "assertion__S_089Cur_Ly", $C->_SUBSUMEr(['embeddedblock'], sub {
my $C = shift;
$C->embeddedblock
}));
}
;
## token assertion:variable {
sub assertion__S_090variable__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_090variable', $retree) }
sub assertion__S_090variable {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_090variable");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "variable";
$self->_MATCHIFYr($S, "assertion__S_090variable", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_SUBSUMEr(['sigil'], sub {
my $C = shift;
$C->sigil
})
}))) { ($C) } else { () }
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($C->cursor_fresh($::LANG{'MAIN'})->unbalanced('>'));
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['variable'], sub {
my $C = shift;
$C->EXPR(\%LOOSEST)
})
}))) {
$C
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:method {
sub assertion__S_091method__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_091method', $retree) }
sub assertion__S_091method {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_091method");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "method";
$self->_MATCHIFYr($S, "assertion__S_091method", do {
my $C = $C;
if (($C) = ($C->_EXACT("\."))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_091method_0') {
$C->deb("Fate passed to assertion__S_091method_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_091method_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_091method_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_091method_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_091method_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
$C->_SUBSUMEr(['assertion'], sub {
my $C = shift;
$C->assertion
})
} else { () }
},
sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($C->cursor_fresh($::LANG{'MAIN'})->unbalanced('>'));
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['dottyop'], sub {
my $C = shift;
$C->dottyop
})
}))) { ($C) } else { () }
}
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))) {
$C
} else { () }
});
}
;
## token assertion:name { [ :lang($¢.cursor_fresh(%*LANG<MAIN>).unbalanced('>')) <longname> ]
sub assertion__S_092name__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_092name', $retree) }
sub assertion__S_092name {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_092name");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'arglist'} = [];
$C->{'assertion'} = [];
$C->{'nibbler'} = [];
$C->{sym} = "name";
$self->_MATCHIFYr($S, "assertion__S_092name", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($C->cursor_fresh($::LANG{'MAIN'})->unbalanced('>'));
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['longname'], sub {
my $C = shift;
$C->longname
})
}))) {
$C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_092name_0') {
$C->deb("Fate passed to assertion__S_092name_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_092name_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_092name_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_092name_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_092name_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C = shift;
$C->assertion
})
} else { () }
},
sub {
my $C=shift;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($C->cursor_fresh($::LANG{'MAIN'})->unbalanced('>'));
$C = bless($C, (ref($newlang) || $newlang));
do {
if (my ($C) = ($C->ws)) {
$C->_SUBSUMEr(['arglist'], sub {
my $C = shift;
$C->arglist
})
} else { () }
}
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $C=shift;
my $newlang = ($::LANG{'MAIN'});
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['arglist'], sub {
my $C = shift;
$C->arglist
})
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->panic("Assertion call missing right parenthesis"))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<:> { <?before ':'> <cclass_expr> }
sub assertion__S_093Colon__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_093Colon', $retree) }
sub assertion__S_093Colon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_093Colon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:";
$self->_MATCHIFYr($S, "assertion__S_093Colon", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\:")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<[> { <?before '['> <cclass_expr> }
sub assertion__S_094Bra__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_094Bra', $retree) }
sub assertion__S_094Bra {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_094Bra");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\[";
$self->_MATCHIFYr($S, "assertion__S_094Bra", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\[")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<+> { <?before '+'> <cclass_expr> }
sub assertion__S_095Plus__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_095Plus', $retree) }
sub assertion__S_095Plus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_095Plus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+";
$self->_MATCHIFYr($S, "assertion__S_095Plus", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\+")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<-> { <?before '-'> <cclass_expr> }
sub assertion__S_096Minus__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_096Minus', $retree) }
sub assertion__S_096Minus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_096Minus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\-";
$self->_MATCHIFYr($S, "assertion__S_096Minus", do {
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
$C->_EXACT("\-")
}))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:sym<.> { <sym> }
sub assertion__S_097Dot__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_097Dot', $retree) }
sub assertion__S_097Dot {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_097Dot");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\.";
$self->_MATCHIFYr($S, "assertion__S_097Dot", $C->_EXACT("\."));
}
;
## token assertion:sym<,> { <sym> }
sub assertion__S_098Comma__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_098Comma', $retree) }
sub assertion__S_098Comma {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_098Comma");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\,";
$self->_MATCHIFYr($S, "assertion__S_098Comma", $C->_EXACT("\,"));
}
;
## token assertion:sym<~~> { <sym> [ <?before '>'> | \d+ | <desigilname> ] }
sub assertion__S_099TildeTilde__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_099TildeTilde', $retree) }
sub assertion__S_099TildeTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_099TildeTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\~";
$self->_MATCHIFYr($S, "assertion__S_099TildeTilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~\~"))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'assertion__S_099TildeTilde_0') {
$C->deb("Fate passed to assertion__S_099TildeTilde_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT assertion__S_099TildeTilde_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM assertion__S_099TildeTilde_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'assertion__S_099TildeTilde_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("assertion__S_099TildeTilde_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token assertion:bogus { <.panic: "Unrecognized regex assertion"> }
sub assertion__S_100bogus__PEEK { $_[0]->_AUTOLEXpeek('assertion__S_100bogus', $retree) }
sub assertion__S_100bogus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE assertion__S_100bogus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "bogus";
$self->_MATCHIFYr($S, "assertion__S_100bogus", $C->panic("Unrecognized regex assertion"));
}
;
## token sign { '+' | '-' | <?> }
sub sign__PEEK { $_[0]->_AUTOLEXpeek('sign', $retree) }
sub sign {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE sign");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "sign", do {
do {
my ($tag, $try);
my @try;
my $relex;
my $fate;
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'sign_0') {
$C->deb("Fate passed to sign_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT sign_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM sign_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'sign_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("sign_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_expr {
sub cclass_expr__PEEK { $_[0]->_AUTOLEXpeek('cclass_expr', $retree) }
sub cclass_expr {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_expr");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'cclass_union'} = [];
$C->{'op'} = [];
$self->_MATCHIFYr($S, "cclass_expr", do {
my $C = $C;
if (($C) = ($C->_COMMITLTM())
and ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->normspace)) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'cclass_expr_0') {
$C->deb("Fate passed to cclass_expr_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT cclass_expr_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM cclass_expr_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'cclass_expr_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("cclass_expr_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_union {
sub cclass_union__PEEK { $_[0]->_AUTOLEXpeek('cclass_union', $retree) }
sub cclass_union {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_union");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'cclass_add'} = [];
$C->{'op'} = [];
$self->_MATCHIFYr($S, "cclass_union", do {
if (my ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->normspace)) { ($C) } else { () }
}))) {
$C->_REPSEPr( sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_add {
sub cclass_add__PEEK { $_[0]->_AUTOLEXpeek('cclass_add', $retree) }
sub cclass_add {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_add");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'cclass_elem'} = [];
$C->{'op'} = [];
$self->_MATCHIFYr($S, "cclass_add", do {
if (my ($C) = ($C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->normspace)) { ($C) } else { () }
}))) {
$C->_REPSEPr( sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'cclass_add_0') {
$C->deb("Fate passed to cclass_add_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT cclass_add_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM cclass_add_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'cclass_add_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("cclass_add_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_elem:name {
sub cclass_elem__S_101name__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem__S_101name', $retree) }
sub cclass_elem__S_101name {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_elem__S_101name");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "name";
$self->_MATCHIFYr($S, "cclass_elem__S_101name", do {
if (my ($C) = ($C->_SUBSUMEr(['name'], sub {
my $C = shift;
$C->name
}))) {
$C->_OPTr(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_elem:sym<[ ]> {
sub cclass_elem__S_102Bra_Ket__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem__S_102Bra_Ket', $retree) }
sub cclass_elem__S_102Bra_Ket {
no warnings 'recursion';
my $self = shift;
local $::CCSTATE = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_elem__S_102Bra_Ket");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\[\ \]";
$self->_MATCHIFYr($S, "cclass_elem__S_102Bra_Ket", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\]";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\["))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['nibble'], sub {
my $C = shift;
$C->nibble($C->cursor_fresh( $::LANG{'Q'} )->tweak('cc' => 1)->unbalanced("]"))
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\]")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'character class element', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_elem:sym<( )> {
sub cclass_elem__S_103Paren_Thesis__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem__S_103Paren_Thesis', $retree) }
sub cclass_elem__S_103Paren_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CCSTATE = '';
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_elem__S_103Paren_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\(\ \)";
$self->_MATCHIFYr($S, "cclass_elem__S_103Paren_Thesis", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['cclass_expr'], sub {
my $C = shift;
$C->cclass_expr
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'character class element', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_elem:property {
sub cclass_elem__S_104property__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem__S_104property', $retree) }
sub cclass_elem__S_104property {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_elem__S_104property");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "property";
$self->_MATCHIFYr($S, "cclass_elem__S_104property", do {
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($::LANG{'MAIN'});
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['colonpair'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token cclass_elem:quote {
sub cclass_elem__S_105quote__PEEK { $_[0]->_AUTOLEXpeek('cclass_elem__S_105quote', $retree) }
sub cclass_elem__S_105quote {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE cclass_elem__S_105quote");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "quote";
$self->_MATCHIFYr($S, "cclass_elem__S_105quote", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = (do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'cclass_elem__S_105quote_0') {
$C->deb("Fate passed to cclass_elem__S_105quote_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT cclass_elem__S_105quote_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM cclass_elem__S_105quote_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'cclass_elem__S_105quote_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("cclass_elem__S_105quote_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_arg { :dba('modifier argument') '(' ~ ')' [:lang(%*LANG<MAIN>) <semilist> ] }
sub mod_arg__PEEK { $_[0]->_AUTOLEXpeek('mod_arg', $retree) }
sub mod_arg {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_arg");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "mod_arg", $C->_BRACKETr(sub {
my $C=shift;
local $::GOAL = "\)";
my $goalpos = $C;
if (($C) = ($C->_EXACT("\("))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ($::LANG{'MAIN'});
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['semilist'], sub {
my $C = shift;
$C->semilist
})
}))
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do { my $C = $C->cursor_xact('ALT ||');
my $xact = $C->xact;
my @gather;
do {
push @gather, $C->_EXACT("\)")
}
or $xact->[-2] or
do {
push @gather, do {
if (my ($C) = ($C->FAILGOAL($::GOAL, 'modifier argument', $goalpos))) { ($C) } else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:my> { ':' <?before ['my'|'state'|'our'|'anon'|'constant'|'temp'|'let'] \s
sub mod_internal__S_106Colonmy__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_106Colonmy', $retree) }
sub mod_internal__S_106Colonmy {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_106Colonmy");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:my";
$self->_MATCHIFYr($S, "mod_internal__S_106Colonmy", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_106Colonmy_0') {
$C->deb("Fate passed to mod_internal__S_106Colonmy_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_106Colonmy_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_106Colonmy_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_106Colonmy_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_106Colonmy_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:i> { $<sym>=[':i'|':ignorecase'] » { %*RX<i> = 1 } }
sub mod_internal__S_107Coloni__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_107Coloni', $retree) }
sub mod_internal__S_107Coloni {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_107Coloni");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:i";
$self->_MATCHIFYr($S, "mod_internal__S_107Coloni", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_107Coloni_0') {
$C->deb("Fate passed to mod_internal__S_107Coloni_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_107Coloni_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_107Coloni_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_107Coloni_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_107Coloni_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:!i> { $<sym>=[':!i'|':!ignorecase'] » { %*RX<i> = 0 } }
sub mod_internal__S_108ColonBangi__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_108ColonBangi', $retree) }
sub mod_internal__S_108ColonBangi {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_108ColonBangi");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\!i";
$self->_MATCHIFYr($S, "mod_internal__S_108ColonBangi", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_108ColonBangi_0') {
$C->deb("Fate passed to mod_internal__S_108ColonBangi_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_108ColonBangi_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_108ColonBangi_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_108ColonBangi_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_108ColonBangi_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:i( )> { $<sym>=[':i'|':ignorecase'] <mod_arg> { %*RX<i> = eval $<mod_arg>.St
sub mod_internal__S_109ColoniParen_Thesis__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_109ColoniParen_Thesis', $retree) }
sub mod_internal__S_109ColoniParen_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_109ColoniParen_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:i\(\ \)";
$self->_MATCHIFYr($S, "mod_internal__S_109ColoniParen_Thesis", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_109ColoniParen_Thesis_0') {
$C->deb("Fate passed to mod_internal__S_109ColoniParen_Thesis_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_109ColoniParen_Thesis_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_109ColoniParen_Thesis_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_109ColoniParen_Thesis_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_109ColoniParen_Thesis_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:0i> { ':' (\d+) ['i'|'ignorecase'] { %*RX<i> = $0 } }
sub mod_internal__S_110Colon0i__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_110Colon0i', $retree) }
sub mod_internal__S_110Colon0i {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_110Colon0i");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:0i";
$self->_MATCHIFYr($S, "mod_internal__S_110Colon0i", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_110Colon0i_0') {
$C->deb("Fate passed to mod_internal__S_110Colon0i_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_110Colon0i_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_110Colon0i_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_110Colon0i_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_110Colon0i_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:m> { $<sym>=[':m'|':ignoremark'] » { %*RX<m> = 1 } }
sub mod_internal__S_111Colonm__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_111Colonm', $retree) }
sub mod_internal__S_111Colonm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_111Colonm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:m";
$self->_MATCHIFYr($S, "mod_internal__S_111Colonm", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_111Colonm_0') {
$C->deb("Fate passed to mod_internal__S_111Colonm_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_111Colonm_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_111Colonm_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_111Colonm_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_111Colonm_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:!m> { $<sym>=[':!m'|':!ignoremark'] » { %*RX<m> = 0 } }
sub mod_internal__S_112ColonBangm__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_112ColonBangm', $retree) }
sub mod_internal__S_112ColonBangm {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_112ColonBangm");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\!m";
$self->_MATCHIFYr($S, "mod_internal__S_112ColonBangm", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_112ColonBangm_0') {
$C->deb("Fate passed to mod_internal__S_112ColonBangm_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_112ColonBangm_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_112ColonBangm_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_112ColonBangm_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_112ColonBangm_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:m( )> { $<sym>=[':m'|':ignoremark'] <mod_arg> { %*RX<m> = eval $<mod_arg>.St
sub mod_internal__S_113ColonmParen_Thesis__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_113ColonmParen_Thesis', $retree) }
sub mod_internal__S_113ColonmParen_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_113ColonmParen_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:m\(\ \)";
$self->_MATCHIFYr($S, "mod_internal__S_113ColonmParen_Thesis", do {
my $C = $C;
if (($C) = ($C->_SUBSUMEr(['sym'], sub {
my $C = shift;
$C->_BRACKETr(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_113ColonmParen_Thesis_0') {
$C->deb("Fate passed to mod_internal__S_113ColonmParen_Thesis_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_113ColonmParen_Thesis_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_113ColonmParen_Thesis_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_113ColonmParen_Thesis_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_113ColonmParen_Thesis_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:0m> { ':' (\d+) ['m'|'ignoremark'] { %*RX<m> = $0 } }
sub mod_internal__S_114Colon0m__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_114Colon0m', $retree) }
sub mod_internal__S_114Colon0m {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_114Colon0m");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:0m";
$self->_MATCHIFYr($S, "mod_internal__S_114Colon0m", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_114Colon0m_0') {
$C->deb("Fate passed to mod_internal__S_114Colon0m_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_114Colon0m_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_114Colon0m_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_114Colon0m_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_114Colon0m_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:s> { ':s' 'igspace'? » { %*RX<s> = 1 } }
sub mod_internal__S_115Colons__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_115Colons', $retree) }
sub mod_internal__S_115Colons {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_115Colons");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:s";
$self->_MATCHIFYr($S, "mod_internal__S_115Colons", do {
if (my ($C) = ($C->_PATTERN(qr/\G\:s(?:igspace)?+\b/))) {
scalar(do {
$::RX{'s'} = 1 }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:!s> { ':!s' 'igspace'? » { %*RX<s> = 0 } }
sub mod_internal__S_116ColonBangs__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_116ColonBangs', $retree) }
sub mod_internal__S_116ColonBangs {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_116ColonBangs");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\!s";
$self->_MATCHIFYr($S, "mod_internal__S_116ColonBangs", do {
if (my ($C) = ($C->_PATTERN(qr/\G\:\!s(?:igspace)?+\b/))) {
scalar(do {
$::RX{'s'} = 0 }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:s( )> { ':s' 'igspace'? <mod_arg> { %*RX<s> = eval $<mod_arg>.Str } }
sub mod_internal__S_117ColonsParen_Thesis__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_117ColonsParen_Thesis', $retree) }
sub mod_internal__S_117ColonsParen_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_117ColonsParen_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:s\(\ \)";
$self->_MATCHIFYr($S, "mod_internal__S_117ColonsParen_Thesis", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G\:s(?:igspace)?+/))
and ($C) = ($C->_SUBSUMEr(['mod_arg'], sub {
my $C = shift;
$C->mod_arg
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:0s> { ':' (\d+) 's' 'igspace'? » { %*RX<s> = $0 } }
sub mod_internal__S_118Colon0s__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_118Colon0s', $retree) }
sub mod_internal__S_118Colon0s {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_118Colon0s");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:0s";
$self->_MATCHIFYr($S, "mod_internal__S_118Colon0s", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:r> { ':r' 'atchet'? » { %*RX<r> = 1 } }
sub mod_internal__S_119Colonr__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_119Colonr', $retree) }
sub mod_internal__S_119Colonr {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_119Colonr");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:r";
$self->_MATCHIFYr($S, "mod_internal__S_119Colonr", do {
if (my ($C) = ($C->_PATTERN(qr/\G\:r(?:atchet)?+\b/))) {
scalar(do {
$::RX{'r'} = 1 }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:!r> { ':!r' 'atchet'? » { %*RX<r> = 0 } }
sub mod_internal__S_120ColonBangr__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_120ColonBangr', $retree) }
sub mod_internal__S_120ColonBangr {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_120ColonBangr");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:\!r";
$self->_MATCHIFYr($S, "mod_internal__S_120ColonBangr", do {
if (my ($C) = ($C->_PATTERN(qr/\G\:\!r(?:atchet)?+\b/))) {
scalar(do {
$::RX{'r'} = 0 }, $C)
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:r( )> { ':r' 'atchet'? » <mod_arg> { %*RX<r> = eval $<mod_arg>.Str } }
sub mod_internal__S_121ColonrParen_Thesis__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_121ColonrParen_Thesis', $retree) }
sub mod_internal__S_121ColonrParen_Thesis {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_121ColonrParen_Thesis");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:r\(\ \)";
$self->_MATCHIFYr($S, "mod_internal__S_121ColonrParen_Thesis", do {
my $C = $C;
if (($C) = ($C->_PATTERN(qr/\G\:r(?:atchet)?+\b/))
and ($C) = ($C->_SUBSUMEr(['mod_arg'], sub {
my $C = shift;
$C->mod_arg
}))) {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:sym<:0r> { ':' (\d+) 'r' 'atchet'? » { %*RX<r> = $0 } }
sub mod_internal__S_122Colon0r__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_122Colon0r', $retree) }
sub mod_internal__S_122Colon0r {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_122Colon0r");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:0r";
$self->_MATCHIFYr($S, "mod_internal__S_122Colon0r", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
}))
and ($C) = ($C->_PATTERN(qr/\Gr(?:atchet)?+\b/))) {
scalar(do {
my $M = $C;
$::RX{'r'} = $M->{0} }, $C)
} else { () }
});
}
;
## token mod_internal:sym<:Perl5> { [':Perl5' | ':P5'] <.require_P5> [ :lang( $¢.cursor_fresh( %*LAN
sub mod_internal__S_123ColonPerl5__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_123ColonPerl5', $retree) }
sub mod_internal__S_123ColonPerl5 {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_123ColonPerl5");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:Perl5";
$self->_MATCHIFYr($S, "mod_internal__S_123ColonPerl5", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_123ColonPerl5_0') {
$C->deb("Fate passed to mod_internal__S_123ColonPerl5_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_123ColonPerl5_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_123ColonPerl5_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_123ColonPerl5_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_123ColonPerl5_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
)[$try])->($C);
last if @gather;
last if $xact->[-2]; # committed?
}
@gather;
};
}))
and ($C) = ($C->require_P5)
and ($C) = ($C->_BRACKETr(sub {
my $C=shift;
my $newlang = ( $C->cursor_fresh( $::LANG{'P5Regex'} )->unbalanced($::GOAL) );
$C = bless($C, (ref($newlang) || $newlang));
$C->_SUBSUMEr(['nibbler'], sub {
my $C = shift;
$C->nibbler
})
}))) {
$C
} else { () }
});
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:p6adv {
sub mod_internal__S_124p6adv__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_124p6adv', $retree) }
sub mod_internal__S_124p6adv {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_124p6adv");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "p6adv";
$self->_MATCHIFYr($S, "mod_internal__S_124p6adv", do {
my $C = $C;
if (($C) = ($C->before(sub {
my $C=shift;
if (my ($C) = ($C->before(sub {
my $C=shift;
do {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'mod_internal__S_124p6adv_0') {
$C->deb("Fate passed to mod_internal__S_124p6adv_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT mod_internal__S_124p6adv_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM mod_internal__S_124p6adv_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'mod_internal__S_124p6adv_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("mod_internal__S_124p6adv_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token mod_internal:oops { {} (':'\w+) <.sorry: "Unrecognized regex modifier " ~ $0.Str > }
sub mod_internal__S_125oops__PEEK { $_[0]->_AUTOLEXpeek('mod_internal__S_125oops', $retree) }
sub mod_internal__S_125oops {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE mod_internal__S_125oops");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "oops";
$self->_MATCHIFYr($S, "mod_internal__S_125oops", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
$C->_PAREN( sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<*> { <sym> <quantmod> }
sub quantifier__S_126Star__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_126Star', $retree) }
sub quantifier__S_126Star {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_126Star");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\*";
$self->_MATCHIFYr($S, "quantifier__S_126Star", do {
if (my ($C) = ($C->_EXACT("\*"))) {
$C->_SUBSUMEr(['quantmod'], sub {
my $C = shift;
$C->quantmod
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<+> { <sym> <quantmod> }
sub quantifier__S_127Plus__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_127Plus', $retree) }
sub quantifier__S_127Plus {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_127Plus");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\+";
$self->_MATCHIFYr($S, "quantifier__S_127Plus", do {
if (my ($C) = ($C->_EXACT("\+"))) {
$C->_SUBSUMEr(['quantmod'], sub {
my $C = shift;
$C->quantmod
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<?> { <sym> <quantmod> }
sub quantifier__S_128Question__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_128Question', $retree) }
sub quantifier__S_128Question {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_128Question");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\?";
$self->_MATCHIFYr($S, "quantifier__S_128Question", do {
if (my ($C) = ($C->_EXACT("\?"))) {
$C->_SUBSUMEr(['quantmod'], sub {
my $C = shift;
$C->quantmod
})
} else { () }
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<:> { <sym> {} <?before \s> }
sub quantifier__S_129Colon__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_129Colon', $retree) }
sub quantifier__S_129Colon {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_129Colon");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\:";
$self->_MATCHIFYr($S, "quantifier__S_129Colon", do {
my $C = $C;
if (($C) = ($C->_EXACT("\:"))
and ($C) = (scalar(do {
}, $C))
and ($C) = ($C->before(sub {
my $C=shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<**> { '**' :: <normspace>? <quantmod> <normspace>?
sub quantifier__S_130StarStar__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_130StarStar', $retree) }
sub quantifier__S_130StarStar {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_130StarStar");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'1'} = [];
$C->{'normspace'} = [];
$C->{sym} = "\*\*";
$self->_MATCHIFYr($S, "quantifier__S_130StarStar", do {
my $C = $C;
if (($C) = ($C->_EXACT("\*\*"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_OPTr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quantifier__S_130StarStar_0') {
$C->deb("Fate passed to quantifier__S_130StarStar_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quantifier__S_130StarStar_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quantifier__S_130StarStar_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'quantifier__S_130StarStar_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quantifier__S_130StarStar_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quantifier__S_130StarStar_1') {
$C->deb("Fate passed to quantifier__S_130StarStar_1: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quantifier__S_130StarStar_1'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quantifier__S_130StarStar_1'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'quantifier__S_130StarStar_1', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quantifier__S_130StarStar_1 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<~> {
sub quantifier__S_131Tilde__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_131Tilde', $retree) }
sub quantifier__S_131Tilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_131Tilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{'normspace'} = [];
$C->{'quantified_atom'} = [];
$C->{sym} = "\~";
$self->_MATCHIFYr($S, "quantifier__S_131Tilde", do {
my $C = $C;
if (($C) = ($C->_EXACT("\~"))
and ($C) = ($C->_COMMITLTM())
and ($C) = ($C->_OPTr(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<~~> {
sub quantifier__S_132TildeTilde__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_132TildeTilde', $retree) }
sub quantifier__S_132TildeTilde {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_132TildeTilde");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\~\~";
$self->_MATCHIFYr($S, "quantifier__S_132TildeTilde", do {
my $C = $C;
if (($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
my @try;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quantifier__S_132TildeTilde_0') {
$C->deb("Fate passed to quantifier__S_132TildeTilde_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quantifier__S_132TildeTilde_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quantifier__S_132TildeTilde_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'quantifier__S_132TildeTilde_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quantifier__S_132TildeTilde_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantmod { ':'? [ '?' | '!' | '+' ]? }
sub quantmod__PEEK { $_[0]->_AUTOLEXpeek('quantmod', $retree) }
sub quantmod {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantmod");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFYr($S, "quantmod", do {
if (my ($C) = ($C->_PATTERN(qr/\G\:?+/))) {
$C->_OPTr(sub {
my $C=shift;
if (my ($C) = ($C->_BRACKETr(sub {
my $C=shift;
do {
my ($tag, $try);
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $x;
if ($fate = $C->{'_fate'} and $fate->[1] eq 'quantmod_0') {
$C->deb("Fate passed to quantmod_0: ", ::fatestr($fate)) if $::DEBUG & DEBUG::fates;
($C->{'_fate'}, $tag, $try) = @$fate;
@try = ($try);
$x = 'ALT quantmod_0'; # some outer ltm is controlling us
}
else {
$x = 'ALTLTM quantmod_0'; # we are top level ltm
}
my $C = $C->cursor_xact($x);
my $xact = $C->{_xact};
my @gather = ();
for (;;) {
unless (@try) {
$relex //= $C->cursor_fate('STD::Regex', 'quantmod_0', $retree);
@try = $relex->($C) or last;
}
$try = shift(@try) // next;
if (ref $try) {
($C->{'_fate'}, $tag, $try) = @$try; # next candidate fate
}
$C->deb("quantmod_0 trying $tag $try") if $::DEBUG & DEBUG::try_processing;
push @gather, ((
share/P6STD/boot/STD.pmc view on Meta::CPAN
;
## token quantifier:sym<{N,M}> {
sub quantifier__S_133CurNCommaMLy__PEEK { $_[0]->_AUTOLEXpeek('quantifier__S_133CurNCommaMLy', $retree) }
sub quantifier__S_133CurNCommaMLy {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE quantifier__S_133CurNCommaMLy");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "\{N\,M\}";
$self->_MATCHIFYr($S, "quantifier__S_133CurNCommaMLy", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_EXACT("\{"))
and ($C) = ($C->_SUBSUMEr(['0'], sub {
my $C = shift;
share/P6STD/boot/STD.pmc view on Meta::CPAN
my $orig = shift;
no warnings 'recursion';
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{Perl5} || exists $args{P5};
my $P5 = exists $args{Perl5} ? delete $args{Perl5} : exists $args{P5} ? delete $args{P5} : undef;
$self->require_P5;
$self->cursor_fresh( $::LANG{'Q'} )->mixin( 'STD::Q::q' )->mixin( 'STD::Q::p5' ) ;
};
}
{
local @_ = @_;
return scalar do { # work around #38809
my $self = shift;
my %args = @_;
last unless exists $args{overlap} || exists $args{ov};
my $ov = exists $args{overlap} ? delete $args{overlap} : exists $args{ov} ? delete $args{ov} : undef;
$::RX{'ov'} = $ov;
share/P6STD/boot/STD.pmc view on Meta::CPAN
next unless $_ =~ m/(\$|\@|\%|\&)\w/;
next if $_ eq '$_' or $_ eq '@_' or $_ eq '%_';
next if $desc->{'used'};
next if $desc->{'rebind'};
next if $desc->{'dynamic'};
my $scope = $desc->{'scope'} // 'my';
next if $scope eq 'our';
next if $scope eq 'state';
next if $desc->{'stub'};
my $pos = $desc->{'declaredat'} // $self->{'_pos'};
$self->cursor($pos)->worry("$_ is declared but not used");
}
};
$self;
};
## method getdecl
sub getdecl {
no warnings 'recursion';
my $self = shift;
$self->{'decl'} = $::DECLARAND;
$self;
share/P6STD/boot/STD.pmc view on Meta::CPAN
$::CURLEX->{$varname}->{'used'} = 1;
$self;
};
## method check_variable ($variable)
sub check_variable {
no warnings 'recursion';
my $self = shift;
die 'Required argument variable omitted' unless @_;
my $variable = @_ ? shift() : undef;
my $name = $variable->Str;
my $here = $self->cursor($variable->from);
$self->deb("check_variable $name") if $::DEBUG & DEBUG::symtab;
my ($sigil, $twigil, $first)= $name =~ /(\$|\@|\%|\&)(\W*)(.?)/;
($first,$twigil) = ($twigil, '') if $first eq '';
given ($twigil) {
when ('') {
my $ok = 0;
$ok ||= $::IN_DECL;
$ok ||= $first lt 'A';
$ok ||= $first eq '¢';
$ok ||= $self->is_known($name);
share/P6STD/boot/STD.pmc view on Meta::CPAN
no warnings 'recursion';
my $self = shift;
die 'Required argument s omitted' unless @_;
my $s = @_ ? shift() : undef;
die "Recursive panic" if $::IN_PANIC;
$::IN_PANIC++;
$self->deb("panic $s") if $::DEBUG;
my $m;
my $here = $self;
my $highvalid = $self->{'_pos'} <= $::HIGHWATER;
$here = $self->cursor($::HIGHWATER) if $highvalid;
my $first = $here->lineof($::LAST_NIBBLE->from);
my $last = $here->lineof($::LAST_NIBBLE->{'_pos'});
if ($first != $last) {
if ($here->lineof($here->{'_pos'}) == $last) {
$m .= "(Possible runaway string from line $first)\n"}
else {
$first = $here->lineof($::LAST_NIBBLE_MULTILINE->from);
$last = $here->lineof($::LAST_NIBBLE_MULTILINE->{'_pos'});
if ($here->lineof($here->{'_pos'}) - $last < $last - $first) {
$m .= "(Possible runaway string from line $first to line $last)\n"};
share/P6STD/boot/STD.pmc view on Meta::CPAN
my @t = $here->suppose( sub {
$here->term } );
if (@t) {
my $endpos = $here->{'_pos'};
my $startpos = $::MEMOS[$endpos]->{'ws'} // $endpos;
if ($self->lineof($startpos) != $self->lineof($endpos)) {
$m =~ s|Confused|Two terms in a row (previous line missing its semicolon?)|}
elsif ($::MEMOS[$startpos]->{'listop'}) {
$m =~ s|Confused|Two terms in a row (listop with args requires whitespace or parens)|}
elsif ($::MEMOS[$startpos]->{'baremeth'}) {
$here = $here->cursor($startpos);
$m =~ s|Confused|Two terms in a row (method call with args requires colon or parens without whitespace)|;
}
elsif ($::MEMOS[$startpos]->{'arraycomp'}) {
$m =~ s|Confused|Two terms in a row (preceding is not a valid reduce operator)|}
else {
$m =~ s|Confused|Two terms in a row|};
}
elsif (my $type = $::MEMOS[$here->{'_pos'} - 1]->{'nodecl'}) {
my @t = $here->suppose( sub {
$here->variable } );
share/P6STD/boot/STD.pmc view on Meta::CPAN
};
## regex is_ok {
sub is_ok__PEEK { $_[0]->_AUTOLEXpeek('is_ok', $retree) }
sub is_ok {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE is_ok");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$self->_MATCHIFY($S, "is_ok", LazyMap::lazymap(sub {
my $C=shift;
if (my ($C) = ($C->_EXACT("\#OK"))) {
LazyMap::lazymap(sub {
my $C=shift;
LazyMap::lazymap(sub {
my $C=shift;
LazyMap::lazymap(sub {
share/P6STD/boot/STD.pmc view on Meta::CPAN
$self->panic("Preceding context expects a term, but found infix $bad instead")};
## token term:sym<miscbad> {
sub term__S_063miscbad__PEEK { $_[0]->_AUTOLEXpeek('term__S_063miscbad', $retree) }
sub term__S_063miscbad {
no warnings 'recursion';
my $self = shift;
local $::CTX = $self->callm() if $::DEBUG & DEBUG::trace_call;
my $C = $self->cursor_xact("RULE term__S_063miscbad");
my $xact = $C->xact;
my $S = $C->{'_pos'};
$C->{sym} = "miscbad";
$self->_MATCHIFYr($S, "term__S_063miscbad", do {
my $C = $C;
if (($C) = (scalar(do {
}, $C))
and ($C) = ($C->_NOTBEFORE(sub {
my $C=shift;
(($C) x !!do {
share/P6STD/lib/DEBUG.pm6 view on Meta::CPAN
my module DEBUG;
constant autolexer is export = 1;
constant symtab is export = 2;
constant fixed_length is export = 4;
constant fates is export = 8;
constant longest_token_pattern_generation is export = 16;
constant EXPR is export = 32;
constant matchers is export = 64;
constant trace_call is export = 128;
constant cursors is export = 256;
constant try_processing is export = 1024;
constant mixins is export = 2048;
constant callm_show_subnames is export = 16384;
constant use_color is export = 32768;
share/P6STD/viv view on Meta::CPAN
}
$::PROTOSIG->{$name} = ($self->kids("signature"))[0];
<<EOT;
sub ${name}__PEEK { \$_[0]->_AUTOLEXpeek('$name:*',\$retree); }
sub $name {
my \$self = shift;
my \$subs;
local \$::CTX = \$self->callm() if \$::DEBUG & DEBUG::trace_call;
my \$C = \$self->cursor_xact('RULE $name');
my \$S = \$C->{'_pos'};
my \@result = do {
my (\$tag, \$try);
my \@try;
my \$relex;
my \$x;
if (my \$fate = \$C->{'_fate'}) {
if (\$fate->[1] eq '$name') {
\$C->deb("Fate passed to $name: ", ::fatestr(\$fate)) if \$::DEBUG & DEBUG::fates;
share/P6STD/viv view on Meta::CPAN
\@try = (\$try);
\$x = 'ALT $name';
}
else {
\$x = 'ALTLTM $name';
}
}
else {
\$x = 'ALTLTM $name';
}
my \$C = \$C->cursor_xact(\$x);
my \$xact = \$C->{_xact};
my \@gather = ();
for (;;) {
unless (\@try) {
\$relex //= \$C->cursor_fate('$::PKG', '$name:*', \$retree);
\@try = \$relex->(\$C) or last;
}
\$try = shift(\@try) // next;
if (ref \$try) {
(\$C->{'_fate'}, \$tag, \$try) = \@\$try; # next candidate fate
}
\$C->deb("$name trying \$tag \$try") if \$::DEBUG & DEBUG::try_processing;
push \@gather, \$C->\$try(\@_);
share/P6STD/viv view on Meta::CPAN
my \$self = shift;
IHDR
. ($::NEEDORIGARGS ? " my \@origargs = \@_;\n" : "")
. ::indent($defsig || $spcsig, 1)
. ::indent(join("", @::DECL), 1)
. <<TEXT
local \$::CTX = \$self->callm() if \$::DEBUG & DEBUG::trace_call;
my \$C = \$self->cursor_xact("RULE $p5name");
my \$xact = \$C->xact;
my \$S = \$C->{'_pos'};
TEXT
. join("", map { "\$C->{'$_'} = [];\n" }
grep { $::BINDINGS{$_} > 1 }
sort keys %::BINDINGS)
. ($::SYM ? '$C->{sym} = "' . ::rd($::SYM) . "\";\n" : '')
. <<END
\$self->_MATCHIFY$ratchet(\$S, "$p5name", ${\ $body->p5expr });
END
share/P6STD/viv view on Meta::CPAN
my \$x;
if (\$fate = \$C->{'_fate'} and \$fate->[1] eq '$altname') {
\$C->deb("Fate passed to $altname: ", ::fatestr(\$fate)) if \$::DEBUG & DEBUG::fates;
(\$C->{'_fate'}, \$tag, \$try) = \@\$fate;
\@try = (\$try);
\$x = 'ALT $altname'; # some outer ltm is controlling us
}
else {
\$x = 'ALTLTM $altname'; # we are top level ltm
}
my \$C = \$C->cursor_xact(\$x);
my \$xact = \$C->{_xact};
my \@gather = ();
for (;;) {
unless (\@try) {
\$relex //= \$C->cursor_fate('$::PKG', '$altname', \$retree);
\@try = \$relex->(\$C) or last;
}
\$try = shift(\@try) // next;
if (ref \$try) {
(\$C->{'_fate'}, \$tag, \$try) = \@\$try; # next candidate fate
}
\$C->deb("$altname trying \$tag \$try") if \$::DEBUG & DEBUG::try_processing;
push \@gather, ((
share/P6STD/viv view on Meta::CPAN
%::BINDINGS = %B;
}
if (@result == 1) {
DEEP::raw($result[0]);
}
else {
die("Cannot reverse serial disjunction") if $::REV;
for (@result) { $_ = "do {\n" . ::indent("push \@gather, $_\n") . "}"; }
# We need to force the scope here because of the my $C
my $result = "do {" . ::indent(
"my \$C = \$C->cursor_xact('ALT ||');\n" .
"my \$xact = \$C->xact;\nmy \@gather;\n" .
join("\nor \$xact->[-2] or\n", @result) . ";\n" .
"\@gather;\n") . "}";
DEEP::raw($result);
}
}
sub kids { my $self = shift; map { \$_ } @{$self->{zyg}} }
sub remove_leading_ws {
share/P6STD/viv view on Meta::CPAN
}
else {
my $al = $self->{rest} // '';
$re = <<"END";
do {
if (not $name) {
\$C;
}
elsif (ref $name eq 'Regexp') {
if (\$::ORIG =~ m/$name/gc) {
\$C->cursor(\$+[0]);
}
else {
();
}
}
else {
\$C->$name$al;
}
}
END
share/P6STD/viv view on Meta::CPAN
if ($text =~ /^(\\[A-Z])(.*)/) {
$text = lc($1) . $2;
$not = 1;
}
# to return yourself, you must either be a symbol or handle $not
if ($text eq '.') {
if ($::REV) {
return DEEP::p5regex("(?<=(?s:.)");
}
else {
$code = "\$C->cursor_incr()";
}
}
elsif ($text eq '.*') {
$code = "\$C->_SCANg$::REV()";
$bt = 1;
}
elsif ($text eq '.*?') {
$code = "\$C->_SCANf$::REV()";
$bt = 1;
}
share/PerlCritic/Critic/Policy/ErrorHandling/RequireCheckingReturnValueOfEval.pm view on Meta::CPAN
}
return;
}
sub _is_in_correct_position_in_a_structure_condition {
my ($elem, $parent, $following) = @_;
my $level = $elem;
while ($level and refaddr $level != $parent) {
my $cursor = refaddr $elem == refaddr $level ? $following : $level;
IS_FINAL_EXPRESSION_AT_DEPTH:
while ($cursor) {
if ( _is_effectively_a_comma($cursor) ) {
$cursor = $cursor->snext_sibling();
while ( _is_effectively_a_comma($cursor) ) {
$cursor = $cursor->snext_sibling();
}
# Semicolon would be a syntax error here.
return if $cursor;
last IS_FINAL_EXPRESSION_AT_DEPTH;
}
$cursor = $cursor->snext_sibling();
}
my $statement = $level->parent();
return $TRUE if not $statement; # Shouldn't happen.
return $TRUE if not $statement->isa('PPI::Statement'); # Shouldn't happen.
$level = $statement->parent();
if (
not $level
or (
share/PerlCritic/Critic/Policy/ErrorHandling/RequireCheckingReturnValueOfEval.pm view on Meta::CPAN
# Shouldn't happen.
return $TRUE;
}
}
return $TRUE;
}
# Replace with PPI implementation once it is released.
sub _descendant_of {
my ($cursor, $potential_ancestor) = @_;
return $EMPTY if not $potential_ancestor;
while ( refaddr $cursor != refaddr $potential_ancestor ) {
$cursor = $cursor->parent() or return $EMPTY;
}
return 1;
}
#-----------------------------------------------------------------------------
sub _is_in_postfix_expression {
my ($elem) = @_;
share/SpamAssassin/easy_ham/00002.9c4069e25e1ef370c078db7ee85ff9ac view on Meta::CPAN
From Steve_Burt@cursor-system.com Thu Aug 22 12:46:39 2002
Return-Path: <Steve_Burt@cursor-system.com>
Delivered-To: zzzz@localhost.netnoteinc.com
Received: from localhost (localhost [127.0.0.1])
by phobos.labs.netnoteinc.com (Postfix) with ESMTP id BE12E43C34
for <zzzz@localhost>; Thu, 22 Aug 2002 07:46:38 -0400 (EDT)
Received: from phobos [127.0.0.1]
by localhost with IMAP (fetchmail-5.9.0)
for zzzz@localhost (single-drop); Thu, 22 Aug 2002 12:46:38 +0100 (IST)
Received: from n20.grp.scd.yahoo.com (n20.grp.scd.yahoo.com
[66.218.66.76]) by dogma.slashnull.org (8.11.6/8.11.6) with SMTP id
g7MBkTZ05087 for <zzzz@spamassassin.taint.org>; Thu, 22 Aug 2002 12:46:29 +0100
X-Egroups-Return: sentto-2242572-52726-1030016790-zzzz=spamassassin.taint.org@returns.groups.yahoo.com
Received: from [66.218.67.196] by n20.grp.scd.yahoo.com with NNFMP;
22 Aug 2002 11:46:30 -0000
X-Sender: steve.burt@cursor-system.com
X-Apparently-To: zzzzteana@yahoogroups.com
Received: (EGP: mail-8_1_0_1); 22 Aug 2002 11:46:29 -0000
Received: (qmail 11764 invoked from network); 22 Aug 2002 11:46:29 -0000
Received: from unknown (66.218.66.217) by m3.grp.scd.yahoo.com with QMQP;
22 Aug 2002 11:46:29 -0000
Received: from unknown (HELO mailgateway.cursor-system.com) (62.189.7.27)
by mta2.grp.scd.yahoo.com with SMTP; 22 Aug 2002 11:46:29 -0000
Received: from exchange1.cps.local (unverified) by
mailgateway.cursor-system.com (Content Technologies SMTPRS 4.2.10) with
ESMTP id <T5cde81f695ac1d100407d@mailgateway.cursor-system.com> for
<forteana@yahoogroups.com>; Thu, 22 Aug 2002 13:14:10 +0100
Received: by exchange1.cps.local with Internet Mail Service (5.5.2653.19)
id <PXX6AT23>; Thu, 22 Aug 2002 12:46:27 +0100
Message-Id: <5EC2AD6D2314D14FB64BDA287D25D9EF12B4F6@exchange1.cps.local>
To: "'zzzzteana@yahoogroups.com'" <zzzzteana@yahoogroups.com>
X-Mailer: Internet Mail Service (5.5.2653.19)
X-Egroups-From: Steve Burt <steve.burt@cursor-system.com>
From: Steve Burt <Steve_Burt@cursor-system.com>
X-Yahoo-Profile: pyruse
MIME-Version: 1.0
Mailing-List: list zzzzteana@yahoogroups.com; contact
forteana-owner@yahoogroups.com
Delivered-To: mailing list zzzzteana@yahoogroups.com
Precedence: bulk
List-Unsubscribe: <mailto:zzzzteana-unsubscribe@yahoogroups.com>
Date: Thu, 22 Aug 2002 12:46:18 +0100
Subject: [zzzzteana] RE: Alexander
Reply-To: zzzzteana@yahoogroups.com
share/SpamAssassin/easy_ham/00174.ea47d0c060fa8ce10dfb448db1f27be8 view on Meta::CPAN
comprehensive
http://www.meteoros.de/indexe.htm
Atmospheric Light Phenomena
http://www.auf.asn.au/meteorology/section12.html
interesting observational stuff from the prior millenium including pix
(click 1997 / colour plates)
http://www.ursa.fi/ursa/jaostot/halot/ehp/index.html
more pix, many of which flip to negative to highlight details (hover cursor)
http://idefix.taide.turkuamk.fi/~iluukkon/taivas/valok/88.html and
subsequent links
john k
------------------------ Yahoo! Groups Sponsor ---------------------~-->
4 DVDs Free +s&p Join Now
http://us.click.yahoo.com/pt6YBB/NXiEAA/MVfIAA/7gSolB/TM
---------------------------------------------------------------------~->
share/SpamAssassin/easy_ham/00188.f416128c8a1bc74ac615e5bdf7ae0172 view on Meta::CPAN
From Steve_Burt@cursor-system.com Wed Aug 28 10:55:32 2002
Return-Path: <Steve_Burt@cursor-system.com>
Delivered-To: zzzz@localhost.netnoteinc.com
Received: from localhost (localhost [127.0.0.1])
by phobos.labs.netnoteinc.com (Postfix) with ESMTP id 876C943F99
for <zzzz@localhost>; Wed, 28 Aug 2002 05:55:27 -0400 (EDT)
Received: from phobos [127.0.0.1]
by localhost with IMAP (fetchmail-5.9.0)
for zzzz@localhost (single-drop); Wed, 28 Aug 2002 10:55:27 +0100 (IST)
Received: from n17.grp.scd.yahoo.com (n17.grp.scd.yahoo.com
[66.218.66.72]) by dogma.slashnull.org (8.11.6/8.11.6) with SMTP id
g7S9gNZ18555 for <zzzz@spamassassin.taint.org>; Wed, 28 Aug 2002 10:42:23 +0100
X-Egroups-Return: sentto-2242572-53141-1030527749-zzzz=spamassassin.taint.org@returns.groups.yahoo.com
Received: from [66.218.67.193] by n17.grp.scd.yahoo.com with NNFMP;
28 Aug 2002 09:42:29 -0000
X-Sender: steve.burt@cursor-system.com
X-Apparently-To: zzzzteana@yahoogroups.com
Received: (EGP: mail-8_1_0_1); 28 Aug 2002 09:42:28 -0000
Received: (qmail 83424 invoked from network); 28 Aug 2002 09:42:27 -0000
Received: from unknown (66.218.66.217) by m11.grp.scd.yahoo.com with QMQP;
28 Aug 2002 09:42:27 -0000
Received: from unknown (HELO mailgateway.cursor-system.com) (62.189.7.27)
by mta2.grp.scd.yahoo.com with SMTP; 28 Aug 2002 09:42:27 -0000
Received: from exchange1.cps.local (unverified) by
mailgateway.cursor-system.com (Content Technologies SMTPRS 4.2.10) with
ESMTP id <T5cfcde4e3fac1d1004129@mailgateway.cursor-system.com> for
<forteana@yahoogroups.com>; Wed, 28 Aug 2002 10:43:38 +0100
Received: by exchange1.cps.local with Internet Mail Service (5.5.2653.19)
id <PXX6AZC6>; Wed, 28 Aug 2002 10:42:26 +0100
Message-Id: <5EC2AD6D2314D14FB64BDA287D25D9EF12B50F@exchange1.cps.local>
To: "'zzzzteana@yahoogroups.com'" <zzzzteana@yahoogroups.com>
X-Mailer: Internet Mail Service (5.5.2653.19)
X-Egroups-From: Steve Burt <steve.burt@cursor-system.com>
From: Steve Burt <Steve_Burt@cursor-system.com>
X-Yahoo-Profile: pyruse
MIME-Version: 1.0
Mailing-List: list zzzzteana@yahoogroups.com; contact
forteana-owner@yahoogroups.com
Delivered-To: mailing list zzzzteana@yahoogroups.com
Precedence: bulk
List-Unsubscribe: <mailto:zzzzteana-unsubscribe@yahoogroups.com>
Date: Wed, 28 Aug 2002 10:42:25 +0100
Subject: RE: [zzzzteana] Digest Number 2453
Reply-To: zzzzteana@yahoogroups.com
share/SpamAssassin/easy_ham/00226.b629152d594cf90a252b1f45dce90a65 view on Meta::CPAN
From Steve_Burt@cursor-system.com Wed Aug 28 12:02:23 2002
Return-Path: <Steve_Burt@cursor-system.com>
Delivered-To: zzzz@localhost.netnoteinc.com
Received: from localhost (localhost [127.0.0.1])
by phobos.labs.netnoteinc.com (Postfix) with ESMTP id 928E843F9B
for <zzzz@localhost>; Wed, 28 Aug 2002 07:02:22 -0400 (EDT)
Received: from phobos [127.0.0.1]
by localhost with IMAP (fetchmail-5.9.0)
for zzzz@localhost (single-drop); Wed, 28 Aug 2002 12:02:22 +0100 (IST)
Received: from n24.grp.scd.yahoo.com (n24.grp.scd.yahoo.com
[66.218.66.80]) by dogma.slashnull.org (8.11.6/8.11.6) with SMTP id
g7SB3PZ21257 for <zzzz@spamassassin.taint.org>; Wed, 28 Aug 2002 12:03:25 +0100
X-Egroups-Return: sentto-2242572-53149-1030532611-zzzz=spamassassin.taint.org@returns.groups.yahoo.com
Received: from [66.218.67.195] by n24.grp.scd.yahoo.com with NNFMP;
28 Aug 2002 11:03:31 -0000
X-Sender: steve.burt@cursor-system.com
X-Apparently-To: zzzzteana@yahoogroups.com
Received: (EGP: mail-8_1_0_1); 28 Aug 2002 11:03:31 -0000
Received: (qmail 72439 invoked from network); 28 Aug 2002 11:03:30 -0000
Received: from unknown (66.218.66.218) by m2.grp.scd.yahoo.com with QMQP;
28 Aug 2002 11:03:30 -0000
Received: from unknown (HELO mailgateway.cursor-system.com) (62.189.7.27)
by mta3.grp.scd.yahoo.com with SMTP; 28 Aug 2002 11:03:30 -0000
Received: from exchange1.cps.local (unverified) by
mailgateway.cursor-system.com (Content Technologies SMTPRS 4.2.10) with
ESMTP id <T5cfd28840dac1d1004129@mailgateway.cursor-system.com> for
<forteana@yahoogroups.com>; Wed, 28 Aug 2002 12:04:42 +0100
Received: by exchange1.cps.local with Internet Mail Service (5.5.2653.19)
id <PXX6AZHS>; Wed, 28 Aug 2002 12:03:29 +0100
Message-Id: <5EC2AD6D2314D14FB64BDA287D25D9EF12B510@exchange1.cps.local>
To: "'zzzzteana@yahoogroups.com'" <zzzzteana@yahoogroups.com>
X-Mailer: Internet Mail Service (5.5.2653.19)
X-Egroups-From: Steve Burt <steve.burt@cursor-system.com>
From: Steve Burt <Steve_Burt@cursor-system.com>
X-Yahoo-Profile: pyruse
MIME-Version: 1.0
Mailing-List: list zzzzteana@yahoogroups.com; contact
forteana-owner@yahoogroups.com
Delivered-To: mailing list zzzzteana@yahoogroups.com
Precedence: bulk
List-Unsubscribe: <mailto:zzzzteana-unsubscribe@yahoogroups.com>
Date: Wed, 28 Aug 2002 12:03:28 +0100
Subject: [zzzzteana] RE:Pictish
Reply-To: zzzzteana@yahoogroups.com
share/SpamAssassin/easy_ham/00670.be029e37187b8615a231865e3663dcf9 view on Meta::CPAN
However, this campaign need not be sequential to be effective, the
cumulative effect across all regions will help achieve the results we
seek.
We will disrupt and destroy terrorist organizations by:
* direct and continuous action using all the elements of national and
international power. Our immediate focus will be those terrorist
organizations of global reach and any terrorist or state sponsor of
terrorism which attempts to gain or use weapons of mass destruction
(WMD) or their precursors;
* defending the United States, the American people, and our interests
at home and abroad by identifying and destroying the threat before it
reaches our borders. While the United States will constantly strive to
enlist the support of the international community, we will not hesitate
to act alone, if necessary, to exercise our right of self-defense by
acting preemptively against such terrorists, to prevent them from doing
harm against our people and our country; and
* denying further sponsorship, support, and sanctuary to terrorists
share/SpamAssassin/easy_ham/00677.b957e34b4dd0d9263b56bf71b1168d8a view on Meta::CPAN
> However, this campaign need not be sequential to be effective, the
> cumulative effect across all regions will help achieve the results we
> seek.
>
> We will disrupt and destroy terrorist organizations by:
>
> * direct and continuous action using all the elements of national and
> international power. Our immediate focus will be those terrorist
> organizations of global reach and any terrorist or state sponsor of
> terrorism which attempts to gain or use weapons of mass destruction
> (WMD) or their precursors;
>
> * defending the United States, the American people, and our interests
> at home and abroad by identifying and destroying the threat before it
> reaches our borders. While the United States will constantly strive to
> enlist the support of the international community, we will not hesitate
> to act alone, if necessary, to exercise our right of self-defense by
> acting preemptively against such terrorists, to prevent them from doing
> harm against our people and our country; and
>
> * denying further sponsorship, support, and sanctuary to terrorists
share/SpamAssassin/easy_ham/01006.4a648f164dd2f6076f59272ea14c3c03 view on Meta::CPAN
List-Id: Discussion list for EXMH users <exmh-users.spamassassin.taint.org>
List-Unsubscribe: <https://listman.spamassassin.taint.org/mailman/listinfo/exmh-users>,
<mailto:exmh-users-request@redhat.com?subject=unsubscribe>
List-Archive: <https://listman.spamassassin.taint.org/mailman/private/exmh-users/>
Date: Thu, 12 Sep 2002 12:19:29 +0000
I am a (tv)twm user. when I snarf text into my mouse cut buffer, and then
attempt to inject it into the exmh input windows for comp/repl, the 'point'
is often an apparently random place in the text pane, not where I think I
have current flashing cursor.
I usually wipe out any of To:/Subject:/<random body> with the text. Its
often not even beginning of line denoted, ie its an unexplicable number
of char spaces in to the text where it inserts,
What am I doing wrong in either X, WM, shell, EXMH which is causing this?
cheers
-George
share/SpamAssassin/easy_ham/01007.69e228a20df371852b13376f64d01002 view on Meta::CPAN
The middle click sets the insert point. If you hate that, go to the
Bindings... Simple Edit preferences window and de-select
"Paste Sets Insert".
>>>George Michaelson said:
>
> I am a (tv)twm user. when I snarf text into my mouse cut buffer, and then
> attempt to inject it into the exmh input windows for comp/repl, the
'point'
> is often an apparently random place in the text pane, not where I think I
> have current flashing cursor.
>
> I usually wipe out any of To:/Subject:/<random body> with the text. Its
> often not even beginning of line denoted, ie its an unexplicable number
> of char spaces in to the text where it inserts,
>
> What am I doing wrong in either X, WM, shell, EXMH which is causing this?
--
Brent Welch
Software Architect, Panasas Inc
share/SpamAssassin/easy_ham/01925.bf3c999d8afa02dda7e5cbadb2590c56 view on Meta::CPAN
From: diveintomark <rssfeeds@spamassassin.taint.org>
Subject: Maps
Date: Thu, 26 Sep 2002 15:11:23 -0000
Content-Type: text/plain; encoding=utf-8
URL: http://diveintomark.org/archives/2002/09/25.html#maps
Date: 2002-09-25T10:45:15-05:00
_Mark Tosczak_: A New Way to Read, Not See, Maps[1]. “The map-navigation
software, dubbed Blind Audio Tactile Mapping System ... takes digital map
information and provides nonvisual feedback as a user moves a cursor across the
map.”
[1] http://www.wired.com/news/school/0,1383,54916,00.html
share/SpamAssassin/easy_ham/02192.41f1b8c296ad29aad5d34d66834cb265 view on Meta::CPAN
Message-Id: <200210020801.g9281LK31730@dogma.slashnull.org>
To: yyyy@spamassassin.taint.org
From: boingboing <rssfeeds@spamassassin.taint.org>
Subject: Distributed.net cracks the RC5-64 cipher
Date: Wed, 02 Oct 2002 08:01:20 -0000
Content-Type: text/plain; encoding=utf-8
URL: http://boingboing.net/#85512053
Date: Not supplied
The Distributed.net project -- a precursor to SETI@Home that used volunteer
computer-time to attack giant, sophisticated ciphers -- has cracked RC564. I
used to have half a dozen computers working on this.
On 14-Jul-2002, a relatively characterless PIII-450 in Tokyo returned the
winning key to the distributed.net keyservers. The key 0x63DE7DC154F4D039
produces the plaintext output:
The unknown message is: some things are better left unread
Unfortunately, due to breakage in scripts (dbaker's fault, naturally) on
share/SpamAssassin/easy_ham_2/00001.1a31cc283af0060967a233d26548a6ce view on Meta::CPAN
"PickInner {exec pick +inbox -list} {4852 -sequence mercury}"
("uplevel" body line 1)
invoked from within
"uplevel #0 $cmd"
(procedure "busyCursorInner" line 8)
invoked from within
"busyCursorInner $cmd $widgets"
(procedure "busyCursorHack" line 32)
invoked from within
"busyCursorHack $args"
("cursor" arm line 1)
invoked from within
"switch $busy(style) {
icon {busyIcon $args}
cursorAll {busyCursor $args}
cursor {busyCursorHack $args}
default {eval $args}
}"
(procedure "busy" line 3)
invoked from within
"busy PickInner $cmd $msgs"
(procedure "Pick_It" line 51)
invoked from within
"Pick_It"
invoked from within
".pick.but.pick invoke"
share/SpamAssassin/easy_ham_2/00004.b2ed6c3c62bbdfab7683d60e214d1445 view on Meta::CPAN
> "PickInner {exec pick +inbox -list} {4852 -sequence mercury}"
> ("uplevel" body line 1)
> invoked from within
> "uplevel #0 $cmd"
> (procedure "busyCursorInner" line 8)
> invoked from within
> "busyCursorInner $cmd $widgets"
> (procedure "busyCursorHack" line 32)
> invoked from within
> "busyCursorHack $args"
> ("cursor" arm line 1)
> invoked from within
> "switch $busy(style) {
> icon {busyIcon $args}
> cursorAll {busyCursor $args}
> cursor {busyCursorHack $args}
> default {eval $args}
> }"
> (procedure "busy" line 3)
> invoked from within
> "busy PickInner $cmd $msgs"
> (procedure "Pick_It" line 51)
> invoked from within
> "Pick_It"
> invoked from within
> ".pick.but.pick invoke"
share/SpamAssassin/easy_ham_2/00006.654c4ec7c059531accf388a807064363 view on Meta::CPAN
> > "PickInner {exec pick +inbox -list} {4852 -sequence mercury}"
> > ("uplevel" body line 1)
> > invoked from within
> > "uplevel #0 $cmd"
> > (procedure "busyCursorInner" line 8)
> > invoked from within
> > "busyCursorInner $cmd $widgets"
> > (procedure "busyCursorHack" line 32)
> > invoked from within
> > "busyCursorHack $args"
> > ("cursor" arm line 1)
> > invoked from within
> > "switch $busy(style) {
> > icon {busyIcon $args}
> > cursorAll {busyCursor $args}
> > cursor {busyCursorHack $args}
> > default {eval $args}
> > }"
> > (procedure "busy" line 3)
> > invoked from within
> > "busy PickInner $cmd $msgs"
> > (procedure "Pick_It" line 51)
> > invoked from within
> > "Pick_It"
> > invoked from within
> > ".pick.but.pick invoke"
share/SpamAssassin/easy_ham_2/00008.6b73027e1e56131377941ff1db17ff12 view on Meta::CPAN
> > > "PickInner {exec pick +inbox -list} {4852 -sequence mercury}"
> > > ("uplevel" body line 1)
> > > invoked from within
> > > "uplevel #0 $cmd"
> > > (procedure "busyCursorInner" line 8)
> > > invoked from within
> > > "busyCursorInner $cmd $widgets"
> > > (procedure "busyCursorHack" line 32)
> > > invoked from within
> > > "busyCursorHack $args"
> > > ("cursor" arm line 1)
> > > invoked from within
> > > "switch $busy(style) {
> > > icon {busyIcon $args}
> > > cursorAll {busyCursor $args}
> > > cursor {busyCursorHack $args}
> > > default {eval $args}
> > > }"
> > > (procedure "busy" line 3)
> > > invoked from within
> > > "busy PickInner $cmd $msgs"
> > > (procedure "Pick_It" line 51)
> > > invoked from within
> > > "Pick_It"
> > > invoked from within
> > > ".pick.but.pick invoke"
share/SpamAssassin/easy_ham_2/01108.29f8f564902b3f0e5f19d1a5fa49b74d view on Meta::CPAN
Experts Scale Back Estimates of World Population Growth
By BARBARA CROSSETTE
Demography has never been an exact science. Ever since social thinkers
began trying to predict the pace of population growth a century or two ago,
the people being counted have been surprising the experts and confounding
projections. Today, it is happening again as stunned demographers watch
birthrates plunge in ways they never expected.
Only a few years ago, some experts argued that economic development and
education for women were necessary precursors for declines in population
growth. Today, village women and slum families in some of the poorest
countries are beginning to prove them wrong, as fertility rates drop faster
than predicted toward the replacement level - 2.1 children for the average
mother, one baby to replace each parent, plus a fraction to compensate for
unexpected deaths in the overall population.
A few decades ago in certain countries like Brazil, Egypt, India and Mexico
fertility rates were as high as five or six.
As a result, United Nations demographers who once predicted the earth's
share/SpamAssassin/easy_ham_subset/00677.b957e34b4dd0d9263b56bf71b1168d8a view on Meta::CPAN
> However, this campaign need not be sequential to be effective, the
> cumulative effect across all regions will help achieve the results we
> seek.
>
> We will disrupt and destroy terrorist organizations by:
>
> * direct and continuous action using all the elements of national and
> international power. Our immediate focus will be those terrorist
> organizations of global reach and any terrorist or state sponsor of
> terrorism which attempts to gain or use weapons of mass destruction
> (WMD) or their precursors;
>
> * defending the United States, the American people, and our interests
> at home and abroad by identifying and destroying the threat before it
> reaches our borders. While the United States will constantly strive to
> enlist the support of the international community, we will not hesitate
> to act alone, if necessary, to exercise our right of self-defense by
> acting preemptively against such terrorists, to prevent them from doing
> harm against our people and our country; and
>
> * denying further sponsorship, support, and sanctuary to terrorists
share/SpamAssassin/spam/0153.eddc658b08a04641a2494ba6b6eb0a3c view on Meta::CPAN
font-family: Verdana, Tahoma, sans-serif;
font-weight: bold;
}
#selected {
color: #F5989D;
text-decoration: none;
}
clicker {cursor: hand}
a {color: white; text-decoration: none;}
//-->
</style>
</head>
<body leftmargin=3D10 topmargin=3D15 marginwidth=3D10 marginheight=3D15>
share/SpamAssassin/spam/0224.486269968d3ad880a016b600dc366393 view on Meta::CPAN
font-family: Verdana, Tahoma, sans-serif;
font-weight: bold;
}
#selected {
color: #F5989D;
text-decoration: none;
}
clicker {cursor: hand}
a {color: white; text-decoration: none;}
//-->
</style>
</head>
<body leftmargin=3D10 topmargin=3D15 marginwidth=3D10 marginheight=3D15>
share/SpamAssassin/spam/0500.2e8762b67913d1b07bc8da293448d27f view on Meta::CPAN
**GENTLE FEROCITY (tm)**
***************************
Heaven-Sent "Viripotent" Energization, Appetite Suppression Tablets without the inclusion of Caffeine or MaHaung Herb or Ephedrine!
* NO jitters.
* NO inability to sleep at bedtime.
* NO strung-out feeling!
A non-caffeine, non-ephedrine, non-ephedra, non-MaHuang; virpotent, herbaceous prescription for the dynamic energization of body, mind and spirit.
This Gentle Ferocity Formulation is amalgamated in accordance with the fundamental Taoist herbal principle of botanical interactiveness and precursorship which in essence is a molecular equation of the relevant botanical/herbal alkaloids and glycosid...
Entirely Natural! Increases Energy! Increases Metabolism! Decreases Appetite!
Contents: Each Gentle Ferocity Tablet contains 500 mg. of the following proprietary formulated, high-ratio concentrated botanical factors: Cortex Eucommiae, Radex Polygoni Multiflori, Zizyphus Seed, Fructus Schisandrae, Radix Panax Ginseng, Radix Ast...
Suggested Usage: 1 - 2 tablets as needed. Best taken on an empty stomach. Not to exceed 6 tablets per day. Please Note: Persons with high blood pressure or any cardio-vascular malady should consult with their health care provider before engaging Gen...
********************************************************
GENTLE FEROCITY TABLETS PRICING:
share/SpamAssassin/spam_2/00040.d9570705b90532c2702859569bf4d01c view on Meta::CPAN
There is ABSOLUTELY nothing else quite like "Seventh Heaven" Prosaka (tm).
Ingredients:
Seventh Heaven Prosaka tablets contain the following herbal factors in precise prescription: Tadix Salviae, Sensitive Mimosa Bark, Arullus Euphoriae, Shizandra, Frutcus Mori, Caulis, Polygoni Multiflori, Zizphus, Tang Kuei, Cedar Seed, Sweetflag Rhiz...
**********************************************
Also.... for your "Sensitive" "Pure Energy" Energization.... "Seventh Heaven" Gentle Ferocity Tablets (tm). A "Seventh Heaven" non-caffeine, non-ephedrine, non-ephedra, non-MaHuang; viripotent, herbaceous prescription for the dynamic energization of...
This Gentle Ferocity Formulation is amalgamated in accordance with the fundamental Taoist herbal principle of botanical interactiveness and precursorship which in essence is a molecular equation of the relevant botanical/herbal alkaloids and glycosid...
Attention! Attention!!
For those of you who seek to achieve most demonstrative/non-invasive/non-prohibitive appetite suppression without the negative implications of ongoing usage of MaHuang Herb, Ephedra/Ephedrine or Caffeine as are so magnaminously utilized in a multitud...
Entirely Natural! Increases Energy! Increases Metabolism! Decreases Appetite!
Contents:
Each Gentle Ferocity Tablet contains 500 mg. of the following proprietary formulated, high-ratio concentrated botanical factors ... Cortex Eucommiae, Radex Polygoni Multiflori, Zizyphus Seed, Fructus Schisandrae, Radix Panax Ginseng, Radix Astragali,...
share/SpamAssassin/spam_2/00252.3b352c8a7266026be4f1c1ba89690cfc view on Meta::CPAN
Entirely natural, proprietary, botanical prescription comprised of uncommon Asian Herbs for Calm, Balance, Serenity and Joyful Living. "Seventh Heaven" Prosaka is indeed a most extraordinary, viripotent, calming, centering, mood-enhancing, holistical...
NO side effects! NO dependency! Vivaciously Mellow!
**********************************************
"Seventh Heaven" Gentle Ferocity Tablets (tm) ...
a non-caffeine, non-ephedrine, non-ephedra, non-MaHuang; viripotent, herbaceous prescription for the dynamic energization of body, mind and spirit.
This Gentle Ferocity Formulation is amalgamated in accordance with the fundamental Taoist herbal principle of botanical interactiveness and precursorship which in essence is a molecular equation of the relevant botanical/herbal alkaloids and glycosid...
For those of you who seek to achieve most demonstrative/non-invasive/non-prohibitive appetite suppression without the negative implications of ongoing usage of MaHuang Herb, Ephedra/Ephedrine or Caffeine as are so magnaminously utilized in a multitud...
Entirely Natural! Increases Energy! Increases Metabolism! Decreases Appetite!
***********************************************
Extreme Martial Arts Botanical Remedies
Eastern culture has long had a treatment for bone, muscle, tendon, ligament, sinew and joint distress, traumas, afflictions and constrictions. We are pleased to offer
( run in 0.443 second using v1.01-cache-2.11-cpan-4d50c553e7e )