no more "auto-detection"

new macro LUA_USE_POSIX to control POSIX-related macros
'mod' may also raise an error when applied to zero
2026-07-29 09:29:07 +00:00 · 2005-11-16 14:25:08 -02:00 · 2005-11-16 09:56:28 -02:00 · 2005-11-16 09:55:27 -02:00 · 2005-11-16 09:55:07 -02:00 · 2005-11-08 17:45:58 -02:00
33 changed files with 930 additions and 916 deletions
--- a/lapi.c
+++ b/lapi.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 2.47 2005/08/24 16:15:49 roberto Exp roberto $
+** $Id: lapi.c,v 2.50 2005/09/20 17:55:10 roberto Exp roberto $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -141,7 +141,7 @@ LUA_API lua_State *lua_newthread (lua_State *L) {
  setthvalue(L, L->top, L1);
  api_incr_top(L);
  lua_unlock(L);
-  luai_userstateopen(L1);
+  luai_userstatethread(L, L1);
  return L1;
 }

@@ -913,6 +913,10 @@ LUA_API int lua_gc (lua_State *L, int what, int data) {
      res = cast(int, g->totalbytes >> 10);
      break;
    }
+    case LUA_GCCOUNTB: {
+      res = cast(int, g->totalbytes & 0x3ff);
+      break;
+    }
    case LUA_GCSTEP: {
      lu_mem a = (cast(lu_mem, data) << 10);
      if (a <= g->totalbytes)
@@ -992,8 +996,20 @@ LUA_API void lua_concat (lua_State *L, int n) {


 LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
+  lua_Alloc f;
+  lua_lock(L);
  if (ud) *ud = G(L)->ud;
-  return G(L)->frealloc;
+  f = G(L)->frealloc;
+  lua_unlock(L);
+  return f;
+}
+
+
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
+  lua_lock(L);
+  G(L)->ud = ud;
+  G(L)->frealloc = f;
+  lua_unlock(L);
 }


--- a/lauxlib.c
+++ b/lauxlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.c,v 1.151 2005/08/26 17:36:32 roberto Exp roberto $
+** $Id: lauxlib.c,v 1.155 2005/10/20 11:35:25 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -176,8 +176,7 @@ LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {


 LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
-  if (lua_isnoneornil(L, narg)) return def;
-  else return luaL_checknumber(L, narg);
+  return luaL_opt(L, luaL_checknumber, narg, def);
 }


@@ -190,16 +189,16 @@ LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {


 LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
-                                        lua_Integer def) {
-  if (lua_isnoneornil(L, narg)) return def;
-  else return luaL_checkinteger(L, narg);
+                                                      lua_Integer def) {
+  return luaL_opt(L, luaL_checkinteger, narg, def);
 }


 LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
  if (!lua_getmetatable(L, obj))  /* no metatable? */
    return 0;
-  lua_getfield(L, -1, event);
+  lua_pushstring(L, event);
+  lua_rawget(L, -2);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 2);  /* remove metatable and metafield */
    return 0;
@@ -231,7 +230,7 @@ LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
                              const luaL_Reg *l, int nup) {
  if (libname) {
    /* check whether lib already exists */
-    lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED");
    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
    if (!lua_istable(L, -1)) {  /* not found? */
      lua_pop(L, 1);  /* remove previous result */
@@ -305,7 +304,7 @@ LUALIB_API int luaL_getn (lua_State *L, int t) {
  if ((n = checkint(L, 2)) >= 0) return n;
  lua_getfield(L, t, "n");  /* else try t.n */
  if ((n = checkint(L, 1)) >= 0) return n;
-  return lua_objlen(L, t);
+  return (int)lua_objlen(L, t);
 }

 #endif
@@ -470,7 +469,7 @@ LUALIB_API int luaL_ref (lua_State *L, int t) {
    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
  }
  else {  /* no free elements */
-    ref = lua_objlen(L, t);
+    ref = (int)lua_objlen(L, t);
    ref++;  /* create new reference */
  }
  lua_rawseti(L, t, ref);
--- a/lauxlib.h
+++ b/lauxlib.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.84 2005/08/26 17:36:32 roberto Exp roberto $
+** $Id: lauxlib.h,v 1.85 2005/09/06 17:19:51 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -114,6 +114,7 @@ LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,

 #define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))

+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))

 /*
 ** {======================================================
--- a/lbaselib.c
+++ b/lbaselib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbaselib.c,v 1.181 2005/08/15 14:12:32 roberto Exp roberto $
+** $Id: lbaselib.c,v 1.185 2005/10/20 11:35:50 roberto Exp roberto $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
@@ -196,9 +196,23 @@ static int luaB_collectgarbage (lua_State *L) {
  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
  int o = luaL_checkoption(L, 1, "collect", opts);
-  int ex = luaL_optinteger(L, 2, 0);
-  lua_pushinteger(L, lua_gc(L, optsnum[o], ex));
-  return 1;
+  int ex = luaL_optint(L, 2, 0);
+  int res = lua_gc(L, optsnum[o], ex);
+  switch (optsnum[o]) {
+    case LUA_GCCOUNT: {
+      int b = lua_gc(L, LUA_GCCOUNTB, 0);
+      lua_pushnumber(L, ((lua_Number)res*1024 + b)/1000);
+      return 1;
+    }
+    case LUA_GCSTEP: {
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    default: {
+      lua_pushnumber(L, res);
+      return 1;
+    }
+  }
 }


@@ -326,12 +340,10 @@ static int luaB_assert (lua_State *L) {


 static int luaB_unpack (lua_State *L) {
-  int i = luaL_optint(L, 2, 1);
-  int e = luaL_optint(L, 3, -1);
-  int n;
+  int i, e, n;
  luaL_checktype(L, 1, LUA_TTABLE);
-  if (e == -1)
-    e = luaL_getn(L, 1);
+  i = luaL_optint(L, 2, 1);
+  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
  n = e - i + 1;  /* number of elements */
  if (n <= 0) return 0;  /* empty range */
  luaL_checkstack(L, n, "table too big to unpack");
@@ -349,8 +361,9 @@ static int luaB_select (lua_State *L) {
  }
  else {
    int i = luaL_checkint(L, 1);
-    if (i <= 0) i = 1;
-    else if (i >= n) i = n;
+    if (i < 0) i = n + i;
+    else if (i > n) i = n;
+    luaL_argcheck(L, 1 <= i, 1, "index out of range");
    return n - i;
  }
 }
@@ -560,7 +573,7 @@ static int luaB_costatus (lua_State *L) {
            lua_pushliteral(L, "dead");
        else
          lua_pushliteral(L, "suspended");  /* initial state */
-        break;  
+        break;
      }
      default:  /* some error occured */
        lua_pushliteral(L, "dead");
@@ -601,8 +614,11 @@ static void auxopen (lua_State *L, const char *name,


 static void base_open (lua_State *L) {
+  /* set global _G */
  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  luaL_register(L, NULL, base_funcs);  /* open lib into global table */
+  lua_setglobal(L, "_G");
+  /* open lib into global table */
+  luaL_register(L, "_G", base_funcs);
  lua_pushliteral(L, LUA_VERSION);
  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
  /* `ipairs' and `pairs' need auxiliary functions as upvalues */
@@ -616,12 +632,6 @@ static void base_open (lua_State *L) {
  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
  lua_pushcclosure(L, luaB_newproxy, 1);
  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
-  /* create register._LOADED to track loaded modules */
-  lua_newtable(L);
-  lua_setfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  /* set global _G */
-  lua_pushvalue(L, LUA_GLOBALSINDEX);
-  lua_setglobal(L, "_G");
 }


--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 2.15 2005/08/17 18:32:09 roberto Exp $
+** $Id: lcode.c,v 2.21 2005/11/08 19:44:31 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -27,16 +27,24 @@
 #define hasjumps(e)	((e)->t != (e)->f)


+static int isnumeral(expdesc *e) {
+  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
+}
+
+
 void luaK_nil (FuncState *fs, int from, int n) {
  Instruction *previous;
-  if (fs->pc > fs->lasttarget &&  /* no jumps to current position? */
-      GET_OPCODE(*(previous = &fs->f->code[fs->pc-1])) == OP_LOADNIL) {
-    int pfrom = GETARG_A(*previous);
-    int pto = GETARG_B(*previous);
-    if (pfrom <= from && from <= pto+1) {  /* can connect both? */
-      if (from+n-1 > pto)
-        SETARG_B(*previous, from+n-1);
-      return;
+  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
+    if (fs->pc == 0)  /* function start? */
+      return;  /* positions are already clean */
+    if (GET_OPCODE(*(previous = &fs->f->code[fs->pc-1])) == OP_LOADNIL) {
+      int pfrom = GETARG_A(*previous);
+      int pto = GETARG_B(*previous);
+      if (pfrom <= from && from <= pto+1) {  /* can connect both? */
+        if (from+n-1 > pto)
+          SETARG_B(*previous, from+n-1);
+        return;
+      }
    }
  }
  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
@@ -115,20 +123,22 @@ static int need_value (FuncState *fs, int list) {
 }


-static void patchtestreg (Instruction *i, int reg) {
-  if (reg != NO_REG)
+static int patchtestreg (FuncState *fs, int node, int reg) {
+  Instruction *i = getjumpcontrol(fs, node);
+  if (GET_OPCODE(*i) != OP_TESTSET)
+    return 0;  /* cannot patch other instructions */
+  if (reg != NO_REG && reg != GETARG_B(*i))
    SETARG_A(*i, reg);
-  else  /* no register to put value; change TESTSET to TEST */
+  else  /* no register to put value or register already has the value */
    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
+
+  return 1;
 }


 static void removevalues (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list)) {
-    Instruction *i = getjumpcontrol(fs, list);
-    if (GET_OPCODE(*i) == OP_TESTSET)
-      patchtestreg(i, NO_REG);
-  }
+  for (; list != NO_JUMP; list = getjump(fs, list))
+      patchtestreg(fs, list, NO_REG);
 }


@@ -136,11 +146,8 @@ static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
                          int dtarget) {
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
-    Instruction *i = getjumpcontrol(fs, list);
-    if (GET_OPCODE(*i) == OP_TESTSET) {
-      patchtestreg(i, reg);
+    if (patchtestreg(fs, list, reg))
      fixjump(fs, list, vtarget);
-    }
    else
      fixjump(fs, list, dtarget);  /* jump to default target */
    list = next;
@@ -210,7 +217,7 @@ static void freereg (FuncState *fs, int reg) {

 static void freeexp (FuncState *fs, expdesc *e) {
  if (e->k == VNONRELOC)
-    freereg(fs, e->info);
+    freereg(fs, e->u.s.info);
 }


@@ -280,7 +287,7 @@ void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
 void luaK_setoneret (FuncState *fs, expdesc *e) {
  if (e->k == VCALL) {  /* expression is an open function call? */
    e->k = VNONRELOC;
-    e->info = GETARG_A(getcode(fs, e));
+    e->u.s.info = GETARG_A(getcode(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_B(getcode(fs, e), 2);
@@ -296,19 +303,19 @@ void luaK_dischargevars (FuncState *fs, expdesc *e) {
      break;
    }
    case VUPVAL: {
-      e->info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->info, 0);
+      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VGLOBAL: {
-      e->info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->info);
+      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
-      freereg(fs, e->aux);
-      freereg(fs, e->info);
-      e->info = luaK_codeABC(fs, OP_GETTABLE, 0, e->info, e->aux);
+      freereg(fs, e->u.s.aux);
+      freereg(fs, e->u.s.info);
+      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
      e->k = VRELOCABLE;
      break;
    }
@@ -340,7 +347,11 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
      break;
    }
    case VK: {
-      luaK_codeABx(fs, OP_LOADK, reg, e->info);
+      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
+      break;
+    }
+    case VKNUM: {
+      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
@@ -349,8 +360,8 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
      break;
    }
    case VNONRELOC: {
-      if (reg != e->info)
-        luaK_codeABC(fs, OP_MOVE, reg, e->info, 0);
+      if (reg != e->u.s.info)
+        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
@@ -358,7 +369,7 @@ static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
      return;  /* nothing to do... */
    }
  }
-  e->info = reg;
+  e->u.s.info = reg;
  e->k = VNONRELOC;
 }

@@ -374,15 +385,13 @@ static void discharge2anyreg (FuncState *fs, expdesc *e) {
 static void exp2reg (FuncState *fs, expdesc *e, int reg) {
  discharge2reg(fs, e, reg);
  if (e->k == VJMP)
-    luaK_concat(fs, &e->t, e->info);  /* put this jump in `t' list */
+    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
  if (hasjumps(e)) {
    int final;  /* position after whole expression */
    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
    if (need_value(fs, e->t) || need_value(fs, e->f)) {
-      int fj = NO_JUMP;  /* first jump (over LOAD ops.) */
-      if (e->k != VJMP)
-        fj = luaK_jump(fs);
+      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
      p_f = code_label(fs, reg, 0, 1);
      p_t = code_label(fs, reg, 1, 0);
      luaK_patchtohere(fs, fj);
@@ -392,7 +401,7 @@ static void exp2reg (FuncState *fs, expdesc *e, int reg) {
    patchlistaux(fs, e->t, final, reg, p_t);
  }
  e->f = e->t = NO_JUMP;
-  e->info = reg;
+  e->u.s.info = reg;
  e->k = VNONRELOC;
 }

@@ -408,14 +417,14 @@ void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
 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->nactvar) {  /* reg. is not a local? */
-      exp2reg(fs, e, e->info);  /* put value on it */
-      return e->info;
+    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
+    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
+      exp2reg(fs, e, e->u.s.info);  /* put value on it */
+      return e->u.s.info;
    }
  }
  luaK_exp2nextreg(fs, e);  /* default */
-  return e->info;
+  return e->u.s.info;
 }


@@ -430,19 +439,22 @@ void luaK_exp2val (FuncState *fs, expdesc *e) {
 int luaK_exp2RK (FuncState *fs, expdesc *e) {
  luaK_exp2val(fs, e);
  switch (e->k) {
+    case VKNUM:
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
-        e->info = (e->k == VNIL) ? nilK(fs) : boolK(fs, (e->k == VTRUE));
+        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
+                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
+                                        boolK(fs, (e->k == VTRUE));
        e->k = VK;
-        return RKASK(e->info);
+        return RKASK(e->u.s.info);
      }
      else break;
    }
    case VK: {
-      if (e->info <= MAXINDEXRK)  /* constant fit in argC? */
-        return RKASK(e->info);
+      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
+        return RKASK(e->u.s.info);
      else break;
    }
    default: break;
@@ -456,22 +468,22 @@ void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
-      exp2reg(fs, ex, var->info);
+      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABC(fs, OP_SETUPVAL, e, var->info, 0);
+      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABx(fs, OP_SETGLOBAL, e, var->info);
+      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
-      luaK_codeABC(fs, OP_SETTABLE, var->info, var->aux, e);
+      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
@@ -489,15 +501,15 @@ void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
-  luaK_codeABC(fs, OP_SELF, func, e->info, luaK_exp2RK(fs, key));
+  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
-  e->info = func;
+  e->u.s.info = func;
  e->k = VNONRELOC;
 }


 static void invertjump (FuncState *fs, expdesc *e) {
-  Instruction *pc = getjumpcontrol(fs, e->info);
+  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
                                           GET_OPCODE(*pc) != OP_TEST);
  SETARG_A(*pc, !(GETARG_A(*pc)));
@@ -515,7 +527,7 @@ static int jumponcond (FuncState *fs, expdesc *e, int cond) {
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
-  return condjump(fs, OP_TESTSET, NO_REG, e->info, cond);
+  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
 }


@@ -523,7 +535,7 @@ void luaK_goiftrue (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
-    case VK: case VTRUE: {
+    case VK: case VKNUM: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
@@ -533,7 +545,7 @@ void luaK_goiftrue (FuncState *fs, expdesc *e) {
    }
    case VJMP: {
      invertjump(fs, e);
-      pc = e->info;
+      pc = e->u.s.info;
      break;
    }
    default: {
@@ -547,7 +559,7 @@ void luaK_goiftrue (FuncState *fs, expdesc *e) {
 }


-void luaK_goiffalse (FuncState *fs, expdesc *e) {
+static void luaK_goiffalse (FuncState *fs, expdesc *e) {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
@@ -560,7 +572,7 @@ void luaK_goiffalse (FuncState *fs, expdesc *e) {
      break;
    }
    case VJMP: {
-      pc = e->info;
+      pc = e->u.s.info;
      break;
    }
    default: {
@@ -581,7 +593,7 @@ static void codenot (FuncState *fs, expdesc *e) {
      e->k = VTRUE;
      break;
    }
-    case VK: case VTRUE: {
+    case VK: case VKNUM: case VTRUE: {
      e->k = VFALSE;
      break;
    }
@@ -593,7 +605,7 @@ static void codenot (FuncState *fs, expdesc *e) {
    case VNONRELOC: {
      discharge2anyreg(fs, e);
      freeexp(fs, e);
-      e->info = luaK_codeABC(fs, OP_NOT, 0, e->info, 0);
+      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
@@ -610,34 +622,81 @@ static void codenot (FuncState *fs, expdesc *e) {


 void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  t->aux = luaK_exp2RK(fs, k);
+  t->u.s.aux = luaK_exp2RK(fs, k);
  t->k = VINDEXED;
 }


+static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
+  lua_Number v1, v2, r;
+  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
+  v1 = e1->u.nval;
+  v2 = e2->u.nval;
+  switch (op) {
+    case OP_ADD: r = luai_numadd(v1, v2); break;
+    case OP_SUB: r = luai_numsub(v1, v2); break;
+    case OP_MUL: r = luai_nummul(v1, v2); break;
+    case OP_DIV:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_numdiv(v1, v2); break;
+    case OP_MOD:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_nummod(v1, v2); break;
+    case OP_POW: r = luai_numpow(v1, v2); break;
+    case OP_UNM: r = luai_numunm(v1); break;
+    case OP_LEN: return 0;  /* no constant folding for 'len' */
+    default: lua_assert(0); r = 0; break;
+  }
+  if (r != r) return 0;  /* do not attempt to produce NaN */
+  e1->u.nval = r;
+  return 1;
+}
+
+
+static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
+  if (constfolding(op, e1, e2))
+    return;
+  else {
+    int o1 = luaK_exp2RK(fs, e1);
+    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
+    freeexp(fs, e2);
+    freeexp(fs, e1);
+    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
+    e1->k = VRELOCABLE;
+  }
+}
+
+
+static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
+                                                          expdesc *e2) {
+  int o1 = luaK_exp2RK(fs, e1);
+  int o2 = luaK_exp2RK(fs, e2);
+  freeexp(fs, e2);
+  freeexp(fs, e1);
+  if (cond == 0 && op != OP_EQ) {
+    int temp;  /* exchange args to replace by `<' or `<=' */
+    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
+    cond = 1;
+  }
+  e1->u.s.info = condjump(fs, op, cond, o1, o2);
+  e1->k = VJMP;
+}
+
+
 void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
+  expdesc e2;
+  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
-      luaK_exp2val(fs, e);
-      if (e->k == VK && ttisnumber(&fs->f->k[e->info]))
-        e->info = luaK_numberK(fs, luai_numunm(L, nvalue(&fs->f->k[e->info])));
-      else {
-        luaK_exp2anyreg(fs, e);
-        freeexp(fs, e);
-        e->info = luaK_codeABC(fs, OP_UNM, 0, e->info, 0);
-        e->k = VRELOCABLE;
-      }
-      break;
-    }
-    case OPR_NOT: {
-      codenot(fs, e);
+      if (e->k == VK)
+        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
+      codearith(fs, OP_UNM, e, &e2);
      break;
    }
+    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
-      luaK_exp2anyreg(fs, e);
-      freeexp(fs, e);
-      e->info = luaK_codeABC(fs, OP_LEN, 0, e->info, 0);
-      e->k = VRELOCABLE;
+      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
+      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
@@ -660,74 +719,58 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
      break;
    }
    default: {
-      luaK_exp2RK(fs, v);
+      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
  }
 }


-static void codebinop (FuncState *fs, expdesc *res, BinOpr op,
-                       int o1, int o2) {
-  if (op <= OPR_POW) {  /* arithmetic operator? */
-    OpCode opc = cast(OpCode, (op - OPR_ADD) + OP_ADD);  /* ORDER OP */
-    res->info = luaK_codeABC(fs, opc, 0, o1, o2);
-    res->k = VRELOCABLE;
-  }
-  else {  /* test operator */
-    static const OpCode ops[] = {OP_EQ, OP_EQ, OP_LT, OP_LE, OP_LT, OP_LE};
-    int cond = 1;
-    if (op >= OPR_GT) {  /* `>' or `>='? */
-      int temp;  /* exchange args and replace by `<' or `<=' */
-      temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
-    }
-    else if (op == OPR_NE) cond = 0;
-    res->info = condjump(fs, ops[op - OPR_NE], cond, o1, o2);
-    res->k = VJMP;
-  }
-}
-
-
 void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
  switch (op) {
    case OPR_AND: {
      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
      luaK_dischargevars(fs, e2);
      luaK_concat(fs, &e1->f, e2->f);
-      e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->t = e2->t;
+      e1->k = e2->k; e1->u.s.info = e2->u.s.info;
+      e1->u.s.aux = e2->u.s.aux; e1->t = e2->t;
      break;
    }
    case OPR_OR: {
      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
      luaK_dischargevars(fs, e2);
      luaK_concat(fs, &e1->t, e2->t);
-      e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->f = e2->f;
+      e1->k = e2->k; e1->u.s.info = e2->u.s.info;
+      e1->u.s.aux = e2->u.s.aux; e1->f = e2->f;
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2val(fs, e2);
      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
-        lua_assert(e1->info == GETARG_B(getcode(fs, e2))-1);
+        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
        freeexp(fs, e1);
-        SETARG_B(getcode(fs, e2), e1->info);
-        e1->k = e2->k; e1->info = e2->info;
+        SETARG_B(getcode(fs, e2), e1->u.s.info);
+        e1->k = e2->k; e1->u.s.info = e2->u.s.info;
      }
      else {
-        luaK_exp2nextreg(fs, e2);
-        freeexp(fs, e2);
-        freeexp(fs, e1);
-        e1->info = luaK_codeABC(fs, OP_CONCAT, 0, e1->info, e2->info);
-        e1->k = VRELOCABLE;
+        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
+        codearith(fs, OP_CONCAT, e1, e2);
      }
      break;
    }
-    default: {
-      int o1 = luaK_exp2RK(fs, e1);
-      int o2 = luaK_exp2RK(fs, e2);
-      freeexp(fs, e2);
-      freeexp(fs, e1);
-      codebinop(fs, e1, op, o1, o2);
-    }
+    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
+    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
+    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
+    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
+    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
+    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
+    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
+    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
+    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
+    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
+    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
+    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    default: lua_assert(0);
  }
 }

@@ -737,7 +780,7 @@ void luaK_fixline (FuncState *fs, int line) {
 }


-int luaK_code (FuncState *fs, Instruction i, int line) {
+static int luaK_code (FuncState *fs, Instruction i, int line) {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
--- a/lcode.h
+++ b/lcode.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.44 2005/05/20 15:53:42 roberto Exp $
+** $Id: lcode.h,v 1.46 2005/10/03 14:02:40 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -24,7 +24,7 @@
 ** grep "ORDER OPR" if you change these enums
 */
 typedef enum BinOpr {
-  OPR_ADD, OPR_SUB, OPR_MULT, OPR_DIV, OPR_MOD, OPR_POW,
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
  OPR_CONCAT,
  OPR_NE, OPR_EQ,
  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
@@ -37,13 +37,12 @@ typedef enum BinOpr {
 typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;


-#define getcode(fs,e)	((fs)->f->code[(e)->info])
+#define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])

 #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)

 #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)

-LUAI_FUNC int luaK_code (FuncState *fs, Instruction i, int line);
 LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
 LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
 LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
@@ -60,7 +59,6 @@ LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
 LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
 LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
 LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
 LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
--- a/ldblib.c
+++ b/ldblib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldblib.c,v 1.100 2005/08/15 14:12:32 roberto Exp roberto $
+** $Id: ldblib.c,v 1.102 2005/10/19 13:05:11 roberto Exp roberto $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
@@ -19,6 +19,12 @@



+static int db_getregistry (lua_State *L) {
+  lua_pushvalue(L, LUA_REGISTRYINDEX);
+  return 1;
+}
+
+
 static int db_getmetatable (lua_State *L) {
  luaL_checkany(L, 1);
  if (!lua_getmetatable(L, 1)) {
@@ -319,7 +325,7 @@ static int db_errorfb (lua_State *L) {
  lua_State *L1 = getthread(L, &arg);
  lua_Debug ar;
  if (lua_isnumber(L, arg+2)) {
-    level = lua_tointeger(L, arg+2);
+    level = (int)lua_tointeger(L, arg+2);
    lua_pop(L, 1);
  }
  else
@@ -371,6 +377,7 @@ static const luaL_Reg dblib[] = {
  {"gethook", db_gethook},
  {"getinfo", db_getinfo},
  {"getlocal", db_getlocal},
+  {"getregistry", db_getregistry},
  {"getmetatable", db_getmetatable},
  {"getupvalue", db_getupvalue},
  {"setfenv", db_setfenv},
--- a/ldebug.c
+++ b/ldebug.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 2.25 2005/07/11 13:59:03 roberto Exp roberto $
+** $Id: ldebug.c,v 2.27 2005/10/06 20:43:44 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -109,40 +109,39 @@ static Proto *getluaproto (CallInfo *ci) {
 }


-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
  const char *name;
-  CallInfo *ci;
-  Proto *fp;
-  lua_lock(L);
-  name = NULL;
-  ci = L->base_ci + ar->i_ci;
-  fp = getluaproto(ci);
-  if (fp) {  /* is a Lua function? */
-    name = luaF_getlocalname(fp, n, currentpc(L, ci));
-    if (name)
-      luaA_pushobject(L, ci->base+(n-1));  /* push value */
+  Proto *fp = getluaproto(ci);
+  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
+    return name;  /* is a local variable in a Lua function */
+  else {
+    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
+    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
+      return "(*temporary)";
+    else
+      return NULL;
  }
+}
+
+
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
+  lua_lock(L);
+  if (name)
+      luaA_pushobject(L, ci->base + (n - 1));
  lua_unlock(L);
  return name;
 }


 LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
-  const char *name;
-  CallInfo *ci;
-  Proto *fp;
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
  lua_lock(L);
-  name = NULL;
-  ci = L->base_ci + ar->i_ci;
-  fp = getluaproto(ci);
-  L->top--;  /* pop new value */
-  if (fp) {  /* is a Lua function? */
-    name = luaF_getlocalname(fp, n, currentpc(L, ci));
-    if (!name || name[0] == '(')  /* `(' starts private locals */
-      name = NULL;
-    else
-      setobjs2s(L, ci->base+(n-1), L->top);
-  }
+  if (name)
+      setobjs2s(L, ci->base + (n - 1), L->top - 1);
+  L->top--;  /* pop value */
  lua_unlock(L);
  return name;
 }
@@ -321,7 +320,7 @@ static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
  check(precheck(pt));
  for (pc = 0; pc < lastpc; pc++) {
-    const Instruction i = pt->code[pc];
+    Instruction i = pt->code[pc];
    OpCode op = GET_OPCODE(i);
    int a = GETARG_A(i);
    int b = 0;
@@ -348,7 +347,7 @@ static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
          check(0 <= dest && dest < pt->sizecode);
          if (dest > 0) {
            /* cannot jump to a setlist count */
-            const Instruction d = pt->code[dest-1];
+            Instruction d = pt->code[dest-1];
            check(!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0));
          }
        }
--- a/ldo.c
+++ b/ldo.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 2.32 2005/08/24 16:15:49 roberto Exp roberto $
+** $Id: ldo.c,v 2.35 2005/10/14 16:23:33 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -276,8 +276,11 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
    Proto *p = cl->p;
    luaD_checkstack(L, p->maxstacksize);
    func = restorestack(L, funcr);
-    if (!p->is_vararg)  /* no varargs? */
+    if (!p->is_vararg) {  /* no varargs? */
      base = func + 1;
+      if (L->top > base + p->numparams)
+        L->top = base + p->numparams;
+    }
    else {  /* vararg function */
      int nargs = cast(int, L->top - func) - 1;
      base = adjust_varargs(L, p, nargs);
@@ -316,14 +319,12 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
    lua_unlock(L);
    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
    lua_lock(L);
-    if (n >= 0) {  /* no yielding? */
+    if (n < 0)  /* yielding? */
+      return PCRYIELD;
+    else {
      luaD_poscall(L, L->top - n);
      return PCRC;
    }
-    else {
-      ci->nresults = nresults;
-      return PCRYIELD;
-    }
  }
 }

@@ -428,6 +429,7 @@ LUA_API int lua_resume (lua_State *L, int nargs) {
  if (status != 0) {  /* error? */
    L->status = cast(lu_byte, status);  /* mark thread as `dead' */
    luaD_seterrorobj(L, status, L->top);
+    L->ci->top = L->top;
  }
  else
    status = L->status;
--- a/ldump.c
+++ b/ldump.c
@@ -1,6 +1,6 @@
 /*
-** $Id: ldump.c,v 2.5 2005/05/05 20:47:02 roberto Exp roberto $
-** save pre-compiled Lua chunks
+** $Id: ldump.c,v 1.13 2005/11/01 17:04:55 lhf Exp lhf $
+** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */

@@ -12,13 +12,9 @@
 #include "lua.h"

 #include "lobject.h"
-#include "lopcodes.h"
 #include "lstate.h"
 #include "lundump.h"

-#define DumpVector(b,n,size,D)	DumpBlock(b,(n)*(size),D)
-#define DumpLiteral(s,D)	DumpBlock("" s,(sizeof(s))-1,D)
-
 typedef struct {
 lua_State* L;
 lua_Writer writer;
@@ -27,6 +23,9 @@ typedef struct {
 int status;
 } DumpState;

+#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
+#define DumpVar(x,D)	 	DumpMem(&x,1,sizeof(x),D)
+
 static void DumpBlock(const void* b, size_t size, DumpState* D)
 {
 if (D->status==0)
@@ -37,48 +36,84 @@ static void DumpBlock(const void* b, size_t size, DumpState* D)
 }
 }

-static void DumpByte(int y, DumpState* D)
+static void DumpChar(int y, DumpState* D)
 {
 char x=(char)y;
- DumpBlock(&x,sizeof(x),D);
+ DumpVar(x,D);
 }

 static void DumpInt(int x, DumpState* D)
 {
- DumpBlock(&x,sizeof(x),D);
-}
-
-static void DumpSize(size_t x, DumpState* D)
-{
- DumpBlock(&x,sizeof(x),D);
+ DumpVar(x,D);
 }

 static void DumpNumber(lua_Number x, DumpState* D)
 {
- DumpBlock(&x,sizeof(x),D);
+ DumpVar(x,D);
+}
+
+static void DumpVector(const void* b, int n, size_t size, DumpState* D)
+{
+ DumpInt(n,D);
+ DumpMem(b,n,size,D);
 }

 static void DumpString(const TString* s, DumpState* D)
 {
 if (s==NULL || getstr(s)==NULL)
-  DumpSize(0,D);
+ {
+  size_t size=0;
+  DumpVar(size,D);
+ }
 else
 {
  size_t size=s->tsv.len+1;		/* include trailing '\0' */
-  DumpSize(size,D);
+  DumpVar(size,D);
  DumpBlock(getstr(s),size,D);
 }
 }

-static void DumpCode(const Proto* f, DumpState* D)
+#define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
+
+static void DumpConstants(const Proto* f, DumpState* D)
 {
- DumpInt(f->sizecode,D);
- DumpVector(f->code,f->sizecode,sizeof(*f->code),D);
+ int i,n=f->sizek;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  const TValue* o=&f->k[i];
+  DumpChar(ttype(o),D);
+  switch (ttype(o))
+  {
+   case LUA_TNIL:
+	break;
+   case LUA_TBOOLEAN:
+	DumpChar(bvalue(o),D);
+	break;
+   case LUA_TNUMBER:
+	DumpNumber(nvalue(o),D);
+	break;
+   case LUA_TSTRING:
+	DumpString(rawtsvalue(o),D);
+	break;
+   default:
+	lua_assert(0);			/* cannot happen */
+	break;
+  }
+ }
+ n=f->sizep;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
 }

-static void DumpLocals(const Proto* f, DumpState* D)
+static void DumpDebug(const Proto* f, DumpState* D)
 {
- int i,n=f->sizelocvars;
+ int i,n;
+ n= (D->strip) ? 0 : f->sizelineinfo;
+ DumpVector(f->lineinfo,n,sizeof(int),D);
+ n= (D->strip) ? 0 : f->sizelocvars;
 DumpInt(n,D);
 for (i=0; i<n; i++)
 {
@@ -86,86 +121,36 @@ static void DumpLocals(const Proto* f, DumpState* D)
  DumpInt(f->locvars[i].startpc,D);
  DumpInt(f->locvars[i].endpc,D);
 }
-}
-
-static void DumpLines(const Proto* f, DumpState* D)
-{
- DumpInt(f->sizelineinfo,D);
- DumpVector(f->lineinfo,f->sizelineinfo,sizeof(*f->lineinfo),D);
-}
-
-static void DumpUpvalues(const Proto* f, DumpState* D)
-{
- int i,n=f->sizeupvalues;
+ n= (D->strip) ? 0 : f->sizeupvalues;
 DumpInt(n,D);
 for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
 }

-static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
-
-static void DumpConstants(const Proto* f, DumpState* D)
-{
- int i,n;
- DumpInt(n=f->sizek,D);
- for (i=0; i<n; i++)
- {
-  const TValue* o=&f->k[i];
-  DumpByte(ttype(o),D);
-  switch (ttype(o))
-  {
-   case LUA_TNUMBER:
-	DumpNumber(nvalue(o),D);
-	break;
-   case LUA_TSTRING:
-	DumpString(rawtsvalue(o),D);
-	break;
-   case LUA_TNIL:
-	break;
-   case LUA_TBOOLEAN:
-        DumpByte(bvalue(o),D);
-        break;
-   default:
-	lua_assert(0);			/* cannot happen */
-	break;
-  }
- }
- DumpInt(n=f->sizep,D);
- for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
-}
-
 static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
 {
 DumpString((f->source==p) ? NULL : f->source,D);
 DumpInt(f->linedefined,D);
 DumpInt(f->lastlinedefined,D);
- DumpByte(f->nups,D);
- DumpByte(f->numparams,D);
- DumpByte(f->is_vararg,D);
- DumpByte(f->maxstacksize,D);
- if (D->strip) DumpInt(0,D); else DumpLines(f,D);
- if (D->strip) DumpInt(0,D); else DumpLocals(f,D);
- if (D->strip) DumpInt(0,D); else DumpUpvalues(f,D);
- DumpConstants(f,D);
+ DumpChar(f->nups,D);
+ DumpChar(f->numparams,D);
+ DumpChar(f->is_vararg,D);
+ DumpChar(f->maxstacksize,D);
 DumpCode(f,D);
+ DumpConstants(f,D);
+ DumpDebug(f,D);
 }

 static void DumpHeader(DumpState* D)
 {
- DumpLiteral(LUA_SIGNATURE,D);
- DumpByte(VERSION,D);
- DumpByte(luaU_endianness(),D);
- DumpByte(sizeof(int),D);
- DumpByte(sizeof(size_t),D);
- DumpByte(sizeof(Instruction),D);
- DumpByte(sizeof(lua_Number),D);
- DumpNumber(TEST_NUMBER,D);
+ char h[LUAC_HEADERSIZE];
+ luaU_header(h);
+ DumpBlock(h,LUAC_HEADERSIZE,D);
 }

 /*
 ** dump Lua function as precompiled chunk
 */
-int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data,
-                             int strip)
+int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
 {
 DumpState D;
 D.L=L;
--- a/liolib.c
+++ b/liolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 2.66 2005/08/17 19:05:04 roberto Exp roberto $
+** $Id: liolib.c,v 2.68 2005/10/14 16:24:11 roberto Exp roberto $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -424,7 +424,7 @@ static int f_seek (lua_State *L) {
  static const char *const modenames[] = {"set", "cur", "end", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, "cur", modenames);
-  lua_Integer offset = luaL_optinteger(L, 3, 0);
+  long offset = luaL_optlong(L, 3, 0);
  op = fseek(f, offset, mode[op]);
  if (op)
    return pushresult(L, 0, NULL);  /* error */
@@ -440,7 +440,7 @@ static int f_setvbuf (lua_State *L) {
  static const char *const modenames[] = {"no", "full", "line", NULL};
  FILE *f = tofile(L);
  int op = luaL_checkoption(L, 2, NULL, modenames);
-  lua_Integer sz = luaL_optinteger(L, 3, BUFSIZ);
+  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
  int res = setvbuf(f, NULL, mode[op], sz);
  return pushresult(L, res == 0, NULL);
 }
--- a/llex.c
+++ b/llex.c
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 2.11 2005/05/16 21:19:00 roberto Exp roberto $
+** $Id: llex.c,v 2.12 2005/05/17 19:49:15 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -155,28 +155,23 @@ void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {



+static int check_next (LexState *ls, const char *set) {
+  if (!strchr(set, ls->current))
+    return 0;
+  save_and_next(ls);
+  return 1;
+}
+
+

 /* LUA_NUMBER */
 static void read_numeral (LexState *ls, SemInfo *seminfo) {
-  while (isdigit(ls->current)) {
+  lua_assert(isdigit(ls->current));
+  do {
    save_and_next(ls);
-  }
-  if (ls->current == '.') {
-    save_and_next(ls);
-    if (ls->current == '.') {
-      save_and_next(ls);
-      luaX_lexerror(ls,
-                 "ambiguous syntax (decimal point x string concatenation)",
-                 TK_NUMBER);
-    }
-  }
-  while (isdigit(ls->current)) {
-    save_and_next(ls);
-  }
-  if (ls->current == 'e' || ls->current == 'E') {
-    save_and_next(ls);  /* read `E' */
-    if (ls->current == '+' || ls->current == '-')
-      save_and_next(ls);  /* optional exponent sign */
+  } while (isdigit(ls->current) || ls->current == '.');
+  if (check_next(ls, "Ee")) {  /* `E'? */
+    check_next(ls, "+-");  /* optional exponent sign */
    while (isdigit(ls->current)) {
      save_and_next(ls);
    }
@@ -375,12 +370,9 @@ int luaX_lex (LexState *ls, SemInfo *seminfo) {
      }
      case '.': {
        save_and_next(ls);
-        if (ls->current == '.') {
-          next(ls);
-          if (ls->current == '.') {
-            next(ls);
+        if (check_next(ls, ".")) {
+          if (check_next(ls, "."))
            return TK_DOTS;   /* ... */
-          }
          else return TK_CONCAT;   /* .. */
        }
        else if (!isdigit(ls->current)) return '.';
--- a/loadlib.c
+++ b/loadlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loadlib.c,v 1.43 2005/08/31 23:17:29 roberto Exp roberto $
+** $Id: loadlib.c,v 1.47 2005/10/06 20:46:10 roberto Exp roberto $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
@@ -97,16 +97,18 @@ static lua_CFunction ll_sym (lua_State *L, void *lib, const char *sym) {

 #undef setprogdir

-void setprogdir (lua_State *L) {
+static void setprogdir (lua_State *L) {
  char buff[MAX_PATH + 1];
  char *lb;
  DWORD nsize = sizeof(buff)/sizeof(char);
  DWORD n = GetModuleFileName(NULL, buff, nsize);
  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
    luaL_error(L, "unable to get ModuleFileName");
-  *lb = '\0';
-  luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
-  lua_remove(L, -2);  /* remove original string */
+  else {
+    *lb = '\0';
+    luaL_gsub(L, lua_tostring(L, -1), LUA_EXECDIR, buff);
+    lua_remove(L, -2);  /* remove original string */
+  }
 }


@@ -440,7 +442,8 @@ static int loader_preload (lua_State *L) {
 }


-static const int sentinel = 0;
+static const int sentinel_ = 0;
+#define sentinel	((void *)&sentinel_)


 static int ll_require (lua_State *L) {
@@ -450,7 +453,7 @@ static int ll_require (lua_State *L) {
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, 2, name);
  if (lua_toboolean(L, -1)) {  /* is it there? */
-    if (lua_touserdata(L, -1) == &sentinel)  /* check loops */
+    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
    return 1;  /* package is already loaded */
  }
@@ -467,14 +470,14 @@ static int ll_require (lua_State *L) {
    if (lua_isnil(L, -1)) lua_pop(L, 1);  /* did not found module */
    else break;  /* module loaded successfully */
  }
-  lua_pushlightuserdata(L, (void *)&sentinel);
+  lua_pushlightuserdata(L, sentinel);
  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
  lua_pushstring(L, name);  /* pass name as argument to module */
  lua_call(L, 1, 1);  /* run loaded module */
  if (!lua_isnil(L, -1))  /* non-nil return? */
    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
  lua_getfield(L, 2, name);
-  if (lua_touserdata(L, -1) == &sentinel) {   /* module did not set a value? */
+  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a value? */
    lua_pushboolean(L, 1);  /* use true as result */
    lua_pushvalue(L, -1);  /* extra copy to be returned */
    lua_setfield(L, 2, name);  /* _LOADED[name] = true */
@@ -623,8 +626,6 @@ LUALIB_API int luaopen_package (lua_State *L) {
  lua_getfield(L, -1, "loadlib");
  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
 #endif
-  lua_pushvalue(L, -1);
-  lua_setfield(L, LUA_REGISTRYINDEX, "_PACKAGE");
  lua_pushvalue(L, -1);
  lua_replace(L, LUA_ENVIRONINDEX);
  /* create `loaders' table */
@@ -642,7 +643,7 @@ LUALIB_API int luaopen_package (lua_State *L) {
                    LUA_EXECDIR "\n" LUA_IGMARK);
  lua_setfield(L, -2, "config");
  /* set field `loaded' */
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_setfield(L, -2, "loaded");
  /* set field `preload' */
  lua_newtable(L);
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 2.17 2005/07/31 17:11:50 roberto Exp roberto $
+** $Id: lobject.c,v 2.18 2005/08/01 04:22:23 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -75,7 +75,7 @@ int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
    case LUA_TNIL:
      return 1;
    case LUA_TNUMBER:
-      return luai_numeq(L, nvalue(t1), nvalue(t2));
+      return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN:
      return bvalue(t1) == bvalue(t2);  /* boolean true must be 1 !! */
    case LUA_TLIGHTUSERDATA:
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 2.16 2005/06/13 14:15:54 roberto Exp roberto $
+** $Id: lobject.h,v 2.17 2005/06/13 14:19:00 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -353,7 +353,7 @@ typedef struct Table {
 ** `module' operation for hashing (size is always a power of 2)
 */
 #define lmod(s,size) \
-	check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1))))
+	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))


 #define twoto(x)	(1<<(x))
--- a/lopcodes.c
+++ b/lopcodes.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.c,v 1.34 2005/05/20 15:53:42 roberto Exp $
+** $Id: lopcodes.c,v 1.36 2005/10/13 12:22:05 roberto Exp roberto $
 ** See Copyright Notice in lua.h
 */

@@ -7,9 +7,7 @@
 #define lopcodes_c
 #define LUA_CORE

-#include "lua.h"

-#include "lobject.h"
 #include "lopcodes.h"


@@ -88,7 +86,7 @@ const lu_byte luaP_opmodes[NUM_OPCODES] = {
 ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
 ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
 ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
- ,opmode(1, 0, OpArgR, OpArgU, iABC)		/* OP_TEST */
+ ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TEST */
 ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
 ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
 ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.121 2005/06/06 13:30:25 roberto Exp $
+** $Id: lopcodes.h,v 1.122 2005/08/29 20:49:21 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -193,12 +193,12 @@ OP_CALL,/*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
 OP_TAILCALL,/*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
 OP_RETURN,/*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/

-OP_FORLOOP,/*	A sBx	R(A)+=R(A+2); if R(A) <?= R(A+1) then pc+=sBx	*/
+OP_FORLOOP,/*	A sBx	R(A)+=R(A+2);
+			if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
 OP_FORPREP,/*	A sBx	R(A)-=R(A+2); pc+=sBx				*/

-OP_TFORLOOP,/*	A C	R(A+2), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); 
-                        if R(A+2) ~= nil then pc++			*/
-
+OP_TFORLOOP,/*	A C	R(A+3), ... ,R(A+3+C) := R(A)(R(A+1), R(A+2)); 
+                        if R(A+3) ~= nil then { pc++; R(A+2)=R(A+3); }	*/ 
 OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/

 OP_CLOSE,/*	A 	close all variables in the stack up to (>=) R(A)*/
--- a/loslib.c
+++ b/loslib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loslib.c,v 1.12 2005/08/26 17:36:32 roberto Exp roberto $
+** $Id: loslib.c,v 1.13 2005/09/09 18:22:46 roberto Exp roberto $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */
@@ -125,8 +125,8 @@ static int getfield (lua_State *L, const char *key, int d) {

 static int io_date (lua_State *L) {
  const char *s = luaL_optstring(L, 1, "%c");
-  lua_Number n = luaL_optnumber(L, 2, -1);
-  time_t t = (n == -1) ? time(NULL) : (time_t)n;
+  time_t t = lua_isnoneornil(L, 2) ? time(NULL) :
+                                     (time_t)luaL_checknumber(L, 2);
  struct tm *stm;
  if (*s == '!') {  /* UTC? */
    stm = gmtime(&t);
--- a/lparser.c
+++ b/lparser.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 2.34 2005/08/24 17:41:10 roberto Exp $
+** $Id: lparser.c,v 2.37 2005/10/03 14:02:40 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -144,7 +144,7 @@ static TString *str_checkname (LexState *ls) {
 static void init_exp (expdesc *e, expkind k, int i) {
  e->f = e->t = NO_JUMP;
  e->k = k;
-  e->info = i;
+  e->u.s.info = i;
 }


@@ -184,7 +184,7 @@ static void new_localvar (LexState *ls, TString *name, int n) {

 static void adjustlocalvars (LexState *ls, int nvars) {
  FuncState *fs = ls->fs;
-  fs->nactvar += nvars;
+  fs->nactvar = cast(lu_byte, fs->nactvar + nvars);
  for (; nvars; nvars--) {
    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
  }
@@ -203,7 +203,7 @@ static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
  Proto *f = fs->f;
  int oldsize = f->sizeupvalues;
  for (i=0; i<f->nups; i++) {
-    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->info) {
+    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
      lua_assert(f->upvalues[i] == name);
      return i;
    }
@@ -217,7 +217,7 @@ static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
  luaC_objbarrier(fs->L, f, name);
  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
  fs->upvalues[f->nups].k = cast(lu_byte, v->k);
-  fs->upvalues[f->nups].info = cast(lu_byte, v->info);
+  fs->upvalues[f->nups].info = cast(lu_byte, v->u.s.info);
  return f->nups++;
 }

@@ -255,7 +255,7 @@ static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
    else {  /* not found at current level; try upper one */
      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
        return VGLOBAL;
-      var->info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
+      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
      var->k = VUPVAL;  /* upvalue in this level */
      return VUPVAL;
    }
@@ -267,7 +267,7 @@ static void singlevar (LexState *ls, expdesc *var) {
  TString *varname = str_checkname(ls);
  FuncState *fs = ls->fs;
  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
-    var->info = luaK_stringK(fs, varname);  /* info points to global name */
+    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
 }


@@ -351,7 +351,7 @@ static void open_func (LexState *ls, FuncState *fs) {
  fs->L = L;
  ls->fs = fs;
  fs->pc = 0;
-  fs->lasttarget = 0;
+  fs->lasttarget = -1;
  fs->jpc = NO_JUMP;
  fs->freereg = 0;
  fs->nk = 0;
@@ -472,8 +472,8 @@ static void recfield (LexState *ls, struct ConsControl *cc) {
  checknext(ls, '=');
  luaK_exp2RK(fs, &key);
  expr(ls, &val);
-  luaK_codeABC(fs, OP_SETTABLE, cc->t->info, luaK_exp2RK(fs, &key),
-                                             luaK_exp2RK(fs, &val));
+  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, luaK_exp2RK(fs, &key),
+                                                 luaK_exp2RK(fs, &val));
  fs->freereg = reg;  /* free registers */
 }

@@ -483,7 +483,7 @@ static void closelistfield (FuncState *fs, struct ConsControl *cc) {
  luaK_exp2nextreg(fs, &cc->v);
  cc->v.k = VVOID;
  if (cc->tostore == LFIELDS_PER_FLUSH) {
-    luaK_setlist(fs, cc->t->info, cc->na, cc->tostore);  /* flush */
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
    cc->tostore = 0;  /* no more items pending */
  }
 }
@@ -493,13 +493,13 @@ static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
  if (cc->tostore == 0) return;
  if (hasmultret(cc->v.k)) {
    luaK_setmultret(fs, &cc->v);
-    luaK_setlist(fs, cc->t->info, cc->na, LUA_MULTRET);
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
    cc->na--;  /* do not count last expression (unknown number of elements) */
  }
  else {
    if (cc->v.k != VVOID)
      luaK_exp2nextreg(fs, &cc->v);
-    luaK_setlist(fs, cc->t->info, cc->na, cc->tostore);
+    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
  }
 }

@@ -657,7 +657,7 @@ static void funcargs (LexState *ls, expdesc *f) {
    }
  }
  lua_assert(f->k == VNONRELOC);
-  base = f->info;  /* base register for call */
+  base = f->u.s.info;  /* base register for call */
  if (hasmultret(args.k))
    nparams = LUA_MULTRET;  /* open call */
  else {
@@ -746,7 +746,8 @@ static void simpleexp (LexState *ls, expdesc *v) {
                  constructor | FUNCTION body | primaryexp */
  switch (ls->t.token) {
    case TK_NUMBER: {
-      init_exp(v, VK, luaK_numberK(ls->fs, ls->t.seminfo.r));
+      init_exp(v, VKNUM, 0);
+      v->u.nval = ls->t.seminfo.r;
      break;
    }
    case TK_STRING: {
@@ -805,7 +806,7 @@ static BinOpr getbinopr (int op) {
  switch (op) {
    case '+': return OPR_ADD;
    case '-': return OPR_SUB;
-    case '*': return OPR_MULT;
+    case '*': return OPR_MUL;
    case '/': return OPR_DIV;
    case '%': return OPR_MOD;
    case '^': return OPR_POW;
@@ -927,18 +928,18 @@ static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
  int conflict = 0;
  for (; lh; lh = lh->prev) {
    if (lh->v.k == VINDEXED) {
-      if (lh->v.info == v->info) {  /* conflict? */
+      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
        conflict = 1;
-        lh->v.info = extra;  /* previous assignment will use safe copy */
+        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
      }
-      if (lh->v.aux == v->info) {  /* conflict? */
+      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
        conflict = 1;
-        lh->v.aux = extra;  /* previous assignment will use safe copy */
+        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
      }
    }
  }
  if (conflict) {
-    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->info, 0);  /* make copy */
+    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
    luaK_reserveregs(fs, 1);
  }
 }
--- a/lparser.h
+++ b/lparser.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.54 2005/03/09 16:28:07 roberto Exp roberto $
+** $Id: lparser.h,v 1.55 2005/04/25 19:24:10 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -23,6 +23,7 @@ typedef enum {
  VTRUE,
  VFALSE,
  VK,		/* info = index of constant in `k' */
+  VKNUM,	/* nval = numerical value */
  VLOCAL,	/* info = local register */
  VUPVAL,       /* info = index of upvalue in `upvalues' */
  VGLOBAL,	/* info = index of table; aux = index of global name in `k' */
@@ -36,7 +37,10 @@ typedef enum {

 typedef struct expdesc {
  expkind k;
-  int info, aux;
+  union {
+    struct { int info, aux; } s;
+    lua_Number nval;
+  } u;
  int t;  /* patch list of `exit when true' */
  int f;  /* patch list of `exit when false' */
 } expdesc;
--- a/lstate.c
+++ b/lstate.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 2.32 2005/06/03 20:15:58 roberto Exp roberto $
+** $Id: lstate.c,v 2.34 2005/09/20 17:55:53 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -71,8 +71,8 @@ static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  stack_init(L, L);  /* init stack */
-  sethvalue(L, gt(L), luaH_new(L, 0, 20));  /* table of globals */
-  sethvalue(L, registry(L), luaH_new(L, 6, 20));  /* registry */
+  sethvalue(L, gt(L), luaH_new(L, 0, 2));  /* table of globals */
+  sethvalue(L, registry(L), luaH_new(L, 0, 2));  /* registry */
  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
  luaT_init(L);
  luaX_init(L);
@@ -134,6 +134,7 @@ lua_State *luaE_newthread (lua_State *L) {
 void luaE_freethread (lua_State *L, lua_State *L1) {
  luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
  lua_assert(L1->openupval == NULL);
+  luai_userstatefree(L1);
  freestack(L, L1);
  luaM_freemem(L, fromstate(L1), state_size(lua_State));
 }
@@ -196,8 +197,9 @@ static void callallgcTM (lua_State *L, void *ud) {


 LUA_API void lua_close (lua_State *L) {
-  lua_lock(L);
  L = G(L)->mainthread;  /* only the main thread can be closed */
+  luai_userstateclose(L);
+  lua_lock(L);
  luaF_close(L, L->stack);  /* close all upvalues for this thread */
  luaC_separateudata(L, 1);  /* separate udata that have GC metamethods */
  L->errfunc = 0;  /* no error function during GC metamethods */
--- a/lstrlib.c
+++ b/lstrlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstrlib.c,v 1.122 2005/08/15 14:12:32 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.126 2005/10/23 17:46:30 roberto Exp roberto $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
@@ -111,7 +111,9 @@ static int str_byte (lua_State *L) {
  if (posi <= 0) posi = 1;
  if ((size_t)pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
-  n = pose -  posi + 1;
+  n = (int)(pose -  posi + 1);
+  if (posi + n <= pose)  /* overflow? */
+    luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
@@ -460,28 +462,32 @@ static const char *lmemfind (const char *s1, size_t l1,
 }


-static void push_onecapture (MatchState *ms, int i) {
-  ptrdiff_t l = ms->capture[i].len;
-  if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
-  if (l == CAP_POSITION)
-    lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
-  else
-    lua_pushlstring(ms->L, ms->capture[i].init, l);
+static void push_onecapture (MatchState *ms, int i, const char *s,
+                                                    const char *e) {
+  if (i >= ms->level) {
+    if (i == 0)  /* ms->level == 0, too */
+      lua_pushlstring(ms->L, s, e - s);  /* add whole match */
+    else
+      luaL_error(ms->L, "invalid capture index");
+  }
+  else {
+    ptrdiff_t l = ms->capture[i].len;
+    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
+    if (l == CAP_POSITION)
+      lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
+    else
+      lua_pushlstring(ms->L, ms->capture[i].init, l);
+  }
 }


 static int push_captures (MatchState *ms, const char *s, const char *e) {
  int i;
-  luaL_checkstack(ms->L, ms->level, "too many captures");
-  if (ms->level == 0 && s) {  /* no explicit captures? */
-    lua_pushlstring(ms->L, s, e-s);  /* return whole match */
-    return 1;
-  }
-  else {  /* return all captures */
-    for (i=0; i<ms->level; i++)
-      push_onecapture(ms, i);
-    return ms->level;  /* number of strings pushed */
-  }
+  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
+  luaL_checkstack(ms->L, nlevels, "too many captures");
+  for (i = 0; i < nlevels; i++)
+    push_onecapture(ms, i, s, e);
+  return nlevels;  /* number of strings pushed */
 }


@@ -516,12 +522,7 @@ static int str_find_aux (lua_State *L, int find) {
        if (find) {
          lua_pushinteger(L, s1-s+1);  /* start */
          lua_pushinteger(L, res-s);   /* end */
-#if defined(LUA_COMPAT_FIND)
          return push_captures(&ms, NULL, 0) + 2;
-#else
-          return 2;
-#endif
-
        }
        else
          return push_captures(&ms, s1, res);
@@ -585,42 +586,61 @@ static int gfind_nodef (lua_State *L) {
 }


-static void add_s (MatchState *ms, luaL_Buffer *b,
-                   const char *s, const char *e) {
-  lua_State *L = ms->L;
-  if (lua_isstring(L, 3)) {
-    size_t l;
-    const char *news = lua_tolstring(L, 3, &l);
-    size_t i;
-    for (i=0; i<l; i++) {
-      if (news[i] != L_ESC)
+static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
+                                                   const char *e) {
+  size_t l, i;
+  const char *news = lua_tolstring(ms->L, 3, &l);
+  for (i = 0; i < l; i++) {
+    if (news[i] != L_ESC)
+      luaL_addchar(b, news[i]);
+    else {
+      i++;  /* skip ESC */
+      if (!isdigit(uchar(news[i])))
        luaL_addchar(b, news[i]);
+      else if (news[i] == '0')
+          luaL_addlstring(b, s, e - s);
      else {
-        i++;  /* skip ESC */
-        if (!isdigit(uchar(news[i])))
-          luaL_addchar(b, news[i]);
-        else {
-          if (news[i] == '0')
-            lua_pushlstring(L, s, e - s);  /* add whole match */
-          else {
-            int level = check_capture(ms, news[i]);
-            push_onecapture(ms, level);
-          }
-          luaL_addvalue(b);  /* add capture to accumulated result */
-        }
+        push_onecapture(ms, news[i] - '1', s, e);
+        luaL_addvalue(b);  /* add capture to accumulated result */
      }
    }
  }
-  else {  /* is a function */
-    int n;
-    lua_pushvalue(L, 3);
-    n = push_captures(ms, s, e);
-    lua_call(L, n, 1);
-    if (lua_isstring(L, -1))
-      luaL_addvalue(b);  /* add return to accumulated result */
-    else
-      lua_pop(L, 1);  /* function result is not a string: pop it */
+}
+
+
+static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
+                                                       const char *e) {
+  lua_State *L = ms->L;
+  switch (lua_type(L, 3)) {
+    case LUA_TNUMBER:
+    case LUA_TSTRING: {
+      add_s(ms, b, s, e);
+      return;
+    }
+    case LUA_TFUNCTION: {
+      int n;
+      lua_pushvalue(L, 3);
+      n = push_captures(ms, s, e);
+      lua_call(L, n, 1);
+      break;
+    }
+    case LUA_TTABLE: {
+      push_onecapture(ms, 0, s, e);
+      lua_gettable(L, 3);
+      break;
+    }
+    default: {
+      luaL_argerror(L, 3, "string/function/table expected"); 
+      return;
+    }
  }
+  if (!lua_toboolean(L, -1)) {  /* nil or false? */
+    lua_pop(L, 1);
+    lua_pushlstring(L, s, e - s);  /* keep original text */
+  }
+  else if (!lua_isstring(L, -1))
+    luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1)); 
+  luaL_addvalue(b);  /* add result to accumulator */
 }


@@ -633,9 +653,6 @@ static int str_gsub (lua_State *L) {
  int n = 0;
  MatchState ms;
  luaL_Buffer b;
-  luaL_argcheck(L,
-    lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)),
-    3, "string or function expected");
  luaL_buffinit(L, &b);
  ms.L = L;
  ms.src_init = src;
@@ -646,7 +663,7 @@ static int str_gsub (lua_State *L) {
    e = match(&ms, src, p);
    if (e) {
      n++;
-      add_s(&ms, &b, src, e);
+      add_value(&ms, &b, src, e);
    }
    if (e && e>src) /* non empty match? */
      src = e;  /* skip it */
--- a/ltable.c
+++ b/ltable.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 2.25 2005/05/31 14:25:18 roberto Exp roberto $
+** $Id: ltable.c,v 2.26 2005/07/11 14:01:37 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -120,7 +120,7 @@ static int arrayindex (const TValue *key) {
    lua_Number n = nvalue(key);
    int k;
    lua_number2int(k, n);
-    if (luai_numeq(L, cast(lua_Number, k), nvalue(key)))
+    if (luai_numeq(cast(lua_Number, k), nvalue(key)))
      return k;
  }
  return -1;  /* `key' did not match some condition */
@@ -437,7 +437,7 @@ const TValue *luaH_getnum (Table *t, int key) {
    lua_Number nk = cast(lua_Number, key);
    Node *n = hashnum(t, nk);
    do {  /* check whether `key' is somewhere in the chain */
-      if (ttisnumber(gkey(n)) && luai_numeq(L, nvalue(gkey(n)), nk))
+      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
        return gval(n);  /* that's it */
      else n = gnext(n);
    } while (n);
@@ -471,7 +471,7 @@ const TValue *luaH_get (Table *t, const TValue *key) {
      int k;
      lua_Number n = nvalue(key);
      lua_number2int(k, n);
-      if (luai_numeq(L, cast(lua_Number, k), nvalue(key))) /* index is int? */
+      if (luai_numeq(cast(lua_Number, k), nvalue(key))) /* index is int? */
        return luaH_getnum(t, k);  /* use specialized version */
      /* else go through */
    }
@@ -495,7 +495,7 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
    return cast(TValue *, p);
  else {
    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-    else if (ttisnumber(key) && !luai_numeq(L, nvalue(key), nvalue(key)))
+    else if (ttisnumber(key) && !luai_numeq(nvalue(key), nvalue(key)))
      luaG_runerror(L, "table index is NaN");
    return newkey(L, t, key);
  }
--- a/ltablib.c
+++ b/ltablib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltablib.c,v 1.34 2005/08/15 14:12:32 roberto Exp roberto $
+** $Id: ltablib.c,v 1.37 2005/10/21 13:47:42 roberto Exp roberto $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
@@ -40,9 +40,7 @@ static int foreach (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  luaL_checktype(L, 2, LUA_TFUNCTION);
  lua_pushnil(L);  /* first key */
-  for (;;) {
-    if (lua_next(L, 1) == 0)
-      return 0;
+  while (lua_next(L, 1)) {
    lua_pushvalue(L, 2);  /* function */
    lua_pushvalue(L, -3);  /* key */
    lua_pushvalue(L, -3);  /* value */
@@ -51,6 +49,23 @@ static int foreach (lua_State *L) {
      return 1;
    lua_pop(L, 2);  /* remove value and result */
  }
+  return 0;
+}
+
+
+static int maxn (lua_State *L) {
+  lua_Number max = 0;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushnil(L);  /* first key */
+  while (lua_next(L, 1)) {
+    lua_pop(L, 1);  /* remove value */
+    if (lua_type(L, -1) == LUA_TNUMBER) {
+      lua_Number v = lua_tonumber(L, -1);
+      if (v > max) max = v;
+    }
+  }
+  lua_pushnumber(L, max);
+  return 1;
 }


@@ -75,16 +90,23 @@ static int setn (lua_State *L) {
 static int tinsert (lua_State *L) {
  int e = aux_getn(L, 1) + 1;  /* first empty element */
  int pos;  /* where to insert new element */
-  if (lua_isnone(L, 3))  /* called with only 2 arguments */
-    pos = e;  /* insert new element at the end */
-  else {
-    int i;
-    pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
-    if (pos > e) e = pos;  /* `grow' array if necessary */
-    lua_settop(L, 3);  /* function may be called with more than 3 args */
-    for (i = e; i > pos; i--) {  /* move up elements */
-      lua_rawgeti(L, 1, i-1);
-      lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
+  switch (lua_gettop(L)) {
+    case 2: {  /* called with only 2 arguments */
+      pos = e;  /* insert new element at the end */
+      break;
+    }
+    case 3: {
+      int i;
+      pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
+      if (pos > e) e = pos;  /* `grow' array if necessary */
+      for (i = e; i > pos; i--) {  /* move up elements */
+        lua_rawgeti(L, 1, i-1);
+        lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
+      }
+      break;
+    }
+    default: {
+      return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
    }
  }
  luaL_setn(L, 1, e);  /* new size */
@@ -112,12 +134,11 @@ static int tremove (lua_State *L) {
 static int tconcat (lua_State *L) {
  luaL_Buffer b;
  size_t lsep;
+  int i, last;
  const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  int i = luaL_optint(L, 3, 1);
-  int last = luaL_optint(L, 4, -2);
  luaL_checktype(L, 1, LUA_TTABLE);
-  if (last == -2)
-    last = luaL_getn(L, 1);
+  i = luaL_optint(L, 3, 1);
+  last = luaL_opt(L, luaL_checkint, 4, luaL_getn(L, 1));
  luaL_buffinit(L, &b);
  for (; i <= last; i++) {
    lua_rawgeti(L, 1, i);
@@ -241,6 +262,7 @@ static const luaL_Reg tab_funcs[] = {
  {"foreach", foreach},
  {"foreachi", foreachi},
  {"getn", getn},
+  {"maxn", maxn},
  {"insert", tinsert},
  {"remove", tremove},
  {"setn", setn},
--- a/ltests.c
+++ b/ltests.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.c,v 2.29 2005/08/26 17:32:05 roberto Exp roberto $
+** $Id: ltests.c,v 2.32 2005/09/20 17:55:10 roberto Exp roberto $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
@@ -725,6 +725,7 @@ static int loadlib (lua_State *L) {
    {"mathlibopen", luaopen_math},
    {"strlibopen", luaopen_string},
    {"tablibopen", luaopen_table},
+    {"packageopen", luaopen_package},
    {NULL, NULL}
  };
  lua_State *L1 = cast(lua_State *,
@@ -737,7 +738,6 @@ static int loadlib (lua_State *L) {
 static int closestate (lua_State *L) {
  lua_State *L1 = cast(lua_State *, cast(unsigned long, luaL_checknumber(L, 1)));
  lua_close(L1);
-  lua_unlock(L);  /* close cannot unlock that */
  return 0;
 }

@@ -1121,39 +1121,27 @@ static const struct luaL_Reg tests_funcs[] = {
 };


-static void fim (void) {
-  if (!islocked)
-    lua_close(lua_state);
-  lua_assert(memcontrol.numblocks == 0);
-  lua_assert(memcontrol.total == 0);
-}
-
-
-static int l_panic (lua_State *L) {
-  UNUSED(L);
-  fprintf(stderr, "unable to recover; exiting\n");
-  return 0;
-}
-
-
 int luaB_opentests (lua_State *L) {
  void *ud;
  lua_assert(lua_getallocf(L, &ud) == debug_realloc);
  lua_assert(ud == cast(void *, &memcontrol));
-  lua_atpanic(L, l_panic);
+  lua_setallocf(L, lua_getallocf(L, NULL), ud);
  lua_state = L;  /* keep first state to be opened */
  luaL_register(L, "T", tests_funcs);
-  atexit(fim);
  return 0;
 }


 #undef main
 int main (int argc, char *argv[]) {
+  int ret;
  char *limit = getenv("MEMLIMIT");
  if (limit)
    memcontrol.memlimit = strtoul(limit, NULL, 10);
-  return l_main(argc, argv);
+  ret = l_main(argc, argv);
+  lua_assert(memcontrol.numblocks == 0);
+  lua_assert(memcontrol.total == 0);
+  return ret;
 }

 #endif
--- a/ltests.h
+++ b/ltests.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.h,v 2.14 2005/05/03 19:01:17 roberto Exp roberto $
+** $Id: ltests.h,v 2.15 2005/06/06 13:30:25 roberto Exp roberto $
 ** Internal Header for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
@@ -55,16 +55,19 @@ int lua_checkpc (lua_State *L, pCallInfo ci);

 /* test for lock/unlock */
 #undef luai_userstateopen
+#undef luai_userstatethread
 #undef lua_lock
 #undef lua_unlock
 #undef LUAI_EXTRASPACE

-LUAI_DATA int islocked;
-#define LUAI_EXTRASPACE		sizeof(double)
-#define getlock(l)	(*(cast(int **, l) - 1))
-#define luai_userstateopen(l)	getlock(l) = &islocked;
-#define lua_lock(l)     lua_assert((*getlock(l))++ == 0)
-#define lua_unlock(l)   lua_assert(--(*getlock(l)) == 0)
+struct L_EXTRA { int lock; int *plock; };
+#define LUAI_EXTRASPACE		sizeof(struct L_EXTRA)
+#define getlock(l)	(cast(struct L_EXTRA *, l) - 1)
+#define luai_userstateopen(l)  \
+	(getlock(l)->lock = 0, getlock(l)->plock = &(getlock(l)->lock))
+#define luai_userstatethread(l,l1)  (getlock(l1)->plock = getlock(l)->plock)
+#define lua_lock(l)     lua_assert((*getlock(l)->plock)++ == 0)
+#define lua_unlock(l)   lua_assert(--(*getlock(l)->plock) == 0)


 int luaB_opentests (lua_State *L);
--- a/lua.c
+++ b/lua.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.149 2005/08/26 17:32:05 roberto Exp roberto $
+** $Id: lua.c,v 1.153 2005/10/21 13:48:31 roberto Exp roberto $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -43,12 +43,13 @@ static void print_usage (void) {
  fprintf(stderr,
  "usage: %s [options] [script [args]].\n"
  "Available options are:\n"
-  "  -        execute stdin as a file\n"
  "  -e stat  execute string " LUA_QL("stat") "\n"
-  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
  "  -l name  require library " LUA_QL("name") "\n"
+  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
  "  -v       show version information\n"
-  "  --       stop handling options\n" ,
+  "  --       stop handling options\n"
+  "  -        execute stdin and stop handling options\n"
+  ,
  progname);
  fflush(stderr);
 }
@@ -99,6 +100,8 @@ static int docall (lua_State *L, int narg, int clear) {
  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
  signal(SIGINT, SIG_DFL);
  lua_remove(L, base);  /* remove traceback function */
+  /* force a complete garbage collection in case of errors */
+  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
  return status;
 }

@@ -108,9 +111,12 @@ static void print_version (void) {
 }


-static int getargs (lua_State *L, int argc, char **argv, int n) {
-  int narg = argc - (n + 1);  /* number of arguments to the script */
+static int getargs (lua_State *L, char **argv, int n) {
+  int narg;
  int i;
+  int argc = 0;
+  while (argv[argc]) argc++;  /* count total number of arguments */
+  narg = argc - (n + 1);  /* number of arguments to the script */
  luaL_checkstack(L, narg + 3, "too many arguments to script");
  for (i=n+1; i < argc; i++)
    lua_pushstring(L, argv[i]);
@@ -229,86 +235,71 @@ static void dotty (lua_State *L) {
 }


-#define clearinteractive(i)	(*i &= 2)
+static int handle_script (lua_State *L, char **argv, int n) {
+  int status;
+  const char *fname;
+  int narg = getargs(L, argv, n);  /* collect arguments */
+  lua_setglobal(L, "arg");
+  fname = argv[n];
+  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) 
+    fname = NULL;  /* stdin */
+  status = luaL_loadfile(L, fname);
+  lua_insert(L, -(narg+1));
+  if (status == 0)
+    status = docall(L, narg, 0);
+  else
+    lua_pop(L, narg);      
+  return report(L, status);
+}

-static int handle_argv (lua_State *L, int argc, char **argv, int *interactive) {
-  if (argv[1] == NULL) {  /* no arguments? */
-    *interactive = 0;
-    if (lua_stdin_is_tty())
-      dotty(L);
-    else
-      dofile(L, NULL);  /* executes stdin as a file */
+
+static int collectargs (char **argv, int *pi, int *pv, int *pe) {
+  int i;
+  for (i = 1; argv[i] != NULL; i++) {
+    if (argv[i][0] != '-')  /* not an option? */
+        return i;
+    switch (argv[i][1]) {  /* option */
+      case '-': return (argv[i+1] != NULL ? i+1 : 0);
+      case '\0': return i;
+      case 'i': *pi = 1; break;
+      case 'v': *pv = 1; break;
+      case 'e': *pe = 1;  /* go through */
+      case 'l':
+        if (argv[i][2] == '\0') {
+          i++;
+          if (argv[i] == NULL) return -1;
+        }
+        break;
+      default: return -1;  /* invalid option */
+    }
  }
-  else {  /* other arguments; loop over them */
-    int i;
-    for (i = 1; argv[i] != NULL; i++) {
-      if (argv[i][0] != '-') break;  /* not an option? */
-      switch (argv[i][1]) {  /* option */
-        case '-': {  /* `--' */
-          if (argv[i][2] != '\0') {
-            print_usage();
-            return 1;
-          }
-          i++;  /* skip this argument */
-          goto endloop;  /* stop handling arguments */
-        }
-        case '\0': {
-          clearinteractive(interactive);
-          dofile(L, NULL);  /* executes stdin as a file */
-          break;
-        }
-        case 'i': {
-          *interactive = 2;  /* force interactive mode after arguments */
-          break;
-        }
-        case 'v': {
-          clearinteractive(interactive);
-          print_version();
-          break;
-        }
-        case 'e': {
-          const char *chunk = argv[i] + 2;
-          clearinteractive(interactive);
-          if (*chunk == '\0') chunk = argv[++i];
-          if (chunk == NULL) {
-            print_usage();
-            return 1;
-          }
-          if (dostring(L, chunk, "=(command line)") != 0)
-            return 1;
-          break;
-        }
-        case 'l': {
-          const char *filename = argv[i] + 2;
-          if (*filename == '\0') filename = argv[++i];
-          if (filename == NULL) {
-            print_usage();
-            return 1;
-          }
-          if (dolibrary(L, filename))
-            return 1;  /* stop if file fails */
-          break;
-        }
-        default: {
-          clearinteractive(interactive);
-          print_usage();
+  return 0;
+}
+
+
+static int runargs (lua_State *L, char **argv, int n) {
+  int i;
+  for (i = 1; i < n; i++) {
+    if (argv[i] == NULL) continue;
+    lua_assert(argv[i][0] == '-');
+    switch (argv[i][1]) {  /* option */
+      case 'e': {
+        const char *chunk = argv[i] + 2;
+        if (*chunk == '\0') chunk = argv[++i];
+        lua_assert(chunk != NULL);
+        if (dostring(L, chunk, "=(command line)") != 0)
          return 1;
-        }
+        break;
      }
-    } endloop:
-    if (argv[i] != NULL) {
-      int status;
-      const char *filename = argv[i];
-      int narg = getargs(L, argc, argv, i);  /* collect arguments */
-      lua_setglobal(L, "arg");
-      clearinteractive(interactive);
-      status = luaL_loadfile(L, filename);
-      lua_insert(L, -(narg+1));
-      if (status == 0)
-        status = docall(L, narg, 0);
-      else
-        lua_pop(L, narg);      
-      return report(L, status);
+      case 'l': {
+        const char *filename = argv[i] + 2;
+        if (*filename == '\0') filename = argv[++i];
+        lua_assert(filename != NULL);
+        if (dolibrary(L, filename))
+          return 1;  /* stop if file fails */
+        break;
+      }
+      default: break;
    }
  }
  return 0;
@@ -334,17 +325,32 @@ struct Smain {

 static int pmain (lua_State *L) {
  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
-  int status;
-  int interactive = 1;
-  if (s->argv[0] && s->argv[0][0]) progname = s->argv[0];
+  char **argv = s->argv;
+  int script;
+  int has_i = 0, has_v = 0, has_e = 0;
  globalL = L;
+  if (argv[0] && argv[0][0]) progname = argv[0];
  luaL_openlibs(L);  /* open libraries */
-  status = handle_luainit(L);
-  if (status == 0) {
-    status = handle_argv(L, s->argc, s->argv, &interactive);
-    if (status == 0 && interactive) dotty(L);
+  s->status = handle_luainit(L);
+  if (s->status != 0) return 0;
+  script = collectargs(argv, &has_i, &has_v, &has_e);
+  if (script < 0) {  /* invalid args? */
+    print_usage();
+    s->status = 1;
+    return 0;
+  }
+  if (has_v) print_version();
+  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
+  if (s->status != 0) return 0;
+  if (script)
+    s->status = handle_script(L, argv, script);
+  if (s->status != 0) return 0;
+  if (has_i)
+    dotty(L);
+  else if (script == 0 && !has_e && !has_v) {
+    if (lua_stdin_is_tty()) dotty(L);
+    else dofile(L, NULL);  /* executes stdin as a file */
  }
-  s->status = status;
  return 0;
 }

--- a/lua.h
+++ b/lua.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.h,v 1.211 2005/08/12 13:34:15 roberto Exp roberto $
+** $Id: lua.h,v 1.213 2005/09/20 17:55:10 roberto Exp roberto $
 ** Lua - An Extensible Extension Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
@@ -221,9 +221,10 @@ LUA_API int  (lua_status) (lua_State *L);
 #define LUA_GCRESTART		1
 #define LUA_GCCOLLECT		2
 #define LUA_GCCOUNT		3
-#define LUA_GCSTEP		4
-#define LUA_GCSETPAUSE		5
-#define LUA_GCSETSTEPMUL	6
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7

 LUA_API int (lua_gc) (lua_State *L, int what, int data);

@@ -239,6 +240,7 @@ LUA_API int   (lua_next) (lua_State *L, int idx);
 LUA_API void  (lua_concat) (lua_State *L, int n);

 LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);



--- a/luaconf.h
+++ b/luaconf.h
@@ -1,5 +1,5 @@
 /*
-** $Id: luaconf.h,v 1.64 2005/09/06 17:21:03 roberto Exp roberto $
+** $Id: luaconf.h,v 1.73 2005/11/16 11:56:28 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
@@ -19,8 +19,6 @@
 */


-
-
 /*
@@ LUA_ANSI controls the use of non-ansi features.
 ** CHANGE it (define it) if you want Lua to avoid the use of any
@@ -30,6 +28,31 @@
 #define LUA_ANSI
 #endif

+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_DL_DYLD		/* does not need extra library */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionallity listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#endif
+

 /*
@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
@@ -92,7 +115,7 @@
 #define LUA_PATHSEP	";"
 #define LUA_PATH_MARK	"?"
 #define LUA_EXECDIR	"!"
-#define LUA_IGMARK	":"
+#define LUA_IGMARK	"-"


 /*
@@ -141,10 +164,12 @@
 #if defined(luaall_c)
 #define LUAI_FUNC	static
 #define LUAI_DATA	/* empty */
+
 #elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
      defined(__ELF__)
 #define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
 #define LUAI_DATA	LUAI_FUNC
+
 #else
 #define LUAI_FUNC	extern
 #define LUAI_DATA	extern
@@ -189,7 +214,7 @@
 ** CHANGE it if you have a better definition for non-POSIX/non-Windows
 ** systems.
 */
-#if !defined(LUA_ANSI) && defined(_POSIX_C_SOURCE)
+#if defined(LUA_USE_ISATTY)
 #include <unistd.h>
 #define lua_stdin_is_tty()	isatty(0)
 #elif !defined(LUA_ANSI) && defined(_WIN32)
@@ -239,17 +264,17 @@
 #include <stdio.h>
 #include <readline/readline.h>
 #include <readline/history.h>
-#define lua_readline(L,b,p)	(((b)=readline(p)) != NULL)
+#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
 #define lua_saveline(L,idx) \
 	if (lua_strlen(L,idx) > 0)  /* non-empty line? */ \
 	  add_history(lua_tostring(L, idx));  /* add it to history */
-#define lua_freeline(L,b)	free(b)
+#define lua_freeline(L,b)	((void)L, free(b))
 #else
 #define lua_readline(L,b,p)	\
-	(fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+	((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
 	fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,idx)	((void)0)
-#define lua_freeline(L,b)	((void)0)
+#define lua_saveline(L,idx)	{ (void)L; (void)idx; }
+#define lua_freeline(L,b)	{ (void)L; (void)b; }
 #endif

 #endif
@@ -315,13 +340,6 @@
 */
 #define LUA_COMPAT_LSTR		1

-/*
-@@ LUA_COMPAT_FIND controls compatibility with old 'string.find' behavior.
-** CHANGE it to undefined as soon as your programs use 'string.find' only
-** to find patterns.
-*/
-#define LUA_COMPAT_FIND
-
 /*
@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name.
 ** CHANGE it to undefined as soon as you rename 'string.gfind' to
@@ -329,7 +347,6 @@
 */
 #define LUA_COMPAT_GFIND

-
 /*
@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib'
@* behavior.
@@ -349,10 +366,10 @@
 */
 #if defined(LUA_USE_APICHECK)
 #include <assert.h>
-#define luai_apicheck(L,o) assert(o)
+#define luai_apicheck(L,o)	{ (void)L; assert(o); }
 #else
 /* (By default lua_assert is empty, so luai_apicheck is also empty.) */
-#define luai_apicheck(L,o)		lua_assert(o)
+#define luai_apicheck(L,o)	{ (void)L; lua_assert(o); }
 #endif


@@ -464,31 +481,6 @@



-/*
-@@ lua_number2int is a macro to convert lua_Number to int.
-@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
-** CHANGE them if you know a faster way to convert a lua_Number to
-** int (with any rounding method and without throwing errors) in your
-** system. In Pentium machines, a naive typecast from double to int
-** in C is extremely slow, so any alternative is worth trying.
-*/
-
-/* On a Pentium, resort to a trick */
-#if !defined(LUA_ANSI) && !defined(__SSE2__) && \
-    (defined(__i386) || defined (_M_IX86))
-union luai_Cast { double l_d; long l_l; };
-#define lua_number2int(i,d) \
-  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
-#define lua_number2integer(i,n)		lua_number2int(i, n)
-
-/* this option always works, but may be slow */
-#else
-#define lua_number2int(i,d)	((i)=(int)(d))
-#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))
-
-#endif
-
-

 /*
 ** {==================================================================
@@ -525,16 +517,44 @@ union luai_Cast { double l_d; long l_l; };
 /*
@@ The luai_num* macros define the primitive operations over numbers.
 */
-#define luai_numadd(L,a,b)	((a)+(b))
-#define luai_numsub(L,a,b)	((a)-(b))
-#define luai_nummul(L,a,b)	((a)*(b))
-#define luai_numdiv(L,a,b)	((a)/(b))
-#define luai_nummod(L,a,b)	((a) - floor((a)/(b))*(b))
-#define luai_numpow(L,a,b)	pow(a,b)
-#define luai_numunm(L,a)	(-(a))
-#define luai_numeq(L,a,b)	((a)==(b))
-#define luai_numlt(L,a,b)	((a)<(b))
-#define luai_numle(L,a,b)	((a)<=(b))
+#if defined(LUA_CORE)
+#include <math.h>
+#define luai_numadd(a,b)	((a)+(b))
+#define luai_numsub(a,b)	((a)-(b))
+#define luai_nummul(a,b)	((a)*(b))
+#define luai_numdiv(a,b)	((a)/(b))
+#define luai_nummod(a,b)	((a) - floor((a)/(b))*(b))
+#define luai_numpow(a,b)	(pow(a,b))
+#define luai_numunm(a)		(-(a))
+#define luai_numeq(a,b)		((a)==(b))
+#define luai_numlt(a,b)		((a)<(b))
+#define luai_numle(a,b)		((a)<=(b))
+#endif
+
+
+/*
+@@ lua_number2int is a macro to convert lua_Number to int.
+@@ lua_number2integer is a macro to convert lua_Number to lua_Integer.
+** CHANGE them if you know a faster way to convert a lua_Number to
+** int (with any rounding method and without throwing errors) in your
+** system. In Pentium machines, a naive typecast from double to int
+** in C is extremely slow, so any alternative is worth trying.
+*/
+
+/* On a Pentium, resort to a trick */
+#if !defined(LUA_ANSI) && !defined(__SSE2__) && \
+    (defined(__i386) || defined (_M_IX86) || defined(__i386__))
+union luai_Cast { double l_d; long l_l; };
+#define lua_number2int(i,d) \
+  { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; }
+#define lua_number2integer(i,n)		lua_number2int(i, n)
+
+/* this option always works, but may be slow */
+#else
+#define lua_number2int(i,d)	((i)=(int)(d))
+#define lua_number2integer(i,d)	((i)=(lua_Integer)(d))
+
+#endif

 /* }================================================================== */

@@ -597,7 +617,7 @@ union luai_Cast { double l_d; long l_l; };
 */
 #if defined(loslib_c) || defined(luaall_c)

-#if !defined(LUA_ANSI) && defined(_POSIX_C_SOURCE)
+#if defined(LUA_USE_MKSTEMP)
 #include <unistd.h>
 #define LUA_TMPNAMBUFSIZE	32
 #define lua_tmpnam(b,e)	{ \
@@ -605,6 +625,7 @@ union luai_Cast { double l_d; long l_l; };
 	e = mkstemp(b); \
 	if (e != -1) close(e); \
 	e = (e == -1); }
+
 #else
 #define LUA_TMPNAMBUFSIZE	L_tmpnam
 #define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
@@ -618,21 +639,21 @@ union luai_Cast { double l_d; long l_l; };
@* the file streams.
 ** CHANGE it if you have a way to implement it in your system.
 */
-#if !defined(LUA_ANSI) && defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 2
+#if defined(LUA_USE_POPEN)

-#define lua_popen(L,c,m)	popen(c,m)
-#define lua_pclose(L,file)	(pclose(file) != -1)
+#define lua_popen(L,c,m)	((void)L, popen(c,m))
+#define lua_pclose(L,file)	((void)L, (pclose(file) != -1))

 #elif !defined(LUA_ANSI) && defined(_WIN32)

-#define lua_popen(L,c,m)	_popen(c,m)
-#define lua_pclose(L,file)	(_pclose(file) != -1)
+#define lua_popen(L,c,m)	((void)L, _popen(c,m))
+#define lua_pclose(L,file)	((void)L, (_pclose(file) != -1))

 #else

 #define lua_popen(L,c,m)  \
  ((void)c, (void)m, luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0)
-#define lua_pclose(L,file)		((void)file, 0)
+#define lua_pclose(L,file)		((void)L, (void)file, 0)

 #endif

@@ -647,16 +668,15 @@ union luai_Cast { double l_d; long l_l; };
 ** automatically.  (When you change the makefile to add -ldl, you must
 ** also add -DLUA_USE_DLOPEN.)
 ** If you do not want any kind of dynamic library, undefine all these
-** options (or just remove these definitions).
+** options.
+** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD.
 */
-#if !defined(LUA_ANSI) 
-#if defined(_WIN32)
-#define LUA_DL_DLL
-#elif defined(__APPLE__) && defined(__MACH__)
-#define LUA_DL_DYLD
-#elif defined(LUA_USE_DLOPEN)
+#if defined(LUA_USE_DLOPEN)
 #define LUA_DL_DLOPEN
 #endif
+
+#if !defined(LUA_ANSI) && defined(_WIN32)
+#define LUA_DL_DLL
 #endif


@@ -674,10 +694,12 @@ union luai_Cast { double l_d; long l_l; };
 ** CHANGE them if you defined LUAI_EXTRASPACE and need to do something
 ** extra when a thread is created/deleted/resumed/yielded.
 */
-#define luai_userstateopen(L)		((void)0)
-#define luai_userstatefree(L)		((void)0)
-#define luai_userstateresume(L,n)	((void)0)
-#define luai_userstateyield(L,n)	((void)0)
+#define luai_userstateopen(L)		((void)L)
+#define luai_userstateclose(L)		((void)L)
+#define luai_userstatethread(L,L1)	((void)L)
+#define luai_userstatefree(L)		((void)L)
+#define luai_userstateresume(L,n)	((void)L)
+#define luai_userstateyield(L,n)	((void)L)



--- a/lundump.c
+++ b/lundump.c
@@ -1,9 +1,11 @@
 /*
-** $Id: lundump.c,v 2.4 2005/05/05 20:47:02 roberto Exp roberto $
-** load pre-compiled Lua chunks
+** $Id: lundump.c,v 1.58 2005/09/02 01:54:47 lhf Exp lhf $
+** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */

+#include <string.h>
+
 #define lundump_c
 #define LUA_CORE

@@ -13,115 +15,132 @@
 #include "ldo.h"
 #include "lfunc.h"
 #include "lmem.h"
-#include "lopcodes.h"
+#include "lobject.h"
 #include "lstring.h"
 #include "lundump.h"
 #include "lzio.h"

-#define	LoadByte	(lu_byte) ezgetc
-
 typedef struct {
 lua_State* L;
 ZIO* Z;
 Mbuffer* b;
- int swap;
 const char* name;
 } LoadState;

-static void unexpectedEOZ (LoadState* S)
+#ifdef LUAC_TRUST_BINARIES
+#define IF(c,s)
+#else
+#define IF(c,s)		if (c) error(S,s)
+
+static void error(LoadState* S, const char* why)
 {
- luaG_runerror(S->L,"unexpected end of file in %s",S->name);
+ luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
+ luaD_throw(S->L,LUA_ERRSYNTAX);
+}
+#endif
+
+#define LoadMem(S,b,n,size)	LoadBlock(S,b,(n)*(size))
+#define	LoadByte(S)		(lu_byte)LoadChar(S)
+#define LoadVar(S,x)		LoadMem(S,&x,1,sizeof(x))
+#define LoadVector(S,b,n,size)	LoadMem(S,b,n,size)
+
+static void LoadBlock(LoadState* S, void* b, size_t size)
+{
+ size_t r=luaZ_read(S->Z,b,size);
+ IF (r!=0, "unexpected end");
 }

-static int ezgetc (LoadState* S)
+static int LoadChar(LoadState* S)
 {
- int c=zgetc(S->Z);
- if (c==EOZ) unexpectedEOZ(S);
- return c;
+ char x;
+ LoadVar(S,x);
+ return x;
 }

-static void ezread (LoadState* S, void* b, size_t n)
-{
- size_t r=luaZ_read(S->Z,b,n);
- if (r!=0) unexpectedEOZ(S);
-}
-
-static void LoadBlock (LoadState* S, void* b, size_t size)
-{
- if (S->swap)
- {
-  char* p=(char*) b+size-1;
-  size_t n=size;
-  while (n--) *p--=(char)ezgetc(S);
- }
- else
-  ezread(S,b,size);
-}
-
-static void LoadVector (LoadState* S, void* b, int m, size_t size)
-{
- if (S->swap)
- {
-  char* q=(char*) b;
-  while (m--)
-  {
-   char* p=q+size-1;
-   size_t n=size;
-   while (n--) *p--=(char)ezgetc(S);
-   q+=size;
-  }
- }
- else
-  ezread(S,b,m*size);
-}
-
-static int LoadInt (LoadState* S)
+static int LoadInt(LoadState* S)
 {
 int x;
- LoadBlock(S,&x,sizeof(x));
- if (x<0) luaG_runerror(S->L,"bad integer in %s",S->name);
+ LoadVar(S,x);
+ IF (x<0, "bad integer");
 return x;
 }

-static size_t LoadSize (LoadState* S)
-{
- size_t x;
- LoadBlock(S,&x,sizeof(x));
- return x;
-}
-
-static lua_Number LoadNumber (LoadState* S)
+static lua_Number LoadNumber(LoadState* S)
 {
 lua_Number x;
- LoadBlock(S,&x,sizeof(x));
+ LoadVar(S,x);
 return x;
 }

-static TString* LoadString (LoadState* S)
+static TString* LoadString(LoadState* S)
 {
- size_t size=LoadSize(S);
+ size_t size;
+ LoadVar(S,size);
 if (size==0)
  return NULL;
 else
 {
  char* s=luaZ_openspace(S->L,S->b,size);
-  ezread(S,s,size);
+  LoadBlock(S,s,size);
  return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
 }
 }

-static void LoadCode (LoadState* S, Proto* f)
+static void LoadCode(LoadState* S, Proto* f)
 {
- int size=LoadInt(S);
- f->code=luaM_newvector(S->L,size,Instruction);
- f->sizecode=size;
- LoadVector(S,f->code,size,sizeof(*f->code));
+ int n=LoadInt(S);
+ f->code=luaM_newvector(S->L,n,Instruction);
+ f->sizecode=n;
+ LoadVector(S,f->code,n,sizeof(Instruction));
 }

-static void LoadLocals (LoadState* S, Proto* f)
+static Proto* LoadFunction(LoadState* S, TString* p);
+
+static void LoadConstants(LoadState* S, Proto* f)
 {
 int i,n;
 n=LoadInt(S);
+ f->k=luaM_newvector(S->L,n,TValue);
+ f->sizek=n;
+ for (i=0; i<n; i++) setnilvalue(&f->k[i]);
+ for (i=0; i<n; i++)
+ {
+  TValue* o=&f->k[i];
+  int t=LoadChar(S);
+  switch (t)
+  {
+   case LUA_TNIL:
+   	setnilvalue(o);
+	break;
+   case LUA_TBOOLEAN:
+   	setbvalue(o,LoadChar(S));
+	break;
+   case LUA_TNUMBER:
+	setnvalue(o,LoadNumber(S));
+	break;
+   case LUA_TSTRING:
+	setsvalue2n(S->L,o,LoadString(S));
+	break;
+   default:
+	IF (1, "bad constant");
+	break;
+  }
+ }
+ n=LoadInt(S);
+ f->p=luaM_newvector(S->L,n,Proto*);
+ f->sizep=n;
+ for (i=0; i<n; i++) f->p[i]=NULL;
+ for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
+}
+
+static void LoadDebug(LoadState* S, Proto* f)
+{
+ int i,n;
+ n=LoadInt(S);
+ f->lineinfo=luaM_newvector(S->L,n,int);
+ f->sizelineinfo=n;
+ LoadVector(S,f->lineinfo,n,sizeof(int));
+ n=LoadInt(S);
 f->locvars=luaM_newvector(S->L,n,LocVar);
 f->sizelocvars=n;
 for (i=0; i<n; i++) f->locvars[i].varname=NULL;
@@ -131,75 +150,17 @@ static void LoadLocals (LoadState* S, Proto* f)
  f->locvars[i].startpc=LoadInt(S);
  f->locvars[i].endpc=LoadInt(S);
 }
-}
-
-static void LoadLines (LoadState* S, Proto* f)
-{
- int size=LoadInt(S);
- f->lineinfo=luaM_newvector(S->L,size,int);
- f->sizelineinfo=size;
- LoadVector(S,f->lineinfo,size,sizeof(*f->lineinfo));
-}
-
-static void LoadUpvalues (LoadState* S, Proto* f)
-{
- int i,n;
 n=LoadInt(S);
- if (n!=0 && n!=f->nups) 
-  luaG_runerror(S->L,"bad nupvalues in %s: read %d; expected %d",
-		S->name,n,f->nups);
 f->upvalues=luaM_newvector(S->L,n,TString*);
 f->sizeupvalues=n;
 for (i=0; i<n; i++) f->upvalues[i]=NULL;
 for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
 }

-static Proto* LoadFunction (LoadState* S, TString* p);
-
-static void LoadConstants (LoadState* S, Proto* f)
+static Proto* LoadFunction(LoadState* S, TString* p)
 {
- int i,n;
- lua_State *L=S->L;
- n=LoadInt(S);
- f->k=luaM_newvector(L,n,TValue);
- f->sizek=n;
- for (i=0; i<n; i++) setnilvalue(&f->k[i]);
- for (i=0; i<n; i++)
- {
-  TValue* o=&f->k[i];
-  int t=LoadByte(S);
-  switch (t)
-  {
-   case LUA_TNUMBER:
-	setnvalue(o,LoadNumber(S));
-	break;
-   case LUA_TSTRING:
-	setsvalue2n(L, o,LoadString(S));
-	break;
-   case LUA_TNIL:
-   	setnilvalue(o);
-	break;
-   case LUA_TBOOLEAN:
-        setbvalue(o, LoadByte(S));
-	break;
-   default:
-	luaG_runerror(L,"bad constant type (%d) in %s",t,S->name);
-	break;
-  }
- }
- n=LoadInt(S);
- f->p=luaM_newvector(L,n,Proto*);
- f->sizep=n;
- for (i=0; i<n; i++) f->p[i]=NULL;
- for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
-}
-
-static Proto* LoadFunction (LoadState* S, TString* p)
-{
- lua_State *L=S->L;
- Proto* f=luaF_newproto(L);
- setptvalue2s(L, L->top, f);
- incr_top(L);
+ Proto* f=luaF_newproto(S->L);
+ setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
 f->source=LoadString(S); if (f->source==NULL) f->source=p;
 f->linedefined=LoadInt(S);
 f->lastlinedefined=LoadInt(S);
@@ -207,90 +168,56 @@ static Proto* LoadFunction (LoadState* S, TString* p)
 f->numparams=LoadByte(S);
 f->is_vararg=LoadByte(S);
 f->maxstacksize=LoadByte(S);
- LoadLines(S,f);
- LoadLocals(S,f);
- LoadUpvalues(S,f);
- LoadConstants(S,f);
 LoadCode(S,f);
-#ifndef TRUST_BINARIES
- if (!luaG_checkcode(f)) luaG_runerror(L,"bad code in %s",S->name);
-#endif
- L->top--;
+ LoadConstants(S,f);
+ LoadDebug(S,f);
+ IF (!luaG_checkcode(f), "bad code");
+ S->L->top--;
 return f;
 }

-static void LoadSignature (LoadState* S)
+static void LoadHeader(LoadState* S)
 {
- const char* s=LUA_SIGNATURE;
- while (*s!=0 && ezgetc(S)==*s)
-  ++s;
- if (*s!=0) luaG_runerror(S->L,"bad signature in %s",S->name);
-}
-
-static void TestSize (LoadState* S, int s, const char* what)
-{
- int r=LoadByte(S);
- if (r!=s)
-  luaG_runerror(S->L,"virtual machine mismatch in %s: "
-	"size of %s is %d but read %d",S->name,what,s,r);
-}
-
-#define TESTSIZE(s,w)	TestSize(S,s,w)
-#define V(v)		v/16,v%16
-
-static void LoadHeader (LoadState* S)
-{
- int version;
- lua_Number x,tx=TEST_NUMBER;
- LoadSignature(S);
- version=LoadByte(S);
- if (version>VERSION)
-  luaG_runerror(S->L,"%s too new: "
-	"read version %d.%d; expected at most %d.%d",
-	S->name,V(version),V(VERSION));
- if (version<VERSION0)				/* check last major change */
-  luaG_runerror(S->L,"%s too old: "
-	"read version %d.%d; expected at least %d.%d",
-	S->name,V(version),V(VERSION0));
- S->swap=(luaU_endianness()!=LoadByte(S));	/* need to swap bytes? */
- TESTSIZE(sizeof(int),"int");
- TESTSIZE(sizeof(size_t), "size_t");
- TESTSIZE(sizeof(Instruction), "Instruction");
- TESTSIZE(sizeof(lua_Number), "number");
- x=LoadNumber(S);
- if ((long)x!=(long)tx)		/* disregard errors in last bits of fraction */
-  luaG_runerror(S->L,"unknown number format in %s",S->name);
-}
-
-static Proto* LoadChunk (LoadState* S)
-{
- LoadHeader(S);
- return LoadFunction(S,NULL);
+ char h[LUAC_HEADERSIZE];
+ char s[LUAC_HEADERSIZE];
+ luaU_header(h);
+ LoadBlock(S,s,LUAC_HEADERSIZE);
+ IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
 }

 /*
 ** load precompiled chunk
 */
-Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char *s)
+Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
 {
 LoadState S;
- if (*s=='@' || *s=='=')
-  S.name=s+1;
- else if (*s==LUA_SIGNATURE[0])
+ if (*name=='@' || *name=='=')
+  S.name=name+1;
+ else if (*name==LUA_SIGNATURE[0])
  S.name="binary string";
 else
-  S.name=s;
+  S.name=name;
 S.L=L;
 S.Z=Z;
 S.b=buff;
- return LoadChunk(&S);
+ LoadHeader(&S);
+ return LoadFunction(&S,NULL);
 }

 /*
-** find byte order
+* make header
 */
-int luaU_endianness (void)
+void luaU_header (char* h)
 {
 int x=1;
- return *(char*)&x;
+ memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
+ h+=sizeof(LUA_SIGNATURE)-1;
+ *h++=(char)LUAC_VERSION;
+ *h++=(char)LUAC_FORMAT;
+ *h++=(char)*(char*)&x;				/* endianness */
+ *h++=(char)sizeof(int);
+ *h++=(char)sizeof(size_t);
+ *h++=(char)sizeof(Instruction);
+ *h++=(char)sizeof(lua_Number);
+ *h++=(char)(((lua_Number)0.5)==0);		/* is lua_Number integral? */
 }
--- a/lundump.h
+++ b/lundump.h
@@ -1,6 +1,6 @@
 /*
-** $Id: lundump.h,v 1.35 2005/04/25 19:24:10 roberto Exp roberto $
-** load pre-compiled Lua chunks
+** $Id: lundump.h,v 1.39 2005/11/01 17:04:55 lhf Exp lhf $
+** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */

@@ -11,25 +11,26 @@
 #include "lzio.h"

 /* load one chunk; from lundump.c */
-LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff,
-                                                    const char *name);
+LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);

-/* find byte order; from lundump.c */
-LUAI_FUNC int luaU_endianness (void);
+/* make header; from lundump.c */
+LUAI_FUNC void luaU_header (char* h);

 /* dump one chunk; from ldump.c */
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* Main, lua_Writer w,
-                                       void* data, int strip);
+LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);

+#ifdef luac_c
 /* print one chunk; from print.c */
-LUAI_FUNC void luaU_print (const Proto* Main);
+LUAI_FUNC void luaU_print (const Proto* f, int full);
+#endif

-/* definitions for headers of binary files */
-#define	VERSION		0x50		/* last format change was in 5.0 */
-#define	VERSION0	0x50		/* last major  change was in 5.0 */
+/* for header of binary files -- this is Lua 5.1 */
+#define LUAC_VERSION		0x51

-/* a multiple of PI for testing native format */
-/* multiplying by 1E7 gives non-trivial integer values */
-#define	TEST_NUMBER	((lua_Number)3.14159265358979323846E7)
+/* for header of binary files -- this is the official format */
+#define LUAC_FORMAT		0
+
+/* size of header of binary files */
+#define LUAC_HEADERSIZE		12

 #endif
--- a/lvm.c
+++ b/lvm.c
@@ -1,11 +1,10 @@
 /*
-** $Id: lvm.c,v 2.54 2005/08/29 20:49:21 roberto Exp roberto $
+** $Id: lvm.c,v 2.58 2005/10/24 17:37:52 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */


-#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -66,7 +65,6 @@ static void traceexec (lua_State *L, const Instruction *pc) {
    if (L->hookcount == 0) {
      resethookcount(L);
      luaD_callhook(L, LUA_HOOKCOUNT, -1);
-      return;
    }
  }
  if (mask & LUA_MASKLINE) {
@@ -226,7 +224,7 @@ int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
  if (ttype(l) != ttype(r))
    return luaG_ordererror(L, l, r);
  else if (ttisnumber(l))
-    return luai_numlt(L, nvalue(l), nvalue(r));
+    return luai_numlt(nvalue(l), nvalue(r));
  else if (ttisstring(l))
    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
@@ -240,7 +238,7 @@ static int lessequal (lua_State *L, const TValue *l, const TValue *r) {
  if (ttype(l) != ttype(r))
    return luaG_ordererror(L, l, r);
  else if (ttisnumber(l))
-    return luai_numle(L, nvalue(l), nvalue(r));
+    return luai_numle(nvalue(l), nvalue(r));
  else if (ttisstring(l))
    return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1)  /* first try `le' */
@@ -256,7 +254,7 @@ int luaV_equalval (lua_State *L, const TValue *t1, const TValue *t2) {
  lua_assert(ttype(t1) == ttype(t2));
  switch (ttype(t1)) {
    case LUA_TNIL: return 1;
-    case LUA_TNUMBER: return luai_numeq(L, nvalue(t1), nvalue(t2));
+    case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
    case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2);  /* true must be 1 !! */
    case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
    case LUA_TUSERDATA: {
@@ -319,13 +317,13 @@ static void Arith (lua_State *L, StkId ra, const TValue *rb,
      (c = luaV_tonumber(rc, &tempc)) != NULL) {
    lua_Number nb = nvalue(b), nc = nvalue(c);
    switch (op) {
-      case TM_ADD: setnvalue(ra, luai_numadd(L, nb, nc)); break;
-      case TM_SUB: setnvalue(ra, luai_numsub(L, nb, nc)); break;
-      case TM_MUL: setnvalue(ra, luai_nummul(L, nb, nc)); break;
-      case TM_DIV: setnvalue(ra, luai_numdiv(L, nb, nc)); break;
-      case TM_MOD: setnvalue(ra, luai_nummod(L, nb, nc)); break;
-      case TM_POW: setnvalue(ra, luai_numpow(L, nb, nc)); break;
-      case TM_UNM: setnvalue(ra, luai_numunm(L, nb)); break;
+      case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
+      case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
+      case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
+      case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
+      case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
+      case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
+      case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
      default: lua_assert(0); break;
    }
  }
@@ -358,6 +356,19 @@ static void Arith (lua_State *L, StkId ra, const TValue *rb,
 #define Protect(x)	{ L->savedpc = pc; {x;}; base = L->base; }


+#define arith_op(op,tm) { \
+        TValue *rb = RKB(i); \
+        TValue *rc = RKC(i); \
+        if (ttisnumber(rb) && ttisnumber(rc)) { \
+          lua_Number nb = nvalue(rb), nc = nvalue(rc); \
+          setnvalue(ra, op(nb, nc)); \
+        } \
+        else \
+          Protect(Arith(L, ra, rb, rc, tm)); \
+      }
+
+
+
 void luaV_execute (lua_State *L, int nexeccalls) {
  LClosure *cl;
  StkId base;
@@ -455,76 +466,34 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_ADD: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_numadd(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_ADD));
+        arith_op(luai_numadd, TM_ADD);
        continue;
      }
      case OP_SUB: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_numsub(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_SUB));
+        arith_op(luai_numsub, TM_SUB);
        continue;
      }
      case OP_MUL: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_nummul(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_MUL));
+        arith_op(luai_nummul, TM_MUL);
        continue;
      }
      case OP_DIV: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_numdiv(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_DIV));
+        arith_op(luai_numdiv, TM_DIV);
        continue;
      }
      case OP_MOD: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_nummod(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_MOD));
+        arith_op(luai_nummod, TM_MOD);
        continue;
      }
      case OP_POW: {
-        TValue *rb = RKB(i);
-        TValue *rc = RKC(i);
-        if (ttisnumber(rb) && ttisnumber(rc)) {
-          lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          setnvalue(ra, luai_numpow(L, nb, nc));
-        }
-        else
-          Protect(Arith(L, ra, rb, rc, TM_POW));
+        arith_op(luai_numpow, TM_POW);
        continue;
      }
      case OP_UNM: {
        TValue *rb = RB(i);
        if (ttisnumber(rb)) {
          lua_Number nb = nvalue(rb);
-          setnvalue(ra, luai_numunm(L, nb));
+          setnvalue(ra, luai_numunm(nb));
        }
        else {
          Protect(Arith(L, ra, rb, rb, TM_UNM));
@@ -594,18 +563,18 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        continue;
      }
      case OP_TEST: {
-        if (l_isfalse(ra) == GETARG_C(i)) pc++;
-        else
-          dojump(L, pc, GETARG_sBx(*pc) + 1);
+        if (l_isfalse(ra) != GETARG_C(i))
+          dojump(L, pc, GETARG_sBx(*pc));
+        pc++;
        continue;
      }
      case OP_TESTSET: {
        TValue *rb = RB(i);
-        if (l_isfalse(rb) == GETARG_C(i)) pc++;
-        else {
+        if (l_isfalse(rb) != GETARG_C(i)) {
          setobjs2s(L, ra, rb);
-          dojump(L, pc, GETARG_sBx(*pc) + 1);
+          dojump(L, pc, GETARG_sBx(*pc));
        }
+        pc++;
        continue;
      }
      case OP_CALL: {
@@ -678,9 +647,9 @@ void luaV_execute (lua_State *L, int nexeccalls) {
      }
      case OP_FORLOOP: {
        lua_Number step = nvalue(ra+2);
-        lua_Number idx = luai_numadd(L, nvalue(ra), step); /* increment index */
+        lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
        lua_Number limit = nvalue(ra+1);
-        if (step > 0 ? luai_numle(L, idx, limit) : luai_numle(L, limit, idx)) {
+        if (step > 0 ? luai_numle(idx, limit) : luai_numle(limit, idx)) {
          dojump(L, pc, GETARG_sBx(i));  /* jump back */
          setnvalue(ra, idx);  /* update internal index... */
          setnvalue(ra+3, idx);  /* ...and external index */
@@ -698,7 +667,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
          luaG_runerror(L, LUA_QL("for") " limit must be a number");
        else if (!tonumber(pstep, ra+2))
          luaG_runerror(L, LUA_QL("for") " step must be a number");
-        setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep)));
+        setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
        dojump(L, pc, GETARG_sBx(i));
        continue;
      }
@@ -711,12 +680,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
        Protect(luaD_call(L, cb, GETARG_C(i)));
        L->top = L->ci->top;
        cb = RA(i) + 3;  /* previous call may change the stack */
-        if (ttisnil(cb))  /* break loop? */
-          pc++;  /* skip jump (break loop) */
-        else {
+        if (!ttisnil(cb)) {  /* continue loop? */
          setobjs2s(L, cb-1, cb);  /* save control variable */
-          dojump(L, pc, GETARG_sBx(*pc) + 1);  /* jump back */
+          dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
        }
+        pc++;
        continue;
      }
      case OP_SETLIST: {
--- a/2
+++ b/2
@@ -29,7 +29,7 @@ MYLIBS=


 # enable Linux goodies
-MYCFLAGS= $(LOCAL) -DLUA_USE_DLOPEN -DLUA_USE_READLINE
+MYCFLAGS= $(LOCAL) -DLUA_USE_LINUX
 MYLDFLAGS= -Wl,-E
 MYLIBS= -ldl -lreadline -lhistory -lncurses
Author	SHA1	Message	Date
Roberto Ierusalimschy	33b4dec1cb	no more "auto-detection"	2005-11-16 14:25:08 -02:00
Roberto Ierusalimschy	7dd10a1d7e	new macro LUA_USE_POSIX to control POSIX-related macros	2005-11-16 09:56:28 -02:00
Roberto Ierusalimschy	521a452f28	'mod' may also raise an error when applied to zero	2005-11-16 09:55:27 -02:00
Roberto Ierusalimschy	2753134a38	new versions by lhf	2005-11-16 09:55:07 -02:00
Roberto Ierusalimschy	cbbde11a8a	better position for lua_number2int (it is related to lua_Number)	2005-11-08 17:45:58 -02:00
Roberto Ierusalimschy	7b89cf3aeb	unused include's	2005-11-08 17:45:36 -02:00
Roberto Ierusalimschy	d2811e8097	simpler checking for numbers (strtod does the rest)	2005-11-08 17:45:14 -02:00
Roberto Ierusalimschy	e43e95553f	more privacy	2005-11-08 17:44:31 -02:00
Roberto Ierusalimschy	930018e273	lua_getlocal/setlocal work also for C locals and temporaries	2005-11-01 14:08:52 -02:00
Roberto Ierusalimschy	a160266c3d	details	2005-11-01 14:08:45 -02:00
Roberto Ierusalimschy	d4c99b2673	new function 'getregistry'	2005-11-01 14:08:32 -02:00
Roberto Ierusalimschy	88f9843eee	better error message	2005-10-26 11:28:19 -02:00
Roberto Ierusalimschy	9b5ae6faf9	better control of which values macros use	2005-10-25 11:36:28 -02:00
Roberto Ierusalimschy	caf3cfc6ac	try to ensure that macros actually use their arguments	2005-10-24 15:39:21 -02:00
Roberto Ierusalimschy	ff7638b0ed	VC warnings	2005-10-24 15:38:47 -02:00
Roberto Ierusalimschy	8e48ebb638	no more L in numer-operator macros (some functions that use those macros have no access to L)	2005-10-24 15:37:52 -02:00
Roberto Ierusalimschy	c2bd68d2c3	detail	2005-10-24 15:37:33 -02:00
Roberto Ierusalimschy	201288b4df	small bug	2005-10-23 15:52:42 -02:00
Roberto Ierusalimschy	62367dda44	string.gsub accepts a table as the replacement value	2005-10-23 15:46:30 -02:00
Roberto Ierusalimschy	056b6a8ef4	more robust implementation for table.insert	2005-10-23 15:38:15 -02:00
Roberto Ierusalimschy	502d8f9a06	comments	2005-10-23 15:37:55 -02:00
Roberto Ierusalimschy	7f376e6ea8	do a complete garbage collection in case of errors	2005-10-21 11:48:31 -02:00
Roberto Ierusalimschy	053e873145	new macro luaL_opt to avoid evaluating defaults when no needed	2005-10-21 11:47:42 -02:00
Roberto Ierusalimschy	9f4211310f	more precision for gc count	2005-10-20 09:35:50 -02:00
Roberto Ierusalimschy	515d556832	access to metamethods and metafields should be raw	2005-10-20 09:35:25 -02:00
Roberto Ierusalimschy	ed7039024d	avoid some warnings	2005-10-19 11:05:11 -02:00
Roberto Ierusalimschy	5511bf6b9d	avoid comparisons between (void ) and (int )	2005-10-17 16:01:51 -02:00
Roberto Ierusalimschy	86704cffe9	detail in usage message	2005-10-14 15:34:23 -03:00
Roberto Ierusalimschy	fa41fafa6e	reorganization of argument handling	2005-10-14 15:15:46 -03:00
Roberto Ierusalimschy	ebf646efb5	detail	2005-10-14 13:24:11 -03:00
Roberto Ierusalimschy	b3f81f1d1d	small bug when debugging dead threads	2005-10-14 13:23:33 -03:00
Roberto Ierusalimschy	a24eb3ef17	different organization for platform dependencies	2005-10-13 09:22:53 -03:00
Roberto Ierusalimschy	4385e2ada4	"conceptually", OP_TEST may change reg. A	2005-10-13 09:22:05 -03:00
Roberto Ierusalimschy	e9b06c506f	small optimization	2005-10-13 09:21:51 -03:00
Roberto Ierusalimschy	cd12ab2597	details (more uniform coding)	2005-10-13 09:21:26 -03:00
Roberto Ierusalimschy	e251e84e0f	constant folding optimizations	2005-10-09 17:05:48 -03:00
Roberto Ierusalimschy	e6bfbc38b5	'luaopen_package' was missing in new states	2005-10-06 17:47:32 -03:00
Roberto Ierusalimschy	d31c04c049	missing macros 'luai_userstate*'	2005-10-06 17:46:25 -03:00
Roberto Ierusalimschy	522481a788	avoid some warnings	2005-10-06 17:46:10 -03:00
Roberto Ierusalimschy	37b49aa451	detail	2005-10-06 17:44:22 -03:00
Roberto Ierusalimschy	0fa9b16148	details	2005-10-06 17:43:44 -03:00
Roberto Ierusalimschy	e41fb9a604	registry._LOADED created "on demand"	2005-10-03 11:36:45 -03:00
Roberto Ierusalimschy	5fc92cce12	registry._LOADED created "on demand" and baselib created as module _G	2005-10-03 11:36:45 -03:00
Roberto Ierusalimschy	6dd0c6ccbc	numeral expressions keep their values in struct 'expdesc'	2005-10-03 11:02:40 -03:00
Roberto Ierusalimschy	a77413acd0	include of math.h depends on luaconf	2005-10-03 11:01:26 -03:00
Roberto Ierusalimschy	5dbb870815	small optimization for local declarations without initializations	2005-09-30 11:23:33 -03:00
Roberto Ierusalimschy	ede19c9138		2005-09-30 11:21:56 -03:00
Roberto Ierusalimschy	9e88b336b4	unused assignment	2005-09-30 10:50:05 -03:00
Roberto Ierusalimschy	0fae476ed4	new function 'table.maxn'	2005-09-20 14:56:47 -03:00
Roberto Ierusalimschy	361a9adba7	smaller initial tables (for programs that create many states)	2005-09-20 14:55:53 -03:00
Roberto Ierusalimschy	d8f1cca16e	new function 'lua_setallocf'	2005-09-20 14:55:10 -03:00
Roberto Ierusalimschy	bf96d3fdd9	'string.find' as it was in 5.0	2005-09-19 10:49:12 -03:00
Roberto Ierusalimschy	c8c2e06899	'select' accepts negative indices	2005-09-16 15:22:48 -03:00
Roberto Ierusalimschy	8dcc6bc532	avoid the use of global lock	2005-09-14 14:48:57 -03:00
Roberto Ierusalimschy	38f585d271	separated macros for thread creation and state creation	2005-09-14 14:44:48 -03:00
Roberto Ierusalimschy	6887f91799	":" is not a good mark as it is not valid in Windows file names	2005-09-14 14:23:03 -03:00