summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorLua Team <team@lua.org>2005-11-18 12:00:00 +0000
committerrepogen <>2005-11-18 12:00:00 +0000
commitb3196343ba1a5dfe10e68eb9c61dc0ad5bb961a8 (patch)
treed3efede68270d3986c0f78101e55d17577a62666 /src
parentbd80c4ee9b6d9464cf9f3ff4ee41890d8b3ca9e6 (diff)
downloadlua-github-b3196343ba1a5dfe10e68eb9c61dc0ad5bb961a8.tar.gz
Lua 5.1-beta5.1-beta
Diffstat (limited to 'src')
-rw-r--r--src/lapi.c22
-rw-r--r--src/lauxlib.c19
-rw-r--r--src/lauxlib.h3
-rw-r--r--src/lbaselib.c48
-rw-r--r--src/lcode.c279
-rw-r--r--src/lcode.h8
-rw-r--r--src/ldblib.c11
-rw-r--r--src/ldebug.c55
-rw-r--r--src/ldo.c16
-rw-r--r--src/ldump.c53
-rw-r--r--src/liolib.c6
-rw-r--r--src/llex.c40
-rw-r--r--src/loadlib.c25
-rw-r--r--src/lobject.c4
-rw-r--r--src/lobject.h4
-rw-r--r--src/lopcodes.c6
-rw-r--r--src/lopcodes.h10
-rw-r--r--src/loslib.c6
-rw-r--r--src/lparser.c43
-rw-r--r--src/lparser.h8
-rw-r--r--src/lstate.c10
-rw-r--r--src/lstrlib.c133
-rw-r--r--src/ltable.c10
-rw-r--r--src/ltablib.c58
-rw-r--r--src/lua.c186
-rw-r--r--src/lua.h12
-rw-r--r--src/luac.c19
-rw-r--r--src/luaconf.h168
-rw-r--r--src/lundump.c149
-rw-r--r--src/lundump.h34
-rw-r--r--src/lvm.c118
-rw-r--r--src/print.c9
32 files changed, 791 insertions, 781 deletions
diff --git a/src/lapi.c b/src/lapi.c
index b85e1dc5..71daabda 100644
--- a/src/lapi.c
+++ b/src/lapi.c
@@ -1,5 +1,5 @@
/*
-** $Id: lapi.c,v 2.48 2005/09/01 17:42:22 roberto Exp $
+** $Id: lapi.c,v 2.51 2005/10/20 11:35:50 roberto Exp $
** 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);
}
diff --git a/src/lauxlib.c b/src/lauxlib.c
index b643d6c3..04620979 100644
--- a/src/lauxlib.c
+++ b/src/lauxlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.c,v 1.152 2005/09/06 17:20:11 roberto Exp $
+** $Id: lauxlib.c,v 1.156 2005/10/21 13:47:42 roberto Exp $
** 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);
diff --git a/src/lauxlib.h b/src/lauxlib.h
index aa07cb2b..ee503cc8 100644
--- a/src/lauxlib.h
+++ b/src/lauxlib.h
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.h,v 1.85 2005/09/06 17:19:51 roberto Exp $
+** $Id: lauxlib.h,v 1.86 2005/10/21 13:47:42 roberto Exp $
** 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)))
/*
** {======================================================
diff --git a/src/lbaselib.c b/src/lbaselib.c
index fb21da4b..7d8724a5 100644
--- a/src/lbaselib.c
+++ b/src/lbaselib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lbaselib.c,v 1.182 2005/08/26 17:36:32 roberto Exp $
+** $Id: lbaselib.c,v 1.186 2005/10/21 13:47:42 roberto Exp $
** 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 auxliliary 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");
}
diff --git a/src/lcode.c b/src/lcode.c
index 04838f33..ecda5cbf 100644
--- a/src/lcode.c
+++ b/src/lcode.c
@@ -1,5 +1,5 @@
/*
-** $Id: lcode.c,v 2.16 2005/08/29 20:49:21 roberto Exp $
+** $Id: lcode.c,v 2.22 2005/11/16 11:55:27 roberto Exp $
** 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 */
diff --git a/src/lcode.h b/src/lcode.h
index ed1a95bc..b5668f22 100644
--- a/src/lcode.h
+++ b/src/lcode.h
@@ -1,5 +1,5 @@
/*
-** $Id: lcode.h,v 1.45 2005/08/29 20:49:21 roberto Exp $
+** $Id: lcode.h,v 1.47 2005/11/08 19:44:31 roberto Exp $
** 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);
diff --git a/src/ldblib.c b/src/ldblib.c
index e7458634..5da6e1da 100644
--- a/src/ldblib.c
+++ b/src/ldblib.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldblib.c,v 1.101 2005/08/26 17:36:32 roberto Exp $
+** $Id: ldblib.c,v 1.103 2005/11/01 16:08:32 roberto Exp $
** 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},
diff --git a/src/ldebug.c b/src/ldebug.c
index 11166c0a..5fb11ce1 100644
--- a/src/ldebug.c
+++ b/src/ldebug.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldebug.c,v 2.26 2005/08/04 13:37:38 roberto Exp $
+** $Id: ldebug.c,v 2.28 2005/11/01 16:08:52 roberto Exp $
** 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));
}
}
diff --git a/src/ldo.c b/src/ldo.c
index d7645835..cb510dd8 100644
--- a/src/ldo.c
+++ b/src/ldo.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldo.c,v 2.33 2005/09/09 18:16:28 roberto Exp $
+** $Id: ldo.c,v 2.36 2005/10/23 17:52:42 roberto Exp $
** 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;
diff --git a/src/ldump.c b/src/ldump.c
index e580047b..73463410 100644
--- a/src/ldump.c
+++ b/src/ldump.c
@@ -1,6 +1,6 @@
/*
-** $Id: ldump.c,v 1.12 2005/06/08 14:40:44 lhf Exp $
-** save pre-compiled Lua chunks
+** $Id: ldump.c,v 1.14 2005/11/11 14:03:13 lhf Exp $
+** save precompiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -12,7 +12,6 @@
#include "lua.h"
#include "lobject.h"
-#include "lopcodes.h"
#include "lstate.h"
#include "lundump.h"
@@ -24,11 +23,8 @@ typedef struct {
int status;
} DumpState;
-#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
-#define DumpLines(f,D) DumpVector(f->lineinfo,f->sizelineinfo,sizeof(int),D)
-#define DumpLiteral(s,D) DumpBlock("" s,(sizeof(s))-1,D)
-#define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D)
#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)
{
@@ -77,24 +73,7 @@ static void DumpString(const TString* s, DumpState* D)
}
}
-static void DumpLocals(const Proto* f, DumpState* D)
-{
- int i,n=f->sizelocvars;
- DumpInt(n,D);
- for (i=0; i<n; i++)
- {
- DumpString(f->locvars[i].varname,D);
- DumpInt(f->locvars[i].startpc,D);
- DumpInt(f->locvars[i].endpc,D);
- }
-}
-
-static void DumpUpvalues(const Proto* f, DumpState* D)
-{
- int i,n=f->sizeupvalues;
- DumpInt(n,D);
- for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
-}
+#define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
@@ -129,6 +108,24 @@ static void DumpConstants(const Proto* f, DumpState* D)
for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
}
+static void DumpDebug(const Proto* f, DumpState* D)
+{
+ 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++)
+ {
+ DumpString(f->locvars[i].varname,D);
+ DumpInt(f->locvars[i].startpc,D);
+ DumpInt(f->locvars[i].endpc,D);
+ }
+ 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)
{
DumpString((f->source==p) ? NULL : f->source,D);
@@ -138,11 +135,9 @@ static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
DumpChar(f->numparams,D);
DumpChar(f->is_vararg,D);
DumpChar(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);
DumpCode(f,D);
+ DumpConstants(f,D);
+ DumpDebug(f,D);
}
static void DumpHeader(DumpState* D)
diff --git a/src/liolib.c b/src/liolib.c
index a7f8743f..cc493aff 100644
--- a/src/liolib.c
+++ b/src/liolib.c
@@ -1,5 +1,5 @@
/*
-** $Id: liolib.c,v 2.67 2005/08/26 17:36:32 roberto Exp $
+** $Id: liolib.c,v 2.69 2005/10/19 13:05:11 roberto Exp $
** 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);
}
diff --git a/src/llex.c b/src/llex.c
index b663b432..d7753394 100644
--- a/src/llex.c
+++ b/src/llex.c
@@ -1,5 +1,5 @@
/*
-** $Id: llex.c,v 2.12 2005/05/17 19:49:15 roberto Exp $
+** $Id: llex.c,v 2.13 2005/11/08 19:45:14 roberto Exp $
** 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 '.';
diff --git a/src/loadlib.c b/src/loadlib.c
index 767fdb8e..9f992086 100644
--- a/src/loadlib.c
+++ b/src/loadlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: loadlib.c,v 1.44 2005/09/06 17:20:25 roberto Exp $
+** $Id: loadlib.c,v 1.48 2005/10/17 18:01:51 roberto Exp $
** 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 */
@@ -624,8 +627,6 @@ LUALIB_API int luaopen_package (lua_State *L) {
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 */
lua_newtable(L);
@@ -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);
diff --git a/src/lobject.c b/src/lobject.c
index 9aa9760f..3974c683 100644
--- a/src/lobject.c
+++ b/src/lobject.c
@@ -1,5 +1,5 @@
/*
-** $Id: lobject.c,v 2.18 2005/08/01 04:22:23 roberto Exp $
+** $Id: lobject.c,v 2.19 2005/10/24 17:37:52 roberto Exp $
** 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:
diff --git a/src/lobject.h b/src/lobject.h
index 1709fa3c..1416e360 100644
--- a/src/lobject.h
+++ b/src/lobject.h
@@ -1,5 +1,5 @@
/*
-** $Id: lobject.h,v 2.17 2005/06/13 14:19:00 roberto Exp $
+** $Id: lobject.h,v 2.18 2005/10/24 17:37:33 roberto Exp $
** 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))
diff --git a/src/lopcodes.c b/src/lopcodes.c
index 5e3bc5f7..bf9cd522 100644
--- a/src/lopcodes.c
+++ b/src/lopcodes.c
@@ -1,5 +1,5 @@
/*
-** $Id: lopcodes.c,v 1.35 2005/08/29 20:49:21 roberto Exp $
+** $Id: lopcodes.c,v 1.37 2005/11/08 19:45:36 roberto Exp $
** 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 */
diff --git a/src/lopcodes.h b/src/lopcodes.h
index b08b6798..88e7e65c 100644
--- a/src/lopcodes.h
+++ b/src/lopcodes.h
@@ -1,5 +1,5 @@
/*
-** $Id: lopcodes.h,v 1.122 2005/08/29 20:49:21 roberto Exp $
+** $Id: lopcodes.h,v 1.123 2005/10/23 17:37:55 roberto Exp $
** 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)*/
diff --git a/src/loslib.c b/src/loslib.c
index 4cee7ba5..01458b90 100644
--- a/src/loslib.c
+++ b/src/loslib.c
@@ -1,5 +1,5 @@
/*
-** $Id: loslib.c,v 1.13 2005/09/09 18:22:46 roberto Exp $
+** $Id: loslib.c,v 1.14 2005/10/21 13:47:42 roberto Exp $
** 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);
diff --git a/src/lparser.c b/src/lparser.c
index 91dc4fff..dd4715d0 100644
--- a/src/lparser.c
+++ b/src/lparser.c
@@ -1,5 +1,5 @@
/*
-** $Id: lparser.c,v 2.35 2005/08/29 20:49:21 roberto Exp $
+** $Id: lparser.c,v 2.38 2005/10/24 17:38:47 roberto Exp $
** 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);
}
}
diff --git a/src/lparser.h b/src/lparser.h
index d8542f9c..d5e6e81d 100644
--- a/src/lparser.h
+++ b/src/lparser.h
@@ -1,5 +1,5 @@
/*
-** $Id: lparser.h,v 1.55 2005/04/25 19:24:10 roberto Exp $
+** $Id: lparser.h,v 1.56 2005/10/03 14:02:40 roberto Exp $
** 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;
diff --git a/src/lstate.c b/src/lstate.c
index 2a4ace12..77e93fbd 100644
--- a/src/lstate.c
+++ b/src/lstate.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstate.c,v 2.33 2005/08/25 15:39:16 roberto Exp $
+** $Id: lstate.c,v 2.35 2005/10/06 20:46:25 roberto Exp $
** 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 */
diff --git a/src/lstrlib.c b/src/lstrlib.c
index 4cf5836a..25258bfe 100644
--- a/src/lstrlib.c
+++ b/src/lstrlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstrlib.c,v 1.123 2005/08/26 17:36:32 roberto Exp $
+** $Id: lstrlib.c,v 1.127 2005/10/26 13:28:19 roberto Exp $
** 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 */
diff --git a/src/ltable.c b/src/ltable.c
index 979cc5ca..5d4a828a 100644
--- a/src/ltable.c
+++ b/src/ltable.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltable.c,v 2.26 2005/07/11 14:01:37 roberto Exp $
+** $Id: ltable.c,v 2.27 2005/10/24 17:37:52 roberto Exp $
** 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);
}
diff --git a/src/ltablib.c b/src/ltablib.c
index 348b6ed5..453b23b3 100644
--- a/src/ltablib.c
+++ b/src/ltablib.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltablib.c,v 1.35 2005/08/26 17:36:32 roberto Exp $
+** $Id: ltablib.c,v 1.38 2005/10/23 17:38:15 roberto Exp $
** 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},
diff --git a/src/lua.c b/src/lua.c
index 14c5e20d..bfae4449 100644
--- a/src/lua.c
+++ b/src/lua.c
@@ -1,5 +1,5 @@
/*
-** $Id: lua.c,v 1.150 2005/09/06 17:19:33 roberto Exp $
+** $Id: lua.c,v 1.154 2005/10/24 17:38:47 roberto Exp $
** 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 */
- }
- 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;
+
+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;
}
- default: {
- clearinteractive(interactive);
- print_usage();
+ break;
+ default: return -1; /* invalid option */
+ }
+ }
+ 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;
}
diff --git a/src/lua.h b/src/lua.h
index 339e076f..d612eec7 100644
--- a/src/lua.h
+++ b/src/lua.h
@@ -1,5 +1,5 @@
/*
-** $Id: lua.h,v 1.212 2005/08/25 20:02:08 roberto Exp $
+** $Id: lua.h,v 1.214 2005/10/20 11:35:50 roberto Exp $
** Lua - An Extensible Extension Language
** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
** See Copyright Notice at the end of this file
@@ -16,7 +16,7 @@
#include "luaconf.h"
-#define LUA_VERSION "Lua 5.1 (alpha)"
+#define LUA_VERSION "Lua 5.1 (beta)"
#define LUA_VERSION_NUM 501
#define LUA_COPYRIGHT "Copyright (C) 1994-2005 Lua.org, PUC-Rio"
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
@@ -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);
diff --git a/src/luac.c b/src/luac.c
index 374ea3ac..2dd76b76 100644
--- a/src/luac.c
+++ b/src/luac.c
@@ -1,5 +1,5 @@
/*
-** $Id: luac.c,v 1.51 2005/06/02 13:39:23 lhf Exp $
+** $Id: luac.c,v 1.52 2005/11/11 14:03:13 lhf Exp $
** Lua compiler (saves bytecodes to files; also list bytecodes)
** See Copyright Notice in lua.h
*/
@@ -23,13 +23,8 @@
#include "lstring.h"
#include "lundump.h"
-#ifndef PROGNAME
#define PROGNAME "luac" /* default program name */
-#endif
-
-#ifndef OUTPUT
-#define OUTPUT "luac.out" /* default output file */
-#endif
+#define OUTPUT PROGNAME ".out" /* default output file */
static int listing=0; /* list bytecodes? */
static int dumping=1; /* dump bytecodes? */
@@ -152,15 +147,15 @@ static int writer(lua_State* L, const void* p, size_t size, void* u)
}
struct Smain {
- int argc;
- char **argv;
+ int argc;
+ char** argv;
};
-static int pmain(lua_State *L)
+static int pmain(lua_State* L)
{
- struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
+ struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
int argc=s->argc;
- char **argv=s->argv;
+ char** argv=s->argv;
Proto* f;
int i;
if (!lua_checkstack(L,argc)) fatal("too many input files");
diff --git a/src/luaconf.h b/src/luaconf.h
index d6d4a2a7..ea685a2d 100644
--- a/src/luaconf.h
+++ b/src/luaconf.h
@@ -1,5 +1,5 @@
/*
-** $Id: luaconf.h,v 1.65 2005/09/09 18:24:42 roberto Exp $
+** $Id: luaconf.h,v 1.74 2005/11/16 16:24: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
@@ -316,20 +341,12 @@
#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
** 'string.gmatch'.
*/
#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)
diff --git a/src/lundump.c b/src/lundump.c
index 726d021d..60a0eeed 100644
--- a/src/lundump.c
+++ b/src/lundump.c
@@ -1,6 +1,6 @@
/*
-** $Id: lundump.c,v 1.58 2005/09/02 01:54:47 lhf Exp $
-** load pre-compiled Lua chunks
+** $Id: lundump.c,v 1.59 2005/11/11 14:03:13 lhf Exp $
+** load precompiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -15,42 +15,34 @@
#include "ldo.h"
#include "lfunc.h"
#include "lmem.h"
-#include "lopcodes.h"
+#include "lobject.h"
#include "lstring.h"
#include "lundump.h"
#include "lzio.h"
-#ifdef LUAC_TRUST_BINARIES
-#define IF(c,s)
-#else
-#define IF(c,s) if (c) error(S,s)
-#endif
-
typedef struct {
lua_State* L;
ZIO* Z;
Mbuffer* b;
const char* name;
-#ifdef LUAC_SWAP_ON_LOAD
- int swap;
-#endif
} LoadState;
-#ifdef LUAC_SWAP_ON_LOAD
-static void LoadMem (LoadState* S, void* b, int n, size_t size);
+#ifdef LUAC_TRUST_BINARIES
+#define IF(c,s)
#else
-#define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
-#endif
-
-#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)
+#define IF(c,s) if (c) error(S,s)
static void error(LoadState* S, const char* why)
{
- luaO_pushfstring(S->L,"%s: %s",S->name,why);
+ 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)
{
@@ -102,39 +94,6 @@ static void LoadCode(LoadState* S, Proto* f)
LoadVector(S,f->code,n,sizeof(Instruction));
}
-static void LoadLocals(LoadState* S, Proto* f)
-{
- int i,n;
- 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;
- for (i=0; i<n; i++)
- {
- f->locvars[i].varname=LoadString(S);
- f->locvars[i].startpc=LoadInt(S);
- f->locvars[i].endpc=LoadInt(S);
- }
-}
-
-static void LoadLines(LoadState* S, Proto* f)
-{
- int n=LoadInt(S);
- f->lineinfo=luaM_newvector(S->L,n,int);
- f->sizelineinfo=n;
- LoadVector(S,f->lineinfo,n,sizeof(int));
-}
-
-static void LoadUpvalues(LoadState* S, Proto* f)
-{
- int i,n;
- n=LoadInt(S);
- 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)
@@ -174,6 +133,30 @@ static void LoadConstants(LoadState* S, Proto* f)
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;
+ for (i=0; i<n; i++)
+ {
+ f->locvars[i].varname=LoadString(S);
+ f->locvars[i].startpc=LoadInt(S);
+ f->locvars[i].endpc=LoadInt(S);
+ }
+ n=LoadInt(S);
+ 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)
{
Proto* f=luaF_newproto(S->L);
@@ -185,11 +168,9 @@ 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);
+ LoadConstants(S,f);
+ LoadDebug(S,f);
IF (!luaG_checkcode(f), "bad code");
S->L->top--;
return f;
@@ -201,9 +182,6 @@ static void LoadHeader(LoadState* S)
char s[LUAC_HEADERSIZE];
luaU_header(h);
LoadBlock(S,s,LUAC_HEADERSIZE);
-#ifdef LUAC_SWAP_ON_LOAD
- S->swap=(s[6]!=h[6]); s[6]=h[6];
-#endif
IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
}
@@ -236,55 +214,10 @@ void luaU_header (char* h)
h+=sizeof(LUA_SIGNATURE)-1;
*h++=(char)LUAC_VERSION;
*h++=(char)LUAC_FORMAT;
- *h++=(char)*(char*)&x;
+ *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);
-}
-
-#ifdef LUAC_SWAP_ON_LOAD
-static void LoadMem (LoadState* S, void* b, int n, size_t size)
-{
- LoadBlock(S,b,n*size);
- if (S->swap)
- {
- char* p=(char*) b;
- char c;
- switch (size)
- {
- case 1:
- break;
- case 2:
- while (n--)
- {
- c=p[0]; p[0]=p[1]; p[1]=c;
- p+=2;
- }
- break;
- case 4:
- while (n--)
- {
- c=p[0]; p[0]=p[3]; p[3]=c;
- c=p[1]; p[1]=p[2]; p[2]=c;
- p+=4;
- }
- break;
- case 8:
- while (n--)
- {
- c=p[0]; p[0]=p[7]; p[7]=c;
- c=p[1]; p[1]=p[6]; p[6]=c;
- c=p[2]; p[2]=p[5]; p[5]=c;
- c=p[3]; p[3]=p[4]; p[4]=c;
- p+=8;
- }
- break;
- default:
- IF(1, "bad size");
- break;
- }
- }
+ *h++=(char)(((lua_Number)0.5)==0); /* is lua_Number integral? */
}
-#endif
diff --git a/src/lundump.h b/src/lundump.h
index 5de3c46e..58cca5d1 100644
--- a/src/lundump.h
+++ b/src/lundump.h
@@ -1,6 +1,6 @@
/*
-** $Id: lundump.h,v 1.38 2005/09/02 01:54:47 lhf Exp $
-** load pre-compiled Lua chunks
+** $Id: lundump.h,v 1.40 2005/11/11 14:03:13 lhf Exp $
+** load precompiled Lua chunks
** See Copyright Notice in lua.h
*/
@@ -10,12 +10,6 @@
#include "lobject.h"
#include "lzio.h"
-/* make it work with Lua 5.0 */
-#ifndef LUA_VERSION_NUM
-#define LUAI_FUNC
-#define lua_Writer lua_Chunkwriter
-#endif
-
/* load one chunk; from lundump.c */
LUAI_FUNC Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
@@ -25,8 +19,10 @@ LUAI_FUNC void luaU_header (char* h);
/* dump one chunk; from ldump.c */
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* f, int full);
+#endif
/* for header of binary files -- this is Lua 5.1 */
#define LUAC_VERSION 0x51
@@ -37,26 +33,4 @@ LUAI_FUNC void luaU_print (const Proto* f, int full);
/* size of header of binary files */
#define LUAC_HEADERSIZE 12
-/* make it work with Lua 5.0 */
-#ifndef LUA_VERSION_NUM
-#define LUA_SIGNATURE "\033Lua"
-#define TValue TObject
-#define rawtsvalue tsvalue
-#define linedefined lineDefined
-#define lastlinedefined lineDefined
-#define setptvalue2s(L,t,f)
-#undef setsvalue2n
-#define setsvalue2n(L,x,y) setsvalue(x,y)
-#define LUA_QL(x) "'" x "'"
-#define LUA_QS LUA_QL("%s")
-#undef LUAC_VERSION
-#define LUAC_VERSION 0x50
-#ifdef lapi_c
-#define luaU_dump(L,f,w,d) (luaU_dump)(L,f,w,d,0)
-#endif
-#ifdef ldo_c
-#define luaU_undump(L,z,b) (luaU_undump)(L,z,b,z->name)
-#endif
-#endif
-
#endif
diff --git a/src/lvm.c b/src/lvm.c
index 92c853b2..c94644f9 100644
--- a/src/lvm.c
+++ b/src/lvm.c
@@ -1,11 +1,10 @@
/*
-** $Id: lvm.c,v 2.55 2005/09/09 18:23:35 roberto Exp $
+** $Id: lvm.c,v 2.59 2005/11/01 16:08:45 roberto Exp $
** 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: {
diff --git a/src/print.c b/src/print.c
index 8090a2d5..cfecba96 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1,5 +1,5 @@
/*
-** $Id: print.c,v 1.52 2005/06/08 14:40:44 lhf Exp $
+** $Id: print.c,v 1.53 2005/11/11 14:03:13 lhf Exp $
** print bytecodes
** See Copyright Notice in lua.h
*/
@@ -7,6 +7,7 @@
#include <ctype.h>
#include <stdio.h>
+#define luac_c
#define LUA_CORE
#include "ldebug.h"
@@ -14,6 +15,8 @@
#include "lopcodes.h"
#include "lundump.h"
+#define PrintFunction luaU_print
+
#define Sizeof(x) ((int)sizeof(x))
#define VOID(p) ((const void*)(p))
@@ -203,7 +206,7 @@ static void PrintUpvalues(const Proto* f)
}
}
-void luaU_print(const Proto* f, int full)
+void PrintFunction(const Proto* f, int full)
{
int i,n=f->sizep;
PrintHeader(f);
@@ -214,5 +217,5 @@ void luaU_print(const Proto* f, int full)
PrintLocals(f);
PrintUpvalues(f);
}
- for (i=0; i<n; i++) luaU_print(f->p[i],full);
+ for (i=0; i<n; i++) PrintFunction(f->p[i],full);
}
View Lorry Controller Status