From 04293aded24f2572b415ff671579af74b6b6c50b Mon Sep 17 00:00:00 2001
From: Hongwe Qiu <qiuhongwen@gmail.com>
Date: Sun, 22 May 2011 23:00:34 +0800
Subject: [PATCH] Compiler rewritten by nqprx can almost comiple now.

But I don't know how to adjust the 'quote_EXPR' method. So none of the tests
will pass right now.
---
 cardinal.pir                    |  31 +-
 src/compiler.pm                 |   4 +
 src/parser/actions.pm           | 344 ++++++++-------------
 src/parser/grammar.pm           | 509 +++++++++++---------------------
 src/parser/quote_expression.pir |   6 +-
 5 files changed, 301 insertions(+), 593 deletions(-)

diff --git a/cardinal.pir b/cardinal.pir
index e0768a9..d371828 100644
--- a/cardinal.pir
+++ b/cardinal.pir
@@ -34,58 +34,43 @@ object.
 .sub 'onload' :anon :load :init
     load_bytecode 'HLL.pbc'
     .local pmc hllns, parrotns, imports
-    hllns    = get_hll_namespace
+    hllns = get_hll_namespace
     parrotns = get_root_namespace ['parrot']
-    imports  = split ' ', 'PAST PCT HLL Regex Hash'
+    imports = split ' ', 'PAST PCT HLL Regex Hash'
     parrotns.'export_to'(hllns, imports)
 .end
 
 .include 'src/gen_grammar.pir'
 .include 'src/parser/quote_expression.pir'
 .include 'src/gen_actions.pir'
+.include 'src/gen_compiler.pir'
 .namespace [ 'cardinal';'Compiler' ]
 
 #no caridinal_group found on my machine
 #.loadlib 'cardinal_group'
 
-=begin comment
-
 .sub 'onload' :anon :load :init
-    .local pmc cardinalmeta, compilerclass, compiler
-    cardinalmeta = get_hll_global ['CardinalObject'], '!CARDINALMETA'
-    compilerclass = cardinalmeta.'new_class'('cardinal::Compiler', 'parent'=>'PCT::HLLCompiler')
-
     $P2 = new 'CardinalString'
     $P2 = ""
     set_hll_global '$,', $P2
 
-    compiler = compilerclass.'new'()
-    compiler.'language'('cardinal')
-    $P0 = get_hll_namespace ['cardinal';'Grammar']
-    compiler.'parsegrammar'($P0)
-    $P0 = get_hll_namespace ['cardinal';'Grammar';'Actions']
-    compiler.'parseactions'($P0)
-
-    compiler.'commandline_banner'("Cardinal - Ruby for the Parrot VM\n\n")
-    compiler.'commandline_prompt'('crb(main):001:0> ')
-
-     ##  create a list of END blocks to be run
+    ##  create a list of END blocks to be run
     $P0 = new 'CardinalArray'
     set_hll_global ['cardinal'], '@?END_BLOCKS', $P0
 
     $P0 = new 'CardinalArray'
-    set_hll_global ['cardinal';'Grammar';'Actions'], '@?BLOCK', $P0
+    set_hll_global ['cardinal';'Actions'], '@?BLOCK', $P0
 
     $P1 = get_hll_global ['PAST';'Compiler'], '%valflags'
     $P1['CardinalString'] = 'e'
 .end
 
- =item main(args :slurpy)  :main
+=item main(args :slurpy)  :main
 
 Start compilation by passing any command line C<args>
 to the cardinal compiler.
 
- =cut
+=cut
 
 .sub 'main' :main
     .param pmc args_str
@@ -141,8 +126,6 @@ to the cardinal compiler.
     .return (retval)
 .end
 
-=end comment
-
 =back
 
 =cut
diff --git a/src/compiler.pm b/src/compiler.pm
index 9b482ac..5488e81 100644
--- a/src/compiler.pm
+++ b/src/compiler.pm
@@ -4,4 +4,8 @@ INIT {
     cardinal::Compiler.language('cardinal');
     cardinal::Compiler.parsegrammar(cardinal::Grammar);
     cardinal::Compiler.parseactions(cardinal::Actions);
+    cardinal::Compiler.commandline_banner("Cardinal - Ruby for the Parrot VM\n\n");
+    cardinal::Compiler.commandline_prompt('crb(main):001:0> ');
 }
