Removing code related to labeled choice and recovery operators and updating tests

7 files changed, 102 insertions, 301 deletions

diff --git a/lpcode.c b/lpcode.c
index 43e83b5..0b813b8 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -220,9 +220,6 @@ int checkaux (TTree *tree, int pred) {
       if (checkaux(sib2(tree), pred)) return 1;
       /* else return checkaux(sib1(tree), pred); */
       tree = sib1(tree); goto tailcall;
-                case TLabChoice:  /* labeled failure */
-     /* we do not know whether sib2 will be evaluated */
-     tree = sib1(tree); goto tailcall;
     case TCapture: case TGrammar: case TRule:
       /* return checkaux(sib1(tree), pred); */
       tree = sib1(tree); goto tailcall;
@@ -264,7 +261,7 @@ int fixedlen (TTree *tree) {
       /* else return fixedlen(sib2(tree)) + len; */
       len += n1; tree = sib2(tree); goto tailcall;
     }
-    case TChoice: case TLabChoice: { /* labeled failure */
+    case TChoice: { 
       int n1 = fixedlen(sib1(tree));
       int n2 = fixedlen(sib2(tree));
       if (n1 != n2 || n1 < 0)
@@ -314,7 +311,7 @@ static int getfirst (TTree *tree, const Charset *follow, Charset *firstset) {
       loopset(i, firstset->cs[i] = follow->cs[i]); /* follow = fullset(?) */
       return 1;
     } 
-    case TChoice: case TLabChoice: { /*(?) labeled failure */
+    case TChoice: { 
       Charset csaux;
       int e1 = getfirst(sib1(tree), follow, firstset);
       int e2 = getfirst(sib2(tree), follow, &csaux);
@@ -399,7 +396,7 @@ static int headfail (TTree *tree) {
       if (!nofail(sib2(tree))) return 0;
       /* else return headfail(sib1(tree)); */
       tree = sib1(tree); goto tailcall;
-    case TChoice: case TLabChoice: /* labeled failure */
+    case TChoice: 
       if (!headfail(sib1(tree))) return 0;
       /* else return headfail(sib2(tree)); */
       tree = sib2(tree); goto tailcall;
@@ -419,7 +416,7 @@ static int needfollow (TTree *tree) {
     case TChar: case TSet: case TAny:
     case TFalse: case TTrue: case TAnd: case TNot:
     case TRunTime: case TGrammar: case TCall: case TBehind:
-    case TThrow: case TLabChoice: /* (?)labeled failure */
+    case TThrow: /* (?)labeled failure */
       return 0;
     case TChoice: case TRep:
       return 1;
@@ -456,8 +453,6 @@ int sizei (const Instruction *i) {
                         return 2;
     case IThrowRec:  /* labeled failure */ 
                         return 3;
-    case ILabChoice:
-      return (CHARSETINSTSIZE - 1) + 2; /* labeled failure */
 
     default: return 1;
   }
@@ -522,8 +517,7 @@ static int addinstruction (CompileState *compst, Opcode op, int aux) {
 static int addoffsetinst (CompileState *compst, Opcode op) {
   int i = addinstruction(compst, op, 0);  /* instruction */
   addinstruction(compst, (Opcode)0, 0);  /* open space for offset */
-  assert(op == ITestSet || sizei(&getinstr(compst, i)) == 2 || 
-         op == ILabChoice); /* labeled failure */
+  assert(op == ITestSet || sizei(&getinstr(compst, i)) == 2);
   return i;
 }
 
@@ -746,24 +740,6 @@ static void codechoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
 }
 
 
-/* labeled failure begin */
-static void codelabchoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
-                        const Charset *fl, const byte *cs) {
-        int emptyp2 = (p2->tag == TTrue);
-                int pcommit;
-    int test = NOINST;
-                int pchoice = addoffsetinst(compst, ILabChoice);
-                addcharset(compst, cs);
-    codegen(compst, p1, emptyp2, test, fullset);
-    pcommit = addoffsetinst(compst, ICommit);
-    jumptohere(compst, pchoice);
-    jumptohere(compst, test);
-    codegen(compst, p2, opt, NOINST, fl);
-    jumptohere(compst, pcommit);
-}
-/* labeled failure end */
-
-
 /*
 ** And predicate
 ** optimization: fixedlen(p) = n ==> <&p> == <p>; behind n
@@ -1001,10 +977,6 @@ static void codegen (CompileState *compst, TTree *tree, int opt, int tt,
       codethrow(compst, tree); 
                         break;
                 }
-                case TLabChoice: { /* labeled failure */
-                        codelabchoice(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
-                        break;
-                }
     default: assert(0);
   }
 }
@@ -1027,7 +999,6 @@ static void peephole (CompileState *compst) {
     switch (code[i].i.code) {
       case IChoice: case ICall: case ICommit: case IPartialCommit:
       case IBackCommit: case ITestChar: case ITestSet:
-      case ILabChoice: /* labeled failure */
       case ITestAny: {  /* instructions with labels */
         jumptothere(compst, i, finallabel(code, i));  /* optimize label */
         break;
diff --git a/lptree.c b/lptree.c
index 90e82ef..6d6b399 100644
--- a/lptree.c
+++ b/lptree.c
@@ -28,7 +28,7 @@ const byte numsiblings[] = {
   0, 0, 2, 1,  /* call, opencall, rule, grammar */
   1,  /* behind */
   1, 1,  /* capture, runtime capture */
-  0, 2, 2  /* labeled failure throw, recovery, labeled choice */
+  0  /* labeled failure throw */
 };
 
 
@@ -533,21 +533,6 @@ static TTree *newthrowleaf (lua_State *L) {
         tree->u.s.ps = 0; /* there is no recovery rule associated */
   return tree;
 }
-
-static TTree *newrootlab2sib (lua_State *L, int tag) {
-  int s1, s2;
-  TTree *tree1 = getpatt(L, 1, &s1);
-  TTree *tree2 = getpatt(L, 2, &s2);
-  TTree *tree = newtree(L, bytes2slots(LABELSETSIZE) + 1 + s1 + s2);  /* create new tree */
-  tree->tag = tag;
-  tree->u.s.ps =  1 + s1;
-        tree->u.s.plab = 1 + s1 + s2;
-        memcpy(sib1(tree), tree1, s1 * sizeof(TTree));
-  memcpy(sib2(tree), tree2, s2 * sizeof(TTree));
-  loopset(i, treelabelset(tree)[i] = 0);
-        joinktables(L, 1, sib2(tree), 2);
-  return tree;
-}
 /* labeled failure end */
 
 
@@ -736,22 +721,6 @@ static int lp_throw (lua_State *L) {
   tree->key = addtonewktable(L, 0, 1);
         return 1;
 }
-
-
-/*
-** labeled choice function
-*/
-static int lp_labchoice (lua_State *L) {
-        int n = lua_gettop(L);
-        TTree *tree = newrootlab2sib(L, TLabChoice);
-        int i;
-        for (i = 3; i <= n; i++) {
-                int d = luaL_checkinteger(L, i);
-                luaL_argcheck(L, d >= 1 && d < MAXLABELS, i, "the number of a label must be between 1 and 255");
-    setlabel(treelabelset(tree), (byte)d);
-        }
-  return 1;
-}
 /* labeled failure end */
 
 
@@ -1088,7 +1057,7 @@ static int verifyrule (lua_State *L, TTree *tree, int *passed, int npassed,
         return nb;
       /* else return verifyrule(L, sib2(tree), passed, npassed, nb); */
       tree = sib2(tree); goto tailcall;
-    case TChoice: case TLabChoice: /* must check both children */  /* labeled failure */
+    case TChoice: /* must check both children */
       nb = verifyrule(L, sib1(tree), passed, npassed, nb);
       /* return verifyrule(L, sib2(tree), passed, npassed, nb); */
       tree = sib2(tree); goto tailcall;
@@ -1344,7 +1313,6 @@ static struct luaL_Reg pattreg[] = {
   {"setmaxstack", lp_setmax},
   {"type", lp_type},
   {"T", lp_throw}, /* labeled failure throw */
-  {"Lc", lp_labchoice}, /* labeled failure choice */
   {NULL, NULL}
 };
 
diff --git a/lptree.h b/lptree.h
index 2980821..27aa476 100644
--- a/lptree.h
+++ b/lptree.h
@@ -35,9 +35,7 @@ typedef enum TTag {
                 'sib1' is capture body */
   TRunTime,  /* run-time capture: 'key' is Lua function;
                'sib1' is capture body */
-  TThrow,    /* labeled failure: ktable[key] is label's */
-  TLabChoice /* labed failure: 'sib1' /{labels} 'sib2' */
-             /* the set of labels is stored in next CHARSETSIZE bytes */
+  TThrow,    /* labeled failure: ktable[key] is label's name */
 } TTag;
 
 
diff --git a/lptypes.h b/lptypes.h
index 0fe250b..25e84a2 100644
--- a/lptypes.h
+++ b/lptypes.h
@@ -145,21 +145,6 @@ typedef struct Charset {
 #define testchar(st,c)  (((int)(st)[((c) >> 3)] & (1 << ((c) & 7))))
 
 /* labeled failure begin */
-#define MAXLABELS (UCHAR_MAX + 1)
-
-#define LABELSETSIZE CHARSETSIZE
-
-typedef Charset Labelset;
-
-#define setlabel setchar
-
-#define testlabel testchar
-
-/* access to labelset */
-#define treelabelset(t)      ((byte *)((t) + (t)->u.s.plab))
-
-#define IDXLFAIL 0
-
 #define LFAIL 0
 
 /* update the farthest failure */
diff --git a/lpvm.c b/lpvm.c
index dfbda74..251fa0a 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -26,13 +26,6 @@
 
 static const Instruction giveup = {{IGiveup, 0, 0}};
 
-/* labeled failure */
-static void setlabelfail(Labelset *ls) { 
-        loopset(i, ls->cs[i] = 0); 
-  ls->cs[IDXLFAIL] = 1;
-}
-/* labeled failure end */
-
 
 /*
 ** {======================================================
@@ -44,7 +37,6 @@ static void setlabelfail(Labelset *ls) {
 typedef struct Stack {
   const char *s;  /* saved position (or NULL for calls) */
   const Instruction *p;  /* next instruction */
-  const Labelset *ls; /* labeled failure */
   int caplevel;
 } Stack;
 
@@ -163,10 +155,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
   int captop = 0;  /* point to first empty slot in captures */
   int ndyncap = 0;  /* number of dynamic captures (in Lua stack) */
   const Instruction *p = op;  /* current instruction */
-  const Instruction *pk = NULL;  /* resume instruction */
-        Labelset lsfail;
-        setlabelfail(&lsfail);
-  stack->p = &giveup; stack->s = s; stack->ls = &lsfail; stack->caplevel = 0; stack++;  /* labeled failure */
+  stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++;  /* labeled failure */
         *sfail = s; /* labeled failure */
   lua_pushlightuserdata(L, stackbase);
   for (;;) {
@@ -198,7 +187,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         if (s < e) { p++; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
-          pk = p + 1;
                                         updatefarthest(*sfail, s); /*labeled failure */
           goto fail;
         }
@@ -213,7 +201,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         if ((byte)*s == p->i.aux && s < e) { p++; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
-          pk = p + 1;
                                         updatefarthest(*sfail, s); /*labeled failure */
           goto fail;
         }
@@ -230,7 +217,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
           { p += CHARSETINSTSIZE; s++; }
         else {
           *labelf = LFAIL; /* labeled failure */
-          pk = p + CHARSETINSTSIZE;
                                         updatefarthest(*sfail, s); /*labeled failure */
           goto fail;
         }
@@ -247,7 +233,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         int n = p->i.aux;
         if (n > s - o) {
           *labelf = LFAIL; /* labeled failure */
-                                        pk = p + 1;
                                         updatefarthest(*sfail, s); /*labeled failure */
           goto fail;
         }
@@ -271,35 +256,22 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
           stack = doublestack(L, &stacklimit, ptop);
         stack->p = p + getoffset(p);
         stack->s = s;
-        stack->ls = &lsfail; /* labeled failure */
         stack->caplevel = captop;
         stack++;
         p += 2;
         continue;
       }
-      case ILabChoice: { /* labeled failure */
-        if (stack == stacklimit)
-          stack = doublestack(L, &stacklimit, ptop);
-        stack->p = p + getoffset(p);
-        stack->s = s;
-        stack->ls = (const Labelset *) ((p + 2)->buff);
-        stack->caplevel = captop;
-        stack++;
-        p += (CHARSETINSTSIZE - 1) + 2;
-        continue;
-      }
       case ICall: {
         if (stack == stacklimit)
           stack = doublestack(L, &stacklimit, ptop);
         stack->s = NULL;
         stack->p = p + 2;  /* save return address */
-        stack->ls = NULL;
         stack++;
         p += getoffset(p);
         continue;
       }
       case ICommit: {
-        assert(stack > getstackbase(L, ptop) && (stack - 1)->ls != NULL); /* labeled failure */
+        assert(stack > getstackbase(L, ptop)); 
         assert((stack - 1)->s != NULL);
         stack--;
         p += getoffset(p);
@@ -325,8 +297,10 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         printf("IThrow there %s top = %d\n", lua_tostring(L, -1), lua_gettop(L));
         lua_pop(L, 1);*/
         *labelf = (p+1)->i.key;
-        pk = p + 1;
+        if (*labelf == LFAIL)
+            luaL_error(L, "labelf is %d", *labelf);
                                 *sfail = s;
+        stack = getstackbase(L, ptop);
         goto fail;
       }
       case IThrowRec: { /* labeled failure */
@@ -335,12 +309,13 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         printf("IThrowRec there %s top = %d\n", lua_tostring(L, -1), lua_gettop(L));
         lua_pop(L, 1);*/
         *labelf = (p+2)->i.key;
+        if (*labelf == LFAIL)
+            luaL_error(L, "labelf is %d", *labelf);
                                 *sfail = s;
         if (stack == stacklimit)
           stack = doublestack(L, &stacklimit, ptop);
         stack->s = NULL;
         stack->p = p + 3;
-        stack->ls = NULL;
         stack->caplevel = captop;
         stack++;
         p += getoffset(p);
@@ -352,31 +327,16 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         /* go through */
       case IFail:
       *labelf = LFAIL; /* labeled failure */
-      pk = NULL;
                         updatefarthest(*sfail, s); /*labeled failure */
       fail: { /* pattern failed: try to backtrack */
-        const Labelset *auxlab = NULL;
-                                Stack *pstack = stack;
         do {  /* remove pending calls */
-          assert(pstack > getstackbase(L, ptop));
-          auxlab = (--pstack)->ls;
-        } while (auxlab == NULL || !(pstack->p == &giveup || testlabel(pstack->ls->cs, *labelf)));
-        if (pstack->s != NULL) { /* labeled failure: giveup or backtrack frame */
-                                        stack = pstack;
-                                        s = stack->s;
-                if (ndyncap > 0)  /* is there matchtime captures? */
-                        ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
-                captop = stack->caplevel;
-                                } else { /* labeled failure: recovery frame */
-                                        if (stack == stacklimit)
-                stack = doublestack(L, &stacklimit, ptop);
-                                        stack->s = NULL;
-                stack->p = pk;  /* save return address */
-                stack->ls = NULL;
-                stack->caplevel = captop; /* TODO: really necessary?? */
-                                        stack++;
-                                }
-        p = pstack->p;
+          assert(stack > getstackbase(L, ptop));
+          s = (--stack)->s;
+        } while (s == NULL);
+        if (ndyncap > 0)  /* is there matchtime captures? */
+          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
+        captop = stack->caplevel;
+        p = stack->p;
 #if defined(DEBUG)
         printf("**FAIL**\n");
 #endif
@@ -394,7 +354,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
         if (res == -1) { /* fail? */
                 *labelf = LFAIL;  /* labeled failure */
-                                        pk = NULL;
                                         updatefarthest(*sfail, s); /*labeled failure */
           goto fail;
         }
diff --git a/lpvm.h b/lpvm.h
index e4c5353..a56da32 100644
--- a/lpvm.h
+++ b/lpvm.h
@@ -36,7 +36,6 @@ typedef enum Opcode {
   ICloseRunTime,
   IThrow,    /* fails with a given label */
   IThrowRec, /* fails with a given label and call rule at 'offset' */
-  ILabChoice /* stack a choice; next fail with label 'f' will jump to 'offset' */
 } Opcode;
 
 
diff --git a/testlabel.lua b/testlabel.lua
index 90a8f9e..9e2a586 100644
--- a/testlabel.lua
+++ b/testlabel.lua
@@ -202,78 +202,77 @@ assert(r == nil and l == '1' and poserr == 1)
 
 p = ##m.T(1) + m.P"a"
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 p = -m.T(1) * m.P"a"
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 p = -m.T(1) * m.P"a"
 r, l, poserr = p:match("bbc")
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 p = -(-m.T(1)) * m.P"a"
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
-p = m.Rec(-m.T(22), m.P"a", 22)
+p = m.P{
+  "S",
+  S = -m.T(22),
+  ["22"] = m.P"a" 
+} 
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 0 and poserr == 2)
+assert(r == nil and l == 'fail' and poserr == 2)
 
 assert(p:match("bbc") == 1)
 
-p = m.Rec(#m.T(22), m.P"a", 22)
-assert(p:match("abc") == 1)
-
-p = #m.Rec(m.T(22), m.P"a", 22)
-assert(p:match("abc") == 1)
-
-p = m.Rec(m.T(22), #m.P"a", 22)
-assert(p:match("abc") == 1)
-
-p = m.Rec(#m.T(22), m.P"a", 22)
-r, l, poserr = p:match("bbc")
-assert(r == nil and l == 0 and poserr == 1)
-
-p = m.Rec(#m.P("a") * m.T(22), m.T(15), 22)
-r, l, poserr = p:match("abc")
-assert(r == nil and l == 15 and poserr == 1)
-
-p = m.Rec(#(m.P("a") * m.T(22)), m.T(15), 22)
-r, l, poserr = p:match("abc")
-assert(r == nil and l == 15 and poserr == 2)
-
-p = m.Lc(#m.T(22), m.P"a", 22)
-assert(p:match("abc") == 2)
-
-p = #m.Lc(m.T(22), m.P"a", 22)
+p = m.P{
+  "S",
+  S = #m.T(22),
+  ["22"] = m.P"a" 
+}
 assert(p:match("abc") == 1)
 
-p = m.Lc(m.T(22), #m.P"a", 22)
+p = m.P{
+  "S",
+  S = m.T(22),
+  ["22"] = #m.P"a" 
+}
 assert(p:match("abc") == 1)
 
-p = m.Lc(#m.T(22), m.P"a", 22)
+p = m.P{
+  "S",
+  S = #m.T(22),
+  ["22"] = m.P"a" 
+}
 r, l, poserr = p:match("bbc")
-assert(r == nil and l == 0 and poserr == 1)
+assert(r == nil and l == 'fail' and poserr == 1)
 
-p = m.Lc(#m.P("a") * m.T(22), m.T(15), 22)
+p = m.P{
+  "S",
+  S = #m.P"a" * m.T(22),
+  ["22"] = m.T(15) 
+}
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 15 and poserr == 1)
+assert(r == nil and l == '15' and poserr == 1)
 
-p = m.Lc(#(m.P("a") * m.T(22)), m.T(15), 22)
+p = m.P{
+  "S",
+  S = #(m.P"a" * m.T(22)),
+  ["22"] = m.T(15) 
+}
 r, l, poserr = p:match("abc")
-assert(r == nil and l == 15 and poserr == 1)
-
+assert(r == nil and l == '15' and poserr == 2)
 
 
 -- tests related to repetition
 p = m.T(1)^0
 r, l, poserr = p:match("ab")
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 p = (m.P"a" + m.T(1))^0
 r, l, poserr = p:match("aa")
-assert(r == nil and l == 1 and poserr == 3)
+assert(r == nil and l == '1' and poserr == 3)
 
 
 -- Bug reported by Matthew Allen
@@ -281,18 +280,19 @@ assert(r == nil and l == 1 and poserr == 3)
 -- applied in case of labels
 
 -- recovery operator
-p = m.Rec(m.P"A", m.P(true), 1) + m.P("B")
-assert(p:match("B") == 2)
-
-p = m.Rec(m.P"A", m.P(false), 1) + m.P("B")
-assert(p:match("B") == 2)
-
+p = m.P{
+  "S",
+  S = m.P"A" + m.P"B",
+  ["2"] = m.P(true) 
+} 
 
--- labeled choices
-p = m.Lc(m.P"A", m.P(true), 1) + m.P("B")
 assert(p:match("B") == 2)
 
-p = m.Lc(m.P"A", m.P(false), 1) + m.P("B")
+p = m.P{
+  "S",
+  S = m.P"A" + m.P"B",
+  ["2"] = m.P(false) 
+} 
 assert(p:match("B") == 2)
 
 
@@ -303,152 +303,73 @@ B -> %1
 ]]
 g = m.P{
   "S",
-  S = m.Rec(m.V"A", m.P"a", 1),
+  S = m.V"A",
   A = m.V"B",
-  B = m.T(1),
+  B = m.T(2),
+  ["2"] = m.P'a'
 }
 assert(g:match("ab") == 2)
 r, l, poserr = g:match("bc")
-assert(r == nil and l == 0 and poserr == 1)
+assert(r == nil and l == 'fail' and poserr == 1)
 
 
 --[[
 S -> A 
-A -> (B (';' / %{1}))*
+A -> (B (';' / %{2}))*
 B -> 'a'
 ]]
 g = m.P{
   "S",
   S = m.V"A",
-  A = m.P(m.V"B" * (";" + m.T(1)))^0,
+  A = m.P(m.V"B" * (";" + m.T(2)))^0,
   B = m.P'a',
 }
 assert(g:match("a;a;") == 5)
 
 r, l, poserr = g:match("a;a")
-assert(r == nil and l == 1 and poserr == 4)
-
+assert(r == nil and l == '2' and poserr == 4)
 
--- %1 //{1,3} %2 //{2} 'a'
-p = m.Rec(m.Rec(m.T(1), m.T(2), 1, 3), m.P"a", 2)
-assert(p:match("abc") == 2)
-
-r, l, poserr = p:match("")
-assert(r == nil and l == 0 and poserr == 1)
 
-p = m.Rec(m.T(1), m.Rec(m.T(2), m.P"a", 2), 1, 3)
-assert(p:match("abc") == 2)
-
-r, l, poserr = p:match("")
-assert(r == nil and l == 0 and poserr == 1)
-
--- labeled choice
---[[
-S -> A /{1} 'a'
-A -> B
-B -> %1
-]]
-g = m.P{
-        "S",
-        S = m.Lc(m.V"A", m.P"a", 1),
-        A = m.V"B",
-        B = m.T(1),
-}
-assert(g:match("ab") == 2)
-r, l, poserr = g:match("bc")
-assert(r == nil and l == 0 and poserr == 1)
-
-
---[[
-S -> A 
-A -> (B (';' / %{1}))*
-B -> 'a'
-]]
-g = m.P{
-        "S",
-        S = m.V"A",
-        A = m.P(m.V"B" * (";" + m.T(1)))^0,
-        B = m.P'a',
+p = m.P{
+  "S",
+  S = m.T'A',
+  A = m.T'B',
+  B = m.P'a'
 }
-assert(g:match("a;a;") == 5)
-
-r, l, poserr = g:match("a;a")
-assert(r == nil and l == 1 and poserr == 4)
-
-
--- %1 /{1,3} %2 /{2} 'a'
-p = m.Lc(m.Lc(m.T(1), m.T(2), 1, 3), m.P"a", 2)
-assert(p:match("abc") == 2)
-
-r, l, poserr = p:match("")
-assert(r == nil and l == 0 and poserr == 1)
-
-p = m.Lc(m.T(1), m.Lc(m.T(2), m.P"a", 2), 1, 3)
 assert(p:match("abc") == 2)
 
 r, l, poserr = p:match("")
-assert(r == nil and l == 0 and poserr == 1)
+assert(r == nil and l == 'fail' and poserr == 1)
 
 
 -- Infinte Loop TODO: check the semantics
--- %1 //{1} %1 
-p = m.Rec(m.T(1), m.T(1), 1)
+p = m.P{
+  "S",
+  S = m.T"A",
+  A = m.T"S",
+}
 --r, l, poserr = p:match("ab")
 --assert(r == nil and l == 1 and poserr == "ab")
 
--- %1 //{1} 'a' (!. / %1) 
-p = m.Rec(m.T(1), m.P"a" * (-m.P(1) + m.T(1)), 1)
+p = m.P{
+  "S",
+  S = m.T"A",
+  A = m.P'a' * (-m.P(1) + m.T"A"),
+}
 r, l, poserr = p:match("ab")
-assert(r == nil and l == 0 and poserr == 2)
+assert(r == nil and l == 'fail' and poserr == 2)
 
 r, l, poserr = p:match("cd")
-assert(r == nil and l == 0 and poserr == 1)
+assert(r == nil and l == 'fail' and poserr == 1)
 
--- %1 //{1} . (!. / %1) 
-p = m.Rec(m.T(1), m.P(1) * (-m.P(1) + m.T(1)), 1)
+p = m.P{
+  "S",
+  S = m.T"A",
+  A = m.P(1) * (-m.P(1) + m.T"A"),
+}
 assert(p:match("abc") == 4)
 
 
--- testing the limit of labels
--- can only throw labels between 1 and 255
-local r = pcall(m.Rec, m.P"b", m.P"a", 0)
-assert(r == false)
-
-local r = pcall(m.Rec, m.P"b", m.P"a", 256)
-assert(r == false)
-
-local r = pcall(m.Rec, m.P"b", m.P"a", -1)
-assert(r == false)
-
-local r = pcall(m.Lc, m.P"b", m.P"a", 0)
-assert(r == false)
-
-local r = pcall(m.Lc, m.P"b", m.P"a", 256)
-assert(r == false)
-
-local r = pcall(m.Lc, m.P"b", m.P"a", -1)
-assert(r == false)
-
-local r = pcall(m.T, 0)
-assert(r == false)
-
-local r = pcall(m.T, 256)
-assert(r == false)
-
-local r = pcall(m.T, -1)
-assert(r == false)
-
-
-local r = m.Rec(m.P"b", m.P"a", 255)
-assert(p:match("a") == 2)
-
-p = m.T(255)
-s = "abc"
-r, l, poserr = p:match(s) 
-assert(r == nil and l == 255 and poserr == 1)
-
-
-
 print("+")
 
 --[[ grammar based on Figure 8 of paper submitted to SCP