view release on metacpan or  search on metacpan

misc/pX/Common/lrep-compiler/Grammar/Perl6.pm.bak  view on Meta::CPAN

         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
    push @statements, sub { Grammar::Perl6->pod(@_) };
*{'use_v6'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
       concat( 
           constant( "use" )
,         concat( 
             sub {  $grammar->p6ws( @_ ) } 
,           concat( 
               constant( "v6" )
,             concat( 
                 constant( '-' )
,               concat( 
                   constant( "pugs" )
,                 concat( 
                   optional(
                     sub {  $grammar->p6ws( @_ ) } 
                   )
,                     constant( ';' )
                 )
               )
             )
           )
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
    push @statements, sub { Grammar::Perl6->use_v6(@_) };
*{'require'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
       concat( 
           constant( "require" )
,         concat( 
             sub {  $grammar->p6ws( @_ ) } 
,           concat( 
               sub {  $grammar->ident( @_ ) } 
,             concat( 
               optional(
                 sub {  $grammar->p6ws( @_ ) } 
               )
,               concat( 
                   constant( ';' )
,                   abort(
                       sub {
                           return { bool => 1, tail => $_[0], return => sub { 
		# XXX This is perl5 code
		# this is ugly
		eval 'require '. $_[0]->() ->[2]{ident}[0]{ident};
		return { require_bareword =>  $_[0]->()  ,} 
	} };
                       }
                   )
               )
             )
           )
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
    push @statements, sub { Grammar::Perl6->require(@_) };
*{'use_rule'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
       concat( 
           constant( "use" )
,         concat( 
             sub {  $grammar->p6ws( @_ ) } 
,           concat( 
               sub {  $grammar->ident( @_ ) } 
,             concat( 
               optional(
                 sub {  $grammar->p6ws( @_ ) } 
               )
,               concat( 
                   constant( ';' )
,                   abort(
                       sub {
                           return { bool => 1, tail => $_[0], return => sub { 
		# XXX This is perl5 code
		# this is ugly
		# eval 'use '. $_[0]->() ->[2]{ident}[0]{ident};
		return { use_bareword =>  $_[0]->()  ,} 
	} };
                       }
                   )
               )
             )
           )
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
    push @statements, sub { Grammar::Perl6->use_rule(@_) };
*{'term1'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
         alternation( \@terms )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
*{'list'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
       concat( 
         greedy_star(
           concat( 
               sub {  $grammar->term1( @_ ) } 
,             concat( 
               optional(
                 sub {  $grammar->p6ws( @_ ) } 
               )
,               concat( 
                   constant( ',' )
,                 optional(
                   sub {  $grammar->p6ws( @_ ) } 
                 )
               )
             )
           )
         )
,         optional(
           sub {  $grammar->term1( @_ ) } 
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
*{'block'} = 
sub {

misc/pX/Common/lrep-compiler/Grammar/Perl6.pm.bak  view on Meta::CPAN

                           )
,                           concat( 
                             optional(
                               sub {  $grammar->list( @_ ) } 
                             )
,                             concat( 
                               optional(
                                 sub {  $grammar->p6ws( @_ ) } 
                               )
,                               concat( 
                                   constant( ')' )
,                                 concat( 
                                   optional(
                                     sub {  $grammar->p6ws( @_ ) } 
                                   )
,                                   concat( 
                                       constant( "is" )
,                                     concat( 
                                         sub {  $grammar->p6ws( @_ ) } 
,                                       concat( 
                                           constant( "parsed" )
,                                         concat( 
                                           optional(
                                             sub {  $grammar->p6ws( @_ ) } 
                                           )
,                                           concat( 
                                               constant( '(' )
,                                             concat( 
                                               optional(
                                                 sub {  $grammar->p6ws( @_ ) } 
                                               )
,                                               concat( 
                                                   constant( '/' )
,                                                 concat( 
                                                   optional(
                                                     sub {  $grammar->p6ws( @_ ) } 
                                                   )
,                                                   concat( 
                                                       sub {  $grammar->rule( @_ ) } 
,                                                     concat( 
                                                       optional(
                                                         sub {  $grammar->p6ws( @_ ) } 
                                                       )
,                                                       concat( 
                                                           constant( '/' )
,                                                         concat( 
                                                           optional(
                                                             sub {  $grammar->p6ws( @_ ) } 
                                                           )
,                                                           concat( 
                                                               constant( ')' )
,                                                             concat( 
                                                               optional(
                                                                 sub {  $grammar->p6ws( @_ ) } 
                                                               )
,                                                               concat( 
                                                                   sub {  $grammar->code( @_ ) } 
,                                                                   abort(
                                                                       sub {
                                                                           return { bool => 1, tail => $_[0], return => sub {
	 # XXX This is perl5 code
	 # XXX This is ugly
	 eval Emitter::Perl5::emit({macro =>  $_[0]->() });
	 return { macro =>  $_[0]->()  ,}
	} };
                                                                       }
                                                                   )
                                                               )
                                                             )
                                                           )
                                                         )
                                                       )
                                                     )
                                                   )
                                                 )
                                               )
                                             )
                                           )
                                         )
                                       )
                                     )
                                   )
                                 )
                               )
                             )
                           )
                         )
                       )
                     )
                   )
                 )
               )
             )
           )
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}
;
    push @statements, sub { Grammar::Perl6->macro_decl(@_) };
*{'empty_list'} = 
sub {
    my $grammar = shift;
    package Pugs::Runtime::Rule;
    my $tree;
    rule_wrapper( $_[0], 
       concat( 
           constant( '(' )
,         concat( 
             constant( ')' )
,             abort(
                 sub {
                     return { bool => 1, tail => $_[0], return => sub { return { empty_list =>  $_[0]->()  } } };
                 }
             )
         )
       )
        ->( $_[0], undef, $tree, $tree )
    );
}