misc/pX/Common/Pugs-Compiler-Rule/lib/Pugs/Grammar/Rule/Rule.pmc

# Generated file - do not edit!
##################((( 32-bit Checksum Validator )))##################
BEGIN { use 5.006; local (*F, $/); ($F = __FILE__) =~ s!c$!!; open(F)
or die "Cannot open $F: $!"; binmode(F, ':crlf'); unpack('%32N*',<F>)
== 0x1D6399E1 or die "Checksum failed for outdated .pmc file: ${F}c"}
#####################################################################
package Pugs::Grammar::Rule;
use base 'Pugs::Grammar::Base';
*{'Pugs::Grammar::Rule::ws'} = sub {
    my $grammar = shift;
    #warn "rule argument is undefined" unless defined $_[0];
    $_[0] = "" unless defined $_[0];
    my $bool = $_[0] =~ /^((?:\s|\#(?-s:.)*)+)(.*)$/sx;
    return {
        bool  => $bool,
        match => $1,
        tail  => $2,
        #capture => $1,
    }
};
*{'Pugs::Grammar::Rule::variable'} = sub {
    my $grammar = shift;
    #warn "rule argument is undefined" unless defined $_[0];
    $_[0] = "" unless defined $_[0];
    my $bool = $_[0] =~ /^([\$\%\@](?:(?:\:\:)?[_[:alnum:]]+)+)(.*)$/sx;
    return {
        bool  => $bool,
        match => $1,
        tail  => $2,
        #capture => $1,
    }
};
*{'Pugs::Grammar::Rule::positional_variable'} = sub {
    my $grammar = shift;
    #warn "rule argument is undefined" unless defined $_[0];
    $_[0] = "" unless defined $_[0];
    my $bool = $_[0] =~ /^([\$\%\@]\^(?:[_[:alnum:]]+))(.*)$/sx;
    return {
        bool  => $bool,
        match => $1,
        tail  => $2,
        #capture => $1,
    }
};
*{'Pugs::Grammar::Rule::ident'} = sub {
    my $grammar = shift;
    #warn "rule argument is undefined" unless defined $_[0];
    $_[0] = "" unless defined $_[0];
    my $bool = $_[0] =~ /^((?:(?:\:\:)?[_[:alnum:]]+)+)(.*)$/sx;
    return {
        bool  => $bool,
        match => $1,
        tail  => $2,
        #capture => $1,
    }
};
*{'Pugs::Grammar::Rule::num_variable'} = sub {
    my $grammar = shift;
    #warn "rule argument is undefined" unless defined $_[0];
    $_[0] = "" unless defined $_[0];
    my $bool = $_[0] =~ /^(?:\$[[:digit:]]+)(.*)$/sx;
    return {
        bool  => $bool,
        match => $1,
        tail  => $2,
        #capture => $1,
    }
};
*{'Pugs::Grammar::Rule::dot'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\." )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { 'dot' => 1 ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'dot';
*{'Pugs::Grammar::Rule::plain_text'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          alternation( [
                capture( 'alnum', sub{ $grammar->alnum(@_) } )
              ,
                constant( "\," )
              ,
                constant( "\;" )
              ,
                constant( "_" )
              ,
                constant( "\/" )
              ,
                constant( "\~" )
              ,
                constant( "\"" )
              ,
                constant( "\'" )
              ,
                constant( "\=" )
              ,
          ] )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { 'constant' =>  $_[0]->()  ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'plain_text';
*{'Pugs::Grammar::Rule::special_char'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\\" )
        ,
          sub{ $grammar->any(@_) }
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { special_char =>  $_[0]->() , } } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'special_char';
*{'Pugs::Grammar::Rule::non_capturing_group'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\[" )
        ,
          capture( 'rule', sub{ $grammar->rule(@_) } )
        ,
          constant( "\]" )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return $_[0]{rule}() } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    push @Pugs::Grammar::Rule::rule_terms, 'non_capturing_group';
*{'Pugs::Grammar::Rule::closure_rule'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'code', sub{ $grammar->code(@_) } )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { closure => $_[0]{code}() ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'closure_rule';
*{'Pugs::Grammar::Rule::variable_rule'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          alternation( [
                capture( 'variable', sub{ $grammar->variable(@_) } )
              ,
                capture( 'positional_variable', sub{ $grammar->positional_variable(@_) } )
              ,
          ] )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { variable =>  $_[0]->()  ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'variable_rule';
*{'Pugs::Grammar::Rule::match_variable'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'num_variable', sub{ $grammar->num_variable(@_) } )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { match_variable => $_[0]{num_variable}() ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'match_variable';
*{'Pugs::Grammar::Rule::named_capture_body'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
          alternation( [
              concat(
                constant( "\(" )
              ,
                capture( 'rule', sub{ $grammar->rule(@_) } )
              ,
                constant( "\)" )
              ,
                Pugs::Runtime::Rule::abort(
                    sub {
                        return { bool => 1, tail => $_[0], return => sub { return { rule => $_[0]{rule}(), } } };
                    }
                )
              ,
              ),
              concat(
                constant( "\[" )
              ,
                capture( 'rule', sub{ $grammar->rule(@_) } )
              ,
                constant( "\]" )
              ,
                Pugs::Runtime::Rule::abort(
                    sub {
                        return { bool => 1, tail => $_[0], return => sub { return { rule => $_[0]{rule}(), } } };
                    }
                )
              ,
              ),
              concat(
                capture( 'metasyntax', sub{ $grammar->metasyntax(@_) } )
              ,
                Pugs::Runtime::Rule::abort(
                    sub {
                        return { bool => 1, tail => $_[0], return => sub { return { rule => $_[0]{metasyntax}(), } } };
                    }
                )
              ,
              ),
          ] )
        ,
        )->( @_ )
    )
};
*{'Pugs::Grammar::Rule::named_capture'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\$" )
        ,
          constant( "\<" )
        ,
          capture( 'ident', sub{ $grammar->ident(@_) } )
        ,
          constant( "\>" )
        ,
          optional(
              sub{ $grammar->ws(@_) }
            ,
          )
        ,
          constant( "\:" )
        ,
          constant( "\=" )
        ,
          optional(
              sub{ $grammar->ws(@_) }
            ,
          )
        ,
          capture( 'named_capture_body', sub{ $grammar->named_capture_body(@_) } )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { my $body = $_[0]{named_capture_body}();
          $body->{ident} = $_[0]{ident}();
          return { named_capture => $body, } 
        } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'named_capture';
*{'Pugs::Grammar::Rule::before'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\<" )
        ,
          constant( "before" )
        ,
          sub{ $grammar->ws(@_) }
        ,
          capture( 'rule', sub{ $grammar->rule(@_) } )
        ,
          constant( "\>" )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { before => {
                rule  => $_[0]{rule}(),
            }, } 
        } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'before';
*{'Pugs::Grammar::Rule::after'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\<" )
        ,
          constant( "after" )
        ,
          sub{ $grammar->ws(@_) }
        ,
          capture( 'rule', sub{ $grammar->rule(@_) } )
        ,
          constant( "\>" )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { after => {
                rule  => $_[0]{rule}(),
            }, } 
        } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'after';
*{'Pugs::Grammar::Rule::capturing_group'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          constant( "\(" )
        ,
          capture( 'rule', sub{ $grammar->rule(@_) } )
        ,
          constant( "\)" )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { capturing_group => $_[0]{rule}() ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    unshift @Pugs::Grammar::Rule::rule_terms, 'capturing_group';
*{'Pugs::Grammar::Rule::colon'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'capturing_group',
              alternation( [
                  concat(
                    constant( "\:" )
                  ,
                    constant( "\:" )
                  ,
                    constant( "\:" )
                  ,
                  ),
                  concat(
                    constant( "\:" )
                  ,
                    constant( "\?" )
                  ,
                  ),
                  concat(
                    constant( "\:" )
                  ,
                    constant( "\+" )
                  ,
                  ),
                  concat(
                    constant( "\:" )
                  ,
                    constant( "\:" )
                  ,
                  ),
                    constant( "\:" )
                  ,
                  concat(
                    constant( "\$" )
                  ,
                    constant( "\$" )
                  ,
                  ),
                    constant( "\$" )
                  ,
                  concat(
                    constant( "\^" )
                  ,
                    constant( "\^" )
                  ,
                  ),
                    constant( "\^" )
                  ,
              ] )
            ,
          )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { colon => $_[0]->() ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
    push @Pugs::Grammar::Rule::rule_terms, 'colon';
*{'Pugs::Grammar::Rule::quantifier'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'ws1', 
              optional(
                  sub{ $grammar->ws(@_) }
                ,
              )
            ,
          )
        ,
          capture( 'term', 
              alternation( \@Pugs::Grammar::Rule::rule_terms )
            ,
          )
        ,
          capture( 'ws2', 
              optional(
                  sub{ $grammar->ws(@_) }
                ,
              )
            ,
          )
        ,
          capture( 'quant', 
              optional(
                  alternation( [
                      concat(
                        constant( "\?" )
                      ,
                        constant( "\?" )
                      ,
                      ),
                      concat(
                        constant( "\*" )
                      ,
                        constant( "\?" )
                      ,
                      ),
                      concat(
                        constant( "\+" )
                      ,
                        constant( "\?" )
                      ,
                      ),
                        constant( "\?" )
                      ,
                        constant( "\*" )
                      ,
                        constant( "\+" )
                      ,
                  ] )
                ,
              )
            ,
          )
        ,
          capture( 'ws3', 
              optional(
                  sub{ $grammar->ws(@_) }
                ,
              )
            ,
          )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return {  
            term  => $_[0]{term}(),
            quant => $_[0]{quant}(),
            ws1   => $_[0]{ws1}(),
            ws2   => $_[0]{ws2}(),
            ws3   => $_[0]{ws3}(),
        } 
    } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
*{'Pugs::Grammar::Rule::concat'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'q1', 
              capture( 'quantifier', sub{ $grammar->quantifier(@_) } )
            ,
          )
        ,
          optional(
            concat(
              capture( 'q2', 
                  capture( 'concat', sub{ $grammar->concat(@_) } )
                ,
              )
            ,
              Pugs::Runtime::Rule::abort(
                  sub {
                      return { bool => 1, tail => $_[0], return => sub { return { concat => [ 
                { quant => $_[0]{q1}() ,}, 
                $_[0]{q2}(),
            ] ,} 
        } };
                  }
              )
            ,
            ),
          )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return { quant => $_[0]{q1}() ,} } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
*{'Pugs::Grammar::Rule::rule'} = 
sub {
    my $grammar = shift;
    $_[0] = '' unless defined $_[0];
    package Pugs::Runtime::Rule;
    rule_wrapper( $_[0], (
        concat(
          capture( 'q1', 
              capture( 'concat', sub{ $grammar->concat(@_) } )
            ,
          )
        ,
          optional(
            concat(
              constant( "\|" )
            ,
              capture( 'q2', 
                  capture( 'rule', sub{ $grammar->rule(@_) } )
                ,
              )
            ,
              Pugs::Runtime::Rule::abort(
                  sub {
                      return { bool => 1, tail => $_[0], return => sub { return { alt => [ 
                $_[0]{q1}(), 
                $_[0]{q2}(),
            ] ,} 
        } };
                  }
              )
            ,
            ),
          )
        ,
          Pugs::Runtime::Rule::abort(
              sub {
                  return { bool => 1, tail => $_[0], return => sub { return $_[0]{q1}() } };
              }
          )
        ,
        ),
        )->( @_ )
    )
};
	Global
`s`	Focus search bar
`?`	Bring up this help dialog
	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)
	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse
	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)