10 files changed, 146 insertions, 107 deletions

diff --git a/lpcode.c b/lpcode.c
index 2a85e02..9fa8867 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -11,7 +11,7 @@
 
 #include "lptypes.h"
 #include "lpcode.h"
-
+#include "lpprint.h" /* labeled failure */
 
 /* signals a "no-instruction */
 #define NOINST          -1
@@ -424,10 +424,11 @@ int sizei (const Instruction *i) {
     case ITestSet: return CHARSETINSTSIZE + 1;
     case ITestChar: case ITestAny: case IChoice: case IJmp: case ICall:
     case IOpenCall: case ICommit: case IPartialCommit: case IBackCommit:
-    case IThrow:  /* labeled failure */
       return 2;
+    case IThrow:  /* labeled failure */ 
+                        return 1;
     case ILabChoice: 
-      return 3; /* labeled failure */
+      return (CHARSETINSTSIZE - 1) + 2; /* labeled failure */
     default: return 1;
   }
 }
@@ -491,27 +492,24 @@ 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);
+  assert(op == ITestSet || sizei(&getinstr(compst, i)) == 2 || op == ILabChoice); /* labeled failure */
   return i;
 }
 
 /* labeled failure begin */
-static int addthrowinstruction (CompileState *compst, Labelset ls) {
-  int i = nextinstruction(compst);
-  getinstr(compst, i).i.code = IThrow;
-  i = nextinstruction(compst);
-  getinstr(compst, i).labels = ls;
-  return i;
+static int addthrowinstruction (CompileState *compst, byte lab) {
+  return addinstruction(compst, IThrow, lab);
 }
 
-static int addoffsetlabinst (CompileState *compst, Labelset ls) {
+/*static int addoffsetlabinst (CompileState *compst, const byte *cs) {
   int j;
-        int i = addinstruction(compst, ILabChoice, 0);  /* instruction */
-  addinstruction(compst, (Opcode)0, 0);  /* open space for offset */
-  j = nextinstruction(compst);  /* open space for labels */
-        getinstr(compst, j).labels = ls;
+        int i = addinstruction(compst, ILabChoice, 0);  
+  addinstruction(compst, (Opcode)0, 0);  
+  j = nextinstruction(compst);  
+        getinstr(compst, j).labels = cs;
+
   return i; 
-}
+}*/
 /* labeled failure end */
 
 /*
@@ -718,18 +716,21 @@ 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, Labelset ls) {
+                        const Charset *fl, const byte *cs) {
         int emptyp2 = (p2->tag == TTrue);
                 int pcommit;
     int test = NOINST;
-    int pchoice = addoffsetlabinst(compst, ls);
+        /*  int pchoice = addoffsetlabinst(compst, cs);*/
+                int pchoice = addoffsetinst(compst, ILabChoice);
+                addcharset(compst, cs);
     codegen(compst, p1, emptyp2, test, fullset);
     pcommit = addoffsetinst(compst, ICommit);
     jumptohere(compst, pchoice);
     jumptohere(compst, test);
+                /*printf("vou codificar codelabchoice %d\n", p2->tag);*/
     codegen(compst, p2, opt, NOINST, fl);
     jumptohere(compst, pcommit);
-
+                /*printf("fim codelabchoice\n");*/
 }
 /* labeled failure end */
 
@@ -961,11 +962,11 @@ static void codegen (CompileState *compst, TTree *tree, int opt, int tt,
       tree = sib2(tree); goto tailcall;
     }
     case TThrow: { /* labeled failure */
-                        addthrowinstruction(compst, tree->labels);
+                        addthrowinstruction(compst, (byte) tree->u.label);
                         break;
                 }
                 case TLabChoice: { /* labeled failure */
-                        codelabchoice(compst, sib1(tree), sib2(tree), opt, fl, tree->labels); 
+                        codelabchoice(compst, sib1(tree), sib2(tree), opt, fl, treelabelset(tree)); 
                         break;
                 }
     default: assert(0);
diff --git a/lpprint.c b/lpprint.c
index 99cc3ac..0ca0b0e 100644
--- a/lpprint.c
+++ b/lpprint.c
@@ -109,12 +109,12 @@ void printinst (const Instruction *op, const Instruction *p) {
       break;
     }
     case IThrow: { /* labeled failure */
-      printf("%d", (p + 1)->labels);
+      printf("%d", p->i.aux);
       break;
     }
                 case ILabChoice: { /* labeled failure */
       printjmp(op, p);
-                        printf(" %d", (p + 2)->labels);
+      printcharset((p+2)->buff);
       break;
     }
     default: break;
@@ -217,14 +217,15 @@ void printtree (TTree *tree, int ident) {
       break;
     }
     case TThrow: { /* labeled failure */
-      printf(" labels: %d\n", tree->labels);
+      printf(" labels: %d\n", tree->u.label);
       break;
     }
     default: {
       int sibs = numsiblings[tree->tag];
       printf("\n");
       if (tree->tag == TLabChoice) { /* labeled failure */
-        printf(" labels: %d\n", tree->labels);
+        printcharset(treelabelset(tree));
+        printf("\n");
                         }
       if (sibs >= 1) {
         printtree(sib1(tree), ident + 2);
diff --git a/lptree.c b/lptree.c
index 22cf606..b974bbb 100644
--- a/lptree.c
+++ b/lptree.c
@@ -34,7 +34,6 @@ const byte numsiblings[] = {
 
 static TTree *newgrammar (lua_State *L, int arg);
 
-
 /*
 ** returns a reasonable name for value at index 'idx' on the stack
 */
@@ -63,7 +62,7 @@ static void fixonecall (lua_State *L, int postable, TTree *g, TTree *t) {
     luaL_error(L, "rule '%s' undefined in given grammar", val2str(L, -1));
   }
   t->tag = TCall;
-  t->u.ps = n - (t - g);  /* position relative to node */
+  t->u.s.ps = n - (t - g);  /* position relative to node */
   assert(sib2(t)->tag == TRule);
   sib2(t)->key = t->key;
 }
@@ -80,13 +79,13 @@ static void correctassociativity (TTree *tree) {
   TTree *t1 = sib1(tree);
   assert(tree->tag == TChoice || tree->tag == TSeq);
   while (t1->tag == tree->tag) {
-    int n1size = tree->u.ps - 1;  /* t1 == Op t11 t12 */
-    int n11size = t1->u.ps - 1;
+    int n1size = tree->u.s.ps - 1;  /* t1 == Op t11 t12 */
+    int n11size = t1->u.s.ps - 1;
     int n12size = n1size - n11size - 1;
     memmove(sib1(tree), sib1(t1), n11size * sizeof(TTree)); /* move t11 */
-    tree->u.ps = n11size + 1;
+    tree->u.s.ps = n11size + 1;
     sib2(tree)->tag = tree->tag;
-    sib2(tree)->u.ps = n12size + 1;
+    sib2(tree)->u.s.ps = n12size + 1;
   }
 }
 
@@ -375,16 +374,6 @@ static TTree *newleaf (lua_State *L, int tag) {
 }
 
 
-/* labeled failure begin */
-static TTree *newlabelleaf (lua_State *L, Labelset ls) {
-  TTree *tree = newtree(L, 1);
-  tree->tag = TThrow;
-        tree->labels = ls;
-  return tree;
-}
-/* labeled failure end */
-
-
 static TTree *newcharset (lua_State *L) {
   TTree *tree = newtree(L, bytes2slots(CHARSETSIZE) + 1);
   tree->tag = TSet;
@@ -398,7 +387,7 @@ static TTree *newcharset (lua_State *L) {
 ** 'sibsize'); returns position for second sibling
 */
 static TTree *seqaux (TTree *tree, TTree *sib, int sibsize) {
-  tree->tag = TSeq; tree->u.ps = sibsize + 1;
+  tree->tag = TSeq; tree->u.s.ps = sibsize + 1;
   memcpy(sib1(tree), sib, sibsize * sizeof(TTree));
   return sib2(tree);
 }
@@ -412,7 +401,7 @@ static TTree *seqaux (TTree *tree, TTree *sib, int sibsize) {
 static void fillseq (TTree *tree, int tag, int n, const char *s) {
   int i;
   for (i = 0; i < n - 1; i++) {  /* initial n-1 copies of Seq tag; Seq ... */
-    tree->tag = TSeq; tree->u.ps = 2;
+    tree->tag = TSeq; tree->u.s.ps = 2;
     sib1(tree)->tag = tag;
     sib1(tree)->u.n = s ? (byte)s[i] : 0;
     tree = sib2(tree);
@@ -519,7 +508,7 @@ static TTree *newroot2sib (lua_State *L, int tag) {
   TTree *tree2 = getpatt(L, 2, &s2);
   TTree *tree = newtree(L, 1 + s1 + s2);  /* create new tree */
   tree->tag = tag;
-  tree->u.ps =  1 + s1;
+  tree->u.s.ps =  1 + s1;
   memcpy(sib1(tree), tree1, s1 * sizeof(TTree));
   memcpy(sib2(tree), tree2, s2 * sizeof(TTree));
   joinktables(L, 1, sib2(tree), 2);
@@ -527,6 +516,32 @@ static TTree *newroot2sib (lua_State *L, int tag) {
 }
 
 
+/* labeled failure begin */
+static TTree *newthrowleaf (lua_State *L, int lab) {
+  TTree *tree = newtree(L, 1);
+  tree->tag = TThrow;
+        tree->u.label = lab;
+  return tree;
+}
+
+static TTree *newlabchoice (lua_State *L) {
+  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 = TLabChoice;
+  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 */
+
+
+
 static int lp_P (lua_State *L) {
   luaL_checkany(L, 1);
   getpatt(L, 1, NULL);
@@ -548,7 +563,7 @@ static int lp_seq (lua_State *L) {
   else if (tree1->tag == TTrue)
     lua_pushvalue(L, 2);  /* true . x = x */
   else
-    newroot2sib(L, TSeq);
+    newroot2sib(L, TSeq); 
   return 1;
 }
 
@@ -599,12 +614,12 @@ static int lp_star (lua_State *L) {
     /* size = (choice + seq + tree1 + true) * n, but the last has no seq */
     tree = newtree(L, n * (size1 + 3) - 1);
     for (; n > 1; n--) {  /* repeat (n - 1) times */
-      tree->tag = TChoice; tree->u.ps = n * (size1 + 3) - 2;
+      tree->tag = TChoice; tree->u.s.ps = n * (size1 + 3) - 2;
       sib2(tree)->tag = TTrue;
       tree = sib1(tree);
       tree = seqaux(tree, tree1, size1);
     }
-    tree->tag = TChoice; tree->u.ps = size1 + 1;
+    tree->tag = TChoice; tree->u.s.ps = size1 + 1;
     sib2(tree)->tag = TTrue;
     memcpy(sib1(tree), tree1, size1 * sizeof(TTree));
   }
@@ -647,7 +662,7 @@ static int lp_sub (lua_State *L) {
   else {
     TTree *tree = newtree(L, 2 + s1 + s2);
     tree->tag = TSeq;  /* sequence of... */
-    tree->u.ps =  2 + s2;
+    tree->u.s.ps =  2 + s2;
     sib1(tree)->tag = TNot;  /* ...not... */
     memcpy(sib1(sib1(tree)), t2, s2 * sizeof(TTree));  /* ...t2 */
     memcpy(sib2(tree), t1, s1 * sizeof(TTree));  /* ... and t1 */
@@ -703,18 +718,12 @@ static int lp_behind (lua_State *L) {
 
 /* labeled failure begin */
 /*
-** Throws a label or a set of labels  
+** Throws a label   
 */
 static int lp_throw (lua_State *L) {
-        int n = lua_gettop(L);
-        Labelset ls = 0;
-        int i;
-        for (i = 1; i <= n; i++) {
-                long long int d = (long long int)luaL_checkinteger(L, i);
-                luaL_argcheck(L, d >= 0 && d < (long long int)MAXLABELS, i, "invalid label index");
-                setlabel(ls, d);
-        }
-        newlabelleaf(L, ls);
+        int label = luaL_checkinteger(L, -1);
+        luaL_argcheck(L, label >= 0 && label < MAXLABELS, -1, "max or min label index exceeded");
+        newthrowleaf(L, label);
         return 1;
 }
 
@@ -722,17 +731,14 @@ static int lp_throw (lua_State *L) {
 ** labeled choice function
 */
 static int lp_labchoice (lua_State *L) {
-        TTree *tree;
         int n = lua_gettop(L);
+        TTree *tree = newlabchoice(L);
         int i;
-        Labelset ls = 0;
         for (i = 3; i <= n; i++) {
-                long long int d = (long long int)luaL_checkinteger(L, i);
-                luaL_argcheck(L, d >= 0 && d < (long long int)MAXLABELS, i, "invalid label index");
-                setlabel(ls, d);
+                int d = luaL_checkinteger(L, i);
+                luaL_argcheck(L, d >= 0 && d < MAXLABELS, i, "max or min label index exceeded");
+    setlabel(treelabelset(tree), (byte)d);
         }
-  tree = newroot2sib(L, TLabChoice);
-        tree->labels = ls;
   return 1;
 }
 /* labeled failure end */
@@ -883,7 +889,7 @@ static int lp_constcapture (lua_State *L) {
     tree = sib1(tree);
     for (i = 1; i <= n - 1; i++) {
       tree->tag = TSeq;
-      tree->u.ps = 3;  /* skip TCapture and its sibling */
+      tree->u.s.ps = 3;  /* skip TCapture and its sibling */
       auxemptycap(sib1(tree), Cconst);
       sib1(tree)->key = addtoktable(L, i);
       tree = sib2(tree);
@@ -985,7 +991,7 @@ static void buildgrammar (lua_State *L, TTree *grammar, int frule, int n) {
     nd->tag = TRule;
     nd->key = 0;
     nd->cap = i;  /* rule number */
-    nd->u.ps = rulesize + 1;  /* point to next rule */
+    nd->u.s.ps = rulesize + 1;  /* point to next rule */
     memcpy(sib1(nd), rn, rulesize * sizeof(TTree));  /* copy rule */
     mergektable(L, ridx, sib1(nd));  /* merge its ktable into new one */
     nd = sib2(nd);  /* move to next rule */
@@ -1213,8 +1219,8 @@ static int lp_match (lua_State *L) {
     long long int j = 0;
     int n = 1;
     lua_pushnil(L);
-    while (j < (long long int) MAXLABELS) {
-      if (labelf & (1ULL << j)) {       
+    while (j < MAXLABELS) {
+      if (testlabel(labelf.cs, j)) {    
         lua_pushinteger(L, j);
         n++;
                                 break; /* Changing the semantics: only one label */
diff --git a/lptree.h b/lptree.h
index 43299a4..5ed67eb 100644
--- a/lptree.h
+++ b/lptree.h
@@ -44,10 +44,13 @@ typedef struct TTree {
   byte tag;
   byte cap;  /* kind of capture (if it is a capture) */
   unsigned short key;  /* key in ktable for Lua data (0 if no key) */
-  Labelset labels; /* labeled failure */
   union {
-    int ps;  /* occasional second sibling */
     int n;  /* occasional counter */
+                int label; /* labeled failure */
+                struct {   /* labeled failure */
+        int ps;  /* occasional second sibling */
+                        int plab; /* occasional label set */
+                } s; /* labeled failure */
   } u;
 } TTree;
 
@@ -68,7 +71,7 @@ extern const byte numsiblings[];
 
 /* access to siblings */
 #define sib1(t)         ((t) + 1)
-#define sib2(t)         ((t) + (t)->u.ps)
+#define sib2(t)         ((t) + (t)->u.s.ps)
 
 
 
diff --git a/lptypes.h b/lptypes.h
index 560ddbb..f61c0ff 100644
--- a/lptypes.h
+++ b/lptypes.h
@@ -110,18 +110,6 @@ typedef struct Charset {
 #define setchar(cs,b)   ((cs)[(b) >> 3] |= (1 << ((b) & 7)))
 
 
-/* labeled failure begin */
-typedef long long int Labelset;
-
-#define MAXLABELS (sizeof(long long int) * 8)
-
-#define LFAIL 1
-
-/* set bit 'b' in set 's' */
-#define setlabel(s, b) ((s) |= (1ULL << (b)))
-/* labeled failure end */
-
-
 /*
 ** in capture instructions, 'kind' of capture and its offset are
 ** packed in field 'aux', 4 bits for each
@@ -156,6 +144,24 @@ typedef long long int Labelset;
 
 #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 testlabel testchar
+/* labeled failure end */
 
 #endif
 
diff --git a/lpvm.c b/lpvm.c
index c15d543..a57c4b3 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -26,6 +26,23 @@
 
 static const Instruction giveup = {{IGiveup, 0, 0}};
 
+/* labeled failure */
+static void setlabelfail(Labelset *ls) { 
+        loopset(i, ls->cs[i] = 0); 
+  ls->cs[IDXLFAIL] = 1;
+}
+
+static void clearandsetlabel(Labelset *ls, byte b) { 
+        loopset(i, ls->cs[i] = 0); 
+  setlabel(ls->cs, b);
+}
+
+
+static int cs_disjoint (const Charset *cs1, const Charset *cs2) {
+  loopset(i, if ((cs1->cs[i] & cs2->cs[i]) != 0) return 0;)
+  return 1;
+}
+/* labeled failure end */
 
 /*
 ** {======================================================
@@ -38,7 +55,7 @@ typedef struct Stack {
   const char *s;  /* saved position (or NULL for calls) */
   const Instruction *p;  /* next instruction */
   int caplevel;
-  Labelset ls; /* labeled failure */
+  const Labelset *ls; /* labeled failure */
 } Stack;
 
 
@@ -142,6 +159,8 @@ static int removedyncap (lua_State *L, Capture *capture,
 }
 
 
+
+
 /*
 ** Opcode interpreter
 */
@@ -154,15 +173,18 @@ 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 */
+        Labelset lsfail;
+        setlabelfail(&lsfail);
   stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++;
   lua_pushlightuserdata(L, stackbase);
-  for (;;) {
-#if defined(DEBUG)
-      printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
+  /*printf("match: %s\n", s);*/
+        for (;;) {
+/*#if defined(DEBUG)*/
+    /*  printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
              s, stack - getstackbase(L, ptop), ndyncap, captop);
-      printinst(op, p);
-      printcaplist(capture, capture + captop);
-#endif
+      printinst(op, p);*/
+      /*printcaplist(capture, capture + captop);*/
+/*#endif*/
     assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
     switch ((Opcode)p->i.code) {
       case IEnd: {
@@ -183,7 +205,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       case IAny: {
         if (s < e) { p++; s++; }
         else {
-          *labelf = LFAIL; /* labeled failure */
+          setlabelfail(labelf);  /* labeled failure */
                                         *sfail = s;
           goto fail;
         }
@@ -197,7 +219,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       case IChar: {
         if ((byte)*s == p->i.aux && s < e) { p++; s++; }
         else {
-          *labelf = LFAIL; /* labeled failure */
+          setlabelfail(labelf);  /* labeled failure */
                                         *sfail = s;
           goto fail;
         }
@@ -213,7 +235,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         if (testchar((p+1)->buff, c) && s < e)
           { p += CHARSETINSTSIZE; s++; }
         else {
-          *labelf = LFAIL; /* labeled failure */
+          setlabelfail(labelf);  /* labeled failure */
                                         *sfail = s;
           goto fail;
         }
@@ -229,7 +251,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
       case IBehind: {
         int n = p->i.aux;
         if (n > s - o) {
-          *labelf = LFAIL; /* labeled failure */
+          setlabelfail(labelf);  /* labeled failure */
                                         *sfail = s;
           goto fail;
         }
@@ -253,7 +275,7 @@ 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 = LFAIL; /* labeled failure */
+        stack->ls = &lsfail; /* labeled failure */
         stack->caplevel = captop;
         stack++;
         p += 2;
@@ -264,10 +286,10 @@ 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 = (p + 2)->labels;
+        stack->ls = (const Labelset *) ((p + 2)->buff);
         stack->caplevel = captop;
         stack++;
-        p += 3;
+        p += (CHARSETINSTSIZE - 1) + 2;
         continue;
       }
       case ICall: {
@@ -300,7 +322,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         continue;
       }
       case IThrow: { /* labeled failure */
-        *labelf = (p+1)->labels;
+        clearandsetlabel(labelf, p->i.aux);
                                 *sfail = s;
                                 /*printf("s = %s, sfail = %s\n", s, *sfail);*/
         goto fail;
@@ -310,13 +332,14 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         stack--;
         /* go through */
       case IFail:
-      *labelf = LFAIL; /* labeled failure */
+      setlabelfail(labelf);  /* labeled failure */
                         *sfail = s;
       fail: { /* pattern failed: try to backtrack */
         do {  /* remove pending calls */
           assert(stack > getstackbase(L, ptop));
           s = (--stack)->s;
-        } while (s == NULL || (!(stack->ls & *labelf) && stack->p != &giveup));
+          /*printf("s = %s, disj = %d\n", s, cs_disjoint(stack->ls, labelf));*/
+        } while (s == NULL || (stack->p != &giveup && cs_disjoint(stack->ls, labelf)));
         if (ndyncap > 0)  /* is there matchtime captures? */
           ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
         captop = stack->caplevel;
@@ -333,7 +356,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         fr -= rem;  /* 'rem' items were popped from Lua stack */
         res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
         if (res == -1) { /* fail? */
-          *labelf = LFAIL; /* labeled failure */
+                setlabelfail(labelf);  /* labeled failure */
                                         *sfail = (const char *) s; /* TODO: ??? */
           goto fail;
         }
diff --git a/lpvm.h b/lpvm.h
index cec9f5a..3e006d3 100644
--- a/lpvm.h
+++ b/lpvm.h
@@ -47,7 +47,6 @@ typedef union Instruction {
     short key;
   } i;
   int offset;
-  Labelset labels; /* labeled failure */
   byte buff[1];
 } Instruction;
 
diff --git a/makefile b/makefile
index 5728b38..ce53890 100644
--- a/makefile
+++ b/makefile
@@ -1,8 +1,8 @@
 LIBNAME = lpeglabel
 LUADIR = ../lua/
 
-COPT = -O2
-# COPT = -DLPEG_DEBUG -g
+#COPT = -O2
+COPT = -DLPEG_DEBUG -g
 
 CWARNS = -Wall -Wextra -pedantic \
         -Waggregate-return \
diff --git a/test.lua b/test.lua
index d5922ac..3f94edc 100755
--- a/test.lua
+++ b/test.lua
@@ -1115,7 +1115,6 @@ local re = require "relabel"
 local match, compile = re.match, re.compile
 
 
-
 assert(match("a", ".") == 2)
 assert(match("a", "''") == 1)
 assert(match("", " ! . ") == 1)
diff --git a/testlabel.lua b/testlabel.lua
index f7180a7..67dc36b 100644
--- a/testlabel.lua
+++ b/testlabel.lua
@@ -1,5 +1,7 @@
 local m = require 'lpeglabel'
 
+p = m.Lc(true, true, 1, 3)
+
 local p, r, l, s, serror
 
 -- throws a label 
@@ -133,7 +135,6 @@ assert(p:match("B") == 2)
 p = m.Lc(m.P"A", m.P(false), 1) + m.P("B")
 assert(p:match("B") == 2)
 
-
 --[[
 S -> A /{1} 'a'
 A -> B