Implement :: and :::

lib/Cursor.cs

@@ -125,7 +125,9 @@ public struct State {
     }
 
     public void CommitGroup(string open, string close) {
-        XAct x = bt.next.obj.xact;
+        XAct x = bt.obj.xact;
+        if (Cursor.Trace)
+            x.Dump("committing " + open + "," + close);
         int level = 1;
         while (x != null) {
             x.committed = true;
@@ -232,6 +234,15 @@ public sealed class XAct {
     public readonly XAct next;
 
     public XAct(string tag, XAct next) { this.tag = tag; this.next = next; }
+
+    public void Dump(string st) {
+        string ac = st;
+        for (XAct x = this; x != null; x = x.next) {
+            ac += x.committed ? " + " : " - ";
+            ac += x.tag;
+        }
+        Console.WriteLine(ac);
+    }
 }
 
 // This is used to carry match states in and out of subrules.  Within subrules,

src/CodeGen.pm

@@ -67,7 +67,9 @@ use 5.010;
               OpenQuant    => [m => 'Void'],
               CloseQuant   => [m => 'Int32'],
               CommitGroup  => [m => 'Void'],
-              CommitGroupZW => [m => 'Void'],
+              CommitRule   => [m => 'Void'],
+              CommitAll    => [m => 'Void'],
+              CommitSpecificRule => [m => 'Void'],
               GetCursorList => [m => 'Variable'],
               LTMPushAlts  => [m => 'Void'],
               PushCursorList => [m => 'Void'],

src/RxOp.pm

@@ -362,6 +362,45 @@ use CgOp;
     no Moose;
 }
 
+{
+    package RxOp::CutLTM;
+    use Moose;
+    extends 'RxOp';
+
+    sub code {
+        my ($self, $body) = @_;
+        CgOp::rawcall(CgOp::rxframe, 'CommitGroup',
+            CgOp::clr_string("LTM"), CgOp::clr_string("ENDLTM"));
+    }
+
+    sub lad {
+        my ($self) = @_;
+        CgOp::rawnew('LADImp'); #special case
+    }
+
+    __PACKAGE__->meta->make_immutable;
+    no Moose;
+}
+
+{
+    package RxOp::CutRule;
+    use Moose;
+    extends 'RxOp';
+
+    sub code {
+        my ($self, $body) = @_;
+        CgOp::rawcall(CgOp::rxframe, 'CommitRule');
+    }
+
+    sub lad {
+        my ($self) = @_;
+        CgOp::rawnew('LADNull');
+    }
+
+    __PACKAGE__->meta->make_immutable;
+    no Moose;
+}
+
 {
     package RxOp::Alt;
     use Moose;
@@ -448,7 +487,8 @@ use CgOp;
               CgOp::letn(
                 "ks", CgOp::methodcall(CgOp::methodcall(
                     CgOp::subcall(CgOp::getindex(CgOp::letvar("i"),
-                        CgOp::letvar("fns")), CgOp::scopedlex('$¢')),
+                        CgOp::letvar("fns")), CgOp::newscalar(
+                        CgOp::rawcall(CgOp::rxframe, 'MakeCursor'))),
                     'list'), 'clone'),
                 CgOp::letvar("i", CgOp::arith('+',
                     CgOp::letvar("i"), CgOp::int(1))),

test2.pl

@@ -3,4 +3,22 @@
 
 ok '{}' ~~ / \{ <.ws> \} /, 'ws matches between \W';
 
+{
+    rxtest /z .* y [ a :: x | . ]/, "z.*y[a::x|.]",
+        ("zyax", "zyb", "zyaxya"), ("zya",);
+    # no ::> until STD gets here...
+    rxtest /z .* y [ a ::: x || . ]/, "z.*y[a:::x||.]",
+        ("zyax", "zyb"), ("zya", "zyaxya");
+
+    my grammar G7 {
+        proto regex TOP {*}
+        regex TOP:foo { a :: x }
+        regex TOP:bar { . }
+    }
+
+    ok G7.parse("ax"), ":: does not block forward";
+    ok G7.parse("b"), ":: does not affect other paths";
+    ok !G7.parse("a"), "cannot backtrack past :: in proto ltm";
+}
+
 done-testing;