+
+# vim: sw=4 ts=4 ft=perl6 expandtab
diff --git a/src/parser/actions.pm b/src/parser/actions.pm
index 057e0bb..8f91d92 100644
--- a/src/parser/actions.pm
+++ b/src/parser/actions.pm
@@ -1,22 +1,4 @@
-# Copyright (C) 2008, Parrot Foundation.
-# $Id$
-
-=begin comments
-
-cardinal::Grammar::Actions - ast transformations for cardinal
-
-This file contains the methods that are used by the parse grammar
-to build the PAST representation of an cardinal program.
-Each method below corresponds to a rule in F<src/parser/grammar.pg>,
-and is invoked at the point where C<{*}> appears in the rule,
-with the current match object as the first argument.  If the
-line containing C<{*}> also has a C<#= key> comment, then the
-value of the comment is passed as the second argument to the method.
-
-=end comments
-=cut
-
-class cardinal::Grammar::Actions;
+class cardinal::Actions is HLL::Actions;
 
 method TOP($/) {
     my $past := $<comp_stmt>.ast();
@@ -53,29 +35,30 @@ method TOP($/) {
     make $past;
 }
 
-method comp_stmt($/,$key) {
+method begin_block($/) {
     our $?BLOCK;
     our @?BLOCK;
     our $?BLOCK_SIGNATURED;
-    if $key eq 'open' {
-        if $?BLOCK_SIGNATURED {
-            $?BLOCK := $?BLOCK_SIGNATURED;
-            $?BLOCK_SIGNATURED := 0;
-        }
-        else {
-            $?BLOCK := PAST::Block.new( PAST::Stmts.new(), :node($/));
-            my $block := PAST::Var.new(:scope('parameter'), :named('!BLOCK'), :name('!BLOCK'), :viviself('Undef'));
-            $?BLOCK.symbol($block.name(), :scope('lexical'));
-            $?BLOCK[0].push($block);
-        }
-        @?BLOCK.unshift($?BLOCK);
-    }
-    if $key eq 'close' {
-        my $past := @?BLOCK.shift();
-        $?BLOCK := @?BLOCK[0];
-        $past.push( $<stmts>.ast() );
-        make $past;
+    if $?BLOCK_SIGNATURED {
+        $?BLOCK := $?BLOCK_SIGNATURED;
+        $?BLOCK_SIGNATURED := 0;
+    } else {
+        $?BLOCK := PAST::Block.new(PAST::Stmts.new, :node($/));
+        my $block := PAST::Var.new(:scope<parameter>, :named<!BLOCK>, :name<!BLOCK>, :viviself<Undef>);
+        $?BLOCK.symbol($block.name, :scope<lexical>);
+        $?BLOCK[0].push($block);
     }
+    @?BLOCK.unshift($?BLOCK);
+}
+
+method comp_stmt($/) {
+    our $?BLOCK;
+    our @?BLOCK;
+    our $?BLOCK_SIGNATURED;
+    my $past := @?BLOCK.shift();
+    $?BLOCK := @?BLOCK[0];
+    $past.push( $<stmts>.ast() );
+    make $past;
 }
 
 method stmts($/) {
@@ -86,10 +69,6 @@ method stmts($/) {
     make $past;
 }
 
-method basic_stmt($/, $key) {
-    make $/{$key}.ast();
-}
-
 method stmt($/) {
     my $past := $<basic_stmt>.ast();
     for $<stmt_mod> {
@@ -115,7 +94,7 @@ method stmt_mod($/) {
 }
 
 method expr($/) {
-    my $past := $<arg>.ast();
+    my $past := $<EXPR>.ast();
     if +$<not> {
         $past := PAST::Op.new( $past, :pirop('not'), :node($/) );
     }
@@ -128,7 +107,7 @@ method expr($/) {
     make $past;
 }
 
-method return_stmt($/) {
+method basic_stmt:sym<return>($/) {
     my $past := $<call_args>.ast();
     $past.pasttype('inline');
     $past.inline('    .return(%0)');
@@ -136,13 +115,13 @@ method return_stmt($/) {
 }
 
 ## not entirely sure what alias does, but this is a guess...
-method alias($/) {
+method basic_stmt:sym<alias>($/) {
     my $fname := $<fname>[0];
     my $alias := $<fname>[1];
     make PAST::Op.new( $alias, $fname, :pasttype('bind'), :node($/) );
 }
 
-method begin($/) {
+method basic_stmt:sym<begin>($/) {
     my $past := $<comp_stmt>.ast();
     my $sub := PAST::Compiler.compile( $past );
     $sub();
@@ -150,7 +129,7 @@ method begin($/) {
     make PAST::Block.new( :node($/) );
 }
 
-method end($/) {
+method basic_stmt:sym<end>($/) {
     my $past := PAST::Block.new( $<comp_stmt>.ast(), :node($/) );
     $past.blocktype('declaration');
     my $sub := PAST::Compiler.compile( $past );
@@ -162,7 +141,7 @@ method end($/) {
     make $past;
 }
 
-method indexed_assignment($/) {
+method basic_stmt:sym<indexed_assignment>($/) {
     my $keys;
     my $rhs := $<rhs>.ast();
     my $primary := $<basic_primary>.ast();
@@ -181,7 +160,7 @@ method indexed_assignment($/) {
 
     make $past;
 }
-method member_assignment($/) {
+method basic_stmt:sym<member_assignment>($/) {
     my $rhs := $<rhs>.ast();
     my $primary := $<basic_primary>.ast();
 
@@ -192,7 +171,7 @@ method member_assignment($/) {
 
     make $past;
 }
-method assignment($/) {
+method basic_stmt:sym<assignment>($/) {
     my $lhs := $<mlhs>.ast();
     our $?BLOCK;
     my $name := $lhs.name();
@@ -230,16 +209,14 @@ method assignment($/) {
     make PAST::Op.new( $lhs, $rhs, :pasttype('bind'), :lvalue(1), :node($/) );
 }
 
-method lhs($/, $key) {
-    make $/{$key}.ast();
-}
+method lhs($/) { make $<varname>.ast }
 
 method member_variable($/) {
     make $<primary>.ast();
     # XXX fix field.
 }
 
-method indexed($/) {
+method post_primary_expr:sym<indexed>($/) {
     my $args;
     if $<args> {
         $args := $<args>[0].ast();
@@ -263,11 +240,9 @@ method variable($/) {
     make $past;
 }
 
-method varname($/, $key) {
-    make $/{$key}.ast();
-}
+method varname($/) { make $<vartype>.ast }
 
-method global($/) {
+method vartype:sym<global>($/) {
     my @namespace;
     our @?BLOCK;
     my $toplevel := @?BLOCK[0];
@@ -275,7 +250,7 @@ method global($/) {
     make PAST::Var.new( :name(~$/), :scope('package'), :namespace(@namespace), :viviself('Undef'), :node($/) );
 }
 
-method instance_variable($/) {
+method vartype:sym<instance>($/) {
     our $?CLASS;
     our $?BLOCK;
     my $name := ~$/;
@@ -300,7 +275,7 @@ method instance_variable($/) {
     make $past;
 }
 
-method class_variable($/) {
+method vartype:sym<class>($/) {
     our $?CLASS;
     our $?BLOCK;
     my $name := ~$/;
@@ -349,12 +324,12 @@ method local_variable($/) {
     make $past;
 }
 
-method funcall($/) {
+method basic_primary:sym<funcall>($/) {
     my $past := $<local_variable>.ast();
     make $past;
 }
 
-method constant_variable($/) {
+method vartype:sym<constant>($/) {
     my @a;
     my $name := ~$/;
     if $name eq 'Integer' { $name := "CardinalInteger"; }
@@ -368,7 +343,7 @@ method constant_variable($/) {
 }
 
 
-method if_stmt($/) {
+method basic_stmt:sym<if>($/) {
     my $cond := +$<expr> - 1;
     my $comp := $<comp_stmt>[$cond].ast();
     $comp.blocktype('immediate');
@@ -396,7 +371,7 @@ method if_stmt($/) {
     make $past;
 }
 
-method unless_stmt($/) {
+method basic_stmt:sym<unless>($/) {
     my $cond := $<expr>.ast();
     my $body := $<comp_stmt>.ast();
     $body.blocktype('immediate');
@@ -414,14 +389,14 @@ method else($/) {
     make $<comp_stmt>.ast();
 }
 
-method while_stmt($/) {
+method basic_stmt:sym<while>($/) {
     my $cond := $<expr>.ast();
     my $body := $<comp_stmt>.ast();
     $body.blocktype('immediate');
     make PAST::Op.new( $cond, $body, :pasttype(~$<sym>), :node($/) );
 }
 
-method for_stmt($/) {
+method basic_stmt:sym<for>($/) {
     my $list := $<expr>.ast();
     my $body := $<comp_stmt>.ast();
     my $var := $<variable>.ast();
@@ -432,14 +407,9 @@ method for_stmt($/) {
     make PAST::Op.new( $list, $body, :pasttype('for'), :node($/) );
 }
 
-method control_command($/,$key) {
-    make PAST::Op.new(
-            :pasttype('call'),
-            :name(~$/),
-        );
-}
+method basic_primary:sym<control_command>($/) { make PAST::Op.new(:pasttype<call>, :name(~$/)) }
 
-method yield($/) {
+method basic_primary:sym<yield>($/) {
     our $?BLOCK;
     our @?BLOCK;
     my $blockname;
@@ -457,7 +427,7 @@ method yield($/) {
     make $call;
 }
 
-method module($/) {
+method basic_stmt:sym<module>($/) {
     my $past := $<comp_stmt>.ast();
     my $name := $<module_identifier>.ast();
     $past.namespace( $name.name() );
@@ -466,90 +436,74 @@ method module($/) {
     make $past;
 }
 
-method begin_end($/) {
+method basic_stmt:sym<begin_end>($/) {
     my $past := $<comp_stmt>.ast();
     # XXX handle resque and ensure clauses
     make $past;
 }
 
-method classdef($/,$key) {
+method begin_class($/) {
     our $?CLASS;
     our @?CLASS;
     our $?INIT;
 
-    my $name := ~$<module_identifier><ident>;
-    if $key eq 'open' {
-        my $decl := PAST::Stmts.new();
-        $decl.push(
-            PAST::Op.new(
-                :pasttype('bind'),
-                PAST::Var.new(
-                    :name('$def'),
-                    :scope('lexical')
-                ),
-                PAST::Op.new(
-                    :pasttype('call'),
-                    :name('!keyword_class'),
-                    PAST::Val.new( :value($name) )
-                )
-            )
-        );
-        @?CLASS.unshift( $?CLASS );
-        $?CLASS := $decl;
-        $?CLASS.unshift( PAST::Block.new() );
-    }
-    else {
-        my $block := $<comp_stmt>.ast();
-        $block.namespace($name);
-        $block.blocktype('declaration');
-        $block.pirflags(':init :load');
+    my $decl := PAST::Stmts.new;
+    $decl.push(
+        PAST::Op.new(
+            :pasttype<bind>,
+            PAST::Var.new(:name<$def>, :scope<lexical>),
+            PAST::Op.new(:pasttype<call>, :name<!keyword_class>, PAST::Val.new(:value(~$/)))
+        )
+    );
+    @?CLASS.unshift($?CLASS);
+    $?CLASS := $decl;
+    $?CLASS.unshift(PAST::Block.new);
+}
 
-        $?CLASS.push(
-            PAST::Op.new(
-                :pasttype('callmethod'),
-                :name('register'),
-                PAST::Var.new(
-                    :scope('package'),
-                    :name('!CARDINALMETA'),
-                    :namespace('CardinalObject')
-                ),
-                PAST::Var.new(
-                    :scope('lexical'),
-                    :name('$def')
-                ),
-                PAST::Val.new(
-                    :value('CardinalObject'),
-                    :named( PAST::Val.new( :value('parent') ) )
-                )
-            )
-        );
+method basic_stmt:sym<class>($/) {
+    our $?CLASS;
+    our @?CLASS;
+    our $?INIT;
 
-        unless defined( $?INIT ) {
-            $?INIT := PAST::Block.new();
-        }
-        for @( $?CLASS ) {
-            if $_.WHAT() eq 'Block' {
-                $block.push( $_ );
-            }
-            else {
-                $?INIT.push( $_ );
-            }
-        }
+    my $block := $<comp_stmt>.ast;
+    $block.namespace(~$<begin_class>);
+    $block.blocktype('declaration');
+    $block.pirflags(':init :load');
+
+    $?CLASS.push(
+        PAST::Op.new(
+            :pasttype<callmethod>,
+            :name<register>,
+            PAST::Var.new(:scope<package>, :name<!CARDINALMETA>, :namespace<CardinalObject>),
+            PAST::Var.new(:scope<lexical>, :name<$def>),
+            PAST::Val.new(:value<CardinalObject>, :named(PAST::Val.new(:value<parent>)))
+        )
+    );
 
-        # Restore outer class.
-        if +@?CLASS {
-            $?CLASS := @?CLASS.shift();
+    unless defined( $?INIT ) {
+        $?INIT := PAST::Block.new();
+    }
+    for @( $?CLASS ) {
+        if $_.WHAT() eq 'Block' {
+            $block.push( $_ );
         }
         else {
-            $?CLASS := @?CLASS[0];
+            $?INIT.push( $_ );
         }
+    }
 
-
-        make $block;
+    # Restore outer class.
+    if +@?CLASS {
+        $?CLASS := @?CLASS.shift();
     }
+    else {
+        $?CLASS := @?CLASS[0];
+    }
+
+    make $block;
 }
 
-method functiondef($/) {
+method basic_stmt:sym<def>($/) {
     my $past := $<comp_stmt>.ast();
     my $name := $<fname>;
     my $arity := +$past[0]<arity>;
@@ -626,7 +580,7 @@ method module_identifier($/) {
     make PAST::Var.new( :name(~$/), :scope('package'), :node($/) );
 }
 
-method methodcall($/) {
+method post_primary_expr:sym<methodcall>($/) {
     my $op := $<operation>;
     my $past;
     if $<call_args> {
@@ -646,10 +600,7 @@ method methodcall($/) {
     make $past;
 }
 
-method do_block($/) {
-    my $past := $<comp_stmt>.ast();
-    make $past;
-}
+method do_block($/) { make $<comp_stmt>.ast }
 
 method super_call($/) {
     my $past := $<call_args>.ast();
@@ -679,15 +630,13 @@ method call_args($/) {
 
 method args($/) {
     my $past := PAST::Op.new( :pasttype('call'), :node($/) );
-    for $<arg> {
+    for $<EXPR> {
         $past.push( $_.ast() );
     }
     make $past;
 }
 
-method basic_primary($/, $key) {
-    make $/{$key}.ast();
-}
+method basic_primary:sym<variable>($/) { make $<variable>.ast }
 
 method primary($/) {
     my $past := $<basic_primary>.ast();
@@ -701,44 +650,25 @@ method primary($/) {
     make $past;
 }
 
-method post_primary_expr($/, $key) {
-    make $/{$key}.ast();
-}
+method post_primary_expr:sym<call_args>($/) { make $<call_args>.ast }
+method post_primary_expr:sym<args>($/) { make $<args> ?? $<args>[0].ast !! PAST::Op.new(:inline<noop>, :pasttype<inline>, :node($/)) }
 
 method scope_identifier($/) {
     make $<identifier>.ast();
     # XXX handle :: operator.
 }
 
-method literal($/, $key) {
-    my $past;
-    if $key eq 'true' {
-        $past := PAST::Op.new(:inline("%t = get_hll_global 'true'"), :returns('Bool'));
-    } elsif $key eq 'false' {
-        $past := PAST::Op.new(:inline("%t = get_hll_global 'false'"), :returns('Bool'));
-    } elsif $key eq 'nil' {
-        $past := PAST::Op.new(:inline("%t = get_hll_global 'nil'"), :returns('NilClass'));
-    } elsif $key eq 'self' {
-        $past := PAST::Op.new(:inline('%r = self'));
-    } else {
-        $past := $/{$key}.ast();
-    }
-    make $past;
-}
-
-method pcomp_stmt($/) {
-    make $<comp_stmt>.ast();
-}
+method literal:sym<true>($/) { make PAST::Op.new(:inline('%t = get_hll_global "true"'), :returns<Bool>) }
+method literal:sym<false>($/) { make PAST::Op.new(:inline('%t = get_hll_global "false"'), :returns<Bool>) }
+method literal:sym<nil>($/) { make PAST::Op.new(:inline('%t = get_hll_global "nil"'), :returns<NilClass>) }
+method literal:sym<self>($/) { make PAST::Op.new(:inline('%r = self')) }
 
-method quote_string($/) {
-    make $<quote_expression>.ast();
-}
+method basic_primary:sym<pcomp_stmt>($/) { make $<comp_stmt>.ast }
 
-method warray($/) {
-    make $<quote_expression>.ast();
-}
+method literal:sym<quote_string>($/) { make $<quote_EXPR>.ast }
+method literal:sym<warray>($/) { make $<quote_EXPR>.ast }
 
-method array($/) {
+method literal:sym<array>($/) {
     my $list;
     if $<args> {
         $list := $<args>[0].ast();
@@ -751,7 +681,7 @@ method array($/) {
     make $list;
 }
 
-method ahash($/) {
+method literal:sym<ahash>($/) {
     my $hash := PAST::Op.new( :name('hash'), :node($/) );
     if $<assocs> {
         my $items := $<assocs>[0].ast();
@@ -773,28 +703,17 @@ method assocs($/) {
 
 method assoc($/) {
     my $past := PAST::Op.new(:name('list'), :node($/));
-    $past.push( $<arg>[0].ast() );
-    $past.push( $<arg>[1].ast() );
+    $past.push( $<EXPR>[0].ast() );
+    $past.push( $<EXPR>[1].ast() );
     make $past;
 }
 
-method float($/) {
-    make PAST::Val.new( :value( ~$/ ), :returns('Float'), :node($/) );
-}
+method literal:sym<float>($/) { make PAST::Val.new(:value(~$/), :returns<CardinalFloat>, :node($/)) }
+method literal:sym<integer>($/) { make PAST::Val.new(:value(~$/), :returns<CardinalInteger>, :node($/)) }
+method literal:sym<string>($/) { make $<quote_EXPR>.ast }
+method literal:sym<regex>($/) { make $<quote_EXPR>.ast }
 
-method integer($/) {
-    make PAST::Val.new( :value( ~$/ ), :returns('CardinalInteger'), :node($/) );
-}
-
-method string($/) {
-    make $<quote_expression>.ast();
-}
-
-method regex($/) {
-    make $<quote_expression>.ast();
-}
-
-method quote_expression($/, $key) {
+method quote_EXPR($/, $key) {
     my $past;
     if $key eq 'quote_regex' {
         our $?NS;
@@ -817,14 +736,13 @@ method quote_expression($/, $key) {
                 :node( $/ )
             );
             for $<quote_concat> {
-                $past.push( $_.ast() );
+               $past.push( $_.ast() );
             }
         }
     }
     make $past;
 }
 
-
 method quote_concat($/) {
     my $terms := +$<quote_term>;
     my $count := 1;
@@ -864,26 +782,6 @@ method quote_term($/, $key) {
     make $past;
 }
 
-method arg($/, $key) {
-    ## Handle the operator table
-    ##
-    if ($key eq 'end') {
-        make $<expr>.ast();
-    }
-    else {
-        my $past := PAST::Op.new( :name($<type>),
-                                  :pasttype($<top><pasttype>),
-                                  :pirop($<top><pirop>),
-                                  :lvalue($<top><lvalue>),
-                                  :node($/)
-                                );
-        for @($/) {
-            $past.push( $_.ast() );
-        }
-        make $past;
-    }
-}
-
 sub is_a_sub($name) {
     our $?BLOCK;
     our @?BLOCK;
@@ -892,7 +790,7 @@ sub is_a_sub($name) {
             return 1;
         }
         else {
-            return0;
+            return 0;
         }
     }
     for @?BLOCK {
@@ -913,10 +811,6 @@ sub is_a_sub($name) {
     return 0;
 }
 
-# Local Variables:
-#   mode: cperl
-#   cperl-indent-level: 4
-#   fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
+=end comment
 
+# vim: sw=4 ts=4 ft=perl6 expandtab
diff --git a/src/parser/grammar.pm b/src/parser/grammar.pm
index 5bf1c4e..07b95d9 100644
--- a/src/parser/grammar.pm
+++ b/src/parser/grammar.pm
@@ -1,5 +1,3 @@
-# $Id$
-
 =begin overview
 
 This is the grammar for cardinal written as a sequence of Perl 6 rules.
@@ -15,120 +13,60 @@ grammar cardinal::Grammar is HLL::Grammar;
 
 token TOP {
     <comp_stmt>
-    [ $ || <.panic('Syntax error')> ]
-    {*}
+    [ $ || <.panic: "Syntax error"> ]
 }
 
 token comp_stmt {
-    {*}                        #= open
+    <.begin_block>
     <stmts>
-    {*}                        #= close
 }
 
+token begin_block { <?> }
+
 rule stmts {
-    <.term>?[ <stmt> [<.term>+ | <.before <end_block>> | $ | <panic('unterminated statement')>] ]* {*}
+    <.terminator>?[ <stmt> [<.terminator>+ | <.before <end_block>> | $ | <.panic: "Unterminated statement">] ]*
 }
 
-token term { \h*\n | \h*';' }
+token terminator { \h*\n | \h*';' }
 token end_block { <.ws> [ 'end' | '}' ] }
 
-token basic_stmt {
-    | <alias> {*}           #= alias
-    | <classdef> {*}        #= classdef
-    | <functiondef> {*}     #= functiondef
-    | <if_stmt> {*}         #= if_stmt
-    | <while_stmt> {*}      #= while_stmt
-    | <for_stmt> {*}        #= for_stmt
-    | <unless_stmt> {*}     #= unless_stmt
-    | <module> {*}          #= module
-    | <begin_end> {*}       #= begin_end
-    | <indexed_assignment> {*}      #= indexed_assignment
-    | <member_assignment> {*}      #= member_assignment
-    | <assignment> {*}      #= assignment
-    | <return_stmt> {*}     #= return_stmt
-    | <expr> {*}            #= expr
-    | <begin> {*}           #= begin
-    | <end> {*}             #= end
-}
+proto token basic_stmt { <...> }
+token basic_stmt:sym<expr> { <expr> }
 
-token return_stmt {
-    'return' <.ws> <call_args> {*}
-}
+token basic_stmt:sym<return> { <sym> <.ws> <call_args> }
 
-rule alias {
-    'alias' <fname> <fname>
-    {*}
-}
+rule basic_stmt:sym<alias> { <sym> <fname> <fname> }
 
-token stmt {
-    <basic_stmt> <.ws> <stmt_mod>*
-    {*}
-}
+token stmt { <basic_stmt> <.ws> <stmt_mod>* }
 
-token stmt_mod {
-    $<sym>=[if|while|unless|until] <.ws> <expr>
-    {*}
-}
-
-rule expr {
-    [$<not>=['!'|'not']]? <EXPR> [$<op>=['and'|'or'] <expr>]?
-    {*}
-}
-
-rule begin {
-    'BEGIN' '{' <comp_stmt> '}'
-    {*}
-}
+token stmt_mod { $<sym>=[if|while|unless|until] <.ws> <expr> }
 
-rule end {
-    'END' '{' <comp_stmt> '}'
-    {*}
-}
+rule expr { [$<not>=['!'|'not']]? <EXPR> [$<op>=['and'|'or'] <expr>]? }
 
-token indexed_assignment {
-    <basic_primary> '[' $<keys>=<args> ']' <.ws> '=' <.ws> $<rhs>=<EXPR>
-    {*}
-}
+rule basic_stmt:sym<begin> { 'BEGIN' '{' <comp_stmt> '}' }
+rule basic_stmt:sym<end> { 'END' '{' <comp_stmt> '}' }
 
-token member_assignment {
-    <basic_primary> '.' $<key>=<identifier> <.ws> '=' <.ws> $<rhs>=<EXPR>
-    {*}
-}
+token basic_stmt:sym<indexed_assignment> { <basic_primary> '[' $<keys>=<args> ']' <.ws> '=' <.ws> $<rhs>=<EXPR> }
+token basic_stmt:sym<member_assignment>  { <basic_primary> '.' $<key>=<identifier> <.ws> '=' <.ws> $<rhs>=<EXPR> }
 
-rule assignment {
-    $<mlhs>=<lhs> '=' $<mrhs>=<EXPR>       #XXX need to figure out multiple assignment
-    {*}
+rule basic_stmt:sym<assignment> {
+    $<mlhs>=<lhs> '=' $<mrhs>=$<EXPR>       #XXX need to figure out multiple assignment
 }
 
-token lhs {
-    | <varname> {*} #= varname
-}
+token lhs { <varname> }
 
-token indexed {
-    '[' <args>? ']'
-    {*}
-}
+token post_primary_expr:sym<indexed> { '[' <args>? ']' }
 
-token member_variable {
-    <primary> '.' <identifier>
-    {*}
-}
+token member_variable { <primary> '.' <identifier> }
 
-token methodcall {
-    $<dot>='.'
-    <operation> <call_args>? <do_block>?
-    {*}
-}
+token post_primary_expr:sym<methodcall> { $<dot>='.' <operation> <call_args>? <do_block>? }
 
 rule do_block {
-    | 'do' <do_args>? <.term>? <.before <stmt>><comp_stmt> 'end' {*}
-    | '{' <do_args>? <.term>? <.before <stmt>><comp_stmt> '}' {*}
+    | 'do' <do_args>? <.terminator>? <.before <stmt>><comp_stmt> 'end'
+    | '{' <do_args>? <.terminator>? <.before <stmt>><comp_stmt> '}'
 }
 
-rule super_call {
-    'super' <call_args>
-    {*}
-}
+rule super_call { 'super' <call_args> }
 
 token operation {
     'class'|
@@ -141,11 +79,12 @@ token operation {
 }
 
 #XXX UGLY!  Refactor into <args> maybe?
+# ?after is not implemented in nqprx
 token call_args {
-    | [<.ws> <do_block>]**{1} {*}
-    | '()' [<.ws> <do_block>]? {*}
-    | [ <.after \s|\)> | <.before \s> ] <args> [<.ws> <do_block>]? {*}
-    | '(' <.ws> <args> <.ws> ')' [<.ws> <do_block>]? {*}
+    | [<.ws> <do_block>]**{1}
+    | '()' [<.ws> <do_block>]?
+    | [ <?[\s \)]> | <.before \s> ] <args> [<.ws> <do_block>]?
+    | '(' <.ws> <args> <.ws> ')' [<.ws> <do_block>]?
 }
 
 rule do_args {
@@ -154,7 +93,7 @@ rule do_args {
 
 rule sig_identifier {
                       #XXX Should this be basic_primary or expr or what?
-    <identifier>[ '=' <default=basic_primary>]? {*}
+    <identifier>[ '=' <default=basic_primary>]?
 }
 
 rule block_signature {
@@ -162,128 +101,91 @@ rule block_signature {
     | <sig_identifier> [',' <sig_identifier>]* [',' <slurpy_param>]? [',' <block_param>]?
     | <slurpy_param> [',' <block_param>]?
     | <block_param>?
-    ] {*}
-}
-
-token variable {
-    <varname> {*}
-}
-
-token varname {
-    <!reserved_word>
-    [ <global> {*}             #= global
-    | <class_variable> {*}     #= class_variable
-    | <instance_variable> {*}  #= instance_variable
-    | <local_variable> {*}     #= local_variable
-    | <constant_variable> {*}  #= constant_variable
     ]
 }
 
-token funcall {
-    <!reserved_word> <local_variable> <.before \s|'('> <.before <call_args>> {*}
-}
+token variable { <varname> }
 
-rule args {
-    <EXPR> [',' <EXPR>]*
-    {*}
-}
+token varname { <!reserved_word> <vartype> }
+proto token vartype { <...> }
+token vartype:sym<local_variable> { <local_variable> }
 
-token basic_primary {
-    | <literal> {*}                         #= literal
-    | <funcall> {*}                         #= funcall
-    | <variable> {*}                        #= variable
-    | <pcomp_stmt> {*}                      #= pcomp_stmt
-    | <yield> {*}                           #= yield
-    | <control_command> {*}                 #= control_command
-}
+token basic_primary:sym<funcall> { <!reserved_word> <local_variable> <.before \s|'('> <.before <call_args>> }
 
-token primary {
-    <basic_primary> <post_primary_expr>*
-    {*}
-}
+rule args { <EXPR> [',' <EXPR>]* }
 
-token post_primary_expr {
-    | <indexed> {*}            #= indexed
-    | <call_args> {*}          #= call_args
-    | <methodcall> {*}         #= methodcall
-    | '[' <args>? ']' {*}      #= args
-}
+proto token basic_primary { <...> }
+token basic_primary:sym<variable> { <variable> }
 
-token pcomp_stmt {
-    '(' <comp_stmt> ')'
-    {*}
-}
+token term { <primary> }
+token primary { <basic_primary> <post_primary_expr>* }
+
+proto token post_primary_expr { <...> }
+token post_primary_expr:sym<call_args> { <call_args> }
+token post_primary_expr:sym<args> { '[' ~ ']' <args>? }
 
+token basic_primary:sym<pcomp_stmt> { '(' <comp_stmt> ')' }
 
-rule if_stmt {
-    'if' <expr> <.then>
-    [<comp_stmt>
+rule basic_stmt:sym<if> {
+    <sym> <expr> <.then>
+    [   <comp_stmt>
     ['elsif' <expr> <.then>
-    <comp_stmt>]*
+        <comp_stmt>]*
     <else>?
     'end'
-    |<panic('syntax error in if statement')>]
-    {*}
+    |<.panic: "Syntax error in if statement">]
 }
 
-token then { ':' | 'then' | <term> ['then']? }
+token then { ':' | 'then' | <terminator> ['then']? }
 
-rule while_stmt {
+rule basic_stmt:sym<while> {
     $<sym>=['while'|'until'] <expr> <.do>
-    <comp_stmt>
+        <comp_stmt>
     'end'
-    {*}
 }
 
-rule for_stmt {
-    'for' <variable> 'in' <expr> <.do>
-    <comp_stmt>
+rule basic_stmt:sym<for> {
+    <sym> <variable> 'in' <expr> <.do>
+        <comp_stmt>
     'end'
-    {*}
 }
 
-token do { ':' | 'do' | <term> ['do']? }
+token do { ':' | 'do' | <terminator> ['do']? }
 
-rule unless_stmt {
-    'unless' <expr> <.then> <comp_stmt>
+rule basic_stmt:sym<unless> {
+    <sym> <expr> <.then> <comp_stmt>
     <else>?
     'end'
-    {*}
 }
 
-token else {
-    'else' <.ws> <comp_stmt>
-    {*}
-}
+token else { 'else' <.ws> <comp_stmt> }
 
-token control_command {
-    | 'next'  {*}                   #= next
-    | 'break' {*}                   #= break
-    | 'redo'  {*}                   #= redo
+token basic_primary:sym<control_command> {
+    | 'next'
+    | 'break'
+    | 'redo'
 }
 
-token yield {
-    'yield' <call_args> {*}
-}
+token basic_primary:sym<yield> { <sym> <call_args> }
 
-rule module {
-    'module' <module_identifier>
-    <comp_stmt>
+rule basic_stmt:sym<module> {
+    <sym> <module_identifier>
+        <comp_stmt>
     'end'
-    {*}
 }
 
-rule classdef {
-    'class' <module_identifier> {*}  #= open
-    <comp_stmt>
-    'end'                       {*}  #= block
+token begin_class { <module_identifier> }
+
+rule basic_stmt:sym<class> {
+    <sym> <begin_class>
+        <comp_stmt>
+    'end'
 }
 
-rule functiondef {
-    'def' <fname> <argdecl>
-    <comp_stmt>
+rule basic_stmt:sym<def> {
+    <sym> <fname> <argdecl>
+        <comp_stmt>
     'end'
-    {*}
 }
 
 rule argdecl {
@@ -292,136 +194,77 @@ rule argdecl {
     ')']?
 }
 
-token slurpy_param {
-    '*' <identifier>
-    {*}
-}
+token slurpy_param { '*' <identifier> }
 
-token block_param {
-    '&' <identifier>
-    {*}
-}
+token block_param { '&' <identifier> }
 
-rule begin_end {
+rule basic_stmt:sym<begin_end> {
     'begin'
-    <comp_stmt>
+        <comp_stmt>
     ['rescue' <args>? <.do> <comp_stmt>]+
     ['else' <comp_stmt>]?
     ['ensure' <comp_stmt>]?
     'end'
-    {*}
 }
 
 token fname {
     <.identifier> <[=!?]>?
 }
 
-token quote_string {
-    ['%q'|'%Q'] <.before <[<[_|({]>> <quote_EXPR: ':qq'>
-    {*}
-}
-
-token warray {
-    '%w' <.before <[<[({]>> <quote_EXPR: ':w :q'>
-    {*}
-}
+token literal:sym<quote_string> { ['%q'|'%Q'] <?before <[<[_|({]>> <quote_EXPR: ':qq'> }
+token literal:sym<warray> { '%w' <.before <[<[({]>> <quote_EXPR: ':w', ':q'> }
 
-rule array {
-    '[' [ <args> [',']? ]? ']'
-    {*}
-}
+rule literal:sym<array> { '[' [ <args> [',']? ]? ']' }
 
-rule ahash {
-    '{' [ <assocs> [',']? ]? '}'
-    {*}
-}
+rule literal:sym<ahash> { '{' [ <assocs> [',']? ]? '}' }
 
-rule assocs {
-    <assoc> [',' <assoc>]*
-    {*}
-}
+rule assocs { <assoc> [',' <assoc>]* }
 
-rule assoc {
-    <EXPR> '=>' <EXPR>
-    {*}
-}
+rule assoc { <EXPR> '=>' <EXPR> }
 
-token identifier {
-    <!reserved_word> <ident> {*}
-}
+token identifier { <!reserved_word> <ident> }
 
-token module_identifier {
-    <.before <[A..Z]>> <ident>
-    {*}
-}
+token module_identifier { <.before <[A..Z]>> <ident> }
 
-token global {
+token vartype:sym<global> {
     '$' [
         | <ident> 
         | <[!@&`'+~=/\\,;.<>_*$?:"]>
         | <digit>+ 
         | '-'<[0adFiIlpvw]>
         ]
-    {*}
 }
 
-token instance_variable {
-    '@' <ident>
-    {*}
-}
-
-token class_variable {
-    '@@' <ident>
-    {*}
-}
+token vartype:sym<instance> { '@' <ident> }
 
-token local_variable {
-    [<ns=ident> '::']* [ <before <[a..z_]>> | <after '::'> ] <ident>
-    {*}
-}
+token vartype:sym<class> { '@@' <ident> }
 
-token constant_variable {
-    <.before <[A..Z]>> <.ident>
-    {*}
-}
+# ?after is not implemented in npqrx
+token local_variable { [<ns=ident> '::']* [ <before <[a..z_]>> | <?double_colon> ] <ident> }
 
-token literal {
-    | <float> {*}          #= float
-    | <integer> {*}        #= integer
-    | <string> {*}         #= string
-    | <ahash> {*}          #= ahash
-    | <regex> {*}          #= regex
-    | <quote_string> {*}   #= quote_string
-    | <warray> {*}         #= warray
-    | <array> {*}          #= array
-    | 'true' {*}           #= true
-    | 'false' {*}          #= false
-    | 'nil' {*}            #= nil
-    | 'self' {*}           #= self
-}
+token double_colon { '::' }
 
-token float {
-    '-'? \d+ '.' \d+
-    {*}
-}
+token vartype:sym<constant> { <.before <[A..Z]>> <.ident> }
 
-token integer {
-    '-'? \d+
-    {*}
-}
+token basic_primary:sym<literal> { <literal> }
+proto token literal { <...> }
+token literal:sym<true> { <sym> }
+token literal:sym<false> { <sym> }
+token literal:sym<nil> { <sym> }
+token literal:sym<self> { <sym> }
+token literal:sym<float> { '-'? \d+ '.' \d+ }
+token literal:sym<integer> { '-'? \d+ }
 
-token string {
+token literal:sym<string> {
     [
     | <.before \'>     <quote_EXPR: ':q'>
     | <.before '"' >   <quote_EXPR: ':qq'>
     ]
-    {*}
 }
 
-token regex {
+token literal:sym<regex> {
     <.before '/'> [<quote_EXPR: ':regex'> $<modifiers>=[<alpha>]*
-                  |<panic('problem parsing regex')>]
-    {*}
+                  |<.panic: 'Problem parsing regex'>]
 }
 
 token reserved_word {
@@ -434,13 +277,15 @@ token reserved_word {
     |while|yield|__FILE__|__LINE__]>>
 }
 
+#?after is not implemented in nqprx
 token ws {
     | '\\' \n                      ## a backslash at end of line
-    | <after [','|'='|'+']> \n     ## a newline after a comma or operator is ignored
+    | <?[,=+]> \n     ## a newline after a comma or operator is ignored
     | \h* ['#' \N* \n* <ws>]?
 }
 
 INIT {
+    cardinal::Grammar.O(':prec<y=>', '%unary');
     cardinal::Grammar.O(':prec<x=>', '%muldiv');
     cardinal::Grammar.O(':prec<w=>', '%plusminus');
     cardinal::Grammar.O(':prec<v=>', '%bsh');
@@ -452,82 +297,64 @@ INIT {
     cardinal::Grammar.O(':prec<j=>', '%or');
     cardinal::Grammar.O(':prec<h=>', '%dotdot');
     cardinal::Grammar.O(':prec<f=>', '%ternary');
-    cardinal::Grammar.O(':prec<d=>, :assoc<right>', '%assignment'); # lvalue?
+    cardinal::Grammar.O(':prec<d=>, :assoc<right>', '%assignment');
     cardinal::Grammar.O(':prec<b=>', '%defined');
 }
 
-token infix:sym<=>         { <sym> <O('%assignment, :pasttype<copy>')> }
-
 token prefix:sym<defined?> { <sym> <O('%defined')> }
 
-token infix:sym<+=>        { <sym> <O('%assignment')> }
-
-token infix:sym<-=>        { <sym> <O('%assignment')> }
-
-token infix:sym</=>        { <sym> <O('%assignment, :pirop<div>')> }
-
-token infix:sym<*=>        { <sym> <O('%assignment, :pirop<mul>')> }
-
-token infix:sym<%=>        { <sym> <O('%assignment, :pirop<mul>')> }
-
-token infix:sym<|=>        { <sym> <O('%assignment')> }
-
-token infix:sym<&=>        { <sym> <O('%assignment')> }
-
-token infix:sym<~=>        { <sym> <O('%assignment')> }
-
-token infix:sym«>>=»        { <sym> <O('%assignment, :pirop<shr>')> }
-
-token infix:sym«<<=»        { <sym> <O('%assignment, :pirop<shl>')> }
-
-token infix:sym<&&=>        { <sym> <O('%assignment, :pirop<and>')> }
-
-token infix:sym<**=>        { <sym> <O('%assignment, :pirop<pow>')> }
-
-token infix:sym<? :>        { <sym> <O('%ternary, :reducecheck<ternary>, :pasttype<if>')> }
-
-token infix:sym<..>         { <sym> <O('%dotdot')> }
-
-token infix:sym<...>        { <sym> <O('%dotdot')> }
-
-token infix:sym<||>         { <sym> <O('%or, :pasttype<unless>')> }
-
-token infix:sym<&&>         { <sym> <O('%and, :pasttype<if>')> }
-
-token infix:sym<==>         { <sym> <O('%equality')> }
-token infix:sym<!=>         { <sym> <O('%equality')> }
-token infix:sym<=~>         { <sym> <O('%equality')> }
-token infix:sym<!~>         { <sym> <O('%equality')> }
-token infix:sym<===>        { <sym> <O('%equality')> }
-token infix:sym«<=>»        { <sym> <O('%equality')> }
-
-token infix:sym«>»          { <sym> <O('%cmp')> }
-token infix:sym«<»          { <sym> <O('%cmp')> }
-token infix:sym«<=»         { <sym> <O('%cmp')> }
-token infix:sym«>=»         { <sym> <O('%cmp')> }
-
-token infix:sym<|>          { <sym> <O('%bor')> }
-token infix:sym<^>          { <sym> <O('%bor')> }
-
-token infix:sym<&>          { <sym> <O('%band')> }
-
-token infix:sym«<<»         { <sym> <O('%bsh')> }
-token infix:sym«<>»         { <sym> <O('%bsh')> }
-
-token infix:sym<+>          { <sym> <O('%plusminus')> }
-token infix:sym<->          { <sym> <O('%plusminus')> }
-
-token infix:sym<*>          { <sym> <O('%muldiv')> }
-token infix:sym</>          { <sym> <O('%muldiv')> }
-token infix:sym<%>          { <sym> <O('%muldiv, :pirop<mod>')> }
-
-#token 'prefix:+' is tighter('infix:*')  { ... }
-#token 'prefix:-' is equiv('prefix:+')  { ... }
-#token 'prefix:!' is equiv('prefix:+')  { ... }
-#token 'prefix:~' is equiv('prefix:+')  { ... }
-
-#TODO
-#token 'term:'   is tighter('infix:*')
-#                is parsed(&primary)     { ... }
-
-#token 'circumfix:( )' is equiv('term:') { ... }
+token infix:sym<=>   { <sym> <O('%assignment, :pasttype<copy>')> }
+token infix:sym<+=>  { <sym> <O('%assignment')> }
+token infix:sym<-=>  { <sym> <O('%assignment')> }
+token infix:sym</=>  { <sym> <O('%assignment, :pirop<div>')> }
+token infix:sym<*=>  { <sym> <O('%assignment, :pirop<mul>')> }
+token infix:sym<%=>  { <sym> <O('%assignment, :pirop<mul>')> }
+token infix:sym<|=>  { <sym> <O('%assignment')> }
+token infix:sym<&=>  { <sym> <O('%assignment')> }
+token infix:sym<~=>  { <sym> <O('%assignment')> }
+token infix:sym«>>=» { <sym> <O('%assignment, :pirop<shr>')> }
+token infix:sym«<<=» { <sym> <O('%assignment, :pirop<shl>')> }
+token infix:sym<&&=> { <sym> <O('%assignment, :pirop<and>')> }
+token infix:sym<**=> { <sym> <O('%assignment, :pirop<pow>')> }
+
+token infix:sym<? :> { <sym> <O('%ternary, :reducecheck<ternary>, :pasttype<if>')> }
+
+token infix:sym<..>  { <sym> <O('%dotdot')> }
+token infix:sym<...> { <sym> <O('%dotdot')> }
+
+token infix:sym<||> { <sym> <O('%or, :pasttype<unless>')> }
+token infix:sym<&&> { <sym> <O('%and, :pasttype<if>')> }
+
+token infix:sym<==>  { <sym> <O('%equality')> }
+token infix:sym<!=>  { <sym> <O('%equality')> }
+token infix:sym<=~>  { <sym> <O('%equality')> }
+token infix:sym<!~>  { <sym> <O('%equality')> }
+token infix:sym<===> { <sym> <O('%equality')> }
+token infix:sym«<=>» { <sym> <O('%equality')> }
+
+token infix:sym«>»  { <sym> <O('%cmp')> }
+token infix:sym«<»  { <sym> <O('%cmp')> }
+token infix:sym«<=» { <sym> <O('%cmp')> }
+token infix:sym«>=» { <sym> <O('%cmp')> }
+
+token infix:sym<|> { <sym> <O('%bor')> }
+token infix:sym<^> { <sym> <O('%bor')> }
+token infix:sym<&> { <sym> <O('%band')> }
+
+token infix:sym«<<» { <sym> <O('%bsh')> }
+token infix:sym«>>» { <sym> <O('%bsh')> }
+
+token infix:sym<+> { <sym> <O('%plusminus')> }
+token infix:sym<-> { <sym> <O('%plusminus')> }
+token infix:sym<*> { <sym> <O('%muldiv')> }
+token infix:sym</> { <sym> <O('%muldiv')> }
+token infix:sym<%> { <sym> <O('%muldiv, :pirop<mod>')> }
+
+#token prefix:sym<+> { <sym> <O('%unary)> }
+#token prefix:sym<-> { <sym> <O('%unary)> }
+#token prefix:sym<!> { <sym> <O('%unary)> }
+#token prefix:sym<~> { <sym> <O('%unary)> }
+
+token circumfix:sym<( )> { '(' <.ws> <EXPR> ')' }
+
+# vim: sw=4 ts=4 ft=perl6 expandtab
diff --git a/src/parser/quote_expression.pir b/src/parser/quote_expression.pir
index 4518f02..2b4c592 100644
--- a/src/parser/quote_expression.pir
+++ b/src/parser/quote_expression.pir
@@ -26,7 +26,7 @@
 .end
 
 
-.sub 'quote_expression' :method
+.sub 'quote_EXPR' :method
     .param string flags
     .param pmc options         :slurpy :named
 
@@ -175,9 +175,9 @@
     pos += stoplen
     mob.'to'(pos)
     if null action goto succeed_done
-    $I0 = can action, 'quote_expression'
+    $I0 = can action, 'quote_EXPR'
     unless $I0 goto succeed_done
-    action.'quote_expression'(mob, key)
+    action.'quote_EXPR'(mob, key)
   succeed_done:
     .return (mob)
   fail: