Start getting various of the p5metachar bits in place, and eliminate a few bits that will be unrequired.

Author: jnthn

src/QRegex/P5Regex/Actions.nqp

@@ -42,22 +42,51 @@ class QRegex::P5Regex::Actions is HLL::Actions {
             $ast.unshift($qast);
             $qast := $ast;
         }
-        $qast.backtrack('r') if $qast && !$qast.backtrack &&
-            (%*RX<r> || $<backmod> && ~$<backmod>[0] eq ':');
+        $qast.backtrack('r') if $qast && !$qast.backtrack && %*RX<r>;
         make $qast;
     }
 
     method atom($/) {
         if $<metachar> {
             make $<metachar>.ast;
         }
+        elsif $<esc> {
+            my $qast := QAST::Regex.new( ~$<esc>, :rxtype<literal>, :node($/));
+            make $qast;
+        }
         else {
             my $qast := QAST::Regex.new( ~$/, :rxtype<literal>, :node($/));
             $qast.subtype('ignorecase') if %*RX<i>;
             make $qast;
         }
     }
+    
+    method p5metachar:sym<bs>($/) {
+        make $<backslash>.ast;
+    }
+    
+    method p5metachar:sym<.>($/) {
+        make QAST::Regex.new( :rxtype<cclass>, :subtype<.>, :node($/) );
+    }
+
+    method p5metachar:sym<^>($/) {
+        make QAST::Regex.new( :rxtype<anchor>, :subtype<bos>, :node($/) );
+    }
+
+    method p5metachar:sym<$>($/) {
+        make QAST::Regex.new(
+            :rxtype('concat'),
+            QAST::Regex.new(
+                :rxtype('quant'), :min(0), :max(1),
+                QAST::Regex.new( :rxtype('literal'), "\n" )
+            ),
+            QAST::Regex.new( :rxtype<anchor>, :subtype<eos>, :node($/) )
+        );
+    }
 
+    
+    # XXX Below here copied from p6regex; needs review
+    
     method quantifier:sym<*>($/) {
         my $qast := QAST::Regex.new( :rxtype<quant>, :min(0), :max(-1), :node($/) );
         make backmod($qast, $<backmod>);
@@ -117,26 +146,6 @@ class QRegex::P5Regex::Actions is HLL::Actions {
         make $qast;
     }
 
-    method metachar:sym<.>($/) {
-        make QAST::Regex.new( :rxtype<cclass>, :subtype<.>, :node($/) );
-    }
-
-    method metachar:sym<^>($/) {
-        make QAST::Regex.new( :rxtype<anchor>, :subtype<bos>, :node($/) );
-    }
-
-    method metachar:sym<^^>($/) {
-        make QAST::Regex.new( :rxtype<anchor>, :subtype<bol>, :node($/) );
-    }
-
-    method metachar:sym<$>($/) {
-        make QAST::Regex.new( :rxtype<anchor>, :subtype<eos>, :node($/) );
-    }
-
-    method metachar:sym<$$>($/) {
-        make QAST::Regex.new( :rxtype<anchor>, :subtype<eol>, :node($/) );
-    }
-
     method metachar:sym<lwb>($/) {
         make QAST::Regex.new( :rxtype<anchor>, :subtype<lwb>, :node($/) );
     }
@@ -157,10 +166,6 @@ class QRegex::P5Regex::Actions is HLL::Actions {
             :name<$!to>, PAST::Node.new('!LITERAL', ''), :node($/) );
     }
 
-    method metachar:sym<bs>($/) {
-        make $<backslash>.ast;
-    }
-
     method metachar:sym<assert>($/) {
         make $<assertion>.ast;
     }

src/QRegex/P5Regex/Grammar.nqp

@@ -35,8 +35,27 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
         [ <.ws> <quantifier=p5quantifier> ]?
         <.ws>
     }
+    
+    token atom {
+        [
+        | \w
+        | <metachar=p5metachar>
+        | '\\' {} $<esc>=.
+        ]
+    }
 
     proto token p5metachar { <...> }
+    
+    token p5metachar:sym<quant> {
+        <quantifier=p5quantifier>
+        <.panic: "quantifier quantifies nothing">
+    }
+    token p5metachar:sym<bs> { <sym> <backslash=p5backslash> }
+    token p5metachar:sym<.>  { <sym> }
+    token p5metachar:sym<^>  { <sym> }
+    token p5metachar:sym<$>  {
+        '$' <?before \W | $>
+    }
 
     proto token p5backslash { <...> }
 
@@ -63,14 +82,6 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
     }
 
     rule arglist { <arg> [ ',' <arg>]* }
-    
-    token atom {
-        # :dba('regex atom')
-        [
-        | \w [ \w+! <?before \w> ]?
-        | <metachar>
-        ]
-    }
 
     proto token quantifier { <...> }
     token quantifier:sym<*> { <sym> <backmod> }
@@ -101,22 +112,11 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
     token metachar:sym<( )> { '(' <nibbler> ')' }
     token metachar:sym<'> { <?[']> <quote_EXPR: ':q'> }
     token metachar:sym<"> { <?["]> <quote_EXPR: ':qq'> }
-    token metachar:sym<.> { <sym> }
-    token metachar:sym<^> { <sym> }
-    token metachar:sym<^^> { <sym> }
-    token metachar:sym<$> { <sym> }
-    token metachar:sym<$$> { <sym> }
-    token metachar:sym<:::> { <sym> <.panic: '::: not yet implemented'> }
-    token metachar:sym<::> { <sym> <.panic: ':: not yet implemented'> }
     token metachar:sym<lwb> { $<sym>=['<<'|'«'] }
     token metachar:sym<rwb> { $<sym>=['>>'|'»'] }
     token metachar:sym<from> { '<(' }
     token metachar:sym<to>   { ')>' }
-    token metachar:sym<bs> { \\ <backslash> }
     token metachar:sym<mod> { <mod_internal> }
-    token metachar:sym<quantifier> {
-        <quantifier> <.panic: 'Quantifier quantifies nothing'>
-    }
 
     ## we cheat here, really should be regex_infix:sym<~>
     token metachar:sym<~> {