no more `global' declarations

lcode.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.102 2002/05/10 19:22:11 roberto Exp roberto $
+** $Id: lcode.c,v 1.103 2002/05/13 13:07:48 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -191,7 +191,7 @@ void luaK_reserveregs (FuncState *fs, int n) {
 
 
 static void freereg (FuncState *fs, int reg) {
-  if (reg >= fs->nactloc && reg < MAXSTACK) {
+  if (reg >= fs->nactvar && reg < MAXSTACK) {
     fs->freereg--;
     lua_assert(reg == fs->freereg);
   }
@@ -375,7 +375,7 @@ int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
   luaK_dischargevars(fs, e);
   if (e->k == VNONRELOC) {
     if (!hasjumps(e)) return e->info;  /* exp is already in a register */ 
-    if (e->info >= fs->nactloc) {  /* reg. is not a local? */
+    if (e->info >= fs->nactvar) {  /* reg. is not a local? */
       luaK_exp2reg(fs, e, e->info);  /* put value on it */
       return e->info;
     }

ldebug.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 1.113 2002/05/09 14:14:34 roberto Exp roberto $
+** $Id: ldebug.c,v 1.114 2002/05/13 13:09:00 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -432,11 +432,6 @@ static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
         break;
       }
       case OP_GETTABLE: {
-        *name = luaF_getlocalname(p, GETARG_B(i)+1, pc);
-        if (*name && *name[0] == '*') {
-          *name = kname(p, GETARG_C(i));
-          return "global";
-        }
         *name = kname(p, GETARG_C(i));
         return "field";
         break;

lparser.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.181 2002/05/10 19:22:11 roberto Exp roberto $
+** $Id: lparser.c,v 1.182 2002/05/13 13:09:00 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -23,15 +23,18 @@
 
 
 
+
+#define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])
+
+
+
 /*
 ** nodes for block list (list of active blocks)
 */
 typedef struct BlockCnt {
   struct BlockCnt *previous;  /* chain */
   int breaklist;  /* list of jumps out of this loop */
-  int nactloc;  /* # active local variables outside the breakable structure */
-  int nactvar;
-  int defaultglob;
+  int nactvar;  /* # active local variables outside the breakable structure */
   int upval;  /* true if some variable in the block is an upvalue */
   int isbreakable;  /* true if `block' is a loop */
 } BlockCnt;
@@ -138,51 +141,26 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) {
 }
 
 
-static vardesc *new_var (LexState *ls, int n) {
-  FuncState *fs = ls->fs;
-  luaX_checklimit(ls, fs->nactvar+n+1, MAXVARS, "variables");
-  return &fs->actvar[fs->nactvar+n];
-}
-
-
 static void new_localvar (LexState *ls, TString *name, int n) {
-  vardesc *v = new_var(ls, n);  
-  v->k = VLOCAL;
-  v->i = luaI_registerlocalvar(ls, name);
-  v->level = ls->fs->nactloc + n;
-}
-
-
-static void adjustlocalvars (LexState *ls, int nvars) {
   FuncState *fs = ls->fs;
-  while (nvars--) {
-    lua_assert(fs->actvar[fs->nactvar].k == VLOCAL);
-    fs->f->locvars[fs->actvar[fs->nactvar].i].startpc = fs->pc;
-    fs->nactvar++;
-    fs->nactloc++;
-  }
+  luaX_checklimit(ls, fs->nactvar+n+1, MAXVARS, "local variables");
+  fs->actvar[fs->nactvar+n] = luaI_registerlocalvar(ls, name);
 }
 
 
-static void adjustglobalvars (LexState *ls, int nvars, int level) {
+static void adjustlocalvars (LexState *ls, int nvars) {
   FuncState *fs = ls->fs;
-  while (nvars--) {
-    fs->actvar[fs->nactvar].k = VGLOBAL;
-    fs->actvar[fs->nactvar].level = level;
-    fs->nactvar++;
+  fs->nactvar += nvars;
+  for (; nvars; nvars--) {
+    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
   }
 }
 
 
 static void removevars (LexState *ls, int tolevel) {
   FuncState *fs = ls->fs;
-  while (fs->nactvar > tolevel) {
-    fs->nactvar--;
-    if (fs->actvar[fs->nactvar].k == VLOCAL) {
-      fs->nactloc--;
-      fs->f->locvars[fs->actvar[fs->nactvar].i].endpc = fs->pc;
-    }
-  }
+  while (fs->nactvar > tolevel)
+    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
 }
 
 
@@ -210,80 +188,48 @@ static int indexupvalue (FuncState *fs, expdesc *v) {
 }
 
 
-static vardesc *searchvar (FuncState *fs, TString *n) {
+static int searchvar (FuncState *fs, TString *n) {
   int i;
   for (i=fs->nactvar-1; i >= 0; i--) {
-    vardesc *v = &fs->actvar[i];
-    if (v->k == VLOCAL ? n == fs->f->locvars[v->i].varname
-                       : n == tsvalue(&fs->f->k[v->i]))
-      return v;
+    if (n == getlocvar(fs, i).varname)
+      return i;
   }
-  return NULL;  /* not found */
+  return -1;  /* not found */
 }
 
 
 static void markupval (FuncState *fs, int level) {
   BlockCnt *bl = fs->bl;
-  while (bl && bl->nactloc > level) bl = bl->previous;
+  while (bl && bl->nactvar > level) bl = bl->previous;
   if (bl) bl->upval = 1;
 }
 
 
-static int singlevar_aux (FuncState *fs, TString *n, expdesc *var, int nd) {
-  if (fs == NULL) {  /* no more levels? */
-    init_exp(var, VGLOBAL, NO_REG);  /* default is free global */
-    return VNIL;  /* not found */
-  }
+static void singlevar (FuncState *fs, TString *n, expdesc *var, int base) {
+  if (fs == NULL)  /* no more levels? */
+    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
   else {
-    vardesc *v = searchvar(fs, n);  /* look up at current level */
-    if (v) {
-      if (v->level == NO_REG) {  /* free global? */
-        lua_assert(v->k == VGLOBAL);
-        init_exp(var, VGLOBAL, NO_REG);
-      }
-      else
-        init_exp(var, VLOCAL, v->level);
-      return v->k;
+    int v = searchvar(fs, n);  /* look up at current level */
+    if (v >= 0) {
+      init_exp(var, VLOCAL, v);
+      if (!base)
+        markupval(fs, v);  /* local will be used as an upval */
     }
     else {  /* not found at current level; try upper one */
-      int k = singlevar_aux(fs->prev, n, var, nd && fs->defaultglob == NO_REG);
+      singlevar(fs->prev, n, var, 0);
       if (var->k == VGLOBAL) {
-        if (k == VNIL && nd && fs->defaultglob != NO_REG) {
-          if (fs->defaultglob == NO_REG1)
-            luaX_syntaxerror(fs->ls, "undeclared global");
-          init_exp(var, VLOCAL, fs->defaultglob);
-          k = VGLOBAL;  /* now there is a declaration */
-        }
+        if (base)
+          var->info = luaK_stringK(fs, n);  /* info points to global name */
       }
       else {  /* LOCAL or UPVAL */
-        if (var->k == VLOCAL)
-          markupval(fs->prev, var->info);  /* local will be used as an upval */
         var->info = indexupvalue(fs, var);
         var->k = VUPVAL;  /* upvalue in this level */
       }
-      return k;
     }
   }
 }
 
 
-static void singlevar (FuncState *fs, TString *n, expdesc *var) {
-  int k = singlevar_aux(fs, n, var, 1);
-  if (k == VNIL || k == VGLOBAL) {  /* global? */
-    if (var->k == VGLOBAL)  /* free global? */
-      var->info = luaK_stringK(fs, n);
-    else {  /* `indexed' global */
-      expdesc e;
-      codestring(fs->ls, &e, n);
-      luaK_exp2anyreg(fs, var);
-      var->aux = luaK_exp2RK(fs, &e);
-      var->k = VINDEXED;
-    }
-  }
-}
-
-
-
 static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
   FuncState *fs = ls->fs;
   int extra = nvars - nexps;
@@ -308,24 +254,22 @@ static void code_params (LexState *ls, int nparams, int dots) {
   FuncState *fs = ls->fs;
   adjustlocalvars(ls, nparams);
   luaX_checklimit(ls, fs->nactvar, MAXPARAMS, "parameters");
-  fs->f->numparams = cast(lu_byte, fs->nactloc);
+  fs->f->numparams = cast(lu_byte, fs->nactvar);
   fs->f->is_vararg = cast(lu_byte, dots);
   if (dots)
     create_local(ls, "arg");
-  luaK_reserveregs(fs, fs->nactloc);  /* reserve register for parameters */
+  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
 }
 
 
 static void enterblock (FuncState *fs, BlockCnt *bl, int isbreakable) {
   bl->breaklist = NO_JUMP;
   bl->isbreakable = isbreakable;
-  bl->nactloc = fs->nactloc;
   bl->nactvar = fs->nactvar;
-  bl->defaultglob = fs->defaultglob;
   bl->upval = 0;
   bl->previous = fs->bl;
   fs->bl = bl;
-  lua_assert(fs->freereg == fs->nactloc);
+  lua_assert(fs->freereg == fs->nactvar);
 }
 
 
@@ -334,11 +278,9 @@ static void leaveblock (FuncState *fs) {
   fs->bl = bl->previous;
   removevars(fs->ls, bl->nactvar);
   if (bl->upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactloc, 0, 0);
-  lua_assert(bl->nactloc == fs->nactloc);
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
   lua_assert(bl->nactvar == fs->nactvar);
-  fs->freereg = fs->nactloc;  /* free registers */
-  fs->defaultglob = bl->defaultglob;
+  fs->freereg = fs->nactvar;  /* free registers */
   luaK_patchtohere(fs, bl->breaklist);
 }
 
@@ -373,9 +315,7 @@ static void open_func (LexState *ls, FuncState *fs) {
   fs->h = luaH_new(ls->L, 0, 0);
   fs->np = 0;
   fs->nlocvars = 0;
-  fs->nactloc = 0;
   fs->nactvar = 0;
-  fs->defaultglob = NO_REG;  /* default is free globals */
   fs->bl = NULL;
   f->code = NULL;
   f->source = ls->source;
@@ -658,13 +598,13 @@ static void prefixexp (LexState *ls, expdesc *v) {
       return;
     }
     case TK_NAME: {
-      singlevar(ls->fs, str_checkname(ls), v);
+      singlevar(ls->fs, str_checkname(ls), v, 1);
       next(ls);
       return;
     }
     case '%': {  /* for compatibility only */
       next(ls);  /* skip `%' */
-      singlevar(ls->fs, str_checkname(ls), v);
+      singlevar(ls->fs, str_checkname(ls), v, 1);
       check_condition(ls, v->k == VUPVAL, "global upvalues are obsolete");
       next(ls);
       return;
@@ -1173,38 +1113,10 @@ static void localstat (LexState *ls) {
 }
 
 
-static void globalstat (LexState *ls) {
-  /* stat -> GLOBAL NAME {`,' NAME} [IN exp] | GLOBAL IN exp */
-  FuncState *fs = ls->fs;
-  int nvars = 0;
-  next(ls);  /* skip GLOBAL */
-  if (ls->t.token == TK_NAME) {
-    do {
-      vardesc *v = new_var(ls, nvars++);  
-      v->i = luaK_stringK(ls->fs, str_checkname(ls));
-      next(ls);  /* skip name */
-    } while (optional(ls, ','));
-  }
-  if (!optional(ls, TK_IN)) {  /* free globals? */
-    if (nvars == 0)  /* default - free is invalid */
-      error_expected(ls, TK_IN);
-    adjustglobalvars(ls, nvars, NO_REG);  /* mark globals as free */
-  }
-  else {
-    int baselocal = fs->freereg;
-    int k = exp1(ls);
-    if (nvars == 0)
-      fs->defaultglob = (k == VNIL) ? NO_REG1 : baselocal;
-    adjustglobalvars(ls, nvars, baselocal);
-    create_local(ls, "*");
-  }
-}
-
-
 static int funcname (LexState *ls, expdesc *v) {
   /* funcname -> NAME {field} [`:' NAME] */
   int needself = 0;
-  singlevar(ls->fs, str_checkname(ls), v);
+  singlevar(ls->fs, str_checkname(ls), v, 1);
   next(ls);  /* skip var name */
   while (ls->t.token == '.') {
     luaY_field(ls, v);
@@ -1259,7 +1171,7 @@ static void retstat (LexState *ls) {
         return;
       }
       luaK_setcallreturns(fs, &e, LUA_MULTRET);
-      first = fs->nactloc;
+      first = fs->nactvar;
       nret = LUA_MULTRET;  /* return all values */
     }
     else {
@@ -1267,7 +1179,7 @@ static void retstat (LexState *ls) {
         first = luaK_exp2anyreg(fs, &e);
       else {
         luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
-        first = fs->nactloc;  /* return all `active' values */
+        first = fs->nactvar;  /* return all `active' values */
         lua_assert(nret == fs->freereg - first);
       }
     }
@@ -1289,7 +1201,7 @@ static void breakstat (LexState *ls) {
   if (!bl)
     luaX_syntaxerror(ls, "no loop to break");
   if (upval)
-    luaK_codeABC(fs, OP_CLOSE, bl->nactloc, 0, 0);
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
   luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
 }
 
@@ -1327,10 +1239,6 @@ static int statement (LexState *ls) {
       localstat(ls);
       return 0;
     }
-    case TK_GLOBAL: {  /* stat -> globalstat */
-      globalstat(ls);
-      return 0;
-    }
     case TK_RETURN: {  /* stat -> retstat */
       retstat(ls);
       return 1;  /* must be last statement */
@@ -1391,8 +1299,8 @@ static void chunk (LexState *ls) {
   while (!islast && !block_follow(ls->t.token)) {
     islast = statement(ls);
     optional(ls, ';');
-    lua_assert(ls->fs->freereg >= ls->fs->nactloc);
-    ls->fs->freereg = ls->fs->nactloc;  /* free registers */
+    lua_assert(ls->fs->freereg >= ls->fs->nactvar);
+    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
   }
 }
 

lparser.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.42 2002/05/09 18:00:38 roberto Exp roberto $
+** $Id: lparser.h,v 1.43 2002/05/10 19:22:11 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -41,18 +41,9 @@ typedef struct expdesc {
 } expdesc;
 
 
-/* describe declared variables */
-typedef struct vardesc {
-  int i;  /* if local, its index in `locvars';
-             if global, its name index in `k' */
-  lu_byte k;
-  lu_byte level;  /* if local, stack level;
-                     if global, corresponding local (NO_REG for free globals) */
-} vardesc;
-
-
 struct BlockCnt;  /* defined in lparser.c */
 
+
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;  /* current function header */
@@ -63,16 +54,14 @@ typedef struct FuncState {
   struct BlockCnt *bl;  /* chain of current blocks */
   int pc;  /* next position to code (equivalent to `ncode') */
   int lasttarget;   /* `pc' of last `jump target' */
-  int jpc;  /* list of jumps to `pc' */
+  int jpc;  /* list of pending jumps to `pc' */
   int freereg;  /* first free register */
-  int defaultglob;  /* where to look for non-declared globals */
   int nk;  /* number of elements in `k' */
   int np;  /* number of elements in `p' */
   int nlocvars;  /* number of elements in `locvars' */
-  int nactloc;  /* number of active local variables */
-  int nactvar;  /* number of elements in array `actvar' */
+  int nactvar;  /* number of active local variables */
   expdesc upvalues[MAXUPVALUES];  /* upvalues */
-  vardesc actvar[MAXVARS];  /* declared-variable stack */
+  int actvar[MAXVARS];  /* declared-variable stack */
 } FuncState;