Modify stack values up to L.top instead of replacing

1 files changed, 49 insertions, 49 deletions

diff --git a/src/lapi.js b/src/lapi.js
index 9b10d94..a8e0c82 100644
--- a/src/lapi.js
+++ b/src/lapi.js
@@ -112,7 +112,9 @@ const lua_xmove = function(from, to, n) {
 
     from.top -= n;
     for (let i = 0; i < n; i++) {
+        to.stack[to.top] = new lobject.TValue();
         lobject.setobj2s(to, to.top, from.stack[from.top + i]);
+        delete from.stack[from.top + i];
         to.top++;
     }
 };
@@ -135,21 +137,24 @@ const lua_gettop = function(L) {
 };
 
 const lua_pushvalue = function(L, idx) {
-    lobject.setobj2s(L, L.top, index2addr(L, idx));
-    L.top++;
+    lobject.pushobj2s(L, index2addr(L, idx));
     assert(L.top <= L.ci.top, "stack overflow");
 };
 
 const lua_settop = function(L, idx) {
     let func = L.ci.funcOff;
+    let newtop;
     if (idx >= 0) {
         assert(idx <= L.stack_last - (func + 1), "new top too large");
-        while (L.top < func + 1 + idx)
-            L.stack[L.top++] = new TValue(CT.LUA_TNIL, null);
-        L.top = func + 1 + idx;
+        newtop = func + 1 + idx;
     } else {
         assert(-(idx + 1) <= L.top - (func + 1), "invalid new top");
-        let newtop = L.top + idx + 1; /* 'subtract' index (index is negative) */
+        newtop = L.top + idx + 1; /* 'subtract' index (index is negative) */
+    }
+    if (L.top < newtop) {
+        while (L.top < newtop)
+            L.stack[L.top++] = new TValue(CT.LUA_TNIL, null);
+    } else {
         while (L.top > newtop)
             delete L.stack[--L.top];
     }
@@ -161,7 +166,8 @@ const lua_pop = function(L, n) {
 
 const reverse = function(L, from, to) {
     for (; from < to; from++, to--) {
-        let temp = L.stack[from];
+        let fromtv = L.stack[from];
+        let temp = new TValue(fromtv.type, fromtv.value);
         lobject.setobjs2s(L, from, to);
         lobject.setobj2s(L, to, temp);
     }
@@ -188,7 +194,7 @@ const lua_rotate = function(L, idx, n) {
 
 const lua_copy = function(L, fromidx, toidx) {
     let from = index2addr(L, fromidx);
-    L.stack[index2addr_(L, toidx)] = new TValue(from.type, from.value);
+    L.stack[index2addr_(L, toidx)].setfrom(from);
 };
 
 const lua_remove = function(L, idx) {
@@ -239,8 +245,7 @@ const lua_pushlstring = function(L, s, len) {
         assert(Array.isArray(s), "lua_pushlstring expects array of byte");
         ts = lstring.luaS_bless(L, s.slice(0, len));
     }
-    lobject.setsvalue2s(L, L.top, ts);
-    L.top++;
+    lobject.pushsvalue2s(L, ts);
     assert(L.top <= L.ci.top, "stack overflow");
 
     return ts.value;
@@ -249,14 +254,14 @@ const lua_pushlstring = function(L, s, len) {
 const lua_pushstring = function (L, s) {
     assert(Array.isArray(s) || s === undefined || s === null, "lua_pushstring expects array of byte");
 
-    if (s === undefined || s === null)
-        L.stack[L.top] = new TValue(CT.LUA_TNIL, null);
-    else {
+    if (s === undefined || s === null) {
+        L.stack[L.top] = new TValue(CT.LUA_TNIL, null)
+        L.top++;
+    } else {
         let ts = lstring.luaS_new(L, s);
-        lobject.setsvalue2s(L, L.top, ts);
+        lobject.pushsvalue2s(L, ts);
         s = ts.getstr(); /* internal copy */
     }
-    L.top++;
     assert(L.top <= L.ci.top, "stack overflow");
 
     return s;
@@ -276,14 +281,14 @@ const lua_pushfstring = function (L, fmt, ...argp) {
 const lua_pushliteral = function (L, s) {
     assert(typeof s === "string" || s === undefined || s === null, "lua_pushliteral expects a JS string");
 
-    if (s === undefined || s === null)
+    if (s === undefined || s === null) {
         L.stack[L.top] = new TValue(CT.LUA_TNIL, null);
-    else {
+        L.top++;
+    } else {
         let ts = lstring.luaS_newliteral(L, s);
-        lobject.setsvalue2s(L, L.top, ts);
+        lobject.pushsvalue2s(L, ts);
         s = ts.getstr(); /* internal copy */
     }
-    L.top++;
     assert(L.top <= L.ci.top, "stack overflow");
 
     return s;
@@ -300,16 +305,14 @@ const lua_pushcclosure = function(L, fn, n) {
         assert(n <= MAXUPVAL, "upvalue index too large");
 
         let cl = new CClosure(L, fn, n);
-
-        L.top -= n;
-        while (n--) {
-            cl.upvalue[n].setfrom(L.stack[L.top + n])
-            delete L.stack[L.top + n];
-        }
-
-        L.stack[L.top] = new TValue(CT.LUA_TCCL, cl);
+        for (let i=0; i<n; i++)
+            cl.upvalue[i].setfrom(L.stack[L.top - n + i]);
+        for (let i=1; i<n; i++)
+            delete L.stack[--L.top];
+        if (n>0)
+            --L.top;
+        L.stack[L.top].setclCvalue(cl);
     }
-
     L.top++;
     assert(L.top <= L.ci.top, "stack overflow");
 };
@@ -357,8 +360,7 @@ const auxsetstr = function(L, t, k) {
 
     let str = lstring.luaS_new(L, k);
     assert(1 < L.top - L.ci.funcOff, "not enough elements in the stack");
-    lobject.setsvalue2s(L, L.top, str); /* push 'str' (to make it a TValue) */
-    L.top++;
+    lobject.pushsvalue2s(L, str); /* push 'str' (to make it a TValue) */
     assert(L.top <= L.ci.top, "stack overflow");
     lvm.settable(L, t, L.stack[L.top - 1], L.stack[L.top - 2]);
     /* pop value and key */
@@ -435,7 +437,8 @@ const lua_rawset = function(L, idx) {
         slot.setfrom(v);
     }
     ltable.invalidateTMcache(o.value);
-    L.top -= 2;
+    delete L.stack[--L.top];
+    delete L.stack[--L.top];
 };
 
 const lua_rawseti = function(L, idx, n) {
@@ -458,7 +461,7 @@ const lua_rawsetp = function(L, idx, p) {
         let slot = ltable.luaH_set(L, o.value, k);
         slot.setfrom(v);
     }
-    L.top--;
+    delete L.stack[--L.top];
 };
 
 /*
@@ -468,8 +471,7 @@ const lua_rawsetp = function(L, idx, p) {
 const auxgetstr = function(L, t, k) {
     assert(Array.isArray(k), "key must be an array of bytes");
     let str = lstring.luaS_new(L, k);
-    lobject.setsvalue2s(L, L.top, str);
-    L.top++;
+    lobject.pushsvalue2s(L, str);
     assert(L.top <= L.ci.top, "stack overflow");
     lvm.gettable(L, t, L.stack[L.top - 1], L.top - 1);
     return L.stack[L.top - 1].ttnov();
@@ -478,8 +480,7 @@ const auxgetstr = function(L, t, k) {
 const lua_rawgeti = function(L, idx, n) {
     let t = index2addr(L, idx);
     assert(t.ttistable(), "table expected");
-    lobject.setobj2s(L, L.top, ltable.luaH_getint(t.value, n));
-    L.top++;
+    lobject.pushobj2s(L, ltable.luaH_getint(t.value, n));
     assert(L.top <= L.ci.top, "stack overflow");
     return L.stack[L.top - 1].ttnov();
 };
@@ -488,8 +489,7 @@ const lua_rawgetp = function(L, idx, p) {
     let t = index2addr(L, idx);
     assert(t.ttistable(), "table expected");
     let k = new TValue(CT.LUA_TLIGHTUSERDATA, p);
-    lobject.setobj2s(L, L.top, ltable.luaH_get(L, t.value, k));
-    L.top++;
+    lobject.pushobj2s(L, ltable.luaH_get(L, t.value, k));
     assert(L.top <= L.ci.top, "stack overflow");
     return L.stack[L.top - 1].ttnov();
 };
@@ -550,8 +550,7 @@ const lua_getupvalue = function(L, funcindex, n) {
     if (up) {
         let name = up.name;
         let val = up.val;
-        lobject.setobj2s(L, L.top, val);
-        L.top++;
+        lobject.pushobj2s(L, val);
         assert(L.top <= L.ci.top, "stack overflow");
         return name;
     }
@@ -565,8 +564,8 @@ const lua_setupvalue = function(L, funcindex, n) {
     if (aux) {
         let name = aux.name;
         let val = aux.val;
-        L.top--;
-        val.setfrom(L.stack[L.top]);
+        val.setfrom(L.stack[L.top-1]);
+        delete L.stack[--L.top];
         return name;
     }
     return null;
@@ -898,13 +897,12 @@ const lua_arith = function(L, op) {
         assert(2 < L.top - L.ci.funcOff, "not enough elements in the stack");  /* all other operations expect two operands */
     else {  /* for unary operations, add fake 2nd operand */
         assert(1 < L.top - L.ci.funcOff, "not enough elements in the stack");
-        lobject.setobjs2s(L, L.top, L.top - 1);
-        L.top++;
+        lobject.pushobj2s(L, L.stack[L.top-1]);
         assert(L.top <= L.ci.top, "stack overflow");
     }
     /* first operand at top - 2, second at top - 1; result go to top - 2 */
     lobject.luaO_arith(L, op, L.stack[L.top - 2], L.stack[L.top - 1], L.stack[L.top - 2]);
-    L.top--;  /* remove second operand */
+    delete L.stack[--L.top];  /* remove second operand */
 };
 
 /*
@@ -1037,13 +1035,15 @@ const lua_error = function(L) {
 const lua_next = function(L, idx) {
     let t = index2addr(L, idx);
     assert(t.ttistable(), "table expected");
+    L.stack[L.top] = new TValue();
     let more = ltable.luaH_next(L, t.value, L.top - 1);
     if (more) {
         L.top++;
         assert(L.top <= L.ci.top, "stack overflow");
         return 1;
     } else {
-        L.top--;
+        delete L.stack[L.top];
+        delete L.stack[--L.top];
         return 0;
     }
 };
@@ -1053,15 +1053,15 @@ const lua_concat = function(L, n) {
     if (n >= 2)
         lvm.luaV_concat(L, n);
     else if (n === 0) {
-        lobject.setsvalue2s(L, L.top, lstring.luaS_bless(L, []));
-        L.top++;
+        lobject.pushsvalue2s(L, lstring.luaS_bless(L, []));
         assert(L.top <= L.ci.top, "stack overflow");
     }
 };
 
 const lua_len = function(L, idx) {
     let t = index2addr(L, idx);
-    lvm.luaV_objlen(L, L.top, t);
+    L.stack[L.top] = new TValue();
+    lvm.luaV_objlen(L, L.stack[L.top], t);
     L.top++;
     assert(L.top <= L.ci.top, "stack overflow");
 };