Get various backslash sequences in place.

Author: jnthn

src/QRegex/P5Regex/Actions.nqp

@@ -140,7 +140,19 @@ class QRegex::P5Regex::Actions is HLL::Actions {
                 QAST::Regex.new( :rxtype<altseq>, |@alts );
         make $qast;
     }
+    
+    method p5backslash:sym<s>($/) {
+        make QAST::Regex.new(:rxtype<cclass>, '.CCLASS_WHITESPACE', 
+                             :subtype($<sym> eq 'n' ?? 'nl' !! ~$<sym>),
+                             :negate($<sym> le 'Z'), :node($/));
+    }
 
+    method p5backslash:sym<b>($/) {
+        make QAST::Regex.new(:rxtype<subrule>, :subtype<method>,
+                             :node($/), PAST::Node.new('wb'), 
+                             :negate($<sym> eq 'B'), :name('') );
+    }
+    
     method p5backslash:sym<misc>($/) {
         my $qast := QAST::Regex.new( ~$/ , :rxtype('literal'), :node($/) );
         make $qast;
@@ -262,18 +274,6 @@ class QRegex::P5Regex::Actions is HLL::Actions {
         make $qast;
     }
 
-    method backslash:sym<s>($/) {
-        make QAST::Regex.new(:rxtype<cclass>, '.CCLASS_WHITESPACE', 
-                             :subtype($<sym> eq 'n' ?? 'nl' !! ~$<sym>), 
-                             :negate($<sym> le 'Z'), :node($/));
-    }
-
-    method backslash:sym<b>($/) {
-        my $qast := QAST::Regex.new( "\b", :rxtype('enumcharlist'),
-                        :negate($<sym> eq 'B'), :node($/) );
-        make $qast;
-    }
-
     method backslash:sym<e>($/) {
         my $qast := QAST::Regex.new( "\c[27]", :rxtype('enumcharlist'),
                         :negate($<sym> eq 'E'), :node($/) );
@@ -333,11 +333,6 @@ class QRegex::P5Regex::Actions is HLL::Actions {
         make QAST::Regex.new( $<charspec>.ast, :rxtype('literal'), :node($/) );
     }
 
-    method backslash:sym<misc>($/) {
-        my $qast := QAST::Regex.new( ~$/ , :rxtype('literal'), :node($/) );
-        make $qast;
-    }
-
     method assertion:sym<?>($/) {
         my $qast;
         if $<assertion> {
@@ -363,22 +358,6 @@ class QRegex::P5Regex::Actions is HLL::Actions {
         make $qast;
     }
 
-    method assertion:sym<|>($/) {
-        my $qast;
-        my $name := ~$<identifier>;
-        if $name eq 'c' {
-            # codepoint boundaries alway match in
-            # our current Unicode abstraction level
-            $qast := 0;
-        }
-        elsif $name eq 'w' {
-            $qast := QAST::Regex.new(:rxtype<subrule>, :subtype<method>,
-                                     :node($/), PAST::Node.new('wb'), 
-                                     :name('') );
-        }
-        make $qast;
-    }
-
     method assertion:sym<method>($/) {
         my $qast := $<assertion>.ast;
         $qast.subtype('method');

src/QRegex/P5Regex/Grammar.nqp

@@ -40,7 +40,6 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
         [
         | \w
         | <metachar=p5metachar>
-        | '\\' {} $<esc>=.
         ]
     }
 
@@ -50,7 +49,7 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
         <quantifier=p5quantifier>
         <.panic: "quantifier quantifies nothing">
     }
-    token p5metachar:sym<bs> { <sym> <backslash=p5backslash> }
+    token p5metachar:sym<bs> { \\ <backslash=p5backslash> }
     token p5metachar:sym<.>  { <sym> }
     token p5metachar:sym<^>  { <sym> }
     token p5metachar:sym<$>  {
@@ -77,7 +76,11 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
     }
 
     proto token p5backslash { <...> }
+    
+    token p5backslash:sym<b> { $<sym>=[<[bB]>] }
+    token p5backslash:sym<s> { $<sym>=[<[dDnNsSwW]>] }
     token p5backslash:sym<misc> { \W }
+    token p5backslash:sym<oops> { <.panic: "Unrecognized Perl 5 regex backslash sequence"> }
 
     proto token p5assertion { <...> }
 
@@ -142,8 +145,6 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
     }
 
     proto token backslash { <...> }
-    token backslash:sym<s> { $<sym>=[<[dDnNsSwW]>] }
-    token backslash:sym<b> { $<sym>=[<[bB]>] }
     token backslash:sym<e> { $<sym>=[<[eE]>] }
     token backslash:sym<f> { $<sym>=[<[fF]>] }
     token backslash:sym<h> { $<sym>=[<[hH]>] }
@@ -158,13 +159,11 @@ grammar QRegex::P5Regex::Grammar is HLL::Grammar {
     token backslash:sym<Z> { 'Z' <.obs: '\\Z as end-of-string matcher', '\\n?$'> }
     token backslash:sym<Q> { 'Q' <.obs: '\\Q as quotemeta', 'quotes or literal variable match'> }
     token backslash:sym<unrec> { {} \w <.panic: 'Unrecognized backslash sequence'> }
-    token backslash:sym<misc> { \W }
 
     proto token assertion { <...> }
 
     token assertion:sym<?> { '?' [ <?before '>' > | <assertion> ] }
     token assertion:sym<!> { '!' [ <?before '>' > | <assertion> ] }
-    token assertion:sym<|> { '|' <identifier> }
 
     token assertion:sym<method> {
         '.' <assertion>