details

lcode.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.9 2000/03/10 14:38:10 roberto Exp roberto $
+** $Id: lcode.c,v 1.10 2000/03/10 18:37:44 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -27,8 +27,7 @@ void luaK_error (LexState *ls, const char *msg) {
 ** If there is a jump target between this and the current instruction,
 ** returns the address of a dummy instruction to avoid wrong optimizations.
 */
-static Instruction *previous_instruction (LexState *ls) {
-  FuncState *fs = ls->fs;
+static Instruction *previous_instruction (FuncState *fs) {
   if (fs->pc > fs->lasttarget)  /* no jumps to current position? */
     return &fs->f->code[fs->pc-1];  /* returns previous instruction */
   else {
@@ -38,123 +37,134 @@ static Instruction *previous_instruction (LexState *ls) {
 }
 
 
-int luaK_primitivecode (LexState *ls, Instruction i) {
-  FuncState *fs = ls->fs;
-  luaM_growvector(ls->L, fs->f->code, fs->pc, 1, Instruction, codeEM, MAXARG_S);
+int luaK_primitivecode (FuncState *fs, Instruction i) {
+  luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction, codeEM, MAXARG_S);
   fs->f->code[fs->pc] = i;
   return fs->pc++;
 }
 
 
-static void luaK_minus (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
+static void luaK_minus (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
   switch(GET_OPCODE(*previous)) {
     case OP_PUSHINT: SETARG_S(*previous, -GETARG_S(*previous)); return;
     case OP_PUSHNUM: SET_OPCODE(*previous, OP_PUSHNEGNUM); return;
     case OP_PUSHNEGNUM: SET_OPCODE(*previous, OP_PUSHNUM); return;
-    default: luaK_primitivecode(ls, CREATE_0(OP_MINUS));
+    default: luaK_primitivecode(fs, CREATE_0(OP_MINUS));
   }
 }
 
 
-static void luaK_gettable (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, -1);
+static void luaK_gettable (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, -1);
   switch(GET_OPCODE(*previous)) {
     case OP_PUSHSTRING: SET_OPCODE(*previous, OP_GETDOTTED); break;
-    default: luaK_primitivecode(ls, CREATE_0(OP_GETTABLE));
+    default: luaK_primitivecode(fs, CREATE_0(OP_GETTABLE));
   }
 }
 
 
-static void luaK_add (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, -1);
+static void luaK_add (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, -1);
   switch(GET_OPCODE(*previous)) {
     case OP_PUSHINT: SET_OPCODE(*previous, OP_ADDI); break;
-    default: luaK_primitivecode(ls, CREATE_0(OP_ADD));
+    default: luaK_primitivecode(fs, CREATE_0(OP_ADD));
   }
 }
 
 
-static void luaK_sub (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, -1);
+static void luaK_sub (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, -1);
   switch(GET_OPCODE(*previous)) {
     case OP_PUSHINT:
       SET_OPCODE(*previous, OP_ADDI);
       SETARG_S(*previous, -GETARG_S(*previous));
       break;
-    default: luaK_primitivecode(ls, CREATE_0(OP_SUB));
+    default: luaK_primitivecode(fs, CREATE_0(OP_SUB));
   }
 }
 
 
-static void luaK_conc (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, -1);
+static void luaK_conc (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, -1);
   switch(GET_OPCODE(*previous)) {
     case OP_CONC: SETARG_U(*previous, GETARG_U(*previous)+1); break;
-    default: luaK_primitivecode(ls, CREATE_U(OP_CONC, 2));
+    default: luaK_primitivecode(fs, CREATE_U(OP_CONC, 2));
   }
 }
 
 
-static void luaK_eq (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
+static void luaK_eq (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
   if (*previous == CREATE_U(OP_PUSHNIL, 1)) {
     *previous = CREATE_0(OP_NOT);
-    luaK_deltastack(ls, -1);  /* undo effect of PUSHNIL */
+    luaK_deltastack(fs, -1);  /* undo effect of PUSHNIL */
   }
   else
-    luaK_S(ls, OP_IFEQJMP, 0, -2);
+    luaK_S(fs, OP_IFEQJMP, 0, -2);
 }
 
 
-static void luaK_neq (LexState *ls) {
-  Instruction *previous = previous_instruction(ls);
+static void luaK_neq (FuncState *fs) {
+  Instruction *previous = previous_instruction(fs);
   if (*previous == CREATE_U(OP_PUSHNIL, 1)) {
-    ls->fs->pc--;  /* remove PUSHNIL */
-    luaK_deltastack(ls, -1);  /* undo effect of PUSHNIL */
+    fs->pc--;  /* remove PUSHNIL */
+    luaK_deltastack(fs, -1);  /* undo effect of PUSHNIL */
   }
   else
-    luaK_S(ls, OP_IFNEQJMP, 0, -2);
+    luaK_S(fs, OP_IFNEQJMP, 0, -2);
 }
 
 
-void luaK_retcode (LexState *ls, int nlocals, int nexps) {
-  Instruction *previous = previous_instruction(ls);
+void luaK_retcode (FuncState *fs, int nlocals, int nexps) {
+  Instruction *previous = previous_instruction(fs);
   if (nexps > 0 && GET_OPCODE(*previous) == OP_CALL) {
-    LUA_ASSERT(ls->L, GETARG_B(*previous) == MULT_RET, "call should be open");
+    LUA_ASSERT(fs->L, GETARG_B(*previous) == MULT_RET, "call should be open");
     SET_OPCODE(*previous, OP_TAILCALL);
     SETARG_B(*previous, nlocals);
   }
   else
-    luaK_primitivecode(ls, CREATE_U(OP_RETURN, nlocals));
+    luaK_primitivecode(fs, CREATE_U(OP_RETURN, nlocals));
 }
 
 
-static void luaK_pushnil (LexState *ls, int n) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, n);
+static void luaK_pushnil (FuncState *fs, int n) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, n);
   switch(GET_OPCODE(*previous)) {
     case OP_PUSHNIL: SETARG_U(*previous, GETARG_U(*previous)+n); break;
-    default: luaK_primitivecode(ls, CREATE_U(OP_PUSHNIL, n));
+    default: luaK_primitivecode(fs, CREATE_U(OP_PUSHNIL, n));
   }
 }
 
 
-int luaK_code (LexState *ls, Instruction i, int delta) {
-  luaK_deltastack(ls, delta);
-  return luaK_primitivecode(ls, i);
+int luaK_code (FuncState *fs, Instruction i, int delta) {
+  luaK_deltastack(fs, delta);
+  return luaK_primitivecode(fs, i);
 }
 
 
-void luaK_fixjump (LexState *ls, int pc, int dest) {
-  FuncState *fs = ls->fs;
+void luaK_fixjump (FuncState *fs, int pc, int dest) {
   Instruction *jmp = &fs->f->code[pc];
-  /* jump is relative to position following jump instruction */
-  SETARG_S(*jmp, dest-(pc+1));
+  if (dest != NO_JUMP) {
+    /* jump is relative to position following jump instruction */
+    SETARG_S(*jmp, dest-(pc+1));
+  }
+  else
+    SETARG_S(*jmp, 0);  /* absolute value to represent end of list */
+}
+
+
+static int luaK_getjump (FuncState *fs, int pc) {
+  int offset = GETARG_S(fs->f->code[pc]);
+  if (offset == 0)
+    return NO_JUMP;  /* end of list */
+  else
+    return (pc+1)+offset;
 }
 
 
@@ -162,26 +172,24 @@ void luaK_fixjump (LexState *ls, int pc, int dest) {
 ** returns current `pc' and marks it as a jump target (to avoid wrong
 ** optimizations with consecutive instructions not in the same basic block).
 */
-int luaK_getlabel (LexState *ls) {
-  FuncState *fs = ls->fs;
+int luaK_getlabel (FuncState *fs) {
   fs->lasttarget = fs->pc;
   return fs->pc;
 }
 
 
-void luaK_deltastack (LexState *ls, int delta) {
-  FuncState *fs = ls->fs;
+void luaK_deltastack (FuncState *fs, int delta) {
   fs->stacksize += delta;
   if (delta > 0 && fs->stacksize > fs->f->maxstacksize) {
     if (fs->stacksize > MAXSTACK)
-      luaK_error(ls, "function or expression too complex");
+      luaK_error(fs->ls, "function or expression too complex");
     fs->f->maxstacksize = fs->stacksize;
   }
 }
 
 
 void luaK_kstr (LexState *ls, int c) {
-  luaK_U(ls, OP_PUSHSTRING, c, 1);
+  luaK_U(ls->fs, OP_PUSHSTRING, c, 1);
 }
 
 
@@ -189,103 +197,104 @@ void luaK_kstr (LexState *ls, int c) {
 #define LOOKBACKNUMS	20	/* arbitrary limit */
 #endif
 
-static int real_constant (LexState *ls, Number r) {
+static int real_constant (FuncState *fs, Number r) {
   /* check whether `r' has appeared within the last LOOKBACKNUMS entries */
-  Proto *f = ls->fs->f;
+  Proto *f = fs->f;
   int c = f->nknum;
   int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS;
   while (--c >= lim)
     if (f->knum[c] == r) return c;
   /* not found; create a new entry */
-  luaM_growvector(ls->L, f->knum, f->nknum, 1, Number, constantEM, MAXARG_U);
+  luaM_growvector(fs->L, f->knum, f->nknum, 1, Number, constantEM, MAXARG_U);
   c = f->nknum++;
   f->knum[c] = r;
   return c;
 }
 
 
-void luaK_number (LexState *ls, Number f) {
+void luaK_number (FuncState *fs, Number f) {
   if (f <= (Number)MAXARG_S && (int)f == f)
-    luaK_S(ls, OP_PUSHINT, (int)f, 1);  /* f has a short integer value */
+    luaK_S(fs, OP_PUSHINT, (int)f, 1);  /* f has a short integer value */
   else
-    luaK_U(ls, OP_PUSHNUM, real_constant(ls, f), 1);
+    luaK_U(fs, OP_PUSHNUM, real_constant(fs, f), 1);
 }
 
 
-void luaK_adjuststack (LexState *ls, int n) {
+void luaK_adjuststack (FuncState *fs, int n) {
   if (n > 0)
-    luaK_U(ls, OP_POP, n, -n);
+    luaK_U(fs, OP_POP, n, -n);
   else if (n < 0)
-    luaK_pushnil(ls, -n);
+    luaK_pushnil(fs, -n);
 }
 
 
-int luaK_lastisopen (LexState *ls) {
+int luaK_lastisopen (FuncState *fs) {
   /* check whether last instruction is an (open) function call */
-  Instruction *i = previous_instruction(ls);
+  Instruction *i = previous_instruction(fs);
   if (GET_OPCODE(*i) == OP_CALL) {
-    LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open");
+    LUA_ASSERT(fs->L, GETARG_B(*i) == MULT_RET, "call should be open");
     return 1;
   }
   else return 0;
 }
 
 
-void luaK_setcallreturns (LexState *ls, int nresults) {
-  Instruction *i = previous_instruction(ls);
+void luaK_setcallreturns (FuncState *fs, int nresults) {
+  Instruction *i = previous_instruction(fs);
   if (GET_OPCODE(*i) == OP_CALL) {  /* expression is a function call? */
-    LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open");
+    LUA_ASSERT(fs->L, GETARG_B(*i) == MULT_RET, "call should be open");
     SETARG_B(*i, nresults);  /* set nresults */
-    luaK_deltastack(ls, nresults);  /* push results */
+    luaK_deltastack(fs, nresults);  /* push results */
   }
 }
 
 
-static void assertglobal (LexState *ls, int index) {
-  luaS_assertglobal(ls->L, ls->fs->f->kstr[index]);
+static void assertglobal (FuncState *fs, int index) {
+  luaS_assertglobal(fs->L, fs->f->kstr[index]);
 }
 
 
-static int discharge (LexState *ls, expdesc *var) {
+static int discharge (FuncState *fs, expdesc *var) {
   switch (var->k) {
     case VLOCAL:
-      luaK_U(ls, OP_PUSHLOCAL, var->u.index, 1);
+      luaK_U(fs, OP_PUSHLOCAL, var->u.index, 1);
       break;
     case VGLOBAL:
-      luaK_U(ls, OP_GETGLOBAL, var->u.index, 1);
-      assertglobal(ls, var->u.index);  /* make sure that there is a global */
+      luaK_U(fs, OP_GETGLOBAL, var->u.index, 1);
+      assertglobal(fs, var->u.index);  /* make sure that there is a global */
       break;
     case VINDEXED:
-      luaK_gettable(ls);
+      luaK_gettable(fs);
       break;
     case VEXP:
       return 0;  /* nothing to do */
   }
   var->k = VEXP;
-  var->u.l.t = var->u.l.f = 0;
+  var->u.l.t = var->u.l.f = NO_JUMP;
   return 1;
 }
 
 
-static void discharge1 (LexState *ls, expdesc *var) {
-  discharge(ls, var);
+static void discharge1 (FuncState *fs, expdesc *var) {
+  discharge(fs, var);
  /* if it has jumps it is already discharged */
-  if (var->u.l.t == 0 && var->u.l.f  == 0)
-    luaK_setcallreturns(ls, 1);  /* call must return 1 value */
+  if (var->u.l.t == NO_JUMP && var->u.l.f  == NO_JUMP)
+    luaK_setcallreturns(fs, 1);  /* call must return 1 value */
 }
   
 
 void luaK_storevar (LexState *ls, const expdesc *var) {
+  FuncState *fs = ls->fs;
   switch (var->k) {
     case VLOCAL:
-      luaK_U(ls, OP_SETLOCAL, var->u.index, -1);
+      luaK_U(fs, OP_SETLOCAL, var->u.index, -1);
       break;
     case VGLOBAL:
-      luaK_U(ls, OP_SETGLOBAL, var->u.index, -1);
-      assertglobal(ls, var->u.index);  /* make sure that there is a global */
+      luaK_U(fs, OP_SETGLOBAL, var->u.index, -1);
+      assertglobal(fs, var->u.index);  /* make sure that there is a global */
       break;
     case VINDEXED:
-      luaK_0(ls, OP_SETTABLEPOP, -3);
+      luaK_0(fs, OP_SETTABLEPOP, -3);
       break;
     default:
       LUA_INTERNALERROR(ls->L, "invalid var kind to store");
@@ -310,128 +319,113 @@ static OpCode invertjump (OpCode op) {
 }
 
 
-static void luaK_jump (LexState *ls, OpCode jump) {
-  Instruction *previous = previous_instruction(ls);
-  luaK_deltastack(ls, -1);
+static void luaK_jump (FuncState *fs, OpCode jump) {
+  Instruction *previous = previous_instruction(fs);
+  luaK_deltastack(fs, -1);
   if (*previous == CREATE_0(OP_NOT))
     *previous = CREATE_S(invertjump(jump), 0);
   else
-    luaK_primitivecode(ls, CREATE_S(jump, 0));
+    luaK_primitivecode(fs, CREATE_S(jump, 0));
 }
 
 
 static void insert_last (FuncState *fs, int *list) {
   int first = *list;
   *list = fs->pc-1;  /* insert last instruction in the list */
-  if (first == 0)
-    SETARG_S(fs->f->code[*list], 0);
-  else
-    SETARG_S(fs->f->code[*list], first-fs->pc);
+  luaK_fixjump(fs, *list, first);
 }
 
 
-static void luaK_patchlistaux (LexState *ls, int list, int target,
+static void luaK_patchlistaux (FuncState *fs, int list, int target,
                                OpCode special, int special_target) {
-  if (list != 0) {
-    Instruction *code = ls->fs->f->code;
-    for (;;) {
-      Instruction *i = &code[list];
-      OpCode op = GET_OPCODE(*i);
-      int next = GETARG_S(*i);
-      if (op == special)  /* this `op' already has a value */
-        SETARG_S(*i, special_target-(list+1));
-      else {
-        SETARG_S(*i, target-(list+1));  /* do the patch */
-        if (op == OP_ONTJMP)  /* remove eventual values */
-          SET_OPCODE(*i, OP_IFTJMP);
-        else if (op == OP_ONFJMP)
-          SET_OPCODE(*i, OP_IFFJMP);
-      }
-      if (next == 0) return;
-      list += next+1;
+  Instruction *code = fs->f->code;
+  while (list != NO_JUMP) {
+    int next = luaK_getjump(fs, list);
+    Instruction *i = &code[list];
+    OpCode op = GET_OPCODE(*i);
+    if (op == special)  /* this `op' already has a value */
+      SETARG_S(*i, special_target-(list+1));
+    else {
+      SETARG_S(*i, target-(list+1));  /* do the patch */
+      if (op == OP_ONTJMP)  /* remove eventual values */
+        SET_OPCODE(*i, OP_IFTJMP);
+      else if (op == OP_ONFJMP)
+        SET_OPCODE(*i, OP_IFFJMP);
     }
+    list = next;
   }
 }
 
 
-void luaK_patchlist (LexState *ls, int list, int target) {
-  luaK_patchlistaux(ls, list, target, OP_END, 0);
+void luaK_patchlist (FuncState *fs, int list, int target) {
+  luaK_patchlistaux(fs, list, target, OP_END, 0);
 }
 
 
 static int need_value (FuncState *fs, int list, OpCode hasvalue) {
-  if (list == 0) return 0;
-  else {  /* check whether list has a jump without a value */
-    Instruction *code = fs->f->code;
-    for (;;) {
-      int next = GETARG_S(code[list]);
-      if (GET_OPCODE(code[list]) != hasvalue) return 1;
-      else if (next == 0) return 0;
-      list += next+1;
-    }
-  }
+  /* check whether list has a jump without a value */
+  for (; list != NO_JUMP; list = luaK_getjump(fs, list))
+    if (GET_OPCODE(fs->f->code[list]) != hasvalue) return 1;
+  return 0;  /* not found */
 }
 
 
-static void concatlists (LexState *ls, int *l1, int l2) {
-  if (*l1 == 0)
+static void concatlists (FuncState *fs, int *l1, int l2) {
+  if (*l1 == NO_JUMP)
     *l1 = l2;
-  else if (l2 != 0) {
-    FuncState *fs = ls->fs;
+  else {
     int list = *l1;
     for (;;) {  /* traverse `l1' */
-      int next = GETARG_S(fs->f->code[list]);
-      if (next == 0) {  /* end of list? */
-        SETARG_S(fs->f->code[list], l2-(list+1));  /* end points to `l2' */
+      int next = luaK_getjump(fs, list);
+      if (next == NO_JUMP) {  /* end of list? */
+        luaK_fixjump(fs, list, l2);
         return;
       }
-      list += next+1;
+      list = next;
     }
   }
 }
 
 
-void luaK_goiftrue (LexState *ls, expdesc *v, int keepvalue) {
-  FuncState *fs = ls->fs;
+void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue) {
   Instruction *previous;
-  discharge1(ls, v);
+  discharge1(fs, v);
   previous = &fs->f->code[fs->pc-1];
   if (ISJUMP(GET_OPCODE(*previous)))
     SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
   else {
     OpCode jump = keepvalue ? OP_ONFJMP : OP_IFFJMP;
-    luaK_jump(ls, jump);
+    luaK_jump(fs, jump);
   }
   insert_last(fs, &v->u.l.f);
-  luaK_patchlist(ls, v->u.l.t, luaK_getlabel(ls));
-  v->u.l.t = 0;
+  luaK_patchlist(fs, v->u.l.t, luaK_getlabel(fs));
+  v->u.l.t = NO_JUMP;
 }
 
 
-void luaK_goiffalse (LexState *ls, expdesc *v, int keepvalue) {
-  FuncState *fs = ls->fs;
+void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue) {
   Instruction previous;
-  discharge1(ls, v);
+  discharge1(fs, v);
   previous = fs->f->code[fs->pc-1];
   if (!ISJUMP(GET_OPCODE(previous))) {
     OpCode jump = keepvalue ? OP_ONTJMP : OP_IFTJMP;
-    luaK_jump(ls, jump);
+    luaK_jump(fs, jump);
   }
   insert_last(fs, &v->u.l.t);
-  luaK_patchlist(ls, v->u.l.f, luaK_getlabel(ls));
-  v->u.l.f = 0;
+  luaK_patchlist(fs, v->u.l.f, luaK_getlabel(fs));
+  v->u.l.f = NO_JUMP;
 }
 
 
 void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
-  if (discharge(ls, v)) return;
+  FuncState *fs = ls->fs;
+  if (discharge(fs, v)) return;
   else {  /* is an expression */
-    FuncState *fs = ls->fs;
     OpCode previous = GET_OPCODE(fs->f->code[fs->pc-1]);
-    if (!ISJUMP(previous) && v->u.l.f == 0 && v->u.l.t == 0) {
+    if (!ISJUMP(previous) && v->u.l.f == NO_JUMP && v->u.l.t == NO_JUMP) {
       /* it is an expression without jumps */
       if (onlyone && v->k == VEXP)
-        luaK_setcallreturns(ls, 1);  /* call must return 1 value */
+        luaK_setcallreturns(fs, 1);  /* call must return 1 value */
       return;
     }
     else {  /* expression has jumps... */
@@ -440,48 +434,48 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
       int final;  /* position after whole expression */
       if (ISJUMP(previous)) {
         insert_last(fs, &v->u.l.t);  /* put `previous' in true list */
-        p_nil = luaK_0(ls, OP_PUSHNILJMP, 0);
-        p_1 = luaK_S(ls, OP_PUSHINT, 1, 1);
+        p_nil = luaK_0(fs, OP_PUSHNILJMP, 0);
+        p_1 = luaK_S(fs, OP_PUSHINT, 1, 1);
       }
       else {  /* still may need a PUSHNIL or a PUSHINT */
         int need_nil = need_value(fs, v->u.l.f, OP_ONFJMP);
         int need_1 = need_value(fs, v->u.l.t, OP_ONTJMP);
         if (need_nil && need_1) {
-          luaK_S(ls, OP_JMP, 2, 0);  /* skip both pushes */
-          p_nil = luaK_0(ls, OP_PUSHNILJMP, 0);
-          p_1 = luaK_S(ls, OP_PUSHINT, 1, 0);
+          luaK_S(fs, OP_JMP, 2, 0);  /* skip both pushes */
+          p_nil = luaK_0(fs, OP_PUSHNILJMP, 0);
+          p_1 = luaK_S(fs, OP_PUSHINT, 1, 0);
         }
         else if (need_nil || need_1) {
-          luaK_S(ls, OP_JMP, 1, 0);  /* skip one push */
+          luaK_S(fs, OP_JMP, 1, 0);  /* skip one push */
           if (need_nil)
-            p_nil = luaK_U(ls, OP_PUSHNIL, 1, 0);
+            p_nil = luaK_U(fs, OP_PUSHNIL, 1, 0);
           else  /* need_1 */
-            p_1 = luaK_S(ls, OP_PUSHINT, 1, 0);
+            p_1 = luaK_S(fs, OP_PUSHINT, 1, 0);
         }
       }
-      final = luaK_getlabel(ls);
-      luaK_patchlistaux(ls, v->u.l.f, p_nil, OP_ONFJMP, final);
-      luaK_patchlistaux(ls, v->u.l.t, p_1, OP_ONTJMP, final);
-      v->u.l.f = v->u.l.t = 0;
+      final = luaK_getlabel(fs);
+      luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_ONFJMP, final);
+      luaK_patchlistaux(fs, v->u.l.t, p_1, OP_ONTJMP, final);
+      v->u.l.f = v->u.l.t = NO_JUMP;
     }
   }
 }
 
 
 void luaK_prefix (LexState *ls, int op, expdesc *v) {
+  FuncState *fs = ls->fs;
   if (op == '-') {
     luaK_tostack(ls, v, 1);
-    luaK_minus(ls);
+    luaK_minus(fs);
   }
   else {  /* op == NOT */
-    FuncState *fs = ls->fs;
     Instruction *previous;
-    discharge1(ls, v);
+    discharge1(fs, v);
     previous = &fs->f->code[fs->pc-1];
     if (ISJUMP(GET_OPCODE(*previous)))
       SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
     else
-      luaK_0(ls, OP_NOT, 0);
+      luaK_0(fs, OP_NOT, 0);
     /* interchange true and false lists */
     { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; }
   }
@@ -489,43 +483,45 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) {
 
 
 void luaK_infix (LexState *ls, int op, expdesc *v) {
+  FuncState *fs = ls->fs;
   if (op == TK_AND)
-    luaK_goiftrue(ls, v, 1);
+    luaK_goiftrue(fs, v, 1);
   else if (op == TK_OR)
-    luaK_goiffalse(ls, v, 1);
+    luaK_goiffalse(fs, v, 1);
   else
     luaK_tostack(ls, v, 1);  /* all other binary operators need a value */
 } 
 
 
 void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
+  FuncState *fs = ls->fs;
   if (op == TK_AND) {
-    LUA_ASSERT(ls->L, v1->u.l.t == 0, "list must be closed");
-    discharge1(ls, v2);
+    LUA_ASSERT(ls->L, v1->u.l.t == NO_JUMP, "list must be closed");
+    discharge1(fs, v2);
     v1->u.l.t = v2->u.l.t;
-    concatlists(ls, &v1->u.l.f, v2->u.l.f);
+    concatlists(fs, &v1->u.l.f, v2->u.l.f);
   }
   else if (op == TK_OR) {
-    LUA_ASSERT(ls->L, v1->u.l.f == 0, "list must be closed");
-    discharge1(ls, v2);
+    LUA_ASSERT(ls->L, v1->u.l.f == NO_JUMP, "list must be closed");
+    discharge1(fs, v2);
     v1->u.l.f = v2->u.l.f;
-    concatlists(ls, &v1->u.l.t, v2->u.l.t);
+    concatlists(fs, &v1->u.l.t, v2->u.l.t);
   }
   else {
     luaK_tostack(ls, v2, 1);  /* `v2' must be a value */
     switch (op) {
-      case '+': luaK_add(ls); break;
-      case '-': luaK_sub(ls); break;
-      case '*': luaK_0(ls, OP_MULT, -1); break;
-      case '/': luaK_0(ls, OP_DIV, -1); break;
-      case '^': luaK_0(ls, OP_POW, -1); break;
-      case TK_CONC: luaK_conc(ls); break;
-      case TK_EQ: luaK_eq(ls); break;
-      case TK_NE: luaK_neq(ls); break;
-      case '>': luaK_S(ls, OP_IFGTJMP, 0, -2); break;
-      case '<': luaK_S(ls, OP_IFLTJMP, 0, -2); break;
-      case TK_GE: luaK_S(ls, OP_IFGEJMP, 0, -2); break;
-      case TK_LE: luaK_S(ls, OP_IFLEJMP, 0, -2); break;
+      case '+': luaK_add(fs); break;
+      case '-': luaK_sub(fs); break;
+      case '*': luaK_0(fs, OP_MULT, -1); break;
+      case '/': luaK_0(fs, OP_DIV, -1); break;
+      case '^': luaK_0(fs, OP_POW, -1); break;
+      case TK_CONC: luaK_conc(fs); break;
+      case TK_EQ: luaK_eq(fs); break;
+      case TK_NE: luaK_neq(fs); break;
+      case '>': luaK_S(fs, OP_IFGTJMP, 0, -2); break;
+      case '<': luaK_S(fs, OP_IFLTJMP, 0, -2); break;
+      case TK_GE: luaK_S(fs, OP_IFGEJMP, 0, -2); break;
+      case TK_LE: luaK_S(fs, OP_IFLEJMP, 0, -2); break;
     }
   }
 }

lcode.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.5 2000/03/09 13:57:37 roberto Exp roberto $
+** $Id: lcode.h,v 1.6 2000/03/10 18:37:44 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -20,20 +20,20 @@
 
 
 void luaK_error (LexState *ls, const char *msg);
-int luaK_primitivecode (LexState *ls, Instruction i);
-int luaK_code (LexState *ls, Instruction i, int delta);
-void luaK_retcode (LexState *ls, int nlocals, int nexps);
-void luaK_fixjump (LexState *ls, int pc, int dest);
-void luaK_patchlist (LexState *ls, int list, int target);
-void luaK_goiftrue (LexState *ls, expdesc *v, int keepvalue);
-void luaK_goiffalse (LexState *ls, expdesc *v, int keepvalue);
-int luaK_getlabel (LexState *ls);
-void luaK_deltastack (LexState *ls, int delta);
+int luaK_primitivecode (FuncState *fs, Instruction i);
+int luaK_code (FuncState *fs, Instruction i, int delta);
+void luaK_retcode (FuncState *fs, int nlocals, int nexps);
+void luaK_fixjump (FuncState *fs, int pc, int dest);
+void luaK_patchlist (FuncState *fs, int list, int target);
+void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue);
+void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue);
+int luaK_getlabel (FuncState *fs);
+void luaK_deltastack (FuncState *fs, int delta);
 void luaK_kstr (LexState *ls, int c);
-void luaK_number (LexState *ls, Number f);
-void luaK_adjuststack (LexState *ls, int n);
-int luaK_lastisopen (LexState *ls);
-void luaK_setcallreturns (LexState *ls, int nresults);
+void luaK_number (FuncState *fs, Number f);
+void luaK_adjuststack (FuncState *fs, int n);
+int luaK_lastisopen (FuncState *fs);
+void luaK_setcallreturns (FuncState *fs, int nresults);
 void luaK_tostack (LexState *ls, expdesc *v, int onlyone);
 void luaK_storevar (LexState *ls, const expdesc *var);
 void luaK_prefix (LexState *ls, int op, expdesc *v);

lopcodes.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.47 2000/03/09 13:57:37 roberto Exp roberto $
+** $Id: lopcodes.h,v 1.48 2000/03/10 18:37:44 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -20,8 +20,8 @@
   type 3: 1st unsigned argument in the higher 16 bits      (`A')
           2nd unsigned argument in the middle 8 bits       (`B')
 
-  The signed argument is represented in excess 2^23; that is, the Number value
-  is the usigned value minus 2^23.
+  The signed argument is represented in excess 2^23; that is, the number
+  value is the usigned value minus 2^23.
 ===========================================================================*/
 
 #define SIZE_INSTRUCTION	32
@@ -92,7 +92,7 @@ OP_END,/*	-	-		(return)			*/
 OP_RETURN,/*	U	-		(return)			*/
 
 OP_CALL,/*	A B	v_n-v_1 f(at a)	r_b-r_1		f(v1,...,v_n)	*/
-OP_TAILCALL,/*	A B	v_a-v_1 f	(return)	f(v1,...,v_a)	*/
+OP_TAILCALL,/*	A B	v_n-v_1 f(at a)	(return)	f(v1,...,v_n)	*/
 
 OP_PUSHNIL,/*	U	-		nil_1-nil_u			*/
 OP_POP,/*	U	a_u-a_1		-				*/
@@ -158,7 +158,7 @@ OP_SETLINE/*	U	-		-		LINE=u		*/
 
 
 #define RFIELDS_PER_FLUSH 32	/* records (SETMAP) */
-#define LFIELDS_PER_FLUSH 64    /* FPF - lists (SETLIST) (<=MAXARG_B) */
+#define LFIELDS_PER_FLUSH 64	/* FPF - lists (SETLIST) (<=MAXARG_B) */
 
 
 #endif

lparser.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.67 2000/03/09 13:57:37 roberto Exp roberto $
+** $Id: lparser.c,v 1.68 2000/03/10 18:37:44 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -115,9 +115,10 @@ static void checklimit (LexState *ls, int val, int limit, const char *msg) {
 
 
 static void check_debugline (LexState *ls) {
-  if (ls->L->debug && ls->linenumber != ls->fs->lastsetline) {
-    luaK_U(ls, OP_SETLINE, ls->linenumber, 0);
-    ls->fs->lastsetline = ls->linenumber;
+  FuncState *fs = ls->fs;
+  if (ls->L->debug && ls->linenumber != fs->lastsetline) {
+    luaK_U(fs, OP_SETLINE, ls->linenumber, 0);
+    fs->lastsetline = ls->linenumber;
   }
 }
 
@@ -130,11 +131,11 @@ static void check_match (LexState *ls, int what, int who, int where) {
 }
 
 
-static int string_constant (LexState *ls, FuncState *fs, TString *s) {
+static int string_constant (FuncState *fs, TString *s) {
   Proto *f = fs->f;
   int c = s->constindex;
   if (c >= f->nkstr || f->kstr[c] != s) {
-    luaM_growvector(ls->L, f->kstr, f->nkstr, 1, TString *,
+    luaM_growvector(fs->L, f->kstr, f->nkstr, 1, TString *,
                     constantEM, MAXARG_U);
     c = f->nkstr++;
     f->kstr[c] = s;
@@ -145,7 +146,7 @@ static int string_constant (LexState *ls, FuncState *fs, TString *s) {
 
 
 static void code_string (LexState *ls, TString *s) {
-  luaK_kstr(ls, string_constant(ls, ls->fs, s));
+  luaK_kstr(ls, string_constant(ls->fs, s));
 }
 
 
@@ -153,7 +154,7 @@ static int checkname (LexState *ls) {
   int sc;
   if (ls->token != TK_NAME)
     luaK_error(ls, "<name> expected");
-  sc = string_constant(ls, ls->fs, ls->seminfo.ts);
+  sc = string_constant(ls->fs, ls->seminfo.ts);
   next(ls);
   return sc;
 }
@@ -226,7 +227,7 @@ static void singlevar (LexState *ls, TString *n, expdesc *var, int prev) {
       if (aux_localname(level, n) >= 0)
         luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str);
     var->k = VGLOBAL;
-    var->u.index = string_constant(ls, fs, n);
+    var->u.index = string_constant(fs, n);
   }
 }
 
@@ -249,29 +250,31 @@ static int indexupvalue (LexState *ls, TString *n) {
 
 
 static void pushupvalue (LexState *ls, TString *n) {
-  if (ls->fs->prev == NULL)
+  FuncState *fs = ls->fs;
+  if (fs->prev == NULL)
     luaX_syntaxerror(ls, "cannot access upvalue in main", n->str);
   if (aux_localname(ls->fs, n) >= 0)
     luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str);
-  luaK_U(ls, OP_PUSHUPVALUE, indexupvalue(ls, n), 1);
+  luaK_U(fs, OP_PUSHUPVALUE, indexupvalue(ls, n), 1);
 }
 
 
 static void adjust_mult_assign (LexState *ls, int nvars, int nexps) {
+  FuncState *fs = ls->fs;
   int diff = nexps - nvars;
-  if (nexps == 0 || !luaK_lastisopen(ls)) {  /* list is empty or closed */
+  if (nexps == 0 || !luaK_lastisopen(fs)) {  /* list is empty or closed */
     /* push or pop eventual difference between list lengths */
-    luaK_adjuststack(ls, diff);
+    luaK_adjuststack(fs, diff);
   }
   else {  /* list ends in a function call; must correct it */
     diff--;  /* do not count function call itself */
     if (diff <= 0) {  /* more variables than values? */
       /* function call must provide extra values */
-      luaK_setcallreturns(ls, -diff);
+      luaK_setcallreturns(fs, -diff);
     }
     else {  /* more values than variables */
-      luaK_setcallreturns(ls, 0);  /* call should provide no value */
-      luaK_adjuststack(ls, diff);  /* pop eventual extra values */
+      luaK_setcallreturns(fs, 0);  /* call should provide no value */
+      luaK_adjuststack(fs, diff);  /* pop eventual extra values */
     }
   }
 }
@@ -285,9 +288,9 @@ static void code_args (LexState *ls, int nparams, int dots) {
   fs->f->numparams = nparams;
   fs->f->is_vararg = dots;
   if (!dots)
-    luaK_deltastack(ls, nparams);
+    luaK_deltastack(fs, nparams);
   else {
-    luaK_deltastack(ls, nparams+1);
+    luaK_deltastack(fs, nparams+1);
     add_localvar(ls, luaS_newfixed(ls->L, "arg"));
   }
 }
@@ -298,7 +301,7 @@ static int getvarname (LexState *ls, expdesc *var) {
     case VGLOBAL:
       return var->u.index;
     case VLOCAL:
-      return string_constant(ls, ls->fs, ls->fs->localvar[var->u.index]);
+      return string_constant(ls->fs, ls->fs->localvar[var->u.index]);
       break;
     default:
       error_unexpected(ls);  /* there is no `var name' */
@@ -308,15 +311,16 @@ static int getvarname (LexState *ls, expdesc *var) {
 
 
 static void func_onstack (LexState *ls, FuncState *func) {
-  Proto *f = ls->fs->f;
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
   int i;
   for (i=0; i<func->nupvalues; i++)
     luaK_tostack(ls, &func->upvalues[i], 1);
   luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *,
                   constantEM, MAXARG_A);
   f->kproto[f->nkproto++] = func->f;
-  luaK_deltastack(ls, 1);  /* CLOSURE puts one extra element before popping */
-  luaK_AB(ls, OP_CLOSURE, f->nkproto-1, func->nupvalues, -func->nupvalues);
+  luaK_deltastack(fs, 1);  /* CLOSURE puts one extra element before popping */
+  luaK_AB(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues, -func->nupvalues);
 }
 
 
@@ -324,6 +328,8 @@ static void init_state (LexState *ls, FuncState *fs, TString *source) {
   lua_State *L = ls->L;
   Proto *f = luaF_newproto(ls->L);
   fs->prev = ls->fs;  /* linked list of funcstates */
+  fs->ls = ls;
+  fs->L = ls->L;
   ls->fs = fs;
   fs->stacksize = 0;
   fs->nlocalvar = 0;
@@ -346,19 +352,20 @@ static void init_state (LexState *ls, FuncState *fs, TString *source) {
 
 
 static void close_func (LexState *ls) {
+  lua_State *L = ls->L;
   FuncState *fs = ls->fs;
   Proto *f = fs->f;
-  luaK_0(ls, OP_END, 0);
-  luaM_reallocvector(ls->L, f->code, fs->pc, Instruction);
-  luaM_reallocvector(ls->L, f->kstr, f->nkstr, TString *);
-  luaM_reallocvector(ls->L, f->knum, f->nknum, Number);
-  luaM_reallocvector(ls->L, f->kproto, f->nkproto, Proto *);
+  luaK_0(fs, OP_END, 0);
+  luaM_reallocvector(L, f->code, fs->pc, Instruction);
+  luaM_reallocvector(L, f->kstr, f->nkstr, TString *);
+  luaM_reallocvector(L, f->knum, f->nknum, Number);
+  luaM_reallocvector(L, f->kproto, f->nkproto, Proto *);
   if (fs->nvars != -1) {  /* debug information? */
     luaI_registerlocalvar(ls, NULL, -1);  /* flag end of vector */
-    luaM_reallocvector(ls->L, f->locvars, fs->nvars, LocVar);
+    luaM_reallocvector(L, f->locvars, fs->nvars, LocVar);
   }
   ls->fs = fs->prev;
-  ls->L->top--;  /* pop function */
+  L->top--;  /* pop function */
 }
 
 
@@ -423,7 +430,7 @@ static void funcargs (LexState *ls, int slf) {
       check_match(ls, ')', '(', line);
 #ifdef LUA_COMPAT_ARGRET
       if (nargs > 0)  /* arg list is not empty? */
-        luaK_setcallreturns(ls, 1);  /* last call returns only 1 value */
+        luaK_setcallreturns(fs, 1);  /* last call returns only 1 value */
 #endif
       break;
     }
@@ -442,7 +449,7 @@ static void funcargs (LexState *ls, int slf) {
       break;
   }
   fs->stacksize = slevel;  /* call will remove function and arguments */
-  luaK_AB(ls, OP_CALL, slevel, MULT_RET, 0);
+  luaK_AB(fs, OP_CALL, slevel, MULT_RET, 0);
 }
 
 
@@ -469,10 +476,10 @@ static void var_or_func_tail (LexState *ls, expdesc *v) {
         next(ls);
         name = checkname(ls);
         luaK_tostack(ls, v, 1);  /* `v' must be on stack */
-        luaK_U(ls, OP_PUSHSELF, name, 1);
+        luaK_U(ls->fs, OP_PUSHSELF, name, 1);
         funcargs(ls, 1);
         v->k = VEXP;
-        v->u.l.t = v->u.l.f = 0;
+        v->u.l.t = v->u.l.f = NO_JUMP;
         break;
       }
 
@@ -480,7 +487,7 @@ static void var_or_func_tail (LexState *ls, expdesc *v) {
         luaK_tostack(ls, v, 1);  /* `v' must be on stack */
         funcargs(ls, 0);
         v->k = VEXP;
-        v->u.l.t = v->u.l.f = 0;
+        v->u.l.t = v->u.l.f = NO_JUMP;
         break;
 
       default: return;  /* should be follow... */
@@ -494,7 +501,7 @@ static void var_or_func (LexState *ls, expdesc *v) {
   if (optional(ls, '%')) {  /* upvalue? */
     pushupvalue(ls, str_checkname(ls));
     v->k = VEXP;
-    v->u.l.t = v->u.l.f = 0;
+    v->u.l.t = v->u.l.f = NO_JUMP;
   }
   else  /* variable name */
     singlevar(ls, str_checkname(ls), v, 0);
@@ -532,6 +539,7 @@ static void recfield (LexState *ls) {
 
 static int recfields (LexState *ls) {
   /* recfields -> { ',' recfield } [','] */
+  FuncState *fs = ls->fs;
   int n = 1;  /* one has been read before */
   int mod_n = 1;  /* mod_n == n%RFIELDS_PER_FLUSH */
   while (ls->token == ',') {
@@ -541,18 +549,19 @@ static int recfields (LexState *ls) {
     recfield(ls);
     n++;
     if (++mod_n == RFIELDS_PER_FLUSH) {
-      luaK_U(ls, OP_SETMAP, RFIELDS_PER_FLUSH-1, -2*RFIELDS_PER_FLUSH);
+      luaK_U(fs, OP_SETMAP, RFIELDS_PER_FLUSH-1, -2*RFIELDS_PER_FLUSH);
       mod_n = 0;
     }
   }
   if (mod_n)
-    luaK_U(ls, OP_SETMAP, mod_n-1, -2*mod_n);
+    luaK_U(fs, OP_SETMAP, mod_n-1, -2*mod_n);
   return n;
 }
 
 
 static int listfields (LexState *ls) {
   /* listfields -> { ',' exp1 } [','] */
+  FuncState *fs = ls->fs;
   int n = 1;  /* one has been read before */
   int mod_n = 1;  /* mod_n == n%LFIELDS_PER_FLUSH */
   while (ls->token == ',') {
@@ -564,13 +573,13 @@ static int listfields (LexState *ls) {
     checklimit(ls, n, MAXARG_A*LFIELDS_PER_FLUSH,
                "items in a list initializer");
     if (++mod_n == LFIELDS_PER_FLUSH) {
-      luaK_AB(ls, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1,
+      luaK_AB(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH-1,
               -LFIELDS_PER_FLUSH);
       mod_n = 0;
     }
   }
   if (mod_n > 0)
-    luaK_AB(ls, OP_SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1, -mod_n);
+    luaK_AB(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH, mod_n-1, -mod_n);
   return n;
 }
 
@@ -618,8 +627,9 @@ static void constructor_part (LexState *ls, constdesc *cd) {
 
 static void constructor (LexState *ls) {
   /* constructor -> '{' constructor_part [';' constructor_part] '}' */
+  FuncState *fs = ls->fs;
   int line = ls->linenumber;
-  int pc = luaK_U(ls, OP_CREATETABLE, 0, 1);
+  int pc = luaK_U(fs, OP_CREATETABLE, 0, 1);
   int nelems;
   constdesc cd;
   check(ls, '{');
@@ -635,7 +645,7 @@ static void constructor (LexState *ls) {
   }
   check_match(ls, '}', '{', line);
   /* set initial table size */
-  SETARG_U(ls->fs->f->code[pc], nelems);
+  SETARG_U(fs->f->code[pc], nelems);
 }
 
 /* }====================================================================== */
@@ -651,12 +661,13 @@ static void constructor (LexState *ls) {
 
 
 static void simpleexp (LexState *ls, expdesc *v) {
+  FuncState *fs = ls->fs;
   check_debugline(ls);
   switch (ls->token) {
     case TK_NUMBER: {  /* simpleexp -> NUMBER */
       Number r = ls->seminfo.r;
       next(ls);
-      luaK_number(ls, r);
+      luaK_number(fs, r);
       break;
     }
 
@@ -666,7 +677,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
       break;
 
     case TK_NIL:  /* simpleexp -> NIL */
-      luaK_adjuststack(ls, -1);
+      luaK_adjuststack(fs, -1);
       next(ls);
       break;
 
@@ -694,7 +705,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
       return;
   }
   v->k = VEXP;
-  v->u.l.t = v->u.l.f = 0;
+  v->u.l.t = v->u.l.f = NO_JUMP;
 }
 
 
@@ -776,7 +787,7 @@ static void block (LexState *ls) {
   FuncState *fs = ls->fs;
   int nlocalvar = fs->nlocalvar;
   chunk(ls);
-  luaK_adjuststack(ls, fs->nlocalvar - nlocalvar);  /* remove local variables */
+  luaK_adjuststack(fs, fs->nlocalvar - nlocalvar);  /* remove local variables */
   for (; fs->nlocalvar > nlocalvar; fs->nlocalvar--)
     luaI_unregisterlocalvar(ls, fs->lastsetline);
 }
@@ -806,7 +817,7 @@ static int assignment (LexState *ls, expdesc *v, int nvars) {
     luaK_storevar(ls, v);
   }
   else {  /* indexed var with values in between*/
-    luaK_U(ls, OP_SETTABLE, left+(nvars-1), -1);
+    luaK_U(ls->fs, OP_SETTABLE, left+(nvars-1), -1);
     left += 2;  /* table&index are not popped, because they aren't on top */
   }
   return left;
@@ -822,7 +833,7 @@ static void whilestat (LexState *ls, int line) {
   /* whilestat -> WHILE exp1 DO block END */
   Instruction buffer[MAX_WHILE_EXP];
   FuncState *fs = ls->fs;
-  int while_init = luaK_getlabel(ls);
+  int while_init = luaK_getlabel(fs);
   int loopentry;  /* point to jump to repeat the loop */
   int cond_init;  /* init of condition, after the move */
   int cond_size;
@@ -830,7 +841,7 @@ static void whilestat (LexState *ls, int line) {
   int i;
   next(ls);  /* skip WHILE */
   expr(ls, &v);  /* read condition */
-  luaK_goiffalse(ls, &v, 0);
+  luaK_goiffalse(fs, &v, 0);
   cond_size = fs->pc - while_init;
   /* save condition (to move it to after body) */
   if (cond_size > MAX_WHILE_EXP)
@@ -838,31 +849,32 @@ static void whilestat (LexState *ls, int line) {
   for (i=0; i<cond_size; i++) buffer[i] = fs->f->code[while_init+i];
   /* go back to state prior condition */
   fs->pc = while_init;
-  luaK_S(ls, OP_JMP, 0, 0);  /* initial jump to condition */
+  luaK_S(fs, OP_JMP, 0, 0);  /* initial jump to condition */
   check(ls, TK_DO);
-  loopentry = luaK_getlabel(ls);
+  loopentry = luaK_getlabel(fs);
   block(ls);
   check_match(ls, TK_END, TK_WHILE, line);
-  cond_init = luaK_getlabel(ls);
-  luaK_fixjump(ls, while_init, cond_init);
+  cond_init = luaK_getlabel(fs);
+  luaK_fixjump(fs, while_init, cond_init);
   /* correct `v' and  copy condition to new position */
-  if (v.u.l.t != 0) v.u.l.t += cond_init-while_init;
-  for (i=0; i<cond_size; i++) luaK_primitivecode(ls, buffer[i]);
-  luaK_patchlist(ls, v.u.l.t, loopentry);
-  luaK_getlabel(ls);  /* mark possible jump to this point */
+  if (v.u.l.t != NO_JUMP) v.u.l.t += cond_init-while_init;
+  for (i=0; i<cond_size; i++) luaK_primitivecode(fs, buffer[i]);
+  luaK_patchlist(fs, v.u.l.t, loopentry);
+  luaK_getlabel(fs);  /* mark possible jump to this point */
 }
 
 
 static void repeatstat (LexState *ls, int line) {
   /* repeatstat -> REPEAT block UNTIL exp1 */
-  int repeat_init = luaK_getlabel(ls);
+  FuncState *fs = ls->fs;
+  int repeat_init = luaK_getlabel(fs);
   expdesc v;
   next(ls);
   block(ls);
   check_match(ls, TK_UNTIL, TK_REPEAT, line);
   expr(ls, &v);
-  luaK_goiftrue(ls, &v, 0);
-  luaK_patchlist(ls, v.u.l.f, repeat_init);
+  luaK_goiftrue(fs, &v, 0);
+  luaK_patchlist(fs, v.u.l.f, repeat_init);
 }
 
 
@@ -935,17 +947,18 @@ static int funcstat (LexState *ls, int line) {
 
 static void namestat (LexState *ls) {
   /* stat -> func | ['%'] NAME assignment */
+  FuncState *fs = ls->fs;
   expdesc v;
   check_debugline(ls);
   var_or_func(ls, &v);
   if (v.k == VEXP) {  /* stat -> func */
-    if (!luaK_lastisopen(ls))  /* is just an upvalue? */
+    if (!luaK_lastisopen(fs))  /* is just an upvalue? */
       luaK_error(ls, "syntax error");
-    luaK_setcallreturns(ls, 0);  /* call statement uses no results */
+    luaK_setcallreturns(fs, 0);  /* call statement uses no results */
   }
   else {  /* stat -> ['%'] NAME assignment */
     int left = assignment(ls, &v, 1);
-    luaK_adjuststack(ls, left);  /* remove eventual garbage left on stack */
+    luaK_adjuststack(fs, left);  /* remove eventual garbage left on stack */
   }
 }
 
@@ -957,11 +970,11 @@ static void ifpart (LexState *ls, int line) {
   int elseinit;
   next(ls);  /* skip IF or ELSEIF */
   expr(ls, &v);  /* cond */
-  luaK_goiftrue(ls, &v, 0);
+  luaK_goiftrue(fs, &v, 0);
   check(ls, TK_THEN);
   block(ls);  /* `then' part */
-  luaK_S(ls, OP_JMP, 0, 0);  /* 2nd jump: over `else' part */
-  elseinit = luaK_getlabel(ls);  /* address of 2nd jump == elseinit-1 */
+  luaK_S(fs, OP_JMP, 0, 0);  /* 2nd jump: over `else' part */
+  elseinit = luaK_getlabel(fs);  /* address of 2nd jump == elseinit-1 */
   if (ls->token == TK_ELSEIF)
     ifpart(ls, line);
   else {
@@ -970,13 +983,13 @@ static void ifpart (LexState *ls, int line) {
     check_match(ls, TK_END, TK_IF, line);
   }
   if (fs->pc > elseinit) {  /* is there an `else' part? */
-    luaK_fixjump(ls, elseinit-1, luaK_getlabel(ls));  /* fix 2nd jump */
+    luaK_fixjump(fs, elseinit-1, luaK_getlabel(fs));  /* fix 2nd jump */
   }
   else {  /* no else part */
     fs->pc--;  /* remove 2nd jump */
-    elseinit = luaK_getlabel(ls);  /* `elseinit' points to end */
+    elseinit = luaK_getlabel(fs);  /* `elseinit' points to end */
   }
-  luaK_patchlist(ls, v.u.l.f, elseinit);  /* fix 1st jump to `else' part */
+  luaK_patchlist(fs, v.u.l.f, elseinit);  /* fix 1st jump to `else' part */
 }
 
 
@@ -1080,12 +1093,13 @@ static void body (LexState *ls, int needself, int line) {
 static void ret (LexState *ls) {
   /* ret -> [RETURN explist sc] */
   if (ls->token == TK_RETURN) {
+    FuncState *fs = ls->fs;
     int nexps;  /* number of expressions returned */
     check_debugline(ls);
     next(ls);
     nexps = explist(ls);
-    luaK_retcode(ls, ls->fs->nlocalvar, nexps);
-    ls->fs->stacksize = ls->fs->nlocalvar;  /* removes all temp values */
+    luaK_retcode(fs, ls->fs->nlocalvar, nexps);
+    fs->stacksize = fs->nlocalvar;  /* removes all temp values */
     optional(ls, ';');
   }
 }

lparser.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.11 2000/03/09 13:57:37 roberto Exp roberto $
+** $Id: lparser.h,v 1.12 2000/03/10 18:37:44 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -65,11 +65,15 @@ typedef struct expdesc {
 } expdesc;
 
 
+#define NO_JUMP	(-1)		/* marks end of patch list */
+
 
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;  /* current function header */
   struct FuncState *prev;  /* enclosing function */
+  struct LexState *ls;  /* lexical state */
+  struct lua_State *L;  /* copy of the Lua state */
   int pc;  /* next position to code */
   int lasttarget;   /* `pc' of last `jump target' */
   int stacksize;  /* number of values on activation register */