new implementation for the Virtual Machine

1 files changed, 231 insertions, 245 deletions

diff --git a/lvm.c b/lvm.c
index 9c1b13d0..4cead1d9 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.177 2001/03/26 14:31:49 roberto Exp roberto $
+** $Id: lvm.c,v 1.178 2001/04/06 18:25:00 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -28,15 +28,14 @@
 
 
 
-int luaV_tonumber (TObject *obj) {
-  if (ttype(obj) != LUA_TSTRING)
-    return 1;
-  else {
-    if (!luaO_str2d(svalue(obj), &nvalue(obj)))
-      return 2;
-    ttype(obj) = LUA_TNUMBER;
-    return 0;
+const TObject *luaV_tonumber (const TObject *obj, TObject *n) {
+  if (ttype(obj) == LUA_TNUMBER) return obj;
+  if (ttype(obj) == LUA_TSTRING && luaO_str2d(svalue(obj), &nvalue(n))) {
+    ttype(n) = LUA_TNUMBER;
+    return n;
   }
+  else
+    return NULL;
 }
 
 
@@ -148,8 +147,7 @@ void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res) {
       }
     }
     /* else will call the tag method */
-  }
-  else {  /* not a table; try a `gettable' tag method */
+  } else {  /* not a table; try a `gettable' tag method */
     tm = luaT_gettmbyObj(G(L), t, TM_GETTABLE);
     if (tm == NULL)  /* no tag method? */
       luaG_typeerror(L, t, l_s("index"));
@@ -162,7 +160,7 @@ void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res) {
 /*
 ** Receives table at `t', key at `key' and value at `val'.
 */
-void luaV_settable (lua_State *L, StkId t, StkId key, StkId val) {
+void luaV_settable (lua_State *L, StkId t, TObject *key, StkId val) {
   Closure *tm;
   if (ttype(t) == LUA_TTABLE) {  /* `t' is a table? */
     int tg = hvalue(t)->htag;
@@ -172,8 +170,7 @@ void luaV_settable (lua_State *L, StkId t, StkId key, StkId val) {
       return;
     }
     /* else will call the tag method */
-  }
-  else {  /* not a table; try a `settable' tag method */
+  } else {  /* not a table; try a `settable' tag method */
     tm = luaT_gettmbyObj(G(L), t, TM_SETTABLE);
     if (tm == NULL)  /* no tag method? */
       luaG_typeerror(L, t, l_s("index"));
@@ -188,8 +185,7 @@ void luaV_getglobal (lua_State *L, TString *name, StkId res) {
   if (!HAS_TM_GETGLOBAL(L, ttype(value)) ||  /* is there a tag method? */
       (tm = luaT_gettmbyObj(G(L), value, TM_GETGLOBAL)) == NULL) {
     setobj(res, value);  /* default behavior */
-  }
-  else
+  } else
     callTM(L, l_s("csor"), tm, name, value, res);
 }
 
@@ -200,8 +196,7 @@ void luaV_setglobal (lua_State *L, TString *name, StkId val) {
   if (!HAS_TM_SETGLOBAL(L, ttype(oldvalue)) ||  /* no tag methods? */
      (tm = luaT_gettmbyObj(G(L), oldvalue, TM_SETGLOBAL)) == NULL) {
     setobj(oldvalue, val);  /* raw set */
-  }
-  else
+  } else
     callTM(L, l_s("csoo"), tm, name, oldvalue, val);
 }
 
@@ -224,9 +219,10 @@ static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2,
 }
 
 
-static void call_arith (lua_State *L, StkId p1, TMS event) {
-  if (!call_binTM(L, p1, p1+1, p1, event))
-    luaG_binerror(L, p1, LUA_TNUMBER, l_s("perform arithmetic on"));
+static void call_arith (lua_State *L, StkId p1, TObject *p2,
+                        StkId res, TMS event) {
+  if (!call_binTM(L, p1, p2, res, event))
+    luaG_aritherror(L, p1, p2);
 }
 
 
@@ -270,9 +266,8 @@ void luaV_strconc (lua_State *L, int total, StkId top) {
     int n = 2;  /* number of elements handled in this pass (at least 2) */
     if (tostring(L, top-2) || tostring(L, top-1)) {
       if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
-        luaG_binerror(L, top-2, LUA_TSTRING, l_s("concat"));
-    }
-    else if (tsvalue(top-1)->len > 0) {  /* if len=0, do nothing */
+        luaG_concaterror(L, top-2, top-1);
+    } else if (tsvalue(top-1)->len > 0) {  /* if len=0, do nothing */
       /* at least two string values; get as many as possible */
       lu_mem tl = (lu_mem)tsvalue(top-1)->len + (lu_mem)tsvalue(top-2)->len;
       l_char *buffer;
@@ -321,7 +316,32 @@ static void adjust_varargs (lua_State *L, StkId base, int nfixargs) {
 
 
 
-#define dojump(pc, i)   ((pc) += GETARG_S(i))
+/*
+** some macros for common tasks in `luaV_execute'
+*/
+
+#define runtime_check(L, c)     { if (!(c)) return L->top; }
+
+#define RA(i)   (base+GETARG_A(i))
+#define RB(i)   (base+GETARG_B(i))
+#define RC(i)   (base+GETARG_C(i))
+#define RKC(i)  ((GETARG_C(i) < MAXSTACK) ? \
+                        base+GETARG_C(i) : \
+                        tf->k+GETARG_C(i)-MAXSTACK)
+#define KBc(i)  (tf->k+GETARG_Bc(i))
+
+#define Arith(op, optm) { \
+  const TObject *b = RB(i); const TObject *c = RKC(i);          \
+  TObject tempb, tempc; \
+  if ((ttype(b) == LUA_TNUMBER || (b = luaV_tonumber(b, &tempb)) != NULL) && \
+      (ttype(c) == LUA_TNUMBER || (c = luaV_tonumber(c, &tempc)) != NULL)) { \
+    setnvalue(RA(i), nvalue(b) op nvalue(c));           \
+  } else                \
+    call_arith(L, RB(i), RKC(i), RA(i), optm); \
+}
+
+
+#define dojump(pc, i)   ((pc) += GETARG_sBc(i))
 
 /*
 ** Executes the given Lua function. Parameters are between [base,top).
@@ -329,328 +349,294 @@ static void adjust_varargs (lua_State *L, StkId base, int nfixargs) {
 */
 StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
   const Proto *const tf = cl->f.l;
-  StkId top;  /* keep top local, for performance */
-  const Instruction *pc = tf->code;
-  const lua_Hook linehook = L->linehook;
-  L->ci->pc = &pc;
+  const Instruction *pc;
+  lua_Hook linehook;
   if (tf->is_vararg)  /* varargs? */
     adjust_varargs(L, base, tf->numparams);
   luaD_adjusttop(L, base, tf->maxstacksize);
-  top = base+tf->numparams+tf->is_vararg;
+  pc = tf->code;
+  L->ci->pc = &pc;
+  linehook = L->linehook;
   /* main loop of interpreter */
   for (;;) {
     const Instruction i = *pc++;
-    lua_assert(L->top == base+tf->maxstacksize);
     if (linehook)
       traceexec(L, linehook);
     switch (GET_OPCODE(i)) {
-      case OP_RETURN: {
-        L->top = top;
-        return base+GETARG_U(i);
-      }
-      case OP_CALL: {
-        int nres = GETARG_B(i);
-        if (nres == MULT_RET) nres = LUA_MULTRET;
-        L->top = top;
-        luaD_call(L, base+GETARG_A(i), nres);
-        top = L->top;
-        L->top = base+tf->maxstacksize;
-        break;
-      }
-      case OP_PUSHNIL: {
-        int n = GETARG_U(i);
-        lua_assert(n>0);
-        do {
-          setnilvalue(top++);
-        } while (--n > 0);
-        break;
-      }
-      case OP_POP: {
-        top -= GETARG_U(i);
-        break;
-      }
-      case OP_PUSHINT: {
-        setnvalue(top, (lua_Number)GETARG_S(i));
-        top++;
-        break;
-      }
-      case OP_PUSHSTRING: {
-        setsvalue(top, tf->kstr[GETARG_U(i)]);
-        top++;
+      case OP_MOVE: {
+        setobj(RA(i), RB(i));
         break;
       }
-      case OP_PUSHNUM: {
-        setnvalue(top, tf->knum[GETARG_U(i)]);
-        top++;
+      case OP_LOADK: {
+        setobj(RA(i), KBc(i));
         break;
       }
-      case OP_PUSHNEGNUM: {
-        setnvalue(top, -tf->knum[GETARG_U(i)]);
-        top++;
+      case OP_LOADINT: {
+        setnvalue(RA(i), (lua_Number)GETARG_sBc(i));
         break;
       }
-      case OP_PUSHUPVALUE: {
-        setobj(top++, &cl->upvalue[GETARG_U(i)]);
+      case OP_LOADUPVAL: {
+        setobj(RA(i), cl->upvalue+GETARG_Bc(i));
         break;
       }
-      case OP_GETLOCAL: {
-        setobj(top++, base+GETARG_U(i));
+      case OP_LOADNIL: {
+        TObject *ra = RA(i);
+        TObject *rb = RB(i);
+        do {
+          setnilvalue(ra++);
+        } while (ra <= rb);
         break;
       }
       case OP_GETGLOBAL: {
-        luaV_getglobal(L, tf->kstr[GETARG_U(i)], top);
-        top++;
+        lua_assert(ttype(KBc(i)) == LUA_TSTRING);
+        luaV_getglobal(L, tsvalue(KBc(i)), RA(i));
         break;
       }
       case OP_GETTABLE: {
-        top--;
-        luaV_gettable(L, top-1, top, top-1);
-        break;
-      }
-      case OP_GETDOTTED: {
-        setsvalue(top, tf->kstr[GETARG_U(i)]);
-        luaV_gettable(L, top-1, top, top-1);
-        break;
-      }
-      case OP_GETINDEXED: {
-        luaV_gettable(L, top-1, base+GETARG_U(i), top-1);
-        break;
-      }
-      case OP_PUSHSELF: {
-        setobj(top, top-1);
-        setsvalue(top+1, tf->kstr[GETARG_U(i)]);
-        luaV_gettable(L, top-1, top+1, top-1);
-        top++;
-        break;
-      }
-      case OP_CREATETABLE: {
-        luaC_checkGC(L);
-        sethvalue(top, luaH_new(L, GETARG_U(i)));
-        top++;
-        break;
-      }
-      case OP_SETLOCAL: {
-        setobj(base+GETARG_U(i), --top);
+        luaV_gettable(L, RB(i), RKC(i), RA(i));
         break;
       }
       case OP_SETGLOBAL: {
-        top--;
-        luaV_setglobal(L, tf->kstr[GETARG_U(i)], top);
+        lua_assert(ttype(KBc(i)) == LUA_TSTRING);
+        luaV_setglobal(L, tsvalue(KBc(i)), RA(i));
         break;
       }
       case OP_SETTABLE: {
-        StkId t = top-GETARG_A(i);
-        luaV_settable(L, t, t+1, top-1);
-        top -= GETARG_B(i);  /* pop values */
+        luaV_settable(L, RB(i), RKC(i), RA(i));
         break;
       }
-      case OP_SETLIST: {
-        int aux = GETARG_A(i) * LFIELDS_PER_FLUSH;
-        TObject *t = base+GETARG_B(i);
-        Hash *h = hvalue(t);
-        int n;
-        for (n = top-t-1; n; n--)
-          setobj(luaH_setnum(L, h, n+aux), --top);
+      case OP_NEWTABLE: {
+        luaC_checkGC(L);
+        sethvalue(RA(i), luaH_new(L, GETARG_Bc(i)));
         break;
       }
-      case OP_SETMAP: {
-        TObject *t = base+GETARG_U(i);
-        Hash *h = hvalue(t);
-        while (top-1 > t) {
-          top-=2;
-          setobj(luaH_set(L, h, top), top+1);
-        }
+      case OP_SELF: {
+        StkId ra = RA(i);
+        StkId rb = RB(i);
+        setobj(ra+1, rb);
+        luaV_gettable(L, rb, RKC(i), ra);
         break;
       }
       case OP_ADD: {
-        if (tonumber(top-2) || tonumber(top-1))
-          call_arith(L, top-2, TM_ADD);
-        else
-          nvalue(top-2) += nvalue(top-1);
-        top--;
-        break;
-      }
-      case OP_ADDI: {
-        if (tonumber(top-1)) {
-          setnvalue(top, (lua_Number)GETARG_S(i));
-          call_arith(L, top-1, TM_ADD);
-        }
-        else
-          nvalue(top-1) += (lua_Number)GETARG_S(i);
+        Arith( + , TM_ADD);
         break;
       }
       case OP_SUB: {
-        if (tonumber(top-2) || tonumber(top-1))
-          call_arith(L, top-2, TM_SUB);
-        else
-          nvalue(top-2) -= nvalue(top-1);
-        top--;
+        Arith( - , TM_SUB);
         break;
       }
-      case OP_MULT: {
-        if (tonumber(top-2) || tonumber(top-1))
-          call_arith(L, top-2, TM_MUL);
-        else
-          nvalue(top-2) *= nvalue(top-1);
-        top--;
+      case OP_MUL: {
+        Arith( * , TM_MUL);
         break;
       }
       case OP_DIV: {
-        if (tonumber(top-2) || tonumber(top-1))
-          call_arith(L, top-2, TM_DIV);
-        else
-          nvalue(top-2) /= nvalue(top-1);
-        top--;
+        Arith( / , TM_DIV);
         break;
       }
       case OP_POW: {
-        if (!call_binTM(L, top-2, top-1, top-2, TM_POW))
-          luaD_error(L, l_s("undefined operation"));
-        top--;
+        call_arith(L, RB(i), RKC(i), RA(i), TM_POW);
         break;
       }
-      case OP_CONCAT: {
-        int n = GETARG_U(i);
-        luaV_strconc(L, n, top);
-        top -= n-1;
-        luaC_checkGC(L);
-        break;
-      }
-      case OP_MINUS: {
-        if (tonumber(top-1)) {
-          setnilvalue(top);
-          call_arith(L, top-1, TM_UNM);
+      case OP_UNM: {
+        const TObject *rb = RB(i);
+        StkId ra = RA(i);
+        if (ttype(rb) == LUA_TNUMBER || (rb=luaV_tonumber(rb, ra)) != NULL) {
+          setnvalue(ra, -nvalue(rb));
+        }
+        else {
+          TObject temp;
+          setnilvalue(&temp);
+          call_arith(L, RB(i), &temp, ra, TM_UNM);
         }
-        else
-          nvalue(top-1) = -nvalue(top-1);
         break;
       }
       case OP_NOT: {
-        ttype(top-1) =
-           (ttype(top-1) == LUA_TNIL) ? LUA_TNUMBER : LUA_TNIL;
-        nvalue(top-1) = 1;
+        if (ttype(RB(i)) == LUA_TNIL) {
+          setnvalue(RA(i), 1);
+        } else {
+          setnilvalue(RA(i));
+        }
         break;
       }
-      case OP_JMPNE: {
-        top -= 2;
-        if (!luaO_equalObj(top, top+1)) dojump(pc, i);
+      case OP_CONCAT: {
+        StkId top = RC(i)+1;
+        StkId rb = RB(i);
+        luaV_strconc(L, top-rb, top);
+        setobj(RA(i), rb);
+        luaC_checkGC(L);
         break;
       }
-      case OP_JMPEQ: {
-        top -= 2;
-        if (luaO_equalObj(top, top+1)) dojump(pc, i);
+      case OP_CJMP:
+      case OP_JMP: {
+        dojump(pc, i);
         break;
       }
-      case OP_JMPLT: {
-        top -= 2;
-        if (luaV_lessthan(L, top, top+1)) dojump(pc, i);
+      case OP_TESTEQ: {
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (luaO_equalObj(RB(i), RKC(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPLE: {  /* a <= b  ===  !(b<a) */
-        top -= 2;
-        if (!luaV_lessthan(L, top+1, top)) dojump(pc, i);
+      case OP_TESTNE: {
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (!luaO_equalObj(RB(i), RKC(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPGT: {  /* a > b  ===  (b<a) */
-        top -= 2;
-        if (luaV_lessthan(L, top+1, top)) dojump(pc, i);
+      case OP_TESTLT: {
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (luaV_lessthan(L, RB(i), RKC(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPGE: {  /* a >= b  ===  !(a<b) */
-        top -= 2;
-        if (!luaV_lessthan(L, top, top+1)) dojump(pc, i);
+      case OP_TESTLE: {  /* b <= c  ===  !(c<b) */
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (!luaV_lessthan(L, RKC(i), RB(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPT: {
-        if (ttype(--top) != LUA_TNIL) dojump(pc, i);
+      case OP_TESTGT: {  /* b > c  ===  (c<b) */
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (luaV_lessthan(L, RKC(i), RB(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPF: {
-        if (ttype(--top) == LUA_TNIL) dojump(pc, i);
+      case OP_TESTGE: {  /* b >= c  === !(b<c) */
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (!luaV_lessthan(L, RB(i), RKC(i))) dojump(pc, *pc);
+        pc++;
         break;
       }
-      case OP_JMPONT: {
-        if (ttype(top-1) == LUA_TNIL) top--;
-        else dojump(pc, i);
+      case OP_TESTT: {
+        StkId rb = RB(i);
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (ttype(rb) != LUA_TNIL) {
+          int a = GETARG_A(i);
+          if (a != NO_REG) setobj(base+a, rb);
+          dojump(pc, *pc);
+        }
+        pc++;
         break;
       }
-      case OP_JMPONF: {
-        if (ttype(top-1) != LUA_TNIL) top--;
-        else dojump(pc, i);
+      case OP_TESTF: {
+        lua_assert(GET_OPCODE(*pc) == OP_CJMP);
+        if (ttype(RB(i)) == LUA_TNIL) {
+          int a = GETARG_A(i);
+          if (a != NO_REG) setnilvalue(base+a);
+          dojump(pc, *pc);
+        }
+        pc++;
         break;
       }
-      case OP_JMP: {
-        dojump(pc, i);
+      case OP_NILJMP: {
+        setnilvalue(RA(i));
+        pc++;
         break;
       }
-      case OP_PUSHNILJMP: {
-        setnilvalue(top++);
-        pc++;
+      case OP_CALL: {
+        int nres;
+        int b = GETARG_B(i);
+        if (b != NO_REG)
+          L->top = base+b;
+        nres = GETARG_C(i);
+        if (nres == NO_REG) nres = LUA_MULTRET;
+        luaD_call(L, RA(i), nres);
+        if (nres != LUA_MULTRET) {
+          lua_assert(L->top == RA(i)+nres);
+          L->top = base+tf->maxstacksize;
+        }
         break;
       }
+      case OP_RETURN: {
+        int b = GETARG_B(i);
+        if (b != NO_REG)
+          L->top = base+b;
+        return RA(i);
+      }
       case OP_FORPREP: {
-        int jmp = GETARG_S(i);
-        if (tonumber(top-1))
-          luaD_error(L, l_s("`for' step must be a number"));
-        if (tonumber(top-2))
-          luaD_error(L, l_s("`for' limit must be a number"));
-        if (tonumber(top-3))
+        int jmp = GETARG_sBc(i);
+        StkId breg = RA(i);
+        if (luaV_tonumber(breg, breg) == NULL)
           luaD_error(L, l_s("`for' initial value must be a number"));
+        if (luaV_tonumber(breg+1, breg+1) == NULL)
+          luaD_error(L, l_s("`for' limit must be a number"));
+        if (luaV_tonumber(breg+2, breg+2) == NULL)
+          luaD_error(L, l_s("`for' step must be a number"));
         pc += -jmp;  /* `jump' to loop end (delta is negated here) */
-        goto forloop;  /* do not increment index */
+        nvalue(breg) -= nvalue(breg+2);/* decrement index (to be incremented) */
+        /* go through */
       }
       case OP_FORLOOP: {
-        lua_assert(ttype(top-1) == LUA_TNUMBER);
-        lua_assert(ttype(top-2) == LUA_TNUMBER);
-        if (ttype(top-3) != LUA_TNUMBER)
+        StkId breg = RA(i);
+        if (ttype(breg) != LUA_TNUMBER)
           luaD_error(L, l_s("`for' index must be a number"));
-        nvalue(top-3) += nvalue(top-1);  /* increment index */
-      forloop:
-        if (nvalue(top-1) > 0 ?
-            nvalue(top-3) > nvalue(top-2) :
-            nvalue(top-3) < nvalue(top-2))
-          top -= 3;  /* end loop: remove control variables */
-        else
+        runtime_check(L, ttype(breg+1) == LUA_TNUMBER &&
+                         ttype(breg+2) == LUA_TNUMBER);
+        nvalue(breg) += nvalue(breg+2);  /* increment index */
+        if (nvalue(breg+2) > 0 ?
+            nvalue(breg) <= nvalue(breg+1) :
+            nvalue(breg) >= nvalue(breg+1))
           dojump(pc, i);  /* repeat loop */
         break;
       }
-      case OP_LFORPREP: {
-        int jmp = GETARG_S(i);
-        if (ttype(top-1) != LUA_TTABLE)
+      case OP_TFORPREP: {
+        int jmp = GETARG_sBc(i);
+        StkId breg = RA(i);
+        if (ttype(breg) != LUA_TTABLE)
           luaD_error(L, l_s("`for' table must be a table"));
-        top += 3;  /* index,key,value */
-        setnvalue(top-3, -1);  /* initial index */
-        setnilvalue(top-2);
-        setnilvalue(top-1);
+        setnvalue(breg+1, -1);  /* initial index */
+        setnilvalue(breg+2);
+        setnilvalue(breg+3);
         pc += -jmp;  /* `jump' to loop end (delta is negated here) */
         /* go through */
       }
-      case OP_LFORLOOP: {
-        Hash *t = hvalue(top-4);
-        int n = (int)nvalue(top-3);
-        lua_assert(ttype(top-3) == LUA_TNUMBER);
-        lua_assert(ttype(top-4) == LUA_TTABLE);
+      case OP_TFORLOOP: {
+        StkId breg = RA(i);
+        Hash *t;
+        int n;
+        runtime_check(L, ttype(breg) == LUA_TTABLE);
+        runtime_check(L, ttype(breg+1) == LUA_TNUMBER);
+        t = hvalue(breg);
+        n = (int)nvalue(breg+1);
         n = luaH_nexti(t, n);
-        if (n == -1)  /* end loop? */
-          top -= 4;  /* remove table, index, key, and value */
-        else {
+        if (n != -1) {  /* repeat loop? */
           Node *node = node(t, n);
-          setnvalue(top-3, n);  /* index */
-          setkey2obj(top-2, node);
-          setobj(top-1, val(node));
+          setnvalue(breg+1, n);  /* index */
+          setkey2obj(breg+2, node);
+          setobj(breg+3, val(node));
           dojump(pc, i);  /* repeat loop */
         }
         break;
       }
+      case OP_SETLIST:
+      case OP_SETLISTO: {
+        int bc;
+        int n;
+        Hash *h;
+        StkId ra = RA(i);
+        runtime_check(L, ttype(ra) == LUA_TTABLE);
+        h = hvalue(ra);
+        bc = GETARG_Bc(i);
+        if (GET_OPCODE(i) == OP_SETLIST)
+          n = (bc&(LFIELDS_PER_FLUSH-1)) + 1;
+        else
+          n = L->top - ra - 1;
+        bc &= ~(LFIELDS_PER_FLUSH-1);  /* bc = bc - bc%FPF */
+        for (; n > 0; n--)
+          setobj(luaH_setnum(L, h, bc+n), ra+n);
+        break;
+      }
       case OP_CLOSURE: {
-        int nup = GETARG_B(i);
-        luaC_checkGC(L);
-        L->top = top;
-        luaV_Lclosure(L, tf->kproto[GETARG_A(i)], nup);
-        top -= (nup-1);
+        Proto *p = tf->kproto[GETARG_Bc(i)];
+        int nup = p->nupvalues;
+        StkId ra = RA(i);
+        L->top = ra+nup;
+        luaV_Lclosure(L, p, nup);
         L->top = base+tf->maxstacksize;
+        luaC_checkGC(L);
         break;
       }
     }
   }
 }
+