Removing code related to previous recovery operator //{}

7 files changed, 15 insertions, 80 deletions

diff --git a/lpcode.c b/lpcode.c
index 82b8830..43e83b5 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -220,7 +220,7 @@ 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 TRecov: case TLabChoice:  /* labeled failure */
+                case TLabChoice:  /* labeled failure */
      /* we do not know whether sib2 will be evaluated */
      tree = sib1(tree); goto tailcall;
     case TCapture: case TGrammar: case TRule:
@@ -257,7 +257,7 @@ int fixedlen (TTree *tree) {
       else
         return len + n1;
     }
-    case TSeq: case TRecov: { /* labeled failure */
+    case TSeq: { 
       int n1 = fixedlen(sib1(tree));
       if (n1 < 0)
         return -1;
@@ -321,12 +321,6 @@ static int getfirst (TTree *tree, const Charset *follow, Charset *firstset) {
       loopset(i, firstset->cs[i] |= csaux.cs[i]);
       return e1 | e2;
     }
-    case TRecov: { /* labeled failure */
-        /* when p1 is not nullable, p2 has nothing to contribute;
-           and when p1 is nullable, then p2 will not match 
-           return getfirst(sib1(tree), fullset, firstset); */
-      tree = sib1(tree); follow = fullset; goto tailcall;
-    }
     case TSeq: {
       if (!nullable(sib1(tree))) {
         /* when p1 is not nullable, p2 has nothing to contribute;
@@ -405,7 +399,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 TRecov: case TLabChoice: /* labeled failure */
+    case TChoice: case TLabChoice: /* labeled failure */
       if (!headfail(sib1(tree))) return 0;
       /* else return headfail(sib2(tree)); */
       tree = sib2(tree); goto tailcall;
@@ -425,7 +419,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 TRecov: case TLabChoice: /* (?)labeled failure */
+    case TThrow: case TLabChoice: /* (?)labeled failure */
       return 0;
     case TChoice: case TRep:
       return 1;
@@ -462,7 +456,7 @@ int sizei (const Instruction *i) {
                         return 2;
     case IThrowRec:  /* labeled failure */ 
                         return 3;
-    case IRecov: case ILabChoice:
+    case ILabChoice:
       return (CHARSETINSTSIZE - 1) + 2; /* labeled failure */
 
     default: return 1;
@@ -529,7 +523,7 @@ 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 == IRecov || op == ILabChoice); /* labeled failure */
+         op == ILabChoice); /* labeled failure */
   return i;
 }
 
@@ -753,22 +747,6 @@ static void codechoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
 
 
 /* labeled failure begin */
-static void coderecovery (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 precovery = addoffsetinst(compst, IRecov);
-                addcharset(compst, cs);
-    codegen(compst, p1, emptyp2, test, fullset);
-    pcommit = addoffsetinst(compst, ICommit);
-    jumptohere(compst, precovery);
-    jumptohere(compst, test);
-    codegen(compst, p2, opt, NOINST, fl);
-    addinstruction(compst, IRet, 0);
-    jumptohere(compst, pcommit);
-}
-
 static void codelabchoice (CompileState *compst, TTree *p1, TTree *p2, int opt,
                         const Charset *fl, const byte *cs) {
         int emptyp2 = (p2->tag == TTrue);
@@ -1020,16 +998,9 @@ static void codegen (CompileState *compst, TTree *tree, int opt, int tt,
       tree = sib2(tree); goto tailcall;
     }
     case TThrow: { /* labeled failure */
-      /*printf("TThrow %s top %d\n", lua_typename(compst->L, -1), lua_gettop(compst->L));*/
-      /*lua_rawgeti(compst->L, -1, tree->key);*/
-      /*printf("Throw2 lab = %s\n", lua_tostring(compst->L, -1));*/
       codethrow(compst, tree); 
                         break;
                 }
-                case TRecov: { /* labeled failure */
-                        coderecovery(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
-                        break;
-                }
                 case TLabChoice: { /* labeled failure */
                         codelabchoice(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
                         break;
@@ -1056,7 +1027,7 @@ 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 IRecov: case ILabChoice: /* labeled failure */
+      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 1e8de3e..90e82ef 100644
--- a/lptree.c
+++ b/lptree.c
@@ -527,10 +527,10 @@ static TTree *newroot2sib (lua_State *L, int tag) {
 
 
 /* labeled failure begin */
-static TTree *newthrowleaf (lua_State *L, int lab) {
+static TTree *newthrowleaf (lua_State *L) {
   TTree *tree = newtree(L, 1);
   tree->tag = TThrow;
-        tree->u.s.ps = 0;
+        tree->u.s.ps = 0; /* there is no recovery rule associated */
   return tree;
 }
 
@@ -730,35 +730,15 @@ static int lp_behind (lua_State *L) {
 ** Throws a label 
 */
 static int lp_throw (lua_State *L) {
-        /*int label = luaL_checkinteger(L, -1);*/
-        /*luaL_argcheck(L, label >= 1 && label < MAXLABELS, -1, "the number of a label must be between 1 and 255");*/
         TTree * tree;
   luaL_checkstring(L, -1); 
-  tree = newthrowleaf(L, 0);
+  tree = newthrowleaf(L);
   tree->key = addtonewktable(L, 0, 1);
-  /*printf("lp_throw %d %s\n", tree->key, lua_tostring(L, 1));*/
         return 1;
 }
 
 
 /*
-** labeled recovery function
-*/
-static int lp_recovery (lua_State *L) {
-        int n = lua_gettop(L);
-        TTree *tree = newrootlab2sib(L, TRecov);
-  int i;
-  luaL_argcheck(L, n >= 3, 3, "non-nil value expected");
-  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 choice function
 */
 static int lp_labchoice (lua_State *L) {
@@ -1108,7 +1088,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 TRecov: case TLabChoice: /* must check both children */  /* labeled failure */
+    case TChoice: case TLabChoice: /* must check both children */  /* labeled failure */
       nb = verifyrule(L, sib1(tree), passed, npassed, nb);
       /* return verifyrule(L, sib2(tree), passed, npassed, nb); */
       tree = sib2(tree); goto tailcall;
@@ -1364,7 +1344,6 @@ static struct luaL_Reg pattreg[] = {
   {"setmaxstack", lp_setmax},
   {"type", lp_type},
   {"T", lp_throw}, /* labeled failure throw */
-  {"Rec", lp_recovery}, /* labeled failure recovery */
   {"Lc", lp_labchoice}, /* labeled failure choice */
   {NULL, NULL}
 };
diff --git a/lptree.h b/lptree.h
index bb53c84..2980821 100644
--- a/lptree.h
+++ b/lptree.h
@@ -35,10 +35,7 @@ typedef enum TTag {
                 'sib1' is capture body */
   TRunTime,  /* run-time capture: 'key' is Lua function;
                'sib1' is capture body */
-  TThrow,    /* labeled failure: 'label' = l */
-  TThrowRec,    /* labeled failure: 'label' = l */
-  TRecov,    /* labed failure: 'sib1' //{labels} 'sib2' */
-             /* the set of labels is stored in next CHARSETSIZE bytes */
+  TThrow,    /* labeled failure: ktable[key] is label's */
   TLabChoice /* labed failure: 'sib1' /{labels} 'sib2' */
              /* the set of labels is stored in next CHARSETSIZE bytes */
 } TTag;
diff --git a/lptree.o b/lptree.o
deleted file mode 100644
index 9e01066..0000000
--- a/lptree.o
+++ /dev/null
diff --git a/lpvm.c b/lpvm.c
index c408e4c..dfbda74 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -288,17 +288,6 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         p += (CHARSETINSTSIZE - 1) + 2;
         continue;
       }
-      case IRecov: { /* labeled failure */
-        if (stack == stacklimit)
-          stack = doublestack(L, &stacklimit, ptop);
-        stack->p = p + getoffset(p);
-        stack->s = NULL;
-        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);
@@ -311,7 +300,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       }
       case ICommit: {
         assert(stack > getstackbase(L, ptop) && (stack - 1)->ls != NULL); /* labeled failure */
-        /*assert((stack - 1)->s != NULL); labeled failure: IRecov does not push s onto the stack */
+        assert((stack - 1)->s != NULL);
         stack--;
         p += getoffset(p);
         continue;
diff --git a/lpvm.h b/lpvm.h
index c22e8d7..e4c5353 100644
--- a/lpvm.h
+++ b/lpvm.h
@@ -34,9 +34,8 @@ typedef enum Opcode {
   IOpenCapture,  /* start a capture */
   ICloseCapture,
   ICloseRunTime,
-  IThrow,    /* "fails" with a specific label labeled failure */
-  IThrowRec, /* "fails" with a specific label labeled failure */
-  IRecov,    /* stack a recovery; next fail with label 'f' will jump to 'offset' */
+  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/lpvm.o b/lpvm.o
deleted file mode 100644
index 19a9b1c..0000000
--- a/lpvm.o
+++ /dev/null