Using field 'key' to allow strings as labels (partial)

4 files changed, 42 insertions, 14 deletions

diff --git a/lpcode.c b/lpcode.c
index f335dcb..d67d42f 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -519,6 +519,15 @@ static int addinstruction (CompileState *compst, Opcode op, int aux) {
   return i;
 }
 
+/* labeled failure */
+static int addthrowinstruction (CompileState *compst, int aux, int key) {
+  int i = addinstruction(compst, IThrow, aux);
+  getinstr(compst, i).i.key = key;
+  return i;
+}
+
+/* labeled failure */
+
 
 /*
 ** Add an instruction followed by space for an offset (to be set later)
@@ -996,7 +1005,10 @@ static void codegen (CompileState *compst, TTree *tree, int opt, int tt,
       tree = sib2(tree); goto tailcall;
     }
     case TThrow: { /* labeled failure */
-      addinstruction(compst, IThrow, (byte) tree->u.label);
+      /*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));*/
+      addthrowinstruction(compst, (byte) tree->u.label, tree->key); 
                         break;
                 }
                 case TRecov: { /* labeled failure */
diff --git a/lptree.c b/lptree.c
index 810e267..fea2ecf 100644
--- a/lptree.c
+++ b/lptree.c
@@ -216,7 +216,7 @@ static void correctkeys (TTree *tree, int n) {
   if (n == 0) return;  /* no correction? */
  tailcall:
   switch (tree->tag) {
-    case TOpenCall: case TCall: case TRunTime: case TRule: {
+    case TOpenCall: case TCall: case TRunTime: case TRule: case TThrow: { /* labeled failure */
       if (tree->key > 0)
         tree->key += n;
       break;
@@ -721,9 +721,14 @@ 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");
-        newthrowleaf(L, label);
+        /*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->u.label = addtonewktable(L, 0, 1);
+  tree->key = tree->u.label; 
+  /*printf("lp_throw %d %s\n", tree->key, lua_tostring(L, 1));*/
         return 1;
 }
 
@@ -1242,7 +1247,10 @@ static int lp_match (lua_State *L) {
   r = match(L, s, s + i, s + l, code, capture, ptop, &labelf, &sfail); /* labeled failure */
   if (r == NULL) { /* labeled failure begin */
     lua_pushnil(L);
-                lua_pushinteger(L, labelf);     
+    if (labelf)
+      lua_rawgeti(L, ktableidx(ptop), labelf);
+    else 
+                  lua_pushstring(L, "fail");
                 lua_pushinteger(L, sfail - (s + i) + 1); /* subject position related to the error */
     return 3;
   }  /* labeled failure end */
diff --git a/lpvm.c b/lpvm.c
index d2b1f55..61d609a 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -331,7 +331,11 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         continue;
       }
       case IThrow: { /* labeled failure */
-        *labelf = p->i.aux;
+        printf("IThrow here: key=%d aux = %d top = %d\n", p->i.key, p->i.aux, lua_gettop(L));
+        lua_rawgeti(L, ktableidx(ptop), p->i.key); 
+        printf("IThrow there %s top = %d\n", lua_tostring(L, -1), lua_gettop(L));
+        lua_pop(L, 1);
+        *labelf = p->i.key;
         pk = p + 1;
                                 *sfail = s;
         goto fail;
diff --git a/testlabel.lua b/testlabel.lua
index 1be1343..72eb9aa 100644
--- a/testlabel.lua
+++ b/testlabel.lua
@@ -6,6 +6,9 @@ local function checklabeq (x, ...)
   y = { ... }
   assert(type(x) == "table")
   assert(#x == #y)
+  if x[2] == 0 then -- 0 -> 'fail'
+    x[2] = 'fail'  
+        end
   for i = 1, 3 do
     assert(x[i] == y[i])
   end
@@ -81,12 +84,12 @@ print"+"
 p = m.T(1)
 s = "abc"
 r, l, poserr = p:match(s) 
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 -- throws a label, choice does not catch labels
 p = m.T(1) + m.P"a"
 r, l, poserr = p:match(s)
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 -- again throws a label that is not caught by choice
 local g = m.P{
@@ -96,21 +99,22 @@ local g = m.P{
   B = m.P"a"
 }
 r, l, poserr = g:match(s)
-assert(r == nil and l == 1 and poserr == 1)
+assert(r == nil and l == '1' and poserr == 1)
 
 -- throws a label in a position that is not the farthest one
 -- but it is the position that should be reported
 p = m.P(1) * m.P"a" + m.T(11) 
 checklabeq({3, nil, nil}, p:match("bac"))
-checklabeq({nil, 11, 1}, p:match("c"))
-checklabeq({nil, 11, 1}, p:match("x"))
-checklabeq({nil, 11, 1}, p:match("kx"))
+checklabeq({nil, '11', 1}, p:match("c"))
+checklabeq({nil, '11', 1}, p:match("x"))
+checklabeq({nil, '11', 1}, p:match("kx"))
 
 
 -- throws a label that is not caught by the recovery operator
 p = m.Rec(m.T(2), m.P"a", 1, 3)
 r, l, poserr = p:match(s)
-assert(r == nil and l == 2 and poserr == 1)
+print(r, l, poserr)
+assert(r == nil and l == '2' and poserr == 1)
 
 -- wraps the previous pattern with a recovery that catches label "2"
 p = m.Rec(p, m.P"a", 2)