lihao/skynet
1
0
Fork 0
mirror of https://github.com/cloudwu/skynet.git synced 2026-07-24 20:23:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

update lua to 5.3.2

Browse Source
This commit is contained in:
Cloud Wu
2015-11-30 20:31:56 +08:00
parent e47a4921fa
commit 3a527f0a66
41 changed files with 1296 additions and 837 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
3rd/lua/README
View File

@@ -1,6 +1,6 @@
This is a modify version of lua 5.3.1 (http://www.lua.org/ftp/lua-5.3.1.tar.gz) . This is a modify version of lua 5.3.2 (http://www.lua.org/ftp/lua-5.3.2.tar.gz) .
For detail , For detail ,
Shared Proto : http://lua-users.org/lists/lua-l/2014-03/msg00489.html Shared Proto : http://lua-users.org/lists/lua-l/2014-03/msg00489.html
Shared short string table : http://blog.codingnow.com/2015/08/lua_vm_share_string.html Shared short string table : http://blog.codingnow.com/2015/08/lua_vm_share_string.html
Signal for debug use : http://blog.codingnow.com/2015/03/skynet_signal.html

149
3rd/lua/lapi.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lapi.c,v 2.249 2015/04/06 12:23:48 roberto Exp $ ** $Id: lapi.c,v 2.257 2015/11/02 18:48:07 roberto Exp $
** Lua API ** Lua API
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -122,11 +122,11 @@ LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
lua_lock(to); lua_lock(to);
api_checknelems(from, n); api_checknelems(from, n);
api_check(from, G(from) == G(to), "moving among independent states"); api_check(from, G(from) == G(to), "moving among independent states");
api_check(from, to->ci->top - to->top >= n, "not enough elements to move"); api_check(from, to->ci->top - to->top >= n, "stack overflow");
from->top -= n; from->top -= n;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
setobj2s(to, to->top, from->top + i); setobj2s(to, to->top, from->top + i);
api_incr_top(to); to->top++; /* stack already checked by previous 'api_check' */
} }
lua_unlock(to); lua_unlock(to);
} }
@@ -472,11 +472,16 @@ LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
} }
/*
** Pushes on the stack a string with given length. Avoid using 's' when
** 'len' == 0 (as 's' can be NULL in that case), due to later use of
** 'memcmp' and 'memcpy'.
*/
LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
TString *ts; TString *ts;
lua_lock(L); lua_lock(L);
luaC_checkGC(L); luaC_checkGC(L);
ts = luaS_newlstr(L, s, len); ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
setsvalue2s(L, L->top, ts); setsvalue2s(L, L->top, ts);
api_incr_top(L); api_incr_top(L);
lua_unlock(L); lua_unlock(L);
@@ -580,19 +585,30 @@ LUA_API int lua_pushthread (lua_State *L) {
*/ */
LUA_API int lua_getglobal (lua_State *L, const char *name) { static int auxgetstr (lua_State *L, const TValue *t, const char *k) {
Table *reg = hvalue(&G(L)->l_registry); const TValue *aux;
const TValue *gt; /* global table */ TString *str = luaS_new(L, k);
lua_lock(L); if (luaV_fastget(L, t, str, aux, luaH_getstr)) {
gt = luaH_getint(reg, LUA_RIDX_GLOBALS); setobj2s(L, L->top, aux);
setsvalue2s(L, L->top, luaS_new(L, name)); api_incr_top(L);
api_incr_top(L); }
luaV_gettable(L, gt, L->top - 1, L->top - 1); else {
setsvalue2s(L, L->top, str);
api_incr_top(L);
luaV_finishget(L, t, L->top - 1, L->top - 1, aux);
}
lua_unlock(L); lua_unlock(L);
return ttnov(L->top - 1); return ttnov(L->top - 1);
} }
LUA_API int lua_getglobal (lua_State *L, const char *name) {
Table *reg = hvalue(&G(L)->l_registry);
lua_lock(L);
return auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
}
LUA_API int lua_gettable (lua_State *L, int idx) { LUA_API int lua_gettable (lua_State *L, int idx) {
StkId t; StkId t;
lua_lock(L); lua_lock(L);
@@ -604,24 +620,25 @@ LUA_API int lua_gettable (lua_State *L, int idx) {
LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
StkId t;
lua_lock(L); lua_lock(L);
t = index2addr(L, idx); return auxgetstr(L, index2addr(L, idx), k);
setsvalue2s(L, L->top, luaS_new(L, k));
api_incr_top(L);
luaV_gettable(L, t, L->top - 1, L->top - 1);
lua_unlock(L);
return ttnov(L->top - 1);
} }
LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) { LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
StkId t; StkId t;
const TValue *aux;
lua_lock(L); lua_lock(L);
t = index2addr(L, idx); t = index2addr(L, idx);
setivalue(L->top, n); if (luaV_fastget(L, t, n, aux, luaH_getint)) {
api_incr_top(L); setobj2s(L, L->top, aux);
luaV_gettable(L, t, L->top - 1, L->top - 1); api_incr_top(L);
}
else {
setivalue(L->top, n);
api_incr_top(L);
luaV_finishget(L, t, L->top - 1, L->top - 1, aux);
}
lua_unlock(L); lua_unlock(L);
return ttnov(L->top - 1); return ttnov(L->top - 1);
} }
@@ -720,18 +737,29 @@ LUA_API int lua_getuservalue (lua_State *L, int idx) {
** set functions (stack -> Lua) ** set functions (stack -> Lua)
*/ */
/*
** t[k] = value at the top of the stack (where 'k' is a string)
*/
static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
const TValue *aux;
TString *str = luaS_new(L, k);
api_checknelems(L, 1);
if (luaV_fastset(L, t, str, aux, luaH_getstr, L->top - 1))
L->top--; /* pop value */
else {
setsvalue2s(L, L->top, str); /* push 'str' (to make it a TValue) */
api_incr_top(L);
luaV_finishset(L, t, L->top - 1, L->top - 2, aux);
L->top -= 2; /* pop value and key */
}
lua_unlock(L); /* lock done by caller */
}
LUA_API void lua_setglobal (lua_State *L, const char *name) { LUA_API void lua_setglobal (lua_State *L, const char *name) {
Table *reg = hvalue(&G(L)->l_registry); Table *reg = hvalue(&G(L)->l_registry);
const TValue *gt; /* global table */ lua_lock(L); /* unlock done in 'auxsetstr' */
lua_lock(L); auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);
api_checknelems(L, 1);
gt = luaH_getint(reg, LUA_RIDX_GLOBALS);
setsvalue2s(L, L->top, luaS_new(L, name));
api_incr_top(L);
luaV_settable(L, gt, L->top - 1, L->top - 2);
L->top -= 2; /* pop value and key */
lua_unlock(L);
} }
@@ -747,42 +775,40 @@ LUA_API void lua_settable (lua_State *L, int idx) {
LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
StkId t; lua_lock(L); /* unlock done in 'auxsetstr' */
lua_lock(L); auxsetstr(L, index2addr(L, idx), k);
api_checknelems(L, 1);
t = index2addr(L, idx);
setsvalue2s(L, L->top, luaS_new(L, k));
api_incr_top(L);
luaV_settable(L, t, L->top - 1, L->top - 2);
L->top -= 2; /* pop value and key */
lua_unlock(L);
} }
LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) { LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
StkId t; StkId t;
const TValue *aux;
lua_lock(L); lua_lock(L);
api_checknelems(L, 1); api_checknelems(L, 1);
t = index2addr(L, idx); t = index2addr(L, idx);
setivalue(L->top, n); if (luaV_fastset(L, t, n, aux, luaH_getint, L->top - 1))
api_incr_top(L); L->top--; /* pop value */
luaV_settable(L, t, L->top - 1, L->top - 2); else {
L->top -= 2; /* pop value and key */ setivalue(L->top, n);
api_incr_top(L);
luaV_finishset(L, t, L->top - 1, L->top - 2, aux);
L->top -= 2; /* pop value and key */
}
lua_unlock(L); lua_unlock(L);
} }
LUA_API void lua_rawset (lua_State *L, int idx) { LUA_API void lua_rawset (lua_State *L, int idx) {
StkId o; StkId o;
Table *t; TValue *slot;
lua_lock(L); lua_lock(L);
api_checknelems(L, 2); api_checknelems(L, 2);
o = index2addr(L, idx); o = index2addr(L, idx);
api_check(L, ttistable(o), "table expected"); api_check(L, ttistable(o), "table expected");
t = hvalue(o); slot = luaH_set(L, hvalue(o), L->top - 2);
setobj2t(L, luaH_set(L, t, L->top-2), L->top-1); setobj2t(L, slot, L->top - 1);
invalidateTMcache(t); invalidateTMcache(hvalue(o));
luaC_barrierback(L, t, L->top-1); luaC_barrierback(L, hvalue(o), L->top-1);
L->top -= 2; L->top -= 2;
lua_unlock(L); lua_unlock(L);
} }
@@ -790,14 +816,12 @@ LUA_API void lua_rawset (lua_State *L, int idx) {
LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) { LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
StkId o; StkId o;
Table *t;
lua_lock(L); lua_lock(L);
api_checknelems(L, 1); api_checknelems(L, 1);
o = index2addr(L, idx); o = index2addr(L, idx);
api_check(L, ttistable(o), "table expected"); api_check(L, ttistable(o), "table expected");
t = hvalue(o); luaH_setint(L, hvalue(o), n, L->top - 1);
luaH_setint(L, t, n, L->top - 1); luaC_barrierback(L, hvalue(o), L->top-1);
luaC_barrierback(L, t, L->top-1);
L->top--; L->top--;
lua_unlock(L); lua_unlock(L);
} }
@@ -805,16 +829,15 @@ LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) { LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
StkId o; StkId o;
Table *t; TValue k, *slot;
TValue k;
lua_lock(L); lua_lock(L);
api_checknelems(L, 1); api_checknelems(L, 1);
o = index2addr(L, idx); o = index2addr(L, idx);
api_check(L, ttistable(o), "table expected"); api_check(L, ttistable(o), "table expected");
t = hvalue(o);
setpvalue(&k, cast(void *, p)); setpvalue(&k, cast(void *, p));
setobj2t(L, luaH_set(L, t, &k), L->top - 1); slot = luaH_set(L, hvalue(o), &k);
luaC_barrierback(L, t, L->top - 1); setobj2t(L, slot, L->top - 1);
luaC_barrierback(L, hvalue(o), L->top - 1);
L->top--; L->top--;
lua_unlock(L); lua_unlock(L);
} }
@@ -896,10 +919,10 @@ LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
if (k != NULL && L->nny == 0) { /* need to prepare continuation? */ if (k != NULL && L->nny == 0) { /* need to prepare continuation? */
L->ci->u.c.k = k; /* save continuation */ L->ci->u.c.k = k; /* save continuation */
L->ci->u.c.ctx = ctx; /* save context */ L->ci->u.c.ctx = ctx; /* save context */
luaD_call(L, func, nresults, 1); /* do the call */ luaD_call(L, func, nresults); /* do the call */
} }
else /* no continuation or no yieldable */ else /* no continuation or no yieldable */
luaD_call(L, func, nresults, 0); /* just do the call */ luaD_callnoyield(L, func, nresults); /* just do the call */
adjustresults(L, nresults); adjustresults(L, nresults);
lua_unlock(L); lua_unlock(L);
} }
@@ -917,7 +940,7 @@ struct CallS { /* data to 'f_call' */
static void f_call (lua_State *L, void *ud) { static void f_call (lua_State *L, void *ud) {
struct CallS *c = cast(struct CallS *, ud); struct CallS *c = cast(struct CallS *, ud);
luaD_call(L, c->func, c->nresults, 0); luaD_callnoyield(L, c->func, c->nresults);
} }
@@ -955,7 +978,7 @@ LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
L->errfunc = func; L->errfunc = func;
setoah(ci->callstatus, L->allowhook); /* save value of 'allowhook' */ setoah(ci->callstatus, L->allowhook); /* save value of 'allowhook' */
ci->callstatus |= CIST_YPCALL; /* function can do error recovery */ ci->callstatus |= CIST_YPCALL; /* function can do error recovery */
luaD_call(L, c.func, nresults, 1); /* do the call */ luaD_call(L, c.func, nresults); /* do the call */
ci->callstatus &= ~CIST_YPCALL; ci->callstatus &= ~CIST_YPCALL;
L->errfunc = ci->u.c.old_errfunc; L->errfunc = ci->u.c.old_errfunc;
status = LUA_OK; /* if it is here, there were no errors */ status = LUA_OK; /* if it is here, there were no errors */
@@ -1096,7 +1119,7 @@ LUA_API int lua_gc (lua_State *L, int what, int data) {
} }
case LUA_GCSTEP: { case LUA_GCSTEP: {
l_mem debt = 1; /* =1 to signal that it did an actual step */ l_mem debt = 1; /* =1 to signal that it did an actual step */
int oldrunning = g->gcrunning; lu_byte oldrunning = g->gcrunning;
g->gcrunning = 1; /* allow GC to run */ g->gcrunning = 1; /* allow GC to run */
if (data == 0) { if (data == 0) {
luaE_setdebt(g, -GCSTEPSIZE); /* to do a "small" step */ luaE_setdebt(g, -GCSTEPSIZE); /* to do a "small" step */

90
3rd/lua/lauxlib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lauxlib.c,v 1.280 2015/02/03 17:38:24 roberto Exp $ ** $Id: lauxlib.c,v 1.284 2015/11/19 19:16:22 roberto Exp $
** Auxiliary functions for building Lua libraries ** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -33,8 +33,8 @@
*/ */
#define LEVELS1 12 /* size of the first part of the stack */ #define LEVELS1 10 /* size of the first part of the stack */
#define LEVELS2 10 /* size of the second part of the stack */ #define LEVELS2 11 /* size of the second part of the stack */
@@ -107,7 +107,7 @@ static void pushfuncname (lua_State *L, lua_Debug *ar) {
} }
static int countlevels (lua_State *L) { static int lastlevel (lua_State *L) {
lua_Debug ar; lua_Debug ar;
int li = 1, le = 1; int li = 1, le = 1;
/* find an upper bound */ /* find an upper bound */
@@ -126,14 +126,16 @@ LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
const char *msg, int level) { const char *msg, int level) {
lua_Debug ar; lua_Debug ar;
int top = lua_gettop(L); int top = lua_gettop(L);
int numlevels = countlevels(L1); int last = lastlevel(L1);
int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0; int n1 = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1;
if (msg) lua_pushfstring(L, "%s\n", msg); if (msg)
lua_pushfstring(L, "%s\n", msg);
luaL_checkstack(L, 10, NULL);
lua_pushliteral(L, "stack traceback:"); lua_pushliteral(L, "stack traceback:");
while (lua_getstack(L1, level++, &ar)) { while (lua_getstack(L1, level++, &ar)) {
if (level == mark) { /* too many levels? */ if (n1-- == 0) { /* too many levels? */
lua_pushliteral(L, "\n\t..."); /* add a '...' */ lua_pushliteral(L, "\n\t..."); /* add a '...' */
level = numlevels - LEVELS2; /* and skip to last ones */ level = last - LEVELS2 + 1; /* and skip to last ones */
} }
else { else {
lua_getinfo(L1, "Slnt", &ar); lua_getinfo(L1, "Slnt", &ar);
@@ -289,7 +291,7 @@ LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */
return 0; /* leave previous value on top, but return 0 */ return 0; /* leave previous value on top, but return 0 */
lua_pop(L, 1); lua_pop(L, 1);
lua_newtable(L); /* create metatable */ lua_createtable(L, 0, 2); /* create metatable */
lua_pushstring(L, tname); lua_pushstring(L, tname);
lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ lua_setfield(L, -2, "__name"); /* metatable.__name = tname */
lua_pushvalue(L, -1); lua_pushvalue(L, -1);
@@ -435,6 +437,47 @@ LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
** ======================================================= ** =======================================================
*/ */
/* userdata to box arbitrary data */
typedef struct UBox {
void *box;
size_t bsize;
} UBox;
static void *resizebox (lua_State *L, int idx, size_t newsize) {
void *ud;
lua_Alloc allocf = lua_getallocf(L, &ud);
UBox *box = (UBox *)lua_touserdata(L, idx);
void *temp = allocf(ud, box->box, box->bsize, newsize);
if (temp == NULL && newsize > 0) { /* allocation error? */
resizebox(L, idx, 0); /* free buffer */
luaL_error(L, "not enough memory for buffer allocation");
}
box->box = temp;
box->bsize = newsize;
return temp;
}
static int boxgc (lua_State *L) {
resizebox(L, 1, 0);
return 0;
}
static void *newbox (lua_State *L, size_t newsize) {
UBox *box = (UBox *)lua_newuserdata(L, sizeof(UBox));
box->box = NULL;
box->bsize = 0;
if (luaL_newmetatable(L, "LUABOX")) { /* creating metatable? */
lua_pushcfunction(L, boxgc);
lua_setfield(L, -2, "__gc"); /* metatable.__gc = boxgc */
}
lua_setmetatable(L, -2);
return resizebox(L, -1, newsize);
}
/* /*
** check whether buffer is using a userdata on the stack as a temporary ** check whether buffer is using a userdata on the stack as a temporary
** buffer ** buffer
@@ -455,11 +498,12 @@ LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
if (newsize < B->n || newsize - B->n < sz) if (newsize < B->n || newsize - B->n < sz)
luaL_error(L, "buffer too large"); luaL_error(L, "buffer too large");
/* create larger buffer */ /* create larger buffer */
newbuff = (char *)lua_newuserdata(L, newsize * sizeof(char));
/* move content to new buffer */
memcpy(newbuff, B->b, B->n * sizeof(char));
if (buffonstack(B)) if (buffonstack(B))
lua_remove(L, -2); /* remove old buffer */ newbuff = (char *)resizebox(L, -1, newsize);
else { /* no buffer yet */
newbuff = (char *)newbox(L, newsize);
memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */
}
B->b = newbuff; B->b = newbuff;
B->size = newsize; B->size = newsize;
} }
@@ -468,9 +512,11 @@ LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
char *b = luaL_prepbuffsize(B, l); if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */
memcpy(b, s, l * sizeof(char)); char *b = luaL_prepbuffsize(B, l);
luaL_addsize(B, l); memcpy(b, s, l * sizeof(char));
luaL_addsize(B, l);
}
} }
@@ -482,8 +528,10 @@ LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
LUALIB_API void luaL_pushresult (luaL_Buffer *B) { LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
lua_State *L = B->L; lua_State *L = B->L;
lua_pushlstring(L, B->b, B->n); lua_pushlstring(L, B->b, B->n);
if (buffonstack(B)) if (buffonstack(B)) {
lua_remove(L, -2); /* remove old buffer */ resizebox(L, -2, 0); /* delete old buffer */
lua_remove(L, -2); /* remove its header from the stack */
}
} }
@@ -605,7 +653,7 @@ static int errfile (lua_State *L, const char *what, int fnameindex) {
static int skipBOM (LoadF *lf) { static int skipBOM (LoadF *lf) {
const char *p = "\xEF\xBB\xBF"; /* Utf8 BOM mark */ const char *p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
int c; int c;
lf->n = 0; lf->n = 0;
do { do {
@@ -1138,4 +1186,4 @@ LUAMOD_API int luaopen_cache(lua_State *L) {
lua_getglobal(L, "loadfile"); lua_getglobal(L, "loadfile");
lua_setfield(L, -2, "loadfile"); lua_setfield(L, -2, "loadfile");
return 1; return 1;
} }

4
3rd/lua/lauxlib.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lauxlib.h,v 1.128 2014/10/29 16:11:17 roberto Exp $ ** $Id: lauxlib.h,v 1.129 2015/11/23 11:29:43 roberto Exp $
** Auxiliary functions for building Lua libraries ** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -65,7 +65,7 @@ LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
LUALIB_API int (luaL_execresult) (lua_State *L, int stat); LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
/* pre-defined references */ /* predefined references */
#define LUA_NOREF (-2) #define LUA_NOREF (-2)
#define LUA_REFNIL (-1) #define LUA_REFNIL (-1)

41
3rd/lua/lbaselib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lbaselib.c,v 1.310 2015/03/28 19:14:47 roberto Exp $ ** $Id: lbaselib.c,v 1.312 2015/10/29 15:21:04 roberto Exp $
** Basic library ** Basic library
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -86,8 +86,8 @@ static int luaB_tonumber (lua_State *L) {
const char *s; const char *s;
lua_Integer n = 0; /* to avoid warnings */ lua_Integer n = 0; /* to avoid warnings */
lua_Integer base = luaL_checkinteger(L, 2); lua_Integer base = luaL_checkinteger(L, 2);
luaL_checktype(L, 1, LUA_TSTRING); /* before 'luaL_checklstring'! */ luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */
s = luaL_checklstring(L, 1, &l); s = lua_tolstring(L, 1, &l);
luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range"); luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
if (b_str2int(s, (int)base, &n) == s + l) { if (b_str2int(s, (int)base, &n) == s + l) {
lua_pushinteger(L, n); lua_pushinteger(L, n);
@@ -198,12 +198,10 @@ static int luaB_collectgarbage (lua_State *L) {
} }
/*
** This function has all type names as upvalues, to maximize performance.
*/
static int luaB_type (lua_State *L) { static int luaB_type (lua_State *L) {
luaL_checkany(L, 1); int t = lua_type(L, 1);
lua_pushvalue(L, lua_upvalueindex(lua_type(L, 1) + 1)); luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
lua_pushstring(L, lua_typename(L, t));
return 1; return 1;
} }
@@ -243,18 +241,7 @@ static int luaB_pairs (lua_State *L) {
/* /*
** Traversal function for 'ipairs' for raw tables ** Traversal function for 'ipairs'
*/
static int ipairsaux_raw (lua_State *L) {
lua_Integer i = luaL_checkinteger(L, 2) + 1;
luaL_checktype(L, 1, LUA_TTABLE);
lua_pushinteger(L, i);
return (lua_rawgeti(L, 1, i) == LUA_TNIL) ? 1 : 2;
}
/*
** Traversal function for 'ipairs' for tables with metamethods
*/ */
static int ipairsaux (lua_State *L) { static int ipairsaux (lua_State *L) {
lua_Integer i = luaL_checkinteger(L, 2) + 1; lua_Integer i = luaL_checkinteger(L, 2) + 1;
@@ -269,13 +256,11 @@ static int ipairsaux (lua_State *L) {
** that can affect the traversal. ** that can affect the traversal.
*/ */
static int luaB_ipairs (lua_State *L) { static int luaB_ipairs (lua_State *L) {
lua_CFunction iter = (luaL_getmetafield(L, 1, "__index") != LUA_TNIL)
? ipairsaux : ipairsaux_raw;
#if defined(LUA_COMPAT_IPAIRS) #if defined(LUA_COMPAT_IPAIRS)
return pairsmeta(L, "__ipairs", 1, iter); return pairsmeta(L, "__ipairs", 1, ipairsaux);
#else #else
luaL_checkany(L, 1); luaL_checkany(L, 1);
lua_pushcfunction(L, iter); /* iteration function */ lua_pushcfunction(L, ipairsaux); /* iteration function */
lua_pushvalue(L, 1); /* state */ lua_pushvalue(L, 1); /* state */
lua_pushinteger(L, 0); /* initial value */ lua_pushinteger(L, 0); /* initial value */
return 3; return 3;
@@ -490,9 +475,9 @@ static const luaL_Reg base_funcs[] = {
{"setmetatable", luaB_setmetatable}, {"setmetatable", luaB_setmetatable},
{"tonumber", luaB_tonumber}, {"tonumber", luaB_tonumber},
{"tostring", luaB_tostring}, {"tostring", luaB_tostring},
{"type", luaB_type},
{"xpcall", luaB_xpcall}, {"xpcall", luaB_xpcall},
/* placeholders */ /* placeholders */
{"type", NULL},
{"_G", NULL}, {"_G", NULL},
{"_VERSION", NULL}, {"_VERSION", NULL},
{NULL, NULL} {NULL, NULL}
@@ -500,7 +485,6 @@ static const luaL_Reg base_funcs[] = {
LUAMOD_API int luaopen_base (lua_State *L) { LUAMOD_API int luaopen_base (lua_State *L) {
int i;
/* open lib into global table */ /* open lib into global table */
lua_pushglobaltable(L); lua_pushglobaltable(L);
luaL_setfuncs(L, base_funcs, 0); luaL_setfuncs(L, base_funcs, 0);
@@ -510,11 +494,6 @@ LUAMOD_API int luaopen_base (lua_State *L) {
/* set global _VERSION */ /* set global _VERSION */
lua_pushliteral(L, LUA_VERSION); lua_pushliteral(L, LUA_VERSION);
lua_setfield(L, -2, "_VERSION"); lua_setfield(L, -2, "_VERSION");
/* set function 'type' with proper upvalues */
for (i = 0; i < LUA_NUMTAGS; i++) /* push all type names as upvalues */
lua_pushstring(L, lua_typename(L, i));
lua_pushcclosure(L, luaB_type, LUA_NUMTAGS);
lua_setfield(L, -2, "type");
return 1; return 1;
} }

51
3rd/lua/lbitlib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lbitlib.c,v 1.28 2014/11/02 19:19:04 roberto Exp $ ** $Id: lbitlib.c,v 1.30 2015/11/11 19:08:09 roberto Exp $
** Standard library for bitwise operations ** Standard library for bitwise operations
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -19,6 +19,10 @@
#if defined(LUA_COMPAT_BITLIB) /* { */ #if defined(LUA_COMPAT_BITLIB) /* { */
#define pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
#define checkunsigned(L,i) ((lua_Unsigned)luaL_checkinteger(L,i))
/* number of bits to consider in a number */ /* number of bits to consider in a number */
#if !defined(LUA_NBITS) #if !defined(LUA_NBITS)
#define LUA_NBITS 32 #define LUA_NBITS 32
@@ -46,14 +50,14 @@ static lua_Unsigned andaux (lua_State *L) {
int i, n = lua_gettop(L); int i, n = lua_gettop(L);
lua_Unsigned r = ~(lua_Unsigned)0; lua_Unsigned r = ~(lua_Unsigned)0;
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
r &= luaL_checkunsigned(L, i); r &= checkunsigned(L, i);
return trim(r); return trim(r);
} }
static int b_and (lua_State *L) { static int b_and (lua_State *L) {
lua_Unsigned r = andaux(L); lua_Unsigned r = andaux(L);
lua_pushunsigned(L, r); pushunsigned(L, r);
return 1; return 1;
} }
@@ -69,8 +73,8 @@ static int b_or (lua_State *L) {
int i, n = lua_gettop(L); int i, n = lua_gettop(L);
lua_Unsigned r = 0; lua_Unsigned r = 0;
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
r |= luaL_checkunsigned(L, i); r |= checkunsigned(L, i);
lua_pushunsigned(L, trim(r)); pushunsigned(L, trim(r));
return 1; return 1;
} }
@@ -79,15 +83,15 @@ static int b_xor (lua_State *L) {
int i, n = lua_gettop(L); int i, n = lua_gettop(L);
lua_Unsigned r = 0; lua_Unsigned r = 0;
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
r ^= luaL_checkunsigned(L, i); r ^= checkunsigned(L, i);
lua_pushunsigned(L, trim(r)); pushunsigned(L, trim(r));
return 1; return 1;
} }
static int b_not (lua_State *L) { static int b_not (lua_State *L) {
lua_Unsigned r = ~luaL_checkunsigned(L, 1); lua_Unsigned r = ~checkunsigned(L, 1);
lua_pushunsigned(L, trim(r)); pushunsigned(L, trim(r));
return 1; return 1;
} }
@@ -104,23 +108,23 @@ static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
else r <<= i; else r <<= i;
r = trim(r); r = trim(r);
} }
lua_pushunsigned(L, r); pushunsigned(L, r);
return 1; return 1;
} }
static int b_lshift (lua_State *L) { static int b_lshift (lua_State *L) {
return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkinteger(L, 2)); return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2));
} }
static int b_rshift (lua_State *L) { static int b_rshift (lua_State *L) {
return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkinteger(L, 2)); return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2));
} }
static int b_arshift (lua_State *L) { static int b_arshift (lua_State *L) {
lua_Unsigned r = luaL_checkunsigned(L, 1); lua_Unsigned r = checkunsigned(L, 1);
lua_Integer i = luaL_checkinteger(L, 2); lua_Integer i = luaL_checkinteger(L, 2);
if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1)))) if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
return b_shift(L, r, -i); return b_shift(L, r, -i);
@@ -128,19 +132,19 @@ static int b_arshift (lua_State *L) {
if (i >= LUA_NBITS) r = ALLONES; if (i >= LUA_NBITS) r = ALLONES;
else else
r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */ r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i)); /* add signal bit */
lua_pushunsigned(L, r); pushunsigned(L, r);
return 1; return 1;
} }
} }
static int b_rot (lua_State *L, lua_Integer d) { static int b_rot (lua_State *L, lua_Integer d) {
lua_Unsigned r = luaL_checkunsigned(L, 1); lua_Unsigned r = checkunsigned(L, 1);
int i = d & (LUA_NBITS - 1); /* i = d % NBITS */ int i = d & (LUA_NBITS - 1); /* i = d % NBITS */
r = trim(r); r = trim(r);
if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */ if (i != 0) /* avoid undefined shift of LUA_NBITS when i == 0 */
r = (r << i) | (r >> (LUA_NBITS - i)); r = (r << i) | (r >> (LUA_NBITS - i));
lua_pushunsigned(L, trim(r)); pushunsigned(L, trim(r));
return 1; return 1;
} }
@@ -175,23 +179,22 @@ static int fieldargs (lua_State *L, int farg, int *width) {
static int b_extract (lua_State *L) { static int b_extract (lua_State *L) {
int w; int w;
lua_Unsigned r = trim(luaL_checkunsigned(L, 1)); lua_Unsigned r = trim(checkunsigned(L, 1));
int f = fieldargs(L, 2, &w); int f = fieldargs(L, 2, &w);
r = (r >> f) & mask(w); r = (r >> f) & mask(w);
lua_pushunsigned(L, r); pushunsigned(L, r);
return 1; return 1;
} }
static int b_replace (lua_State *L) { static int b_replace (lua_State *L) {
int w; int w;
lua_Unsigned r = trim(luaL_checkunsigned(L, 1)); lua_Unsigned r = trim(checkunsigned(L, 1));
lua_Unsigned v = luaL_checkunsigned(L, 2); lua_Unsigned v = trim(checkunsigned(L, 2));
int f = fieldargs(L, 3, &w); int f = fieldargs(L, 3, &w);
int m = mask(w); lua_Unsigned m = mask(w);
v &= m; /* erase bits outside given width */ r = (r & ~(m << f)) | ((v & m) << f);
r = (r & ~(m << f)) | (v << f); pushunsigned(L, r);
lua_pushunsigned(L, r);
return 1; return 1;
} }

6
3rd/lua/lcode.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lcode.c,v 2.101 2015/04/29 18:24:11 roberto Exp $ ** $Id: lcode.c,v 2.103 2015/11/19 19:16:22 roberto Exp $
** Code generator for Lua ** Code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -37,7 +37,7 @@
static int tonumeral(expdesc *e, TValue *v) { static int tonumeral(expdesc *e, TValue *v) {
if (e->t != NO_JUMP || e->f != NO_JUMP) if (hasjumps(e))
return 0; /* not a numeral */ return 0; /* not a numeral */
switch (e->k) { switch (e->k) {
case VKINT: case VKINT:
@@ -816,7 +816,7 @@ static void codeexpval (FuncState *fs, OpCode op,
freeexp(fs, e1); freeexp(fs, e1);
} }
e1->u.info = luaK_codeABC(fs, op, 0, o1, o2); /* generate opcode */ e1->u.info = luaK_codeABC(fs, op, 0, o1, o2); /* generate opcode */
e1->k = VRELOCABLE; /* all those operations are relocable */ e1->k = VRELOCABLE; /* all those operations are relocatable */
luaK_fixline(fs, line); luaK_fixline(fs, line);
} }
} }

6
3rd/lua/ldblib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldblib.c,v 1.149 2015/02/19 17:06:21 roberto Exp $ ** $Id: ldblib.c,v 1.151 2015/11/23 11:29:43 roberto Exp $
** Interface from Lua to its debug API ** Interface from Lua to its debug API
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -28,8 +28,8 @@ static const int HOOKKEY = 0;
/* /*
** If L1 != L, L1 can be in any state, and therefore there is no ** If L1 != L, L1 can be in any state, and therefore there are no
** garanties about its stack space; any push in L1 must be ** guarantees about its stack space; any push in L1 must be
** checked. ** checked.
*/ */
static void checkstack (lua_State *L, lua_State *L1, int n) { static void checkstack (lua_State *L, lua_State *L1, int n) {

8
3rd/lua/ldebug.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldebug.c,v 2.115 2015/05/22 17:45:56 roberto Exp $ ** $Id: ldebug.c,v 2.117 2015/11/02 18:48:07 roberto Exp $
** Debug Interface ** Debug Interface
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -618,7 +618,7 @@ l_noret luaG_errormsg (lua_State *L) {
setobjs2s(L, L->top, L->top - 1); /* move argument */ setobjs2s(L, L->top, L->top - 1); /* move argument */
setobjs2s(L, L->top - 1, errfunc); /* push function */ setobjs2s(L, L->top - 1, errfunc); /* push function */
L->top++; /* assume EXTRA_STACK */ L->top++; /* assume EXTRA_STACK */
luaD_call(L, L->top - 2, 1, 0); /* call it */ luaD_callnoyield(L, L->top - 2, 1); /* call it */
} }
luaD_throw(L, LUA_ERRRUN); luaD_throw(L, LUA_ERRRUN);
} }
@@ -640,9 +640,11 @@ l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
void luaG_traceexec (lua_State *L) { void luaG_traceexec (lua_State *L) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
lu_byte mask = L->hookmask; lu_byte mask = L->hookmask;
int counthook = ((mask & LUA_MASKCOUNT) && L->hookcount == 0); int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
if (counthook) if (counthook)
resethookcount(L); /* reset count */ resethookcount(L); /* reset count */
else if (!(mask & LUA_MASKLINE))
return; /* no line hook and count != 0; nothing to be done */
if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */
ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */
return; /* do not call hook again (VM yielded, so it did not move) */ return; /* do not call hook again (VM yielded, so it did not move) */

194
3rd/lua/ldo.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldo.c,v 2.138 2015/05/22 17:48:19 roberto Exp $ ** $Id: ldo.c,v 2.150 2015/11/19 19:16:22 roberto Exp $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -150,6 +150,11 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
/* }====================================================== */ /* }====================================================== */
/*
** {==================================================================
** Stack reallocation
** ===================================================================
*/
static void correctstack (lua_State *L, TValue *oldstack) { static void correctstack (lua_State *L, TValue *oldstack) {
CallInfo *ci; CallInfo *ci;
UpVal *up; UpVal *up;
@@ -221,14 +226,22 @@ void luaD_shrinkstack (lua_State *L) {
luaE_freeCI(L); /* free all CIs (list grew because of an error) */ luaE_freeCI(L); /* free all CIs (list grew because of an error) */
else else
luaE_shrinkCI(L); /* shrink list */ luaE_shrinkCI(L); /* shrink list */
if (inuse > LUAI_MAXSTACK || /* still handling stack overflow? */ if (inuse <= LUAI_MAXSTACK && /* not handling stack overflow? */
goodsize >= L->stacksize) /* would grow instead of shrink? */ goodsize < L->stacksize) /* trying to shrink? */
condmovestack(L); /* don't change stack (change only for debugging) */
else
luaD_reallocstack(L, goodsize); /* shrink it */ luaD_reallocstack(L, goodsize); /* shrink it */
else
condmovestack(L,,); /* don't change stack (change only for debugging) */
} }
void luaD_inctop (lua_State *L) {
luaD_checkstack(L, 1);
L->top++;
}
/* }================================================================== */
void luaD_hook (lua_State *L, int event, int line) { void luaD_hook (lua_State *L, int event, int line) {
lua_Hook hook = L->hook; lua_Hook hook = L->hook;
if (hook && L->allowhook) { if (hook && L->allowhook) {
@@ -273,15 +286,15 @@ static StkId adjust_varargs (lua_State *L, SharedProto *p, int actual) {
int i; int i;
int nfixargs = p->numparams; int nfixargs = p->numparams;
StkId base, fixed; StkId base, fixed;
lua_assert(actual >= nfixargs);
/* move fixed parameters to final position */ /* move fixed parameters to final position */
luaD_checkstack(L, p->maxstacksize); /* check again for new 'base' */
fixed = L->top - actual; /* first fixed argument */ fixed = L->top - actual; /* first fixed argument */
base = L->top; /* final position of first argument */ base = L->top; /* final position of first argument */
for (i=0; i<nfixargs; i++) { for (i = 0; i < nfixargs && i < actual; i++) {
setobjs2s(L, L->top++, fixed + i); setobjs2s(L, L->top++, fixed + i);
setnilvalue(fixed + i); setnilvalue(fixed + i); /* erase original copy (for GC) */
} }
for (; i < nfixargs; i++)
setnilvalue(L->top++); /* complete missing arguments */
return base; return base;
} }
@@ -308,26 +321,36 @@ static void tryfuncTM (lua_State *L, StkId func) {
#define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L))) #define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
/* macro to check stack size, preserving 'p' */
#define checkstackp(L,n,p) \
luaD_checkstackaux(L, n, \
ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \
luaC_checkGC(L), /* stack grow uses memory */ \
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
/* /*
** returns true if function has been executed (C function) ** Prepares a function call: checks the stack, creates a new CallInfo
** entry, fills in the relevant information, calls hook if needed.
** If function is a C function, does the call, too. (Otherwise, leave
** the execution ('luaV_execute') to the caller, to allow stackless
** calls.) Returns true iff function has been executed (C function).
*/ */
int luaD_precall (lua_State *L, StkId func, int nresults) { int luaD_precall (lua_State *L, StkId func, int nresults) {
lua_CFunction f; lua_CFunction f;
CallInfo *ci; CallInfo *ci;
int n; /* number of arguments (Lua) or returns (C) */
ptrdiff_t funcr = savestack(L, func);
switch (ttype(func)) { switch (ttype(func)) {
case LUA_TCCL: /* C closure */
f = clCvalue(func)->f;
goto Cfunc;
case LUA_TLCF: /* light C function */ case LUA_TLCF: /* light C function */
f = fvalue(func); f = fvalue(func);
goto Cfunc; Cfunc: {
case LUA_TCCL: { /* C closure */ int n; /* number of returns */
f = clCvalue(func)->f; checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
Cfunc:
luaC_checkGC(L); /* stack grow uses memory */
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
ci = next_ci(L); /* now 'enter' new function */ ci = next_ci(L); /* now 'enter' new function */
ci->nresults = nresults; ci->nresults = nresults;
ci->func = restorestack(L, funcr); ci->func = func;
ci->top = L->top + LUA_MINSTACK; ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last); lua_assert(ci->top <= L->stack_last);
ci->callstatus = 0; ci->callstatus = 0;
@@ -337,41 +360,36 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
n = (*f)(L); /* do the actual call */ n = (*f)(L); /* do the actual call */
lua_lock(L); lua_lock(L);
api_checknelems(L, n); api_checknelems(L, n);
luaD_poscall(L, L->top - n, n); luaD_poscall(L, ci, L->top - n, n);
return 1; return 1;
} }
case LUA_TLCL: { /* Lua function: prepare its call */ case LUA_TLCL: { /* Lua function: prepare its call */
StkId base; StkId base;
SharedProto *p = clLvalue(func)->p->sp; SharedProto *p = clLvalue(func)->p->sp;
n = cast_int(L->top - func) - 1; /* number of real arguments */ int n = cast_int(L->top - func) - 1; /* number of real arguments */
luaC_checkGC(L); /* stack grow uses memory */ int fsize = p->maxstacksize; /* frame size */
luaD_checkstack(L, p->maxstacksize); checkstackp(L, fsize, func);
for (; n < p->numparams; n++) if (p->is_vararg != 1) { /* do not use vararg? */
setnilvalue(L->top++); /* complete missing arguments */ for (; n < p->numparams; n++)
if (!p->is_vararg) { setnilvalue(L->top++); /* complete missing arguments */
func = restorestack(L, funcr);
base = func + 1; base = func + 1;
} }
else { else
base = adjust_varargs(L, p, n); base = adjust_varargs(L, p, n);
func = restorestack(L, funcr); /* previous call can change stack */
}
ci = next_ci(L); /* now 'enter' new function */ ci = next_ci(L); /* now 'enter' new function */
ci->nresults = nresults; ci->nresults = nresults;
ci->func = func; ci->func = func;
ci->u.l.base = base; ci->u.l.base = base;
ci->top = base + p->maxstacksize; L->top = ci->top = base + fsize;
lua_assert(ci->top <= L->stack_last); lua_assert(ci->top <= L->stack_last);
ci->u.l.savedpc = p->code; /* starting point */ ci->u.l.savedpc = p->code; /* starting point */
ci->callstatus = CIST_LUA; ci->callstatus = CIST_LUA;
L->top = ci->top;
if (L->hookmask & LUA_MASKCALL) if (L->hookmask & LUA_MASKCALL)
callhook(L, ci); callhook(L, ci);
return 0; return 0;
} }
default: { /* not a function */ default: { /* not a function */
luaD_checkstack(L, 1); /* ensure space for metamethod */ checkstackp(L, 1, func); /* ensure space for metamethod */
func = restorestack(L, funcr); /* previous call may change stack */
tryfuncTM(L, func); /* try to get '__call' metamethod */ tryfuncTM(L, func); /* try to get '__call' metamethod */
return luaD_precall(L, func, nresults); /* now it must be a function */ return luaD_precall(L, func, nresults); /* now it must be a function */
} }
@@ -379,10 +397,57 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
} }
int luaD_poscall (lua_State *L, StkId firstResult, int nres) { /*
** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
** Handle most typical cases (zero results for commands, one result for
** expressions, multiple results for tail calls/single parameters)
** separated.
*/
static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
int nres, int wanted) {
switch (wanted) { /* handle typical cases separately */
case 0: break; /* nothing to move */
case 1: { /* one result needed */
if (nres == 0) /* no results? */
firstResult = luaO_nilobject; /* adjust with nil */
setobjs2s(L, res, firstResult); /* move it to proper place */
break;
}
case LUA_MULTRET: {
int i;
for (i = 0; i < nres; i++) /* move all results to correct place */
setobjs2s(L, res + i, firstResult + i);
L->top = res + nres;
return 0; /* wanted == LUA_MULTRET */
}
default: {
int i;
if (wanted <= nres) { /* enough results? */
for (i = 0; i < wanted; i++) /* move wanted results to correct place */
setobjs2s(L, res + i, firstResult + i);
}
else { /* not enough results; use all of them plus nils */
for (i = 0; i < nres; i++) /* move all results to correct place */
setobjs2s(L, res + i, firstResult + i);
for (; i < wanted; i++) /* complete wanted number of results */
setnilvalue(res + i);
}
break;
}
}
L->top = res + wanted; /* top points after the last result */
return 1;
}
/*
** Finishes a function call: calls hook if necessary, removes CallInfo,
** moves current number of results to proper place; returns 0 iff call
** wanted multiple (variable number of) results.
*/
int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
StkId res; StkId res;
int wanted, i; int wanted = ci->nresults;
CallInfo *ci = L->ci;
if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) { if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
if (L->hookmask & LUA_MASKRET) { if (L->hookmask & LUA_MASKRET) {
ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */ ptrdiff_t fr = savestack(L, firstResult); /* hook may change stack */
@@ -392,15 +457,24 @@ int luaD_poscall (lua_State *L, StkId firstResult, int nres) {
L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */ L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for caller function */
} }
res = ci->func; /* res == final position of 1st result */ res = ci->func; /* res == final position of 1st result */
wanted = ci->nresults;
L->ci = ci->previous; /* back to caller */ L->ci = ci->previous; /* back to caller */
/* move results to correct place */ /* move results to proper place */
for (i = wanted; i != 0 && nres-- > 0; i--) return moveresults(L, firstResult, res, nres, wanted);
setobjs2s(L, res++, firstResult++); }
while (i-- > 0)
setnilvalue(res++);
L->top = res; /*
return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */ ** Check appropriate error for stack overflow ("regular" overflow or
** overflow while handling stack overflow). If 'nCalls' is larger than
** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
** allow overflow handling to work)
*/
static void stackerror (lua_State *L) {
if (L->nCcalls == LUAI_MAXCCALLS)
luaG_runerror(L, "C stack overflow");
else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
} }
@@ -410,21 +484,25 @@ int luaD_poscall (lua_State *L, StkId firstResult, int nres) {
** When returns, all the results are on the stack, starting at the original ** When returns, all the results are on the stack, starting at the original
** function position. ** function position.
*/ */
void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) { void luaD_call (lua_State *L, StkId func, int nResults) {
if (++L->nCcalls >= LUAI_MAXCCALLS) { if (++L->nCcalls >= LUAI_MAXCCALLS)
if (L->nCcalls == LUAI_MAXCCALLS) stackerror(L);
luaG_runerror(L, "C stack overflow");
else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
}
if (!allowyield) L->nny++;
if (!luaD_precall(L, func, nResults)) /* is a Lua function? */ if (!luaD_precall(L, func, nResults)) /* is a Lua function? */
luaV_execute(L); /* call it */ luaV_execute(L); /* call it */
if (!allowyield) L->nny--;
L->nCcalls--; L->nCcalls--;
} }
/*
** Similar to 'luaD_call', but does not allow yields during the call
*/
void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
L->nny++;
luaD_call(L, func, nResults);
L->nny--;
}
/* /*
** Completes the execution of an interrupted C function, calling its ** Completes the execution of an interrupted C function, calling its
** continuation function. ** continuation function.
@@ -449,7 +527,7 @@ static void finishCcall (lua_State *L, int status) {
lua_lock(L); lua_lock(L);
api_checknelems(L, n); api_checknelems(L, n);
/* finish 'luaD_precall' */ /* finish 'luaD_precall' */
luaD_poscall(L, L->top - n, n); luaD_poscall(L, ci, L->top - n, n);
} }
@@ -560,7 +638,7 @@ static void resume (lua_State *L, void *ud) {
api_checknelems(L, n); api_checknelems(L, n);
firstArg = L->top - n; /* yield results come from continuation */ firstArg = L->top - n; /* yield results come from continuation */
} }
luaD_poscall(L, firstArg, n); /* finish 'luaD_precall' */ luaD_poscall(L, ci, firstArg, n); /* finish 'luaD_precall' */
} }
unroll(L, NULL); /* run continuation */ unroll(L, NULL); /* run continuation */
} }
@@ -570,7 +648,7 @@ static void resume (lua_State *L, void *ud) {
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) { LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
int status; int status;
int oldnny = L->nny; /* save "number of non-yieldable" calls */ unsigned short oldnny = L->nny; /* save "number of non-yieldable" calls */
lua_lock(L); lua_lock(L);
luai_userstateresume(L, nargs); luai_userstateresume(L, nargs);
L->nCcalls = (from) ? from->nCcalls + 1 : 1; L->nCcalls = (from) ? from->nCcalls + 1 : 1;
@@ -684,7 +762,7 @@ static void f_parser (lua_State *L, void *ud) {
int c = zgetc(p->z); /* read first character */ int c = zgetc(p->z); /* read first character */
if (c == LUA_SIGNATURE[0]) { if (c == LUA_SIGNATURE[0]) {
checkmode(L, p->mode, "binary"); checkmode(L, p->mode, "binary");
cl = luaU_undump(L, p->z, &p->buff, p->name); cl = luaU_undump(L, p->z, p->name);
} }
else { else {
checkmode(L, p->mode, "text"); checkmode(L, p->mode, "text");

26
3rd/lua/ldo.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldo.h,v 2.22 2015/05/22 17:48:19 roberto Exp $ ** $Id: ldo.h,v 2.28 2015/11/23 11:29:43 roberto Exp $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -13,11 +13,21 @@
#include "lzio.h" #include "lzio.h"
#define luaD_checkstack(L,n) if (L->stack_last - L->top <= (n)) \ /*
luaD_growstack(L, n); else condmovestack(L); ** Macro to check stack size and grow stack if needed. Parameters
** 'pre'/'pos' allow the macro to preserve a pointer into the
** stack across reallocations, doing the work only when needed.
** 'condmovestack' is used in heavy tests to force a stack reallocation
** at every check.
*/
#define luaD_checkstackaux(L,n,pre,pos) \
if (L->stack_last - L->top <= (n)) \
{ pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); }
/* In general, 'pre'/'pos' are empty (nothing to save) */
#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,,)
#define incr_top(L) {L->top++; luaD_checkstack(L,0);}
#define savestack(L,p) ((char *)(p) - (char *)L->stack) #define savestack(L,p) ((char *)(p) - (char *)L->stack)
#define restorestack(L,n) ((TValue *)((char *)L->stack + (n))) #define restorestack(L,n) ((TValue *)((char *)L->stack + (n)))
@@ -30,14 +40,16 @@ LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
const char *mode); const char *mode);
LUAI_FUNC void luaD_hook (lua_State *L, int event, int line); LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults); LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults, LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
int allowyield); LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
ptrdiff_t oldtop, ptrdiff_t ef); ptrdiff_t oldtop, ptrdiff_t ef);
LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult, int nres); LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult,
int nres);
LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize); LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
LUAI_FUNC void luaD_growstack (lua_State *L, int n); LUAI_FUNC void luaD_growstack (lua_State *L, int n);
LUAI_FUNC void luaD_shrinkstack (lua_State *L); LUAI_FUNC void luaD_shrinkstack (lua_State *L);
LUAI_FUNC void luaD_inctop (lua_State *L);
LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode); LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);

4
3rd/lua/ldump.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldump.c,v 2.36 2015/03/30 15:43:51 roberto Exp $ ** $Id: ldump.c,v 2.37 2015/10/08 15:53:49 roberto Exp $
** save precompiled Lua chunks ** save precompiled Lua chunks
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -38,7 +38,7 @@ typedef struct {
static void DumpBlock (const void *b, size_t size, DumpState *D) { static void DumpBlock (const void *b, size_t size, DumpState *D) {
if (D->status == 0) { if (D->status == 0 && size > 0) {
lua_unlock(D->L); lua_unlock(D->L);
D->status = (*D->writer)(D->L, b, size, D->data); D->status = (*D->writer)(D->L, b, size, D->data);
lua_lock(D->L); lua_lock(D->L);

28
3rd/lua/lgc.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lgc.c,v 2.205 2015/03/25 13:42:19 roberto Exp $ ** $Id: lgc.c,v 2.210 2015/11/03 18:10:44 roberto Exp $
** Garbage Collector ** Garbage Collector
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -114,8 +114,13 @@ static void reallymarkobject (global_State *g, GCObject *o);
/* /*
** if key is not marked, mark its entry as dead (therefore removing it ** If key is not marked, mark its entry as dead. This allows key to be
** from the table) ** collected, but keeps its entry in the table. A dead node is needed
** when Lua looks up for a key (it may be part of a chain) and when
** traversing a weak table (key might be removed from the table during
** traversal). Other places never manipulate dead keys, because its
** associated nil value is enough to signal that the entry is logically
** empty.
*/ */
static void removeentry (Node *n) { static void removeentry (Node *n) {
lua_assert(ttisnil(gval(n))); lua_assert(ttisnil(gval(n)));
@@ -549,7 +554,8 @@ static lu_mem traversethread (global_State *g, lua_State *th) {
} }
else if (g->gckind != KGC_EMERGENCY) else if (g->gckind != KGC_EMERGENCY)
luaD_shrinkstack(th); /* do not change stack in emergency cycle */ luaD_shrinkstack(th); /* do not change stack in emergency cycle */
return (sizeof(lua_State) + sizeof(TValue) * th->stacksize); return (sizeof(lua_State) + sizeof(TValue) * th->stacksize +
sizeof(CallInfo) * th->nci);
} }
@@ -776,12 +782,11 @@ static GCObject **sweeptolive (lua_State *L, GCObject **p, int *n) {
*/ */
/* /*
** If possible, free concatenation buffer and shrink string table ** If possible, shrink string table
*/ */
static void checkSizes (lua_State *L, global_State *g) { static void checkSizes (lua_State *L, global_State *g) {
if (g->gckind != KGC_EMERGENCY) { if (g->gckind != KGC_EMERGENCY) {
l_mem olddebt = g->GCdebt; l_mem olddebt = g->GCdebt;
luaZ_freebuffer(L, &g->buff); /* free concatenation buffer */
if (g->strt.nuse < g->strt.size / 4) /* string table too big? */ if (g->strt.nuse < g->strt.size / 4) /* string table too big? */
luaS_resize(L, g->strt.size / 2); /* shrink it a little */ luaS_resize(L, g->strt.size / 2); /* shrink it a little */
g->GCestimate += g->GCdebt - olddebt; /* update estimate */ g->GCestimate += g->GCdebt - olddebt; /* update estimate */
@@ -804,7 +809,7 @@ static GCObject *udata2finalize (global_State *g) {
static void dothecall (lua_State *L, void *ud) { static void dothecall (lua_State *L, void *ud) {
UNUSED(ud); UNUSED(ud);
luaD_call(L, L->top - 2, 0, 0); luaD_callnoyield(L, L->top - 2, 0);
} }
@@ -1121,9 +1126,12 @@ void luaC_runtilstate (lua_State *L, int statesmask) {
static l_mem getdebt (global_State *g) { static l_mem getdebt (global_State *g) {
l_mem debt = g->GCdebt; l_mem debt = g->GCdebt;
int stepmul = g->gcstepmul; int stepmul = g->gcstepmul;
debt = (debt / STEPMULADJ) + 1; if (debt <= 0) return 0; /* minimal debt */
debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM; else {
return debt; debt = (debt / STEPMULADJ) + 1;
debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
return debt;
}
} }
/* /*

41
3rd/lua/lgc.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lgc.h,v 2.86 2014/10/25 11:50:46 roberto Exp $ ** $Id: lgc.h,v 2.90 2015/10/21 18:15:15 roberto Exp $
** Garbage Collector ** Garbage Collector
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -101,26 +101,35 @@
#define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS) #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
#define luaC_condGC(L,c) \ /*
{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);} ** Does one step of collection when debt becomes positive. 'pre'/'pos'
#define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);) ** allows some adjustments to be done only when needed. macro
** 'condchangemem' is used only for heavy tests (forcing a full
** GC cycle on every opportunity)
*/
#define luaC_condGC(L,pre,pos) \
{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
condchangemem(L,pre,pos); }
/* more often than not, 'pre'/'pos' are empty */
#define luaC_checkGC(L) luaC_condGC(L,,)
#define luaC_barrier(L,p,v) { \ #define luaC_barrier(L,p,v) ( \
if (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) \ (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
luaC_barrier_(L,obj2gco(p),gcvalue(v)); } luaC_barrier_(L,obj2gco(p),gcvalue(v)) : cast_void(0))
#define luaC_barrierback(L,p,v) { \ #define luaC_barrierback(L,p,v) ( \
if (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) \ (iscollectable(v) && isblack(p) && iswhite(gcvalue(v))) ? \
luaC_barrierback_(L,p); } luaC_barrierback_(L,p) : cast_void(0))
#define luaC_objbarrier(L,p,o) { \ #define luaC_objbarrier(L,p,o) ( \
if (isblack(p) && iswhite(o)) \ (isblack(p) && iswhite(o)) ? \
luaC_barrier_(L,obj2gco(p),obj2gco(o)); } luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
#define luaC_upvalbarrier(L,uv) \ #define luaC_upvalbarrier(L,uv) ( \
{ if (iscollectable((uv)->v) && !upisopen(uv)) \ (iscollectable((uv)->v) && !upisopen(uv)) ? \
luaC_upvalbarrier_(L,uv); } luaC_upvalbarrier_(L,uv) : cast_void(0))
LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o); LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
LUAI_FUNC void luaC_freeallobjects (lua_State *L); LUAI_FUNC void luaC_freeallobjects (lua_State *L);

31
3rd/lua/liolib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: liolib.c,v 2.144 2015/04/03 18:41:57 roberto Exp $ ** $Id: liolib.c,v 2.148 2015/11/23 11:36:11 roberto Exp $
** Standard I/O (and system) library ** Standard I/O (and system) library
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -23,18 +23,24 @@
#include "lualib.h" #include "lualib.h"
#if !defined(l_checkmode)
/* /*
** Check whether 'mode' matches '[rwa]%+?b?'.
** Change this macro to accept other modes for 'fopen' besides ** Change this macro to accept other modes for 'fopen' besides
** the standard ones. ** the standard ones.
*/ */
#if !defined(l_checkmode)
/* accepted extensions to 'mode' in 'fopen' */
#if !defined(L_MODEEXT)
#define L_MODEEXT "b"
#endif
/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */
#define l_checkmode(mode) \ #define l_checkmode(mode) \
(*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \ (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && \
(*mode != '+' || ++mode) && /* skip if char is '+' */ \ (*mode != '+' || (++mode, 1)) && /* skip if char is '+' */ \
(*mode != 'b' || ++mode) && /* skip if char is 'b' */ \ (strspn(mode, L_MODEEXT) == strlen(mode)))
(*mode == '\0'))
#endif #endif
@@ -176,7 +182,7 @@ static FILE *tofile (lua_State *L) {
/* /*
** When creating file handles, always creates a 'closed' file handle ** When creating file handles, always creates a 'closed' file handle
** before opening the actual file; so, if there is a memory error, the ** before opening the actual file; so, if there is a memory error, the
** file is not left opened. ** handle is in a consistent state.
*/ */
static LStream *newprefile (lua_State *L) { static LStream *newprefile (lua_State *L) {
LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream)); LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
@@ -318,8 +324,15 @@ static int io_output (lua_State *L) {
static int io_readline (lua_State *L); static int io_readline (lua_State *L);
/*
** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
** in the limit for upvalues of a closure)
*/
#define MAXARGLINE 250
static void aux_lines (lua_State *L, int toclose) { static void aux_lines (lua_State *L, int toclose) {
int n = lua_gettop(L) - 1; /* number of arguments to read */ int n = lua_gettop(L) - 1; /* number of arguments to read */
luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
lua_pushinteger(L, n); /* number of arguments to read */ lua_pushinteger(L, n); /* number of arguments to read */
lua_pushboolean(L, toclose); /* close/not close file when finished */ lua_pushboolean(L, toclose); /* close/not close file when finished */
lua_rotate(L, 2, 2); /* move 'n' and 'toclose' to their positions */ lua_rotate(L, 2, 2); /* move 'n' and 'toclose' to their positions */
@@ -462,7 +475,7 @@ static int read_line (lua_State *L, FILE *f, int chop) {
int c = '\0'; int c = '\0';
luaL_buffinit(L, &b); luaL_buffinit(L, &b);
while (c != EOF && c != '\n') { /* repeat until end of line */ while (c != EOF && c != '\n') { /* repeat until end of line */
char *buff = luaL_prepbuffer(&b); /* pre-allocate buffer */ char *buff = luaL_prepbuffer(&b); /* preallocate buffer */
int i = 0; int i = 0;
l_lockfile(f); /* no memory errors can happen inside the lock */ l_lockfile(f); /* no memory errors can happen inside the lock */
while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n') while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
@@ -483,7 +496,7 @@ static void read_all (lua_State *L, FILE *f) {
luaL_Buffer b; luaL_Buffer b;
luaL_buffinit(L, &b); luaL_buffinit(L, &b);
do { /* read file in chunks of LUAL_BUFFERSIZE bytes */ do { /* read file in chunks of LUAL_BUFFERSIZE bytes */
char *p = luaL_prepbuffsize(&b, LUAL_BUFFERSIZE); char *p = luaL_prepbuffer(&b);
nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f); nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
luaL_addsize(&b, nr); luaL_addsize(&b, nr);
} while (nr == LUAL_BUFFERSIZE); } while (nr == LUAL_BUFFERSIZE);

10
3rd/lua/llex.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: llex.c,v 2.93 2015/05/22 17:45:56 roberto Exp $ ** $Id: llex.c,v 2.95 2015/11/19 19:16:22 roberto Exp $
** Lexical Analyzer ** Lexical Analyzer
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -220,8 +220,6 @@ static void buffreplace (LexState *ls, char from, char to) {
} }
#define buff2num(b,o) (luaO_str2num(luaZ_buffer(b), o) != 0)
/* /*
** in case of format error, try to change decimal point separator to ** in case of format error, try to change decimal point separator to
** the one defined in the current locale and check again ** the one defined in the current locale and check again
@@ -230,7 +228,7 @@ static void trydecpoint (LexState *ls, TValue *o) {
char old = ls->decpoint; char old = ls->decpoint;
ls->decpoint = lua_getlocaledecpoint(); ls->decpoint = lua_getlocaledecpoint();
buffreplace(ls, old, ls->decpoint); /* try new decimal separator */ buffreplace(ls, old, ls->decpoint); /* try new decimal separator */
if (!buff2num(ls->buff, o)) { if (luaO_str2num(luaZ_buffer(ls->buff), o) == 0) {
/* format error with correct decimal point: no more options */ /* format error with correct decimal point: no more options */
buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */ buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */
lexerror(ls, "malformed number", TK_FLT); lexerror(ls, "malformed number", TK_FLT);
@@ -262,7 +260,7 @@ static int read_numeral (LexState *ls, SemInfo *seminfo) {
} }
save(ls, '\0'); save(ls, '\0');
buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */ buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
if (!buff2num(ls->buff, &obj)) /* format error? */ if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */
trydecpoint(ls, &obj); /* try to update decimal point separator */ trydecpoint(ls, &obj); /* try to update decimal point separator */
if (ttisinteger(&obj)) { if (ttisinteger(&obj)) {
seminfo->i = ivalue(&obj); seminfo->i = ivalue(&obj);
@@ -277,7 +275,7 @@ static int read_numeral (LexState *ls, SemInfo *seminfo) {
/* /*
** skip a sequence '[=*[' or ']=*]'; if sequence is wellformed, return ** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return
** its number of '='s; otherwise, return a negative number (-1 iff there ** its number of '='s; otherwise, return a negative number (-1 iff there
** are no '='s after initial bracket) ** are no '='s after initial bracket)
*/ */

34
3rd/lua/llimits.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: llimits.h,v 1.135 2015/06/09 14:21:00 roberto Exp $ ** $Id: llimits.h,v 1.141 2015/11/19 19:16:22 roberto Exp $
** Limits, basic types, and some other 'installation-dependent' definitions ** Limits, basic types, and some other 'installation-dependent' definitions
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -64,7 +64,13 @@ typedef unsigned char lu_byte;
#if defined(LUAI_USER_ALIGNMENT_T) #if defined(LUAI_USER_ALIGNMENT_T)
typedef LUAI_USER_ALIGNMENT_T L_Umaxalign; typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
#else #else
typedef union { double u; void *s; lua_Integer i; long l; } L_Umaxalign; typedef union {
lua_Number n;
double u;
void *s;
lua_Integer i;
long l;
} L_Umaxalign;
#endif #endif
@@ -78,7 +84,7 @@ typedef LUAI_UACINT l_uacInt;
#if defined(lua_assert) #if defined(lua_assert)
#define check_exp(c,e) (lua_assert(c), (e)) #define check_exp(c,e) (lua_assert(c), (e))
/* to avoid problems with conditions too long */ /* to avoid problems with conditions too long */
#define lua_longassert(c) { if (!(c)) lua_assert(0); } #define lua_longassert(c) ((c) ? (void)0 : lua_assert(0))
#else #else
#define lua_assert(c) ((void)0) #define lua_assert(c) ((void)0)
#define check_exp(c,e) (e) #define check_exp(c,e) (e)
@@ -184,10 +190,13 @@ typedef unsigned long Instruction;
/* /*
** Size of cache for strings in the API (better be a prime) ** Size of cache for strings in the API. 'N' is the number of
** sets (better be a prime) and "M" is the size of each set (M == 1
** makes a direct cache.)
*/ */
#if !defined(STRCACHE_SIZE) #if !defined(STRCACHE_N)
#define STRCACHE_SIZE 127 #define STRCACHE_N 53
#define STRCACHE_M 2
#endif #endif
@@ -198,7 +207,7 @@ typedef unsigned long Instruction;
/* /*
** macros that are executed whenether program enters the Lua core ** macros that are executed whenever program enters the Lua core
** ('lua_lock') and leaves the core ('lua_unlock') ** ('lua_lock') and leaves the core ('lua_unlock')
*/ */
#if !defined(lua_lock) #if !defined(lua_lock)
@@ -297,17 +306,18 @@ typedef unsigned long Instruction;
** macro to control inclusion of some hard tests on stack reallocation ** macro to control inclusion of some hard tests on stack reallocation
*/ */
#if !defined(HARDSTACKTESTS) #if !defined(HARDSTACKTESTS)
#define condmovestack(L) ((void)0) #define condmovestack(L,pre,pos) ((void)0)
#else #else
/* realloc stack keeping its size */ /* realloc stack keeping its size */
#define condmovestack(L) luaD_reallocstack((L), (L)->stacksize) #define condmovestack(L,pre,pos) \
{ int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_); pos; }
#endif #endif
#if !defined(HARDMEMTESTS) #if !defined(HARDMEMTESTS)
#define condchangemem(L) condmovestack(L) #define condchangemem(L,pre,pos) ((void)0)
#else #else
#define condchangemem(L) \ #define condchangemem(L,pre,pos) \
((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1))) { if (G(L)->gcrunning) { pre; luaC_fullgc(L, 0); pos; } }
#endif #endif
#endif #endif

6
3rd/lua/lmathlib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lmathlib.c,v 1.115 2015/03/12 14:04:04 roberto Exp $ ** $Id: lmathlib.c,v 1.117 2015/10/02 15:39:23 roberto Exp $
** Standard mathematical library ** Standard mathematical library
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -39,7 +39,7 @@
static int math_abs (lua_State *L) { static int math_abs (lua_State *L) {
if (lua_isinteger(L, 1)) { if (lua_isinteger(L, 1)) {
lua_Integer n = lua_tointeger(L, 1); lua_Integer n = lua_tointeger(L, 1);
if (n < 0) n = (lua_Integer)(0u - n); if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
lua_pushinteger(L, n); lua_pushinteger(L, n);
} }
else else
@@ -273,7 +273,7 @@ static int math_random (lua_State *L) {
static int math_randomseed (lua_State *L) { static int math_randomseed (lua_State *L) {
l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1)); l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
(void)rand(); /* discard first value to avoid undesirable correlations */ (void)l_rand(); /* discard first value to avoid undesirable correlations */
return 0; return 0;
} }

4
3rd/lua/loadlib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: loadlib.c,v 1.126 2015/02/16 13:14:33 roberto Exp $ ** $Id: loadlib.c,v 1.127 2015/11/23 11:30:45 roberto Exp $
** Dynamic library loader for Lua ** Dynamic library loader for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
** **
@@ -732,7 +732,7 @@ static void createsearcherstable (lua_State *L) {
int i; int i;
/* create 'searchers' table */ /* create 'searchers' table */
lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0); lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
/* fill it with pre-defined searchers */ /* fill it with predefined searchers */
for (i=0; searchers[i] != NULL; i++) { for (i=0; searchers[i] != NULL; i++) {
lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */ lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */
lua_pushcclosure(L, searchers[i], 1); lua_pushcclosure(L, searchers[i], 1);

30
3rd/lua/lobject.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lobject.c,v 2.104 2015/04/11 18:30:08 roberto Exp $ ** $Id: lobject.c,v 2.108 2015/11/02 16:09:30 roberto Exp $
** Some generic functions over Lua objects ** Some generic functions over Lua objects
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -55,9 +55,7 @@ int luaO_int2fb (unsigned int x) {
/* converts back */ /* converts back */
int luaO_fb2int (int x) { int luaO_fb2int (int x) {
int e = (x >> 3) & 0x1f; return (x < 8) ? x : ((x & 7) + 8) << ((x >> 3) - 1);
if (e == 0) return x;
else return ((x & 7) + 8) << (e - 1);
} }
@@ -333,9 +331,9 @@ void luaO_tostring (lua_State *L, StkId obj) {
size_t len; size_t len;
lua_assert(ttisnumber(obj)); lua_assert(ttisnumber(obj));
if (ttisinteger(obj)) if (ttisinteger(obj))
len = lua_integer2str(buff, ivalue(obj)); len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
else { else {
len = lua_number2str(buff, fltvalue(obj)); len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
#if !defined(LUA_COMPAT_FLOATSTRING) #if !defined(LUA_COMPAT_FLOATSTRING)
if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */
buff[len++] = lua_getlocaledecpoint(); buff[len++] = lua_getlocaledecpoint();
@@ -348,7 +346,8 @@ void luaO_tostring (lua_State *L, StkId obj) {
static void pushstr (lua_State *L, const char *str, size_t l) { static void pushstr (lua_State *L, const char *str, size_t l) {
setsvalue2s(L, L->top++, luaS_newlstr(L, str, l)); setsvalue2s(L, L->top, luaS_newlstr(L, str, l));
luaD_inctop(L);
} }
@@ -359,7 +358,6 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
for (;;) { for (;;) {
const char *e = strchr(fmt, '%'); const char *e = strchr(fmt, '%');
if (e == NULL) break; if (e == NULL) break;
luaD_checkstack(L, 2); /* fmt + item */
pushstr(L, fmt, e - fmt); pushstr(L, fmt, e - fmt);
switch (*(e+1)) { switch (*(e+1)) {
case 's': { case 's': {
@@ -377,23 +375,23 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
break; break;
} }
case 'd': { case 'd': {
setivalue(L->top++, va_arg(argp, int)); setivalue(L->top, va_arg(argp, int));
luaO_tostring(L, L->top - 1); goto top2str;
break;
} }
case 'I': { case 'I': {
setivalue(L->top++, cast(lua_Integer, va_arg(argp, l_uacInt))); setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt)));
luaO_tostring(L, L->top - 1); goto top2str;
break;
} }
case 'f': { case 'f': {
setfltvalue(L->top++, cast_num(va_arg(argp, l_uacNumber))); setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
top2str:
luaD_inctop(L);
luaO_tostring(L, L->top - 1); luaO_tostring(L, L->top - 1);
break; break;
} }
case 'p': { case 'p': {
char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */ char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
int l = sprintf(buff, "%p", va_arg(argp, void *)); int l = l_sprintf(buff, sizeof(buff), "%p", va_arg(argp, void *));
pushstr(L, buff, l); pushstr(L, buff, l);
break; break;
} }

86
3rd/lua/lobject.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lobject.h,v 2.111 2015/06/09 14:21:42 roberto Exp $ ** $Id: lobject.h,v 2.116 2015/11/03 18:33:10 roberto Exp $
** Type definitions for Lua objects ** Type definitions for Lua objects
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -19,8 +19,8 @@
/* /*
** Extra tags for non-values ** Extra tags for non-values
*/ */
#define LUA_TPROTO LUA_NUMTAGS #define LUA_TPROTO LUA_NUMTAGS /* function prototypes */
#define LUA_TDEADKEY (LUA_NUMTAGS+1) #define LUA_TDEADKEY (LUA_NUMTAGS+1) /* removed keys in tables */
/* /*
** number of all possible tags (including LUA_TNONE but excluding DEADKEY) ** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
@@ -88,22 +88,32 @@ struct GCObject {
/*
** Union of all Lua values
*/
typedef union Value Value;
/* /*
** Tagged Values. This is the basic representation of values in Lua, ** Tagged Values. This is the basic representation of values in Lua,
** an actual value plus a tag with its type. ** an actual value plus a tag with its type.
*/ */
/*
** Union of all Lua values
*/
typedef union Value {
GCObject *gc; /* collectable objects */
void *p; /* light userdata */
int b; /* booleans */
lua_CFunction f; /* light C functions */
lua_Integer i; /* integer numbers */
lua_Number n; /* float numbers */
} Value;
#define TValuefields Value value_; int tt_ #define TValuefields Value value_; int tt_
typedef struct lua_TValue TValue;
typedef struct lua_TValue {
TValuefields;
} TValue;
/* macro defining a nil value */ /* macro defining a nil value */
@@ -177,9 +187,9 @@ typedef struct lua_TValue TValue;
/* Macros for internal tests */ /* Macros for internal tests */
#define righttt(obj) (ttype(obj) == gcvalue(obj)->tt) #define righttt(obj) (ttype(obj) == gcvalue(obj)->tt)
#define checkliveness(g,obj) \ #define checkliveness(L,obj) \
lua_longassert(!iscollectable(obj) || \ lua_longassert(!iscollectable(obj) || \
(righttt(obj) && !isdead(g,gcvalue(obj)))) (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))
/* Macros to set values */ /* Macros to set values */
@@ -215,32 +225,32 @@ typedef struct lua_TValue TValue;
#define setsvalue(L,obj,x) \ #define setsvalue(L,obj,x) \
{ TValue *io = (obj); TString *x_ = (x); \ { TValue *io = (obj); TString *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define setuvalue(L,obj,x) \ #define setuvalue(L,obj,x) \
{ TValue *io = (obj); Udata *x_ = (x); \ { TValue *io = (obj); Udata *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define setthvalue(L,obj,x) \ #define setthvalue(L,obj,x) \
{ TValue *io = (obj); lua_State *x_ = (x); \ { TValue *io = (obj); lua_State *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define setclLvalue(L,obj,x) \ #define setclLvalue(L,obj,x) \
{ TValue *io = (obj); LClosure *x_ = (x); \ { TValue *io = (obj); LClosure *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define setclCvalue(L,obj,x) \ #define setclCvalue(L,obj,x) \
{ TValue *io = (obj); CClosure *x_ = (x); \ { TValue *io = (obj); CClosure *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define sethvalue(L,obj,x) \ #define sethvalue(L,obj,x) \
{ TValue *io = (obj); Table *x_ = (x); \ { TValue *io = (obj); Table *x_ = (x); \
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \ val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY) #define setdeadvalue(obj) settt_(obj, LUA_TDEADKEY)
@@ -248,7 +258,7 @@ typedef struct lua_TValue TValue;
#define setobj(L,obj1,obj2) \ #define setobj(L,obj1,obj2) \
{ TValue *io1=(obj1); *io1 = *(obj2); \ { TValue *io1=(obj1); *io1 = *(obj2); \
(void)L; checkliveness(G(L),io1); } (void)L; checkliveness(L,io1); }
/* /*
@@ -264,12 +274,13 @@ typedef struct lua_TValue TValue;
#define setptvalue2s setptvalue #define setptvalue2s setptvalue
/* from table to same table */ /* from table to same table */
#define setobjt2t setobj #define setobjt2t setobj
/* to table */
#define setobj2t setobj
/* to new object */ /* to new object */
#define setobj2n setobj #define setobj2n setobj
#define setsvalue2n setsvalue #define setsvalue2n setsvalue
/* to table (define it as an expression to be used in macros) */
#define setobj2t(L,o1,o2) ((void)L, *(o1)=*(o2), checkliveness(L,(o1)))
@@ -280,21 +291,6 @@ typedef struct lua_TValue TValue;
*/ */
union Value {
GCObject *gc; /* collectable objects */
void *p; /* light userdata */
int b; /* booleans */
lua_CFunction f; /* light C functions */
lua_Integer i; /* integer numbers */
lua_Number n; /* float numbers */
};
struct lua_TValue {
TValuefields;
};
typedef TValue *StkId; /* index to stack elements */ typedef TValue *StkId; /* index to stack elements */
@@ -329,9 +325,9 @@ typedef union UTString {
** Get the actual string (array of bytes) from a 'TString'. ** Get the actual string (array of bytes) from a 'TString'.
** (Access to 'extra' ensures that value is really a 'TString'.) ** (Access to 'extra' ensures that value is really a 'TString'.)
*/ */
#define getaddrstr(ts) (cast(char *, (ts)) + sizeof(UTString))
#define getstr(ts) \ #define getstr(ts) \
check_exp(sizeof((ts)->extra), cast(const char*, getaddrstr(ts))) check_exp(sizeof((ts)->extra), cast(char *, (ts)) + sizeof(UTString))
/* get the actual string (array of bytes) from a Lua value */ /* get the actual string (array of bytes) from a Lua value */
#define svalue(o) getstr(tsvalue(o)) #define svalue(o) getstr(tsvalue(o))
@@ -375,13 +371,13 @@ typedef union UUdata {
#define setuservalue(L,u,o) \ #define setuservalue(L,u,o) \
{ const TValue *io=(o); Udata *iu = (u); \ { const TValue *io=(o); Udata *iu = (u); \
iu->user_ = io->value_; iu->ttuv_ = rttype(io); \ iu->user_ = io->value_; iu->ttuv_ = rttype(io); \
checkliveness(G(L),io); } checkliveness(L,io); }
#define getuservalue(L,u,o) \ #define getuservalue(L,u,o) \
{ TValue *io=(o); const Udata *iu = (u); \ { TValue *io=(o); const Udata *iu = (u); \
io->value_ = iu->user_; settt_(io, iu->ttuv_); \ io->value_ = iu->user_; settt_(io, iu->ttuv_); \
checkliveness(G(L),io); } checkliveness(L,io); }
/* /*
@@ -406,7 +402,7 @@ typedef struct LocVar {
typedef struct SharedProto { typedef struct SharedProto {
lu_byte numparams; /* number of fixed parameters */ lu_byte numparams; /* number of fixed parameters */
lu_byte is_vararg; lu_byte is_vararg; /* 2: declared vararg; 1: uses vararg */
lu_byte maxstacksize; /* number of registers needed by this function */ lu_byte maxstacksize; /* number of registers needed by this function */
int sizeupvalues; /* size of 'upvalues' */ int sizeupvalues; /* size of 'upvalues' */
int sizek; /* size of 'k' */ int sizek; /* size of 'k' */
@@ -414,8 +410,8 @@ typedef struct SharedProto {
int sizelineinfo; int sizelineinfo;
int sizep; /* size of 'p' */ int sizep; /* size of 'p' */
int sizelocvars; int sizelocvars;
int linedefined; int linedefined; /* debug information */
int lastlinedefined; int lastlinedefined; /* debug information */
void *l_G; /* global state belongs to */ void *l_G; /* global state belongs to */
Instruction *code; /* opcodes */ Instruction *code; /* opcodes */
int *lineinfo; /* map from opcodes to source lines (debug information) */ int *lineinfo; /* map from opcodes to source lines (debug information) */
@@ -493,7 +489,7 @@ typedef union TKey {
#define setnodekey(L,key,obj) \ #define setnodekey(L,key,obj) \
{ TKey *k_=(key); const TValue *io_=(obj); \ { TKey *k_=(key); const TValue *io_=(obj); \
k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \ k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \
(void)L; checkliveness(G(L),io_); } (void)L; checkliveness(L,io_); }
typedef struct Node { typedef struct Node {

72
3rd/lua/loslib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: loslib.c,v 1.57 2015/04/10 17:41:04 roberto Exp $ ** $Id: loslib.c,v 1.60 2015/11/19 19:16:22 roberto Exp $
** Standard Operating System library ** Standard Operating System library
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -54,7 +54,12 @@
*/ */
#define l_timet lua_Integer #define l_timet lua_Integer
#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t)) #define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t))
#define l_checktime(L,a) ((time_t)luaL_checkinteger(L,a))
static time_t l_checktime (lua_State *L, int arg) {
lua_Integer t = luaL_checkinteger(L, arg);
luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds");
return (time_t)t;
}
#endif /* } */ #endif /* } */
@@ -198,17 +203,29 @@ static int getboolfield (lua_State *L, const char *key) {
} }
static int getfield (lua_State *L, const char *key, int d) { /* maximum value for date fields (to avoid arithmetic overflows with 'int') */
int res, isnum; #if !defined(L_MAXDATEFIELD)
lua_getfield(L, -1, key); #define L_MAXDATEFIELD (INT_MAX / 2)
res = (int)lua_tointegerx(L, -1, &isnum); #endif
if (!isnum) {
if (d < 0) static int getfield (lua_State *L, const char *key, int d, int delta) {
int isnum;
int t = lua_getfield(L, -1, key);
lua_Integer res = lua_tointegerx(L, -1, &isnum);
if (!isnum) { /* field is not a number? */
if (t != LUA_TNIL) /* some other value? */
return luaL_error(L, "field '%s' not an integer", key);
else if (d < 0) /* absent field; no default? */
return luaL_error(L, "field '%s' missing in date table", key); return luaL_error(L, "field '%s' missing in date table", key);
res = d; res = d;
} }
else {
if (!(-L_MAXDATEFIELD <= res && res <= L_MAXDATEFIELD))
return luaL_error(L, "field '%s' out-of-bounds", key);
res -= delta;
}
lua_pop(L, 1); lua_pop(L, 1);
return res; return (int)res;
} }
@@ -236,6 +253,10 @@ static const char *checkoption (lua_State *L, const char *conv, char *buff) {
} }
/* maximum size for an individual 'strftime' item */
#define SIZETIMEFMT 250
static int os_date (lua_State *L) { static int os_date (lua_State *L) {
const char *s = luaL_optstring(L, 1, "%c"); const char *s = luaL_optstring(L, 1, "%c");
time_t t = luaL_opt(L, l_checktime, 2, time(NULL)); time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
@@ -247,8 +268,8 @@ static int os_date (lua_State *L) {
else else
stm = l_localtime(&t, &tmr); stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */ if (stm == NULL) /* invalid date? */
lua_pushnil(L); luaL_error(L, "time result cannot be represented in this installation");
else if (strcmp(s, "*t") == 0) { if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */ lua_createtable(L, 0, 9); /* 9 = number of fields */
setfield(L, "sec", stm->tm_sec); setfield(L, "sec", stm->tm_sec);
setfield(L, "min", stm->tm_min); setfield(L, "min", stm->tm_min);
@@ -266,14 +287,14 @@ static int os_date (lua_State *L) {
cc[0] = '%'; cc[0] = '%';
luaL_buffinit(L, &b); luaL_buffinit(L, &b);
while (*s) { while (*s) {
if (*s != '%') /* no conversion specifier? */ if (*s != '%') /* not a conversion specifier? */
luaL_addchar(&b, *s++); luaL_addchar(&b, *s++);
else { else {
size_t reslen; size_t reslen;
char buff[200]; /* should be big enough for any conversion result */ char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
s = checkoption(L, s + 1, cc); s = checkoption(L, s + 1, cc);
reslen = strftime(buff, sizeof(buff), cc, stm); reslen = strftime(buff, SIZETIMEFMT, cc, stm);
luaL_addlstring(&b, buff, reslen); luaL_addsize(&b, reslen);
} }
} }
luaL_pushresult(&b); luaL_pushresult(&b);
@@ -290,21 +311,18 @@ static int os_time (lua_State *L) {
struct tm ts; struct tm ts;
luaL_checktype(L, 1, LUA_TTABLE); luaL_checktype(L, 1, LUA_TTABLE);
lua_settop(L, 1); /* make sure table is at the top */ lua_settop(L, 1); /* make sure table is at the top */
ts.tm_sec = getfield(L, "sec", 0); ts.tm_sec = getfield(L, "sec", 0, 0);
ts.tm_min = getfield(L, "min", 0); ts.tm_min = getfield(L, "min", 0, 0);
ts.tm_hour = getfield(L, "hour", 12); ts.tm_hour = getfield(L, "hour", 12, 0);
ts.tm_mday = getfield(L, "day", -1); ts.tm_mday = getfield(L, "day", -1, 0);
ts.tm_mon = getfield(L, "month", -1) - 1; ts.tm_mon = getfield(L, "month", -1, 1);
ts.tm_year = getfield(L, "year", -1) - 1900; ts.tm_year = getfield(L, "year", -1, 1900);
ts.tm_isdst = getboolfield(L, "isdst"); ts.tm_isdst = getboolfield(L, "isdst");
t = mktime(&ts); t = mktime(&ts);
} }
if (t != (time_t)(l_timet)t) if (t != (time_t)(l_timet)t || t == (time_t)(-1))
luaL_error(L, "time result cannot be represented in this Lua installation"); luaL_error(L, "time result cannot be represented in this installation");
else if (t == (time_t)(-1)) l_pushtime(L, t);
lua_pushnil(L);
else
l_pushtime(L, t);
return 1; return 1;
} }

11
3rd/lua/lparser.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lparser.c,v 2.147 2014/12/27 20:31:43 roberto Exp $ ** $Id: lparser.c,v 2.149 2015/11/02 16:09:30 roberto Exp $
** Lua Parser ** Lua Parser
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -763,7 +763,7 @@ static void parlist (LexState *ls) {
} }
case TK_DOTS: { /* param -> '...' */ case TK_DOTS: { /* param -> '...' */
luaX_next(ls); luaX_next(ls);
f->is_vararg = 1; f->is_vararg = 2; /* declared vararg */
break; break;
} }
default: luaX_syntaxerror(ls, "<name> or '...' expected"); default: luaX_syntaxerror(ls, "<name> or '...' expected");
@@ -959,6 +959,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
FuncState *fs = ls->fs; FuncState *fs = ls->fs;
check_condition(ls, fs->f->sp->is_vararg, check_condition(ls, fs->f->sp->is_vararg,
"cannot use '...' outside a vararg function"); "cannot use '...' outside a vararg function");
fs->f->sp->is_vararg = 1; /* function actually uses vararg */
init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0)); init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
break; break;
} }
@@ -1613,7 +1614,7 @@ static void mainfunc (LexState *ls, FuncState *fs) {
BlockCnt bl; BlockCnt bl;
expdesc v; expdesc v;
open_func(ls, fs, &bl); open_func(ls, fs, &bl);
fs->f->sp->is_vararg = 1; /* main function is always vararg */ fs->f->sp->is_vararg = 2; /* main function is always declared vararg */
init_exp(&v, VLOCAL, 0); /* create and... */ init_exp(&v, VLOCAL, 0); /* create and... */
newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */ newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */
luaX_next(ls); /* read first token */ luaX_next(ls); /* read first token */
@@ -1629,10 +1630,10 @@ LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
FuncState funcstate; FuncState funcstate;
LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */
setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */ setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */
incr_top(L); luaD_inctop(L);
lexstate.h = luaH_new(L); /* create table for scanner */ lexstate.h = luaH_new(L); /* create table for scanner */
sethvalue(L, L->top, lexstate.h); /* anchor it */ sethvalue(L, L->top, lexstate.h); /* anchor it */
incr_top(L); luaD_inctop(L);
funcstate.f = cl->p = luaF_newproto(L, NULL); funcstate.f = cl->p = luaF_newproto(L, NULL);
funcstate.f->sp->source = luaS_new(L, name); /* create and anchor TString */ funcstate.f->sp->source = luaS_new(L, name); /* create and anchor TString */
lua_assert(iswhite(funcstate.f)); /* do not need barrier here */ lua_assert(iswhite(funcstate.f)); /* do not need barrier here */

29
3rd/lua/lstate.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lstate.c,v 2.128 2015/03/04 13:31:21 roberto Exp $ ** $Id: lstate.c,v 2.133 2015/11/13 12:16:51 roberto Exp $
** Global State ** Global State
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -76,7 +76,7 @@ typedef struct LG {
*/ */
#define addbuff(b,p,e) \ #define addbuff(b,p,e) \
{ size_t t = cast(size_t, e); \ { size_t t = cast(size_t, e); \
memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); } memcpy(b + p, &t, sizeof(t)); p += sizeof(t); }
static unsigned int makeseed (lua_State *L) { static unsigned int makeseed (lua_State *L) {
char buff[4 * sizeof(size_t)]; char buff[4 * sizeof(size_t)];
@@ -93,10 +93,14 @@ static unsigned int makeseed (lua_State *L) {
/* /*
** set GCdebt to a new value keeping the value (totalbytes + GCdebt) ** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
** invariant ** invariant (and avoiding underflows in 'totalbytes')
*/ */
void luaE_setdebt (global_State *g, l_mem debt) { void luaE_setdebt (global_State *g, l_mem debt) {
g->totalbytes -= (debt - g->GCdebt); l_mem tb = gettotalbytes(g);
lua_assert(tb > 0);
if (debt < tb - MAX_LMEM)
debt = tb - MAX_LMEM; /* will make 'totalbytes == MAX_LMEM' */
g->totalbytes = tb - debt;
g->GCdebt = debt; g->GCdebt = debt;
} }
@@ -107,6 +111,7 @@ CallInfo *luaE_extendCI (lua_State *L) {
L->ci->next = ci; L->ci->next = ci;
ci->previous = L->ci; ci->previous = L->ci;
ci->next = NULL; ci->next = NULL;
L->nci++;
return ci; return ci;
} }
@@ -121,6 +126,7 @@ void luaE_freeCI (lua_State *L) {
while ((ci = next) != NULL) { while ((ci = next) != NULL) {
next = ci->next; next = ci->next;
luaM_free(L, ci); luaM_free(L, ci);
L->nci--;
} }
} }
@@ -130,13 +136,14 @@ void luaE_freeCI (lua_State *L) {
*/ */
void luaE_shrinkCI (lua_State *L) { void luaE_shrinkCI (lua_State *L) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
while (ci->next != NULL) { /* while there is 'next' */ CallInfo *next2; /* next's next */
CallInfo *next2 = ci->next->next; /* next's next */ /* while there are two nexts */
if (next2 == NULL) break; while (ci->next != NULL && (next2 = ci->next->next) != NULL) {
luaM_free(L, ci->next); /* remove next */ luaM_free(L, ci->next); /* free next */
L->nci--;
ci->next = next2; /* remove 'next' from the list */ ci->next = next2; /* remove 'next' from the list */
next2->previous = ci; next2->previous = ci;
ci = next2; ci = next2; /* keep next's next */
} }
} }
@@ -166,6 +173,7 @@ static void freestack (lua_State *L) {
return; /* stack not completely built yet */ return; /* stack not completely built yet */
L->ci = &L->base_ci; /* free the entire 'ci' list */ L->ci = &L->base_ci; /* free the entire 'ci' list */
luaE_freeCI(L); luaE_freeCI(L);
lua_assert(L->nci == 0);
luaM_freearray(L, L->stack, L->stacksize); /* free stack array */ luaM_freearray(L, L->stack, L->stacksize); /* free stack array */
} }
@@ -214,6 +222,7 @@ static void preinit_thread (lua_State *L, global_State *g) {
G(L) = g; G(L) = g;
L->stack = NULL; L->stack = NULL;
L->ci = NULL; L->ci = NULL;
L->nci = 0;
L->stacksize = 0; L->stacksize = 0;
L->twups = L; /* thread has no upvalues */ L->twups = L; /* thread has no upvalues */
L->errorJmp = NULL; L->errorJmp = NULL;
@@ -237,7 +246,6 @@ static void close_state (lua_State *L) {
if (g->version) /* closing a fully built state? */ if (g->version) /* closing a fully built state? */
luai_userstateclose(L); luai_userstateclose(L);
luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
luaZ_freebuffer(L, &g->buff);
freestack(L); freestack(L);
lua_assert(gettotalbytes(g) == sizeof(LG)); lua_assert(gettotalbytes(g) == sizeof(LG));
(*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */
@@ -306,7 +314,6 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
g->strt.size = g->strt.nuse = 0; g->strt.size = g->strt.nuse = 0;
g->strt.hash = NULL; g->strt.hash = NULL;
setnilvalue(&g->l_registry); setnilvalue(&g->l_registry);
luaZ_initbuffer(L, &g->buff);
g->panic = NULL; g->panic = NULL;
g->version = NULL; g->version = NULL;
g->gcstate = GCSpause; g->gcstate = GCSpause;

14
3rd/lua/lstate.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lstate.h,v 2.122 2015/06/01 16:34:37 roberto Exp $ ** $Id: lstate.h,v 2.128 2015/11/13 12:16:51 roberto Exp $
** Global State ** Global State
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -89,8 +89,8 @@ typedef struct CallInfo {
#define CIST_OAH (1<<0) /* original value of 'allowhook' */ #define CIST_OAH (1<<0) /* original value of 'allowhook' */
#define CIST_LUA (1<<1) /* call is running a Lua function */ #define CIST_LUA (1<<1) /* call is running a Lua function */
#define CIST_HOOKED (1<<2) /* call is running a debug hook */ #define CIST_HOOKED (1<<2) /* call is running a debug hook */
#define CIST_REENTRY (1<<3) /* call is running on same invocation of #define CIST_FRESH (1<<3) /* call is running on a fresh invocation
luaV_execute of previous call */ of luaV_execute */
#define CIST_YPCALL (1<<4) /* call is a yieldable protected call */ #define CIST_YPCALL (1<<4) /* call is a yieldable protected call */
#define CIST_TAIL (1<<5) /* call was tail called */ #define CIST_TAIL (1<<5) /* call was tail called */
#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ #define CIST_HOOKYIELD (1<<6) /* last hook called yielded */
@@ -109,7 +109,7 @@ typedef struct CallInfo {
typedef struct global_State { typedef struct global_State {
lua_Alloc frealloc; /* function to reallocate memory */ lua_Alloc frealloc; /* function to reallocate memory */
void *ud; /* auxiliary data to 'frealloc' */ void *ud; /* auxiliary data to 'frealloc' */
lu_mem totalbytes; /* number of bytes currently allocated - GCdebt */ l_mem totalbytes; /* number of bytes currently allocated - GCdebt */
l_mem GCdebt; /* bytes allocated not yet compensated by the collector */ l_mem GCdebt; /* bytes allocated not yet compensated by the collector */
lu_mem GCmemtrav; /* memory traversed by the GC */ lu_mem GCmemtrav; /* memory traversed by the GC */
lu_mem GCestimate; /* an estimate of the non-garbage memory in use */ lu_mem GCestimate; /* an estimate of the non-garbage memory in use */
@@ -131,7 +131,6 @@ typedef struct global_State {
GCObject *tobefnz; /* list of userdata to be GC */ GCObject *tobefnz; /* list of userdata to be GC */
GCObject *fixedgc; /* list of objects not to be collected */ GCObject *fixedgc; /* list of objects not to be collected */
struct lua_State *twups; /* list of threads with open upvalues */ struct lua_State *twups; /* list of threads with open upvalues */
Mbuffer buff; /* temporary buffer for string concatenation */
unsigned int gcfinnum; /* number of finalizers to call in each GC step */ unsigned int gcfinnum; /* number of finalizers to call in each GC step */
int gcpause; /* size of pause between successive GCs */ int gcpause; /* size of pause between successive GCs */
int gcstepmul; /* GC 'granularity' */ int gcstepmul; /* GC 'granularity' */
@@ -141,7 +140,7 @@ typedef struct global_State {
TString *memerrmsg; /* memory-error message */ TString *memerrmsg; /* memory-error message */
TString *tmname[TM_N]; /* array with tag-method names */ TString *tmname[TM_N]; /* array with tag-method names */
struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */ struct Table *mt[LUA_NUMTAGS]; /* metatables for basic types */
TString *strcache[STRCACHE_SIZE][1]; /* cache for strings in API */ TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */
} global_State; } global_State;
@@ -150,6 +149,7 @@ typedef struct global_State {
*/ */
struct lua_State { struct lua_State {
CommonHeader; CommonHeader;
unsigned short nci; /* number of items in 'ci' list */
lu_byte status; lu_byte status;
StkId top; /* first free slot in the stack */ StkId top; /* first free slot in the stack */
global_State *l_G; global_State *l_G;
@@ -212,7 +212,7 @@ union GCUnion {
/* actual number of total bytes allocated */ /* actual number of total bytes allocated */
#define gettotalbytes(g) ((g)->totalbytes + (g)->GCdebt) #define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt)
LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt); LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1); LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);

83
3rd/lua/lstring.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lstring.c,v 2.49 2015/06/01 16:34:37 roberto Exp $ ** $Id: lstring.c,v 2.56 2015/11/23 11:32:51 roberto Exp $
** String table (keeps all strings handled by Lua) ** String table (keeps all strings handled by Lua)
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -48,14 +48,23 @@ int luaS_eqlngstr (TString *a, TString *b) {
unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
unsigned int h = seed ^ cast(unsigned int, l); unsigned int h = seed ^ cast(unsigned int, l);
size_t l1;
size_t step = (l >> LUAI_HASHLIMIT) + 1; size_t step = (l >> LUAI_HASHLIMIT) + 1;
for (l1 = l; l1 >= step; l1 -= step) for (; l >= step; l -= step)
h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1])); h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
return h; return h;
} }
unsigned int luaS_hashlongstr (TString *ts) {
lua_assert(ts->tt == LUA_TLNGSTR);
if (ts->extra == 0) { /* no hash? */
ts->hash = luaS_hash(getstr(ts), ts->u.lnglen, ts->hash);
ts->extra = 1; /* now it has its hash */
}
return ts->hash;
}
/* /*
** resizes the string table ** resizes the string table
*/ */
@@ -92,11 +101,12 @@ void luaS_resize (lua_State *L, int newsize) {
** a non-collectable string.) ** a non-collectable string.)
*/ */
void luaS_clearcache (global_State *g) { void luaS_clearcache (global_State *g) {
int i; int i, j;
for (i = 0; i < STRCACHE_SIZE; i++) { for (i = 0; i < STRCACHE_N; i++)
if (iswhite(g->strcache[i][0])) /* will entry be collected? */ for (j = 0; j < STRCACHE_M; j++) {
g->strcache[i][0] = g->memerrmsg; /* replace it with something fixed */ if (iswhite(g->strcache[i][j])) /* will entry be collected? */
} g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */
}
} }
@@ -105,13 +115,14 @@ void luaS_clearcache (global_State *g) {
*/ */
void luaS_init (lua_State *L) { void luaS_init (lua_State *L) {
global_State *g = G(L); global_State *g = G(L);
int i; int i, j;
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
/* pre-create memory-error message */ /* pre-create memory-error message */
g->memerrmsg = luaS_newliteral(L, MEMERRMSG); g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */
for (i = 0; i < STRCACHE_SIZE; i++) /* fill cache with valid strings */ for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */
g->strcache[i][0] = g->memerrmsg; for (j = 0; j < STRCACHE_M; j++)
g->strcache[i][j] = g->memerrmsg;
} }
@@ -119,8 +130,7 @@ void luaS_init (lua_State *L) {
/* /*
** creates a new string object ** creates a new string object
*/ */
static TString *createstrobj (lua_State *L, const char *str, size_t l, static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
int tag, unsigned int h) {
TString *ts; TString *ts;
GCObject *o; GCObject *o;
size_t totalsize; /* total size of TString object */ size_t totalsize; /* total size of TString object */
@@ -129,8 +139,14 @@ static TString *createstrobj (lua_State *L, const char *str, size_t l,
ts = gco2ts(o); ts = gco2ts(o);
ts->hash = h; ts->hash = h;
ts->extra = 0; ts->extra = 0;
memcpy(getaddrstr(ts), str, l * sizeof(char)); getstr(ts)[l] = '\0'; /* ending 0 */
getaddrstr(ts)[l] = '\0'; /* ending 0 */ return ts;
}
TString *luaS_createlngstrobj (lua_State *L, size_t l) {
TString *ts = createstrobj(L, l, LUA_TLNGSTR, G(L)->seed);
ts->u.lnglen = l;
return ts; return ts;
} }
@@ -152,6 +168,7 @@ static TString *queryshrstr (lua_State *L, const char *str, size_t l, unsigned i
TString *ts; TString *ts;
global_State *g = G(L); global_State *g = G(L);
TString **list = &g->strt.hash[lmod(h, g->strt.size)]; TString **list = &g->strt.hash[lmod(h, g->strt.size)];
lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */
for (ts = *list; ts != NULL; ts = ts->u.hnext) { for (ts = *list; ts != NULL; ts = ts->u.hnext) {
if (l == ts->shrlen && if (l == ts->shrlen &&
(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) { (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
@@ -172,7 +189,8 @@ static TString *addshrstr (lua_State *L, const char *str, size_t l, unsigned int
luaS_resize(L, g->strt.size * 2); luaS_resize(L, g->strt.size * 2);
list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */ list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */
} }
ts = createstrobj(L, str, l, LUA_TSHRSTR, h); ts = createstrobj(L, l, LUA_TSHRSTR, h);
memcpy(getstr(ts), str, l * sizeof(char));
ts->shrlen = cast_byte(l); ts->shrlen = cast_byte(l);
ts->u.hnext = *list; ts->u.hnext = *list;
*list = ts; *list = ts;
@@ -190,10 +208,10 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
return internshrstr(L, str, l); return internshrstr(L, str, l);
else { else {
TString *ts; TString *ts;
if (l + 1 > (MAX_SIZE - sizeof(TString))/sizeof(char)) if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
luaM_toobig(L); luaM_toobig(L);
ts = createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed); ts = luaS_createlngstrobj(L, l);
ts->u.lnglen = l; memcpy(getstr(ts), str, l * sizeof(char));
return ts; return ts;
} }
} }
@@ -206,15 +224,19 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
** check hits. ** check hits.
*/ */
TString *luaS_new (lua_State *L, const char *str) { TString *luaS_new (lua_State *L, const char *str) {
unsigned int i = point2uint(str) % STRCACHE_SIZE; /* hash */ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */
int j;
TString **p = G(L)->strcache[i]; TString **p = G(L)->strcache[i];
if (strcmp(str, getstr(p[0])) == 0) /* hit? */ for (j = 0; j < STRCACHE_M; j++) {
return p[0]; /* that it is */ if (strcmp(str, getstr(p[j])) == 0) /* hit? */
else { /* normal route */ return p[j]; /* that is it */
TString *s = luaS_newlstr(L, str, strlen(str));
p[0] = s;
return s;
} }
/* normal route */
for (j = STRCACHE_M - 1; j > 0; j--)
p[j] = p[j - 1]; /* move out last element */
/* new element is first in the list */
p[0] = luaS_newlstr(L, str, strlen(str));
return p[0];
} }
@@ -241,6 +263,7 @@ Udata *luaS_newudata (lua_State *L, size_t s) {
#define SHRSTR_SLOT 0x10000 #define SHRSTR_SLOT 0x10000
#define HASH_NODE(h) ((h) % SHRSTR_SLOT) #define HASH_NODE(h) ((h) % SHRSTR_SLOT)
#define getaddrstr(ts) (cast(char *, (ts)) + sizeof(UTString))
struct shrmap_slot { struct shrmap_slot {
struct rwlock lock; struct rwlock lock;
@@ -282,7 +305,7 @@ query_string(unsigned int h, const char *str, lu_byte l) {
rwlock_rlock(&s->lock); rwlock_rlock(&s->lock);
TString *ts = s->str; TString *ts = s->str;
while (ts) { while (ts) {
if (ts->hash == h && if (ts->hash == h &&
ts->shrlen == l && ts->shrlen == l &&
memcmp(str, ts+1, l) == 0) { memcmp(str, ts+1, l) == 0) {
break; break;
@@ -327,7 +350,7 @@ add_string(unsigned int h, const char *str, lu_byte l) {
rwlock_wlock(&s->lock); rwlock_wlock(&s->lock);
TString *ts = s->str; TString *ts = s->str;
while (ts) { while (ts) {
if (ts->hash == h && if (ts->hash == h &&
ts->shrlen == l && ts->shrlen == l &&
memcmp(str, ts+1, l) == 0) { memcmp(str, ts+1, l) == 0) {
break; break;
@@ -384,7 +407,7 @@ luaS_clonestring(lua_State *L, TString *ts) {
const char * str = getaddrstr(ts); const char * str = getaddrstr(ts);
global_State *g = G(L); global_State *g = G(L);
TString *result; TString *result;
if (ts->tt == LUA_TLNGSTR) if (ts->tt == LUA_TLNGSTR)
return luaS_newlstr(L, str, ts->u.lnglen); return luaS_newlstr(L, str, ts->u.lnglen);
// look up global state of this L first // look up global state of this L first
l = ts->shrlen; l = ts->shrlen;

4
3rd/lua/lstring.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lstring.h,v 1.59 2015/03/25 13:42:19 roberto Exp $ ** $Id: lstring.h,v 1.61 2015/11/03 15:36:01 roberto Exp $
** String table (keep all strings handled by Lua) ** String table (keep all strings handled by Lua)
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -34,6 +34,7 @@
LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed); LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b); LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
LUAI_FUNC void luaS_resize (lua_State *L, int newsize); LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
LUAI_FUNC void luaS_clearcache (global_State *g); LUAI_FUNC void luaS_clearcache (global_State *g);
@@ -42,6 +43,7 @@ LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s); LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l); LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
LUAI_FUNC TString *luaS_new (lua_State *L, const char *str); LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
#define ENABLE_SHORT_STRING_TABLE #define ENABLE_SHORT_STRING_TABLE

181
3rd/lua/lstrlib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lstrlib.c,v 1.229 2015/05/20 17:39:23 roberto Exp $ ** $Id: lstrlib.c,v 1.239 2015/11/25 16:28:17 roberto Exp $
** Standard library for string operations and pattern-matching ** Standard library for string operations and pattern-matching
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -41,8 +41,10 @@
** Some sizes are better limited to fit in 'int', but must also fit in ** Some sizes are better limited to fit in 'int', but must also fit in
** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.) ** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.)
*/ */
#define MAX_SIZET ((size_t)(~(size_t)0))
#define MAXSIZE \ #define MAXSIZE \
(sizeof(size_t) < sizeof(int) ? (~(size_t)0) : (size_t)(INT_MAX)) (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))
@@ -208,11 +210,12 @@ static int str_dump (lua_State *L) {
typedef struct MatchState { typedef struct MatchState {
int matchdepth; /* control for recursive depth (to avoid C stack overflow) */
const char *src_init; /* init of source string */ const char *src_init; /* init of source string */
const char *src_end; /* end ('\0') of source string */ const char *src_end; /* end ('\0') of source string */
const char *p_end; /* end ('\0') of pattern */ const char *p_end; /* end ('\0') of pattern */
lua_State *L; lua_State *L;
size_t nrep; /* limit to avoid non-linear complexity */
int matchdepth; /* control for recursive depth (to avoid C stack overflow) */
int level; /* total number of captures (finished or unfinished) */ int level; /* total number of captures (finished or unfinished) */
struct { struct {
const char *init; const char *init;
@@ -231,6 +234,17 @@ static const char *match (MatchState *ms, const char *s, const char *p);
#endif #endif
/*
** parameters to control the maximum number of operators handled in
** a match (to avoid non-linear complexity). The maximum will be:
** (subject length) * A_REPS + B_REPS
*/
#if !defined(A_REPS)
#define A_REPS 4
#define B_REPS 100000
#endif
#define L_ESC '%' #define L_ESC '%'
#define SPECIALS "^$*+?.([%-" #define SPECIALS "^$*+?.([%-"
@@ -488,6 +502,8 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
s = NULL; /* fail */ s = NULL; /* fail */
} }
else { /* matched once */ else { /* matched once */
if (ms->nrep-- == 0)
luaL_error(ms->L, "pattern too complex");
switch (*ep) { /* handle optional suffix */ switch (*ep) { /* handle optional suffix */
case '?': { /* optional */ case '?': { /* optional */
const char *res; const char *res;
@@ -584,6 +600,26 @@ static int nospecials (const char *p, size_t l) {
} }
static void prepstate (MatchState *ms, lua_State *L,
const char *s, size_t ls, const char *p, size_t lp) {
ms->L = L;
ms->matchdepth = MAXCCALLS;
ms->src_init = s;
ms->src_end = s + ls;
ms->p_end = p + lp;
if (ls < (MAX_SIZET - B_REPS) / A_REPS)
ms->nrep = A_REPS * ls + B_REPS;
else /* overflow (very long subject) */
ms->nrep = MAX_SIZET; /* no limit */
}
static void reprepstate (MatchState *ms) {
ms->level = 0;
lua_assert(ms->matchdepth == MAXCCALLS);
}
static int str_find_aux (lua_State *L, int find) { static int str_find_aux (lua_State *L, int find) {
size_t ls, lp; size_t ls, lp;
const char *s = luaL_checklstring(L, 1, &ls); const char *s = luaL_checklstring(L, 1, &ls);
@@ -611,15 +647,10 @@ static int str_find_aux (lua_State *L, int find) {
if (anchor) { if (anchor) {
p++; lp--; /* skip anchor character */ p++; lp--; /* skip anchor character */
} }
ms.L = L; prepstate(&ms, L, s, ls, p, lp);
ms.matchdepth = MAXCCALLS;
ms.src_init = s;
ms.src_end = s + ls;
ms.p_end = p + lp;
do { do {
const char *res; const char *res;
ms.level = 0; reprepstate(&ms);
lua_assert(ms.matchdepth == MAXCCALLS);
if ((res=match(&ms, s1, p)) != NULL) { if ((res=match(&ms, s1, p)) != NULL) {
if (find) { if (find) {
lua_pushinteger(L, (s1 - s) + 1); /* start */ lua_pushinteger(L, (s1 - s) + 1); /* start */
@@ -646,29 +677,26 @@ static int str_match (lua_State *L) {
} }
/* state for 'gmatch' */
typedef struct GMatchState {
const char *src; /* current position */
const char *p; /* pattern */
MatchState ms; /* match state */
} GMatchState;
static int gmatch_aux (lua_State *L) { static int gmatch_aux (lua_State *L) {
MatchState ms; GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
size_t ls, lp;
const char *s = lua_tolstring(L, lua_upvalueindex(1), &ls);
const char *p = lua_tolstring(L, lua_upvalueindex(2), &lp);
const char *src; const char *src;
ms.L = L; for (src = gm->src; src <= gm->ms.src_end; src++) {
ms.matchdepth = MAXCCALLS;
ms.src_init = s;
ms.src_end = s+ls;
ms.p_end = p + lp;
for (src = s + (size_t)lua_tointeger(L, lua_upvalueindex(3));
src <= ms.src_end;
src++) {
const char *e; const char *e;
ms.level = 0; reprepstate(&gm->ms);
lua_assert(ms.matchdepth == MAXCCALLS); if ((e = match(&gm->ms, src, gm->p)) != NULL) {
if ((e = match(&ms, src, p)) != NULL) { if (e == src) /* empty match? */
lua_Integer newstart = e-s; gm->src =src + 1; /* go at least one position */
if (e == src) newstart++; /* empty match? go at least one position */ else
lua_pushinteger(L, newstart); gm->src = e;
lua_replace(L, lua_upvalueindex(3)); return push_captures(&gm->ms, src, e);
return push_captures(&ms, src, e);
} }
} }
return 0; /* not found */ return 0; /* not found */
@@ -676,10 +704,14 @@ static int gmatch_aux (lua_State *L) {
static int gmatch (lua_State *L) { static int gmatch (lua_State *L) {
luaL_checkstring(L, 1); size_t ls, lp;
luaL_checkstring(L, 2); const char *s = luaL_checklstring(L, 1, &ls);
lua_settop(L, 2); const char *p = luaL_checklstring(L, 2, &lp);
lua_pushinteger(L, 0); GMatchState *gm;
lua_settop(L, 2); /* keep them on closure to avoid being collected */
gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState));
prepstate(&gm->ms, L, s, ls, p, lp);
gm->src = s; gm->p = p;
lua_pushcclosure(L, gmatch_aux, 3); lua_pushcclosure(L, gmatch_aux, 3);
return 1; return 1;
} }
@@ -761,17 +793,11 @@ static int str_gsub (lua_State *L) {
if (anchor) { if (anchor) {
p++; lp--; /* skip anchor character */ p++; lp--; /* skip anchor character */
} }
ms.L = L; prepstate(&ms, L, src, srcl, p, lp);
ms.matchdepth = MAXCCALLS;
ms.src_init = src;
ms.src_end = src+srcl;
ms.p_end = p + lp;
while (n < max_s) { while (n < max_s) {
const char *e; const char *e;
ms.level = 0; reprepstate(&ms);
lua_assert(ms.matchdepth == MAXCCALLS); if ((e = match(&ms, src, p)) != NULL) {
e = match(&ms, src, p);
if (e) {
n++; n++;
add_value(&ms, &b, src, e, tr); add_value(&ms, &b, src, e, tr);
} }
@@ -830,13 +856,12 @@ static lua_Number adddigit (char *buff, int n, lua_Number x) {
} }
static int num2straux (char *buff, lua_Number x) { static int num2straux (char *buff, int sz, lua_Number x) {
if (x != x || x == HUGE_VAL || x == -HUGE_VAL) /* inf or NaN? */ if (x != x || x == HUGE_VAL || x == -HUGE_VAL) /* inf or NaN? */
return sprintf(buff, LUA_NUMBER_FMT, x); /* equal to '%g' */ return l_sprintf(buff, sz, LUA_NUMBER_FMT, x); /* equal to '%g' */
else if (x == 0) { /* can be -0... */ else if (x == 0) { /* can be -0... */
sprintf(buff, LUA_NUMBER_FMT, x); /* create "0" or "-0" followed by exponent */
strcat(buff, "x0p+0"); /* reuses '0/-0' from 'sprintf'... */ return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", x);
return strlen(buff);
} }
else { else {
int e; int e;
@@ -855,15 +880,16 @@ static int num2straux (char *buff, lua_Number x) {
m = adddigit(buff, n++, m * 16); m = adddigit(buff, n++, m * 16);
} while (m > 0); } while (m > 0);
} }
n += sprintf(buff + n, "p%+d", e); /* add exponent */ n += l_sprintf(buff + n, sz - n, "p%+d", e); /* add exponent */
lua_assert(n < sz);
return n; return n;
} }
} }
static int lua_number2strx (lua_State *L, char *buff, const char *fmt, static int lua_number2strx (lua_State *L, char *buff, int sz,
lua_Number x) { const char *fmt, lua_Number x) {
int n = num2straux(buff, x); int n = num2straux(buff, sz, x);
if (fmt[SIZELENMOD] == 'A') { if (fmt[SIZELENMOD] == 'A') {
int i; int i;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
@@ -879,10 +905,12 @@ static int lua_number2strx (lua_State *L, char *buff, const char *fmt,
/* /*
** Maximum size of each formatted item. This maximum size is produced ** Maximum size of each formatted item. This maximum size is produced
** by format('%.99f', minfloat), and is equal to 99 + 2 ('-' and '.') + ** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.',
** number of decimal digits to represent minfloat. ** and '\0') + number of decimal digits to represent maxfloat (which
** is maximum exponent + 1). (99+3+1 then rounded to 120 for "extra
** expenses", such as locale-dependent stuff)
*/ */
#define MAX_ITEM (120 + l_mathlim(MAX_10_EXP)) #define MAX_ITEM (120 + l_mathlim(MAX_10_EXP))
/* valid flags in a format specification */ /* valid flags in a format specification */
@@ -906,9 +934,9 @@ static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
else if (*s == '\0' || iscntrl(uchar(*s))) { else if (*s == '\0' || iscntrl(uchar(*s))) {
char buff[10]; char buff[10];
if (!isdigit(uchar(*(s+1)))) if (!isdigit(uchar(*(s+1))))
sprintf(buff, "\\%d", (int)uchar(*s)); l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s));
else else
sprintf(buff, "\\%03d", (int)uchar(*s)); l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s));
luaL_addstring(b, buff); luaL_addstring(b, buff);
} }
else else
@@ -975,24 +1003,25 @@ static int str_format (lua_State *L) {
strfrmt = scanformat(L, strfrmt, form); strfrmt = scanformat(L, strfrmt, form);
switch (*strfrmt++) { switch (*strfrmt++) {
case 'c': { case 'c': {
nb = sprintf(buff, form, (int)luaL_checkinteger(L, arg)); nb = l_sprintf(buff, MAX_ITEM, form, (int)luaL_checkinteger(L, arg));
break; break;
} }
case 'd': case 'i': case 'd': case 'i':
case 'o': case 'u': case 'x': case 'X': { case 'o': case 'u': case 'x': case 'X': {
lua_Integer n = luaL_checkinteger(L, arg); lua_Integer n = luaL_checkinteger(L, arg);
addlenmod(form, LUA_INTEGER_FRMLEN); addlenmod(form, LUA_INTEGER_FRMLEN);
nb = sprintf(buff, form, n); nb = l_sprintf(buff, MAX_ITEM, form, n);
break; break;
} }
case 'a': case 'A': case 'a': case 'A':
addlenmod(form, LUA_NUMBER_FRMLEN); addlenmod(form, LUA_NUMBER_FRMLEN);
nb = lua_number2strx(L, buff, form, luaL_checknumber(L, arg)); nb = lua_number2strx(L, buff, MAX_ITEM, form,
luaL_checknumber(L, arg));
break; break;
case 'e': case 'E': case 'f': case 'e': case 'E': case 'f':
case 'g': case 'G': { case 'g': case 'G': {
addlenmod(form, LUA_NUMBER_FRMLEN); addlenmod(form, LUA_NUMBER_FRMLEN);
nb = sprintf(buff, form, luaL_checknumber(L, arg)); nb = l_sprintf(buff, MAX_ITEM, form, luaL_checknumber(L, arg));
break; break;
} }
case 'q': { case 'q': {
@@ -1002,14 +1031,18 @@ static int str_format (lua_State *L) {
case 's': { case 's': {
size_t l; size_t l;
const char *s = luaL_tolstring(L, arg, &l); const char *s = luaL_tolstring(L, arg, &l);
if (!strchr(form, '.') && l >= 100) { if (form[2] == '\0') /* no modifiers? */
/* no precision and string is too long to be formatted; luaL_addvalue(&b); /* keep entire string */
keep original string */
luaL_addvalue(&b);
}
else { else {
nb = sprintf(buff, form, s); luaL_argcheck(L, l == strlen(s), arg, "string contains zeros");
lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ if (!strchr(form, '.') && l >= 100) {
/* no precision and string is too long to be formatted */
luaL_addvalue(&b); /* keep entire string */
}
else { /* format the string into 'buff' */
nb = l_sprintf(buff, MAX_ITEM, form, s);
lua_pop(L, 1); /* remove result from 'luaL_tolstring' */
}
} }
break; break;
} }
@@ -1018,6 +1051,7 @@ static int str_format (lua_State *L) {
*(strfrmt - 1)); *(strfrmt - 1));
} }
} }
lua_assert(nb < MAX_ITEM);
luaL_addsize(&b, nb); luaL_addsize(&b, nb);
} }
} }
@@ -1309,8 +1343,13 @@ static int str_pack (lua_State *L) {
case Kchar: { /* fixed-size string */ case Kchar: { /* fixed-size string */
size_t len; size_t len;
const char *s = luaL_checklstring(L, arg, &len); const char *s = luaL_checklstring(L, arg, &len);
luaL_argcheck(L, len == (size_t)size, arg, "wrong length"); if ((size_t)size <= len) /* string larger than (or equal to) needed? */
luaL_addlstring(&b, s, size); luaL_addlstring(&b, s, size); /* truncate string to asked size */
else { /* string smaller than needed */
luaL_addlstring(&b, s, len); /* add it all */
while (len++ < (size_t)size) /* pad extra space */
luaL_addchar(&b, LUA_PACKPADBYTE);
}
break; break;
} }
case Kstring: { /* strings with length count */ case Kstring: { /* strings with length count */
@@ -1360,7 +1399,7 @@ static int str_packsize (lua_State *L) {
case Kstring: /* strings with length count */ case Kstring: /* strings with length count */
case Kzstr: /* zero-terminated string */ case Kzstr: /* zero-terminated string */
luaL_argerror(L, 1, "variable-length format"); luaL_argerror(L, 1, "variable-length format");
break; /* call never return, but to avoid warnings: *//* FALLTHROUGH */
default: break; default: break;
} }
} }

78
3rd/lua/ltable.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ltable.c,v 2.111 2015/06/09 14:21:13 roberto Exp $ ** $Id: ltable.c,v 2.117 2015/11/19 19:16:22 roberto Exp $
** Lua tables (hash) ** Lua tables (hash)
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -85,7 +85,7 @@ static const Node dummynode_ = {
/* /*
** Hash for floating-point numbers. ** Hash for floating-point numbers.
** The main computation should be just ** The main computation should be just
** n = frepx(n, &i); return (n * INT_MAX) + i ** n = frexp(n, &i); return (n * INT_MAX) + i
** but there are some numerical subtleties. ** but there are some numerical subtleties.
** In a two-complement representation, INT_MAX does not has an exact ** In a two-complement representation, INT_MAX does not has an exact
** representation as a float, but INT_MIN does; because the absolute ** representation as a float, but INT_MIN does; because the absolute
@@ -101,7 +101,7 @@ static int l_hashfloat (lua_Number n) {
lua_Integer ni; lua_Integer ni;
n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN);
if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */
lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == HUGE_VAL); lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL));
return 0; return 0;
} }
else { /* normal case */ else { /* normal case */
@@ -124,14 +124,8 @@ static Node *mainposition (const Table *t, const TValue *key) {
return hashmod(t, l_hashfloat(fltvalue(key))); return hashmod(t, l_hashfloat(fltvalue(key)));
case LUA_TSHRSTR: case LUA_TSHRSTR:
return hashstr(t, tsvalue(key)); return hashstr(t, tsvalue(key));
case LUA_TLNGSTR: { case LUA_TLNGSTR:
TString *s = tsvalue(key); return hashpow2(t, luaS_hashlongstr(tsvalue(key)));
if (s->extra == 0) { /* no hash? */
s->hash = luaS_hash(getstr(s), s->u.lnglen, s->hash);
s->extra = 1; /* now it has its hash */
}
return hashstr(t, tsvalue(key));
}
case LUA_TBOOLEAN: case LUA_TBOOLEAN:
return hashboolean(t, bvalue(key)); return hashboolean(t, bvalue(key));
case LUA_TLIGHTUSERDATA: case LUA_TLIGHTUSERDATA:
@@ -139,6 +133,7 @@ static Node *mainposition (const Table *t, const TValue *key) {
case LUA_TLCF: case LUA_TLCF:
return hashpointer(t, fvalue(key)); return hashpointer(t, fvalue(key));
default: default:
lua_assert(!ttisdeadkey(key));
return hashpointer(t, gcvalue(key)); return hashpointer(t, gcvalue(key));
} }
} }
@@ -463,7 +458,7 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
Node *f = getfreepos(t); /* get a free place */ Node *f = getfreepos(t); /* get a free place */
if (f == NULL) { /* cannot find a free place? */ if (f == NULL) { /* cannot find a free place? */
rehash(L, t, key); /* grow table */ rehash(L, t, key); /* grow table */
/* whatever called 'newkey' takes care of TM cache and GC barrier */ /* whatever called 'newkey' takes care of TM cache */
return luaH_set(L, t, key); /* insert key into grown table */ return luaH_set(L, t, key); /* insert key into grown table */
} }
lua_assert(!isdummy(f)); lua_assert(!isdummy(f));
@@ -501,7 +496,7 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
*/ */
const TValue *luaH_getint (Table *t, lua_Integer key) { const TValue *luaH_getint (Table *t, lua_Integer key) {
/* (1 <= key && key <= t->sizearray) */ /* (1 <= key && key <= t->sizearray) */
if (l_castS2U(key - 1) < t->sizearray) if (l_castS2U(key) - 1 < t->sizearray)
return &t->array[key - 1]; return &t->array[key - 1];
else { else {
Node *n = hashint(t, key); Node *n = hashint(t, key);
@@ -513,7 +508,7 @@ const TValue *luaH_getint (Table *t, lua_Integer key) {
if (nx == 0) break; if (nx == 0) break;
n += nx; n += nx;
} }
}; }
return luaO_nilobject; return luaO_nilobject;
} }
} }
@@ -522,7 +517,7 @@ const TValue *luaH_getint (Table *t, lua_Integer key) {
/* /*
** search function for short strings ** search function for short strings
*/ */
const TValue *luaH_getstr (Table *t, TString *key) { const TValue *luaH_getshortstr (Table *t, TString *key) {
Node *n = hashstr(t, key); Node *n = hashstr(t, key);
lua_assert(key->tt == LUA_TSHRSTR); lua_assert(key->tt == LUA_TSHRSTR);
for (;;) { /* check whether 'key' is somewhere in the chain */ for (;;) { /* check whether 'key' is somewhere in the chain */
@@ -531,11 +526,41 @@ const TValue *luaH_getstr (Table *t, TString *key) {
return gval(n); /* that's it */ return gval(n); /* that's it */
else { else {
int nx = gnext(n); int nx = gnext(n);
if (nx == 0) break; if (nx == 0)
return luaO_nilobject; /* not found */
n += nx; n += nx;
} }
}; }
return luaO_nilobject; }
/*
** "Generic" get version. (Not that generic: not valid for integers,
** which may be in array part, nor for floats with integral values.)
*/
static const TValue *getgeneric (Table *t, const TValue *key) {
Node *n = mainposition(t, key);
for (;;) { /* check whether 'key' is somewhere in the chain */
if (luaV_rawequalobj(gkey(n), key))
return gval(n); /* that's it */
else {
int nx = gnext(n);
if (nx == 0)
return luaO_nilobject; /* not found */
n += nx;
}
}
}
const TValue *luaH_getstr (Table *t, TString *key) {
if (key->tt == LUA_TSHRSTR)
return luaH_getshortstr(t, key);
else { /* for long strings, use generic case */
TValue ko;
setsvalue(cast(lua_State *, NULL), &ko, key);
return getgeneric(t, &ko);
}
} }
@@ -544,7 +569,7 @@ const TValue *luaH_getstr (Table *t, TString *key) {
*/ */
const TValue *luaH_get (Table *t, const TValue *key) { const TValue *luaH_get (Table *t, const TValue *key) {
switch (ttype(key)) { switch (ttype(key)) {
case LUA_TSHRSTR: return luaH_getstr(t, tsvalue(key)); case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key));
case LUA_TNUMINT: return luaH_getint(t, ivalue(key)); case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
case LUA_TNIL: return luaO_nilobject; case LUA_TNIL: return luaO_nilobject;
case LUA_TNUMFLT: { case LUA_TNUMFLT: {
@@ -553,19 +578,8 @@ const TValue *luaH_get (Table *t, const TValue *key) {
return luaH_getint(t, k); /* use specialized version */ return luaH_getint(t, k); /* use specialized version */
/* else... */ /* else... */
} /* FALLTHROUGH */ } /* FALLTHROUGH */
default: { default:
Node *n = mainposition(t, key); return getgeneric(t, key);
for (;;) { /* check whether 'key' is somewhere in the chain */
if (luaV_rawequalobj(gkey(n), key))
return gval(n); /* that's it */
else {
int nx = gnext(n);
if (nx == 0) break;
n += nx;
}
};
return luaO_nilobject;
}
} }
} }

7
3rd/lua/ltable.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ltable.h,v 2.20 2014/09/04 18:15:29 roberto Exp $ ** $Id: ltable.h,v 2.21 2015/11/03 15:47:30 roberto Exp $
** Lua tables (hash) ** Lua tables (hash)
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -18,6 +18,10 @@
/* 'const' to avoid wrong writings that can mess up field 'next' */ /* 'const' to avoid wrong writings that can mess up field 'next' */
#define gkey(n) cast(const TValue*, (&(n)->i_key.tvk)) #define gkey(n) cast(const TValue*, (&(n)->i_key.tvk))
/*
** writable version of 'gkey'; allows updates to individual fields,
** but not to the whole (which has incompatible type)
*/
#define wgkey(n) (&(n)->i_key.nk) #define wgkey(n) (&(n)->i_key.nk)
#define invalidateTMcache(t) ((t)->flags = 0) #define invalidateTMcache(t) ((t)->flags = 0)
@@ -31,6 +35,7 @@
LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key); LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key, LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
TValue *value); TValue *value);
LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key); LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key); LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key); LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);

374
3rd/lua/ltablib.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ltablib.c,v 1.80 2015/01/13 16:27:29 roberto Exp $ ** $Id: ltablib.c,v 1.90 2015/11/25 12:48:57 roberto Exp $
** Library for Table Manipulation ** Library for Table Manipulation
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -12,6 +12,7 @@
#include <limits.h> #include <limits.h>
#include <stddef.h> #include <stddef.h>
#include <string.h>
#include "lua.h" #include "lua.h"
@@ -19,40 +20,42 @@
#include "lualib.h" #include "lualib.h"
/* /*
** Structure with table-access functions ** Operations that an object must define to mimic a table
** (some functions only need some of them)
*/ */
typedef struct { #define TAB_R 1 /* read */
int (*geti) (lua_State *L, int idx, lua_Integer n); #define TAB_W 2 /* write */
void (*seti) (lua_State *L, int idx, lua_Integer n); #define TAB_L 4 /* length */
} TabA; #define TAB_RW (TAB_R | TAB_W) /* read/write */
/* #define aux_getn(L,n,w) (checktab(L, n, (w) | TAB_L), luaL_len(L, n))
** Check that 'arg' has a table and set access functions in 'ta' to raw
** or non-raw according to the presence of corresponding metamethods.
*/ static int checkfield (lua_State *L, const char *key, int n) {
static void checktab (lua_State *L, int arg, TabA *ta) { lua_pushstring(L, key);
ta->geti = NULL; ta->seti = NULL; return (lua_rawget(L, -n) != LUA_TNIL);
if (lua_getmetatable(L, arg)) {
lua_pushliteral(L, "__index"); /* 'index' metamethod */
if (lua_rawget(L, -2) != LUA_TNIL)
ta->geti = lua_geti;
lua_pushliteral(L, "__newindex"); /* 'newindex' metamethod */
if (lua_rawget(L, -3) != LUA_TNIL)
ta->seti = lua_seti;
lua_pop(L, 3); /* pop metatable plus both metamethods */
}
if (ta->geti == NULL || ta->seti == NULL) {
luaL_checktype(L, arg, LUA_TTABLE); /* must be table for raw methods */
if (ta->geti == NULL) ta->geti = lua_rawgeti;
if (ta->seti == NULL) ta->seti = lua_rawseti;
}
} }
#define aux_getn(L,n,ta) (checktab(L, n, ta), luaL_len(L, n)) /*
** Check that 'arg' either is a table or can behave like one (that is,
** has a metatable with the required metamethods)
*/
static void checktab (lua_State *L, int arg, int what) {
if (lua_type(L, arg) != LUA_TTABLE) { /* is it not a table? */
int n = 1; /* number of elements to pop */
if (lua_getmetatable(L, arg) && /* must have metatable */
(!(what & TAB_R) || checkfield(L, "__index", ++n)) &&
(!(what & TAB_W) || checkfield(L, "__newindex", ++n)) &&
(!(what & TAB_L) || checkfield(L, "__len", ++n))) {
lua_pop(L, n); /* pop metatable and tested metamethods */
}
else
luaL_argerror(L, arg, "table expected"); /* force an error */
}
}
#if defined(LUA_COMPAT_MAXN) #if defined(LUA_COMPAT_MAXN)
@@ -74,8 +77,7 @@ static int maxn (lua_State *L) {
static int tinsert (lua_State *L) { static int tinsert (lua_State *L) {
TabA ta; lua_Integer e = aux_getn(L, 1, TAB_RW) + 1; /* first empty element */
lua_Integer e = aux_getn(L, 1, &ta) + 1; /* first empty element */
lua_Integer pos; /* where to insert new element */ lua_Integer pos; /* where to insert new element */
switch (lua_gettop(L)) { switch (lua_gettop(L)) {
case 2: { /* called with only 2 arguments */ case 2: { /* called with only 2 arguments */
@@ -87,8 +89,8 @@ static int tinsert (lua_State *L) {
pos = luaL_checkinteger(L, 2); /* 2nd argument is the position */ pos = luaL_checkinteger(L, 2); /* 2nd argument is the position */
luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds"); luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds");
for (i = e; i > pos; i--) { /* move up elements */ for (i = e; i > pos; i--) { /* move up elements */
(*ta.geti)(L, 1, i - 1); lua_geti(L, 1, i - 1);
(*ta.seti)(L, 1, i); /* t[i] = t[i - 1] */ lua_seti(L, 1, i); /* t[i] = t[i - 1] */
} }
break; break;
} }
@@ -96,57 +98,57 @@ static int tinsert (lua_State *L) {
return luaL_error(L, "wrong number of arguments to 'insert'"); return luaL_error(L, "wrong number of arguments to 'insert'");
} }
} }
(*ta.seti)(L, 1, pos); /* t[pos] = v */ lua_seti(L, 1, pos); /* t[pos] = v */
return 0; return 0;
} }
static int tremove (lua_State *L) { static int tremove (lua_State *L) {
TabA ta; lua_Integer size = aux_getn(L, 1, TAB_RW);
lua_Integer size = aux_getn(L, 1, &ta);
lua_Integer pos = luaL_optinteger(L, 2, size); lua_Integer pos = luaL_optinteger(L, 2, size);
if (pos != size) /* validate 'pos' if given */ if (pos != size) /* validate 'pos' if given */
luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds"); luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
(*ta.geti)(L, 1, pos); /* result = t[pos] */ lua_geti(L, 1, pos); /* result = t[pos] */
for ( ; pos < size; pos++) { for ( ; pos < size; pos++) {
(*ta.geti)(L, 1, pos + 1); lua_geti(L, 1, pos + 1);
(*ta.seti)(L, 1, pos); /* t[pos] = t[pos + 1] */ lua_seti(L, 1, pos); /* t[pos] = t[pos + 1] */
} }
lua_pushnil(L); lua_pushnil(L);
(*ta.seti)(L, 1, pos); /* t[pos] = nil */ lua_seti(L, 1, pos); /* t[pos] = nil */
return 1; return 1;
} }
/*
** Copy elements (1[f], ..., 1[e]) into (tt[t], tt[t+1], ...). Whenever
** possible, copy in increasing order, which is better for rehashing.
** "possible" means destination after original range, or smaller
** than origin, or copying to another table.
*/
static int tmove (lua_State *L) { static int tmove (lua_State *L) {
TabA ta;
lua_Integer f = luaL_checkinteger(L, 2); lua_Integer f = luaL_checkinteger(L, 2);
lua_Integer e = luaL_checkinteger(L, 3); lua_Integer e = luaL_checkinteger(L, 3);
lua_Integer t = luaL_checkinteger(L, 4); lua_Integer t = luaL_checkinteger(L, 4);
int tt = !lua_isnoneornil(L, 5) ? 5 : 1; /* destination table */ int tt = !lua_isnoneornil(L, 5) ? 5 : 1; /* destination table */
checktab(L, 1, TAB_R);
checktab(L, tt, TAB_W);
if (e >= f) { /* otherwise, nothing to move */ if (e >= f) { /* otherwise, nothing to move */
lua_Integer n, i; lua_Integer n, i;
ta.geti = (luaL_getmetafield(L, 1, "__index") == LUA_TNIL)
? (luaL_checktype(L, 1, LUA_TTABLE), lua_rawgeti)
: lua_geti;
ta.seti = (luaL_getmetafield(L, tt, "__newindex") == LUA_TNIL)
? (luaL_checktype(L, tt, LUA_TTABLE), lua_rawseti)
: lua_seti;
luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3, luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3,
"too many elements to move"); "too many elements to move");
n = e - f + 1; /* number of elements to move */ n = e - f + 1; /* number of elements to move */
luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4, luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4,
"destination wrap around"); "destination wrap around");
if (t > f) { if (t > e || t <= f || tt != 1) {
for (i = n - 1; i >= 0; i--) { for (i = 0; i < n; i++) {
(*ta.geti)(L, 1, f + i); lua_geti(L, 1, f + i);
(*ta.seti)(L, tt, t + i); lua_seti(L, tt, t + i);
} }
} }
else { else {
for (i = 0; i < n; i++) { for (i = n - 1; i >= 0; i--) {
(*ta.geti)(L, 1, f + i); lua_geti(L, 1, f + i);
(*ta.seti)(L, tt, t + i); lua_seti(L, tt, t + i);
} }
} }
} }
@@ -155,8 +157,8 @@ static int tmove (lua_State *L) {
} }
static void addfield (lua_State *L, luaL_Buffer *b, TabA *ta, lua_Integer i) { static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
(*ta->geti)(L, 1, i); lua_geti(L, 1, i);
if (!lua_isstring(L, -1)) if (!lua_isstring(L, -1))
luaL_error(L, "invalid value (%s) at index %d in table for 'concat'", luaL_error(L, "invalid value (%s) at index %d in table for 'concat'",
luaL_typename(L, -1), i); luaL_typename(L, -1), i);
@@ -165,21 +167,19 @@ static void addfield (lua_State *L, luaL_Buffer *b, TabA *ta, lua_Integer i) {
static int tconcat (lua_State *L) { static int tconcat (lua_State *L) {
TabA ta;
luaL_Buffer b; luaL_Buffer b;
lua_Integer last = aux_getn(L, 1, TAB_R);
size_t lsep; size_t lsep;
lua_Integer i, last;
const char *sep = luaL_optlstring(L, 2, "", &lsep); const char *sep = luaL_optlstring(L, 2, "", &lsep);
checktab(L, 1, &ta); lua_Integer i = luaL_optinteger(L, 3, 1);
i = luaL_optinteger(L, 3, 1); last = luaL_opt(L, luaL_checkinteger, 4, last);
last = luaL_opt(L, luaL_checkinteger, 4, luaL_len(L, 1));
luaL_buffinit(L, &b); luaL_buffinit(L, &b);
for (; i < last; i++) { for (; i < last; i++) {
addfield(L, &b, &ta, i); addfield(L, &b, i);
luaL_addlstring(&b, sep, lsep); luaL_addlstring(&b, sep, lsep);
} }
if (i == last) /* add last value (if interval was not empty) */ if (i == last) /* add last value (if interval was not empty) */
addfield(L, &b, &ta, i); addfield(L, &b, i);
luaL_pushresult(&b); luaL_pushresult(&b);
return 1; return 1;
} }
@@ -197,7 +197,7 @@ static int pack (lua_State *L) {
lua_createtable(L, n, 1); /* create result table */ lua_createtable(L, n, 1); /* create result table */
lua_insert(L, 1); /* put it at index 1 */ lua_insert(L, 1); /* put it at index 1 */
for (i = n; i >= 1; i--) /* assign elements */ for (i = n; i >= 1; i--) /* assign elements */
lua_rawseti(L, 1, i); lua_seti(L, 1, i);
lua_pushinteger(L, n); lua_pushinteger(L, n);
lua_setfield(L, 1, "n"); /* t.n = number of elements */ lua_setfield(L, 1, "n"); /* t.n = number of elements */
return 1; /* return table */ return 1; /* return table */
@@ -205,20 +205,17 @@ static int pack (lua_State *L) {
static int unpack (lua_State *L) { static int unpack (lua_State *L) {
TabA ta;
lua_Integer i, e;
lua_Unsigned n; lua_Unsigned n;
checktab(L, 1, &ta); lua_Integer i = luaL_optinteger(L, 2, 1);
i = luaL_optinteger(L, 2, 1); lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
if (i > e) return 0; /* empty range */ if (i > e) return 0; /* empty range */
n = (lua_Unsigned)e - i; /* number of elements minus 1 (avoid overflows) */ n = (lua_Unsigned)e - i; /* number of elements minus 1 (avoid overflows) */
if (n >= (unsigned int)INT_MAX || !lua_checkstack(L, (int)(++n))) if (n >= (unsigned int)INT_MAX || !lua_checkstack(L, (int)(++n)))
return luaL_error(L, "too many results to unpack"); return luaL_error(L, "too many results to unpack");
do { /* must have at least one element */ for (; i < e; i++) { /* push arg[i..e - 1] (to avoid overflows) */
(*ta.geti)(L, 1, i); /* push arg[i..e] */ lua_geti(L, 1, i);
} while (i++ < e); }
lua_geti(L, 1, e); /* push last element */
return (int)n; return (int)n;
} }
@@ -235,97 +232,190 @@ static int unpack (lua_State *L) {
*/ */
static void set2 (lua_State *L, TabA *ta, int i, int j) { /*
(*ta->seti)(L, 1, i); ** Produce a "random" 'unsigned int' to randomize pivot choice. This
(*ta->seti)(L, 1, j); ** macro is used only when 'sort' detects a big imbalance in the result
** of a partition. (If you don't want/need this "randomness", ~0 is a
** good choice.)
*/
#if !defined(l_randomizePivot) /* { */
#include <time.h>
/* size of 'e' measured in number of 'unsigned int's */
#define sof(e) (sizeof(e) / sizeof(unsigned int))
/*
** Use 'time' and 'clock' as sources of "randomness". Because we don't
** know the types 'clock_t' and 'time_t', we cannot cast them to
** anything without risking overflows. A safe way to use their values
** is to copy them to an array of a known type and use the array values.
*/
static unsigned int l_randomizePivot (void) {
clock_t c = clock();
time_t t = time(NULL);
unsigned int buff[sof(c) + sof(t)];
unsigned int i, rnd = 0;
memcpy(buff, &c, sof(c) * sizeof(unsigned int));
memcpy(buff + sof(c), &t, sof(t) * sizeof(unsigned int));
for (i = 0; i < sof(buff); i++)
rnd += buff[i];
return rnd;
} }
#endif /* } */
/* arrays larger than 'RANLIMIT' may use randomized pivots */
#define RANLIMIT 100u
static void set2 (lua_State *L, unsigned int i, unsigned int j) {
lua_seti(L, 1, i);
lua_seti(L, 1, j);
}
/*
** Return true iff value at stack index 'a' is less than the value at
** index 'b' (according to the order of the sort).
*/
static int sort_comp (lua_State *L, int a, int b) { static int sort_comp (lua_State *L, int a, int b) {
if (!lua_isnil(L, 2)) { /* function? */ if (lua_isnil(L, 2)) /* no function? */
return lua_compare(L, a, b, LUA_OPLT); /* a < b */
else { /* function */
int res; int res;
lua_pushvalue(L, 2); lua_pushvalue(L, 2); /* push function */
lua_pushvalue(L, a-1); /* -1 to compensate function */ lua_pushvalue(L, a-1); /* -1 to compensate function */
lua_pushvalue(L, b-2); /* -2 to compensate function and 'a' */ lua_pushvalue(L, b-2); /* -2 to compensate function and 'a' */
lua_call(L, 2, 1); lua_call(L, 2, 1); /* call function */
res = lua_toboolean(L, -1); res = lua_toboolean(L, -1); /* get result */
lua_pop(L, 1); lua_pop(L, 1); /* pop result */
return res; return res;
} }
else /* a < b? */
return lua_compare(L, a, b, LUA_OPLT);
} }
static void auxsort (lua_State *L, TabA *ta, int l, int u) {
while (l < u) { /* for tail recursion */ /*
int i, j; ** Does the partition: Pivot P is at the top of the stack.
/* sort elements a[l], a[(l+u)/2] and a[u] */ ** precondition: a[lo] <= P == a[up-1] <= a[up],
(*ta->geti)(L, 1, l); ** so it only needs to do the partition from lo + 1 to up - 2.
(*ta->geti)(L, 1, u); ** Pos-condition: a[lo .. i - 1] <= a[i] == P <= a[i + 1 .. up]
if (sort_comp(L, -1, -2)) /* a[u] < a[l]? */ ** returns 'i'.
set2(L, ta, l, u); /* swap a[l] - a[u] */ */
static unsigned int partition (lua_State *L, unsigned int lo,
unsigned int up) {
unsigned int i = lo; /* will be incremented before first use */
unsigned int j = up - 1; /* will be decremented before first use */
/* loop invariant: a[lo .. i] <= P <= a[j .. up] */
for (;;) {
/* next loop: repeat ++i while a[i] < P */
while (lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) {
if (i == up - 1) /* a[i] < P but a[up - 1] == P ?? */
luaL_error(L, "invalid order function for sorting");
lua_pop(L, 1); /* remove a[i] */
}
/* after the loop, a[i] >= P and a[lo .. i - 1] < P */
/* next loop: repeat --j while P < a[j] */
while (lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {
if (j < i) /* j < i but a[j] > P ?? */
luaL_error(L, "invalid order function for sorting");
lua_pop(L, 1); /* remove a[j] */
}
/* after the loop, a[j] <= P and a[j + 1 .. up] >= P */
if (j < i) { /* no elements out of place? */
/* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */
lua_pop(L, 1); /* pop a[j] */
/* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */
set2(L, up - 1, i);
return i;
}
/* otherwise, swap a[i] - a[j] to restore invariant and repeat */
set2(L, i, j);
}
}
/*
** Choose an element in the middle (2nd-3th quarters) of [lo,up]
** "randomized" by 'rnd'
*/
static unsigned int choosePivot (unsigned int lo, unsigned int up,
unsigned int rnd) {
unsigned int r4 = (unsigned int)(up - lo) / 4u; /* range/4 */
unsigned int p = rnd % (r4 * 2) + (lo + r4);
lua_assert(lo + r4 <= p && p <= up - r4);
return p;
}
/*
** QuickSort algorithm (recursive function)
*/
static void auxsort (lua_State *L, unsigned int lo, unsigned int up,
unsigned int rnd) {
while (lo < up) { /* loop for tail recursion */
unsigned int p; /* Pivot index */
unsigned int n; /* to be used later */
/* sort elements 'lo', 'p', and 'up' */
lua_geti(L, 1, lo);
lua_geti(L, 1, up);
if (sort_comp(L, -1, -2)) /* a[up] < a[lo]? */
set2(L, lo, up); /* swap a[lo] - a[up] */
else else
lua_pop(L, 2); lua_pop(L, 2); /* remove both values */
if (u-l == 1) break; /* only 2 elements */ if (up - lo == 1) /* only 2 elements? */
i = (l+u)/2; return; /* already sorted */
(*ta->geti)(L, 1, i); if (up - lo < RANLIMIT || rnd == 0) /* small interval or no randomize? */
(*ta->geti)(L, 1, l); p = (lo + up)/2; /* middle element is a good pivot */
if (sort_comp(L, -2, -1)) /* a[i]<a[l]? */ else /* for larger intervals, it is worth a random pivot */
set2(L, ta, i, l); p = choosePivot(lo, up, rnd);
lua_geti(L, 1, p);
lua_geti(L, 1, lo);
if (sort_comp(L, -2, -1)) /* a[p] < a[lo]? */
set2(L, p, lo); /* swap a[p] - a[lo] */
else { else {
lua_pop(L, 1); /* remove a[l] */ lua_pop(L, 1); /* remove a[lo] */
(*ta->geti)(L, 1, u); lua_geti(L, 1, up);
if (sort_comp(L, -1, -2)) /* a[u]<a[i]? */ if (sort_comp(L, -1, -2)) /* a[up] < a[p]? */
set2(L, ta, i, u); set2(L, p, up); /* swap a[up] - a[p] */
else else
lua_pop(L, 2); lua_pop(L, 2);
} }
if (u-l == 2) break; /* only 3 elements */ if (up - lo == 2) /* only 3 elements? */
(*ta->geti)(L, 1, i); /* Pivot */ return; /* already sorted */
lua_pushvalue(L, -1); lua_geti(L, 1, p); /* get middle element (Pivot) */
(*ta->geti)(L, 1, u-1); lua_pushvalue(L, -1); /* push Pivot */
set2(L, ta, i, u-1); lua_geti(L, 1, up - 1); /* push a[up - 1] */
/* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */ set2(L, p, up - 1); /* swap Pivot (a[p]) with a[up - 1] */
i = l; j = u-1; p = partition(L, lo, up);
for (;;) { /* invariant: a[l..i] <= P <= a[j..u] */ /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */
/* repeat ++i until a[i] >= P */ if (p - lo < up - p) { /* lower interval is smaller? */
while ((*ta->geti)(L, 1, ++i), sort_comp(L, -1, -2)) { auxsort(L, lo, p - 1, rnd); /* call recursively for lower interval */
if (i>=u) luaL_error(L, "invalid order function for sorting"); n = p - lo; /* size of smaller interval */
lua_pop(L, 1); /* remove a[i] */ lo = p + 1; /* tail call for [p + 1 .. up] (upper interval) */
}
/* repeat --j until a[j] <= P */
while ((*ta->geti)(L, 1, --j), sort_comp(L, -3, -1)) {
if (j<=l) luaL_error(L, "invalid order function for sorting");
lua_pop(L, 1); /* remove a[j] */
}
if (j<i) {
lua_pop(L, 3); /* pop pivot, a[i], a[j] */
break;
}
set2(L, ta, i, j);
}
(*ta->geti)(L, 1, u-1);
(*ta->geti)(L, 1, i);
set2(L, ta, u-1, i); /* swap pivot (a[u-1]) with a[i] */
/* a[l..i-1] <= a[i] == P <= a[i+1..u] */
/* adjust so that smaller half is in [j..i] and larger one in [l..u] */
if (i-l < u-i) {
j=l; i=i-1; l=i+2;
} }
else { else {
j=i+1; i=u; u=j-2; auxsort(L, p + 1, up, rnd); /* call recursively for upper interval */
n = up - p; /* size of smaller interval */
up = p - 1; /* tail call for [lo .. p - 1] (lower interval) */
} }
auxsort(L, ta, j, i); /* call recursively the smaller one */ if ((up - lo) / 128u > n) /* partition too imbalanced? */
} /* repeat the routine for the larger one */ rnd = l_randomizePivot(); /* try a new randomization */
} /* tail call auxsort(L, lo, up, rnd) */
} }
static int sort (lua_State *L) { static int sort (lua_State *L) {
TabA ta; lua_Integer n = aux_getn(L, 1, TAB_RW);
int n = (int)aux_getn(L, 1, &ta); if (n > 1) { /* non-trivial interval? */
luaL_checkstack(L, 50, ""); /* assume array is smaller than 2^50 */ luaL_argcheck(L, n < INT_MAX, 1, "array too big");
if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ luaL_checkstack(L, 40, ""); /* assume array is smaller than 2^40 */
luaL_checktype(L, 2, LUA_TFUNCTION); if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */
lua_settop(L, 2); /* make sure there are two arguments */ luaL_checktype(L, 2, LUA_TFUNCTION); /* must be a function */
auxsort(L, &ta, 1, n); lua_settop(L, 2); /* make sure there are two arguments */
auxsort(L, 1, (unsigned int)n, 0u);
}
return 0; return 0;
} }

19
3rd/lua/ltm.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ltm.c,v 2.34 2015/03/30 15:42:27 roberto Exp $ ** $Id: ltm.c,v 2.36 2015/11/03 15:47:30 roberto Exp $
** Tag methods ** Tag methods
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -57,7 +57,7 @@ void luaT_init (lua_State *L) {
** tag methods ** tag methods
*/ */
const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
const TValue *tm = luaH_getstr(events, ename); const TValue *tm = luaH_getshortstr(events, ename);
lua_assert(event <= TM_EQ); lua_assert(event <= TM_EQ);
if (ttisnil(tm)) { /* no tag method? */ if (ttisnil(tm)) { /* no tag method? */
events->flags |= cast_byte(1u<<event); /* cache this fact */ events->flags |= cast_byte(1u<<event); /* cache this fact */
@@ -79,20 +79,25 @@ const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
default: default:
mt = G(L)->mt[ttnov(o)]; mt = G(L)->mt[ttnov(o)];
} }
return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject); return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
} }
void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
const TValue *p2, TValue *p3, int hasres) { const TValue *p2, TValue *p3, int hasres) {
ptrdiff_t result = savestack(L, p3); ptrdiff_t result = savestack(L, p3);
setobj2s(L, L->top++, f); /* push function (assume EXTRA_STACK) */ StkId func = L->top;
setobj2s(L, L->top++, p1); /* 1st argument */ setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */
setobj2s(L, L->top++, p2); /* 2nd argument */ setobj2s(L, func + 1, p1); /* 1st argument */
setobj2s(L, func + 2, p2); /* 2nd argument */
L->top += 3;
if (!hasres) /* no result? 'p3' is third argument */ if (!hasres) /* no result? 'p3' is third argument */
setobj2s(L, L->top++, p3); /* 3rd argument */ setobj2s(L, L->top++, p3); /* 3rd argument */
/* metamethod may yield only when called from Lua code */ /* metamethod may yield only when called from Lua code */
luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci)); if (isLua(L->ci))
luaD_call(L, func, hasres);
else
luaD_callnoyield(L, func, hasres);
if (hasres) { /* if has result, move it to its place */ if (hasres) { /* if has result, move it to its place */
p3 = restorestack(L, result); p3 = restorestack(L, result);
setobjs2s(L, p3, --L->top); setobjs2s(L, p3, --L->top);

20
3rd/lua/lua.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lua.c,v 1.225 2015/03/30 15:42:59 roberto Exp $ ** $Id: lua.c,v 1.226 2015/08/14 19:11:20 roberto Exp $
** Lua stand-alone interpreter ** Lua stand-alone interpreter
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -325,24 +325,20 @@ static int pushline (lua_State *L, int firstline) {
/* /*
** Try to compile line on the stack as 'return <line>'; on return, stack ** Try to compile line on the stack as 'return <line>;'; on return, stack
** has either compiled chunk or original line (if compilation failed). ** has either compiled chunk or original line (if compilation failed).
*/ */
static int addreturn (lua_State *L) { static int addreturn (lua_State *L) {
int status; const char *line = lua_tostring(L, -1); /* original line */
size_t len; const char *line; const char *retline = lua_pushfstring(L, "return %s;", line);
lua_pushliteral(L, "return "); int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
lua_pushvalue(L, -2); /* duplicate line */ if (status == LUA_OK) {
lua_concat(L, 2); /* new line is "return ..." */ lua_remove(L, -2); /* remove modified line */
line = lua_tolstring(L, -1, &len);
if ((status = luaL_loadbuffer(L, line, len, "=stdin")) == LUA_OK) {
lua_remove(L, -3); /* remove original line */
line += sizeof("return")/sizeof(char); /* remove 'return' for history */
if (line[0] != '\0') /* non empty? */ if (line[0] != '\0') /* non empty? */
lua_saveline(L, line); /* keep history */ lua_saveline(L, line); /* keep history */
} }
else else
lua_pop(L, 2); /* remove result from 'luaL_loadbuffer' and new line */ lua_pop(L, 2); /* pop result from 'luaL_loadbuffer' and modified line */
return status; return status;
} }

4
3rd/lua/lua.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lua.h,v 1.328 2015/06/03 13:03:38 roberto Exp $ ** $Id: lua.h,v 1.329 2015/11/13 17:18:42 roberto Exp $
** Lua - A Scripting Language ** Lua - A Scripting Language
** Lua.org, PUC-Rio, Brazil (http://www.lua.org) ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
** See Copyright Notice at the end of this file ** See Copyright Notice at the end of this file
@@ -19,7 +19,7 @@
#define LUA_VERSION_MAJOR "5" #define LUA_VERSION_MAJOR "5"
#define LUA_VERSION_MINOR "3" #define LUA_VERSION_MINOR "3"
#define LUA_VERSION_NUM 503 #define LUA_VERSION_NUM 503
#define LUA_VERSION_RELEASE "1" #define LUA_VERSION_RELEASE "2"
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR #define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE #define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE

65
3rd/lua/luaconf.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: luaconf.h,v 1.251 2015/05/20 17:39:23 roberto Exp $ ** $Id: luaconf.h,v 1.254 2015/10/21 18:17:40 roberto Exp $
** Configuration file for Lua ** Configuration file for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -145,7 +145,7 @@
#if !defined(LUA_FLOAT_TYPE) #if !defined(LUA_FLOAT_TYPE)
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE #define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
#endif /* } */ #endif
/* }================================================================== */ /* }================================================================== */
@@ -412,9 +412,33 @@
@@ LUA_NUMBER_FMT is the format for writing floats. @@ LUA_NUMBER_FMT is the format for writing floats.
@@ lua_number2str converts a float to a string. @@ lua_number2str converts a float to a string.
@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. @@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
@@ l_floor takes the floor of a float.
@@ lua_str2number converts a decimal numeric string to a number. @@ lua_str2number converts a decimal numeric string to a number.
*/ */
/* The following definitions are good for most cases here */
#define l_floor(x) (l_mathop(floor)(x))
#define lua_number2str(s,sz,n) l_sprintf((s), sz, LUA_NUMBER_FMT, (n))
/*
@@ lua_numbertointeger converts a float number to an integer, or
** returns 0 if float is not within the range of a lua_Integer.
** (The range comparisons are tricky because of rounding. The tests
** here assume a two-complement representation, where MININTEGER always
** has an exact representation as a float; MAXINTEGER may not have one,
** and therefore its conversion to float may have an ill-defined value.)
*/
#define lua_numbertointeger(n,p) \
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
(*(p) = (LUA_INTEGER)(n), 1))
/* now the variable definitions */
#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ #if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
#define LUA_NUMBER float #define LUA_NUMBER float
@@ -468,25 +492,6 @@
#endif /* } */ #endif /* } */
#define l_floor(x) (l_mathop(floor)(x))
#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
/*
@@ lua_numbertointeger converts a float number to an integer, or
** returns 0 if float is not within the range of a lua_Integer.
** (The range comparisons are tricky because of rounding. The tests
** here assume a two-complement representation, where MININTEGER always
** has an exact representation as a float; MAXINTEGER may not have one,
** and therefore its conversion to float may have an ill-defined value.)
*/
#define lua_numbertointeger(n,p) \
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
(*(p) = (LUA_INTEGER)(n), 1))
/* /*
@@ LUA_INTEGER is the integer type used by Lua. @@ LUA_INTEGER is the integer type used by Lua.
@@ -506,7 +511,7 @@
/* The following definitions are good for most cases here */ /* The following definitions are good for most cases here */
#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" #define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
#define lua_integer2str(s,n) sprintf((s), LUA_INTEGER_FMT, (n)) #define lua_integer2str(s,sz,n) l_sprintf((s), sz, LUA_INTEGER_FMT, (n))
#define LUAI_UACINT LUA_INTEGER #define LUAI_UACINT LUA_INTEGER
@@ -537,6 +542,7 @@
#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ #elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
/* use presence of macro LLONG_MAX as proxy for C99 compliance */
#if defined(LLONG_MAX) /* { */ #if defined(LLONG_MAX) /* { */
/* use ISO C99 stuff */ /* use ISO C99 stuff */
@@ -577,6 +583,17 @@
** =================================================================== ** ===================================================================
*/ */
/*
@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
** (All uses in Lua have only one format item.)
*/
#if !defined(LUA_USE_C89)
#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
#else
#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
#endif
/* /*
@@ lua_strx2number converts an hexadecimal numeric string to a number. @@ lua_strx2number converts an hexadecimal numeric string to a number.
** In C99, 'strtod' does that conversion. Otherwise, you can ** In C99, 'strtod' does that conversion. Otherwise, you can
@@ -584,7 +601,7 @@
** implementation. ** implementation.
*/ */
#if !defined(LUA_USE_C89) #if !defined(LUA_USE_C89)
#define lua_strx2number(s,p) lua_str2number(s,p) #define lua_strx2number(s,p) lua_str2number(s,p)
#endif #endif
@@ -595,7 +612,7 @@
** provide its own implementation. ** provide its own implementation.
*/ */
#if !defined(LUA_USE_C89) #if !defined(LUA_USE_C89)
#define lua_number2strx(L,b,f,n) sprintf(b,f,n) #define lua_number2strx(L,b,sz,f,n) l_sprintf(b,sz,f,n)
#endif #endif

22
3rd/lua/lundump.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lundump.c,v 2.41 2014/11/02 19:19:04 roberto Exp $ ** $Id: lundump.c,v 2.44 2015/11/02 16:09:30 roberto Exp $
** load precompiled Lua chunks ** load precompiled Lua chunks
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -32,7 +32,6 @@
typedef struct { typedef struct {
lua_State *L; lua_State *L;
ZIO *Z; ZIO *Z;
Mbuffer *b;
const char *name; const char *name;
} LoadState; } LoadState;
@@ -92,10 +91,15 @@ static TString *LoadString (LoadState *S) {
LoadVar(S, size); LoadVar(S, size);
if (size == 0) if (size == 0)
return NULL; return NULL;
else { else if (--size <= LUAI_MAXSHORTLEN) { /* short string? */
char *s = luaZ_openspace(S->L, S->b, --size); char buff[LUAI_MAXSHORTLEN];
LoadVector(S, s, size); LoadVector(S, buff, size);
return luaS_newlstr(S->L, s, size); return luaS_newlstr(S->L, buff, size);
}
else { /* long string */
TString *ts = luaS_createlngstrobj(S->L, size);
LoadVector(S, getstr(ts), size); /* load directly in final place */
return ts;
} }
} }
@@ -252,8 +256,7 @@ static void checkHeader (LoadState *S) {
/* /*
** load precompiled chunk ** load precompiled chunk
*/ */
LClosure *luaU_undump(lua_State *L, ZIO *Z, Mbuffer *buff, LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
const char *name) {
LoadState S; LoadState S;
LClosure *cl; LClosure *cl;
if (*name == '@' || *name == '=') if (*name == '@' || *name == '=')
@@ -264,11 +267,10 @@ LClosure *luaU_undump(lua_State *L, ZIO *Z, Mbuffer *buff,
S.name = name; S.name = name;
S.L = L; S.L = L;
S.Z = Z; S.Z = Z;
S.b = buff;
checkHeader(&S); checkHeader(&S);
cl = luaF_newLclosure(L, LoadByte(&S)); cl = luaF_newLclosure(L, LoadByte(&S));
setclLvalue(L, L->top, cl); setclLvalue(L, L->top, cl);
incr_top(L); luaD_inctop(L);
cl->p = luaF_newproto(L, NULL); cl->p = luaF_newproto(L, NULL);
LoadFunction(&S, cl->p, NULL); LoadFunction(&S, cl->p, NULL);
lua_assert(cl->nupvalues == cl->p->sizeupvalues); lua_assert(cl->nupvalues == cl->p->sizeupvalues);

5
3rd/lua/lundump.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lundump.h,v 1.44 2014/06/19 18:27:20 roberto Exp $ ** $Id: lundump.h,v 1.45 2015/09/08 15:41:05 roberto Exp $
** load precompiled Lua chunks ** load precompiled Lua chunks
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -23,8 +23,7 @@
#define LUAC_FORMAT 0 /* this is the official format */ #define LUAC_FORMAT 0 /* this is the official format */
/* load one chunk; from lundump.c */ /* load one chunk; from lundump.c */
LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
const char* name);
/* dump one chunk; from ldump.c */ /* dump one chunk; from ldump.c */
LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,

219
3rd/lua/lvm.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lvm.c,v 2.245 2015/06/09 15:53:35 roberto Exp $ ** $Id: lvm.c,v 2.265 2015/11/23 11:30:45 roberto Exp $
** Lua virtual machine ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -66,7 +66,7 @@
/* Add by skynet */ /* Add by skynet */
lua_State * skynet_sig_L = NULL; lua_State * skynet_sig_L = NULL;
LUA_API void LUA_API void
lua_checksig_(lua_State *L) { lua_checksig_(lua_State *L) {
if (skynet_sig_L == G(L)->mainthread) { if (skynet_sig_L == G(L)->mainthread) {
skynet_sig_L = NULL; skynet_sig_L = NULL;
@@ -163,30 +163,28 @@ static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step,
/* /*
** Main function for table access (invoking metamethods if needed). ** Complete a table access: if 't' is a table, 'tm' has its metamethod;
** Compute 'val = t[key]' ** otherwise, 'tm' is NULL.
*/ */
void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) { void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
const TValue *tm) {
int loop; /* counter to avoid infinite loops */ int loop; /* counter to avoid infinite loops */
lua_assert(tm != NULL || !ttistable(t));
for (loop = 0; loop < MAXTAGLOOP; loop++) { for (loop = 0; loop < MAXTAGLOOP; loop++) {
const TValue *tm; if (tm == NULL) { /* no metamethod (from a table)? */
if (ttistable(t)) { /* 't' is a table? */ if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
Table *h = hvalue(t); luaG_typeerror(L, t, "index"); /* no metamethod */
const TValue *res = luaH_get(h, key); /* do a primitive get */
if (!ttisnil(res) || /* result is not nil? */
(tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
setobj2s(L, val, res); /* result is the raw get */
return;
}
/* else will try metamethod */
} }
else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
luaG_typeerror(L, t, "index"); /* no metamethod */
if (ttisfunction(tm)) { /* metamethod is a function */ if (ttisfunction(tm)) { /* metamethod is a function */
luaT_callTM(L, tm, t, key, val, 1); luaT_callTM(L, tm, t, key, val, 1); /* call it */
return; return;
} }
t = tm; /* else repeat access over 'tm' */ t = tm; /* else repeat access over 'tm' */
if (luaV_fastget(L,t,key,tm,luaH_get)) { /* try fast track */
setobj2s(L, val, tm); /* done */
return;
}
/* else repeat */
} }
luaG_runerror(L, "gettable chain too long; possible loop"); luaG_runerror(L, "gettable chain too long; possible loop");
} }
@@ -196,40 +194,41 @@ void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
** Main function for table assignment (invoking metamethods if needed). ** Main function for table assignment (invoking metamethods if needed).
** Compute 't[key] = val' ** Compute 't[key] = val'
*/ */
void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) { void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
StkId val, const TValue *oldval) {
int loop; /* counter to avoid infinite loops */ int loop; /* counter to avoid infinite loops */
for (loop = 0; loop < MAXTAGLOOP; loop++) { for (loop = 0; loop < MAXTAGLOOP; loop++) {
const TValue *tm; const TValue *tm;
if (ttistable(t)) { /* 't' is a table? */ if (oldval != NULL) {
Table *h = hvalue(t); lua_assert(ttistable(t) && ttisnil(oldval));
TValue *oldval = cast(TValue *, luaH_get(h, key)); /* must check the metamethod */
/* if previous value is not nil, there must be a previous entry if ((tm = fasttm(L, hvalue(t)->metatable, TM_NEWINDEX)) == NULL &&
in the table; a metamethod has no relevance */
if (!ttisnil(oldval) ||
/* previous value is nil; must check the metamethod */
((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL &&
/* no metamethod; is there a previous entry in the table? */ /* no metamethod; is there a previous entry in the table? */
(oldval != luaO_nilobject || (oldval != luaO_nilobject ||
/* no previous entry; must create one. (The next test is /* no previous entry; must create one. (The next test is
always true; we only need the assignment.) */ always true; we only need the assignment.) */
(oldval = luaH_newkey(L, h, key), 1)))) { (oldval = luaH_newkey(L, hvalue(t), key), 1))) {
/* no metamethod and (now) there is an entry with given key */ /* no metamethod and (now) there is an entry with given key */
setobj2t(L, oldval, val); /* assign new value to that entry */ setobj2t(L, cast(TValue *, oldval), val);
invalidateTMcache(h); invalidateTMcache(hvalue(t));
luaC_barrierback(L, h, val); luaC_barrierback(L, hvalue(t), val);
return; return;
} }
/* else will try the metamethod */ /* else will try the metamethod */
} }
else /* not a table; check metamethod */ else { /* not a table; check metamethod */
if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
luaG_typeerror(L, t, "index"); luaG_typeerror(L, t, "index");
}
/* try the metamethod */ /* try the metamethod */
if (ttisfunction(tm)) { if (ttisfunction(tm)) {
luaT_callTM(L, tm, t, key, val, 0); luaT_callTM(L, tm, t, key, val, 0);
return; return;
} }
t = tm; /* else repeat assignment over 'tm' */ t = tm; /* else repeat assignment over 'tm' */
if (luaV_fastset(L, t, key, oldval, luaH_get, val))
return; /* done */
/* else loop */
} }
luaG_runerror(L, "settable chain too long; possible loop"); luaG_runerror(L, "settable chain too long; possible loop");
} }
@@ -453,6 +452,17 @@ int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0)
/* copy strings in stack from top - n up to top - 1 to buffer */
static void copy2buff (StkId top, int n, char *buff) {
size_t tl = 0; /* size already copied */
do {
size_t l = vslen(top - n); /* length of string being copied */
memcpy(buff + tl, svalue(top - n), l * sizeof(char));
tl += l;
} while (--n > 0);
}
/* /*
** Main operation for concatenation: concat 'total' values in the stack, ** Main operation for concatenation: concat 'total' values in the stack,
** from 'L->top - total' up to 'L->top - 1'. ** from 'L->top - total' up to 'L->top - 1'.
@@ -472,24 +482,24 @@ void luaV_concat (lua_State *L, int total) {
else { else {
/* at least two non-empty string values; get as many as possible */ /* at least two non-empty string values; get as many as possible */
size_t tl = vslen(top - 1); size_t tl = vslen(top - 1);
char *buffer; TString *ts;
int i; /* collect total length and number of strings */
/* collect total length */ for (n = 1; n < total && tostring(L, top - n - 1); n++) {
for (i = 1; i < total && tostring(L, top-i-1); i++) { size_t l = vslen(top - n - 1);
size_t l = vslen(top - i - 1);
if (l >= (MAX_SIZE/sizeof(char)) - tl) if (l >= (MAX_SIZE/sizeof(char)) - tl)
luaG_runerror(L, "string length overflow"); luaG_runerror(L, "string length overflow");
tl += l; tl += l;
} }
buffer = luaZ_openspace(L, &G(L)->buff, tl); if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */
tl = 0; char buff[LUAI_MAXSHORTLEN];
n = i; copy2buff(top, n, buff); /* copy strings to buffer */
do { /* copy all strings to buffer */ ts = luaS_newlstr(L, buff, tl);
size_t l = vslen(top - i); }
memcpy(buffer+tl, svalue(top-i), l * sizeof(char)); else { /* long string; copy strings directly to final result */
tl += l; ts = luaS_createlngstrobj(L, tl);
} while (--i > 0); copy2buff(top, n, getstr(ts));
setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl)); /* create result */ }
setsvalue2s(L, top - n, ts); /* create result */
} }
total -= n-1; /* got 'n' strings to create 1 new */ total -= n-1; /* got 'n' strings to create 1 new */
L->top -= n-1; /* popped 'n' strings and pushed one */ L->top -= n-1; /* popped 'n' strings and pushed one */
@@ -710,27 +720,20 @@ void luaV_finishOp (lua_State *L) {
** some macros for common tasks in 'luaV_execute' ** some macros for common tasks in 'luaV_execute'
*/ */
#if !defined(luai_runtimecheck)
#define luai_runtimecheck(L, c) /* void */
#endif
#define RA(i) (base+GETARG_A(i)) #define RA(i) (base+GETARG_A(i))
/* to be used after possible stack reallocation */
#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
#define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
#define KBx(i) \
(k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++)))
/* execute a jump instruction */ /* execute a jump instruction */
#define dojump(ci,i,e) \ #define dojump(ci,i,e) \
{ int a = GETARG_A(i); \ { int a = GETARG_A(i); \
if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \ if (a != 0) luaF_close(L, ci->u.l.base + a - 1); \
ci->u.l.savedpc += GETARG_sBx(i) + e; } ci->u.l.savedpc += GETARG_sBx(i) + e; }
/* for test instructions, execute the jump instruction that follows it */ /* for test instructions, execute the jump instruction that follows it */
@@ -740,34 +743,49 @@ void luaV_finishOp (lua_State *L) {
#define Protect(x) { {x;}; base = ci->u.l.base; } #define Protect(x) { {x;}; base = ci->u.l.base; }
#define checkGC(L,c) \ #define checkGC(L,c) \
Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ { luaC_condGC(L, L->top = (c), /* limit of live values */ \
luaC_step(L); \ Protect(L->top = ci->top)); /* restore top */ \
L->top = ci->top;}) /* restore top */ \ luai_threadyield(L); }
luai_threadyield(L); )
#define vmdispatch(o) switch(o) #define vmdispatch(o) switch(o)
#define vmcase(l) case l: #define vmcase(l) case l:
#define vmbreak break #define vmbreak break
/*
** copy of 'luaV_gettable', but protecting call to potential metamethod
** (which can reallocate the stack)
*/
#define gettableProtected(L,t,k,v) { const TValue *aux; \
if (luaV_fastget(L,t,k,aux,luaH_get)) { setobj2s(L, v, aux); } \
else Protect(luaV_finishget(L,t,k,v,aux)); }
/* same for 'luaV_settable' */
#define settableProtected(L,t,k,v) { const TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
Protect(luaV_finishset(L,t,k,v,slot)); }
void luaV_execute (lua_State *L) { void luaV_execute (lua_State *L) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
LClosure *cl; LClosure *cl;
TValue *k; TValue *k;
StkId base; StkId base;
ci->callstatus |= CIST_FRESH; /* fresh invocation of 'luaV_execute" */
newframe: /* reentry point when frame changes (call/return) */ newframe: /* reentry point when frame changes (call/return) */
lua_assert(ci == L->ci); lua_assert(ci == L->ci);
cl = clLvalue(ci->func); cl = clLvalue(ci->func); /* local reference to function's closure */
k = cl->p->k; k = cl->p->k; /* local reference to function's constant table */
base = ci->u.l.base; base = ci->u.l.base; /* local copy of function's base */
/* main loop of interpreter */ /* main loop of interpreter */
for (;;) { for (;;) {
Instruction i = *(ci->u.l.savedpc++); Instruction i = *(ci->u.l.savedpc++);
StkId ra; StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT))
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
Protect(luaG_traceexec(L)); Protect(luaG_traceexec(L));
}
/* WARNING: several calls may realloc the stack and invalidate 'ra' */ /* WARNING: several calls may realloc the stack and invalidate 'ra' */
ra = RA(i); ra = RA(i);
lua_assert(base == ci->u.l.base); lua_assert(base == ci->u.l.base);
@@ -807,17 +825,22 @@ void luaV_execute (lua_State *L) {
vmbreak; vmbreak;
} }
vmcase(OP_GETTABUP) { vmcase(OP_GETTABUP) {
int b = GETARG_B(i); TValue *upval = cl->upvals[GETARG_B(i)]->v;
Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra)); TValue *rc = RKC(i);
gettableProtected(L, upval, rc, ra);
vmbreak; vmbreak;
} }
vmcase(OP_GETTABLE) { vmcase(OP_GETTABLE) {
Protect(luaV_gettable(L, RB(i), RKC(i), ra)); StkId rb = RB(i);
TValue *rc = RKC(i);
gettableProtected(L, rb, rc, ra);
vmbreak; vmbreak;
} }
vmcase(OP_SETTABUP) { vmcase(OP_SETTABUP) {
int a = GETARG_A(i); TValue *upval = cl->upvals[GETARG_A(i)]->v;
Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i))); TValue *rb = RKB(i);
TValue *rc = RKC(i);
settableProtected(L, upval, rb, rc);
vmbreak; vmbreak;
} }
vmcase(OP_SETUPVAL) { vmcase(OP_SETUPVAL) {
@@ -827,7 +850,9 @@ void luaV_execute (lua_State *L) {
vmbreak; vmbreak;
} }
vmcase(OP_SETTABLE) { vmcase(OP_SETTABLE) {
Protect(luaV_settable(L, ra, RKB(i), RKC(i))); TValue *rb = RKB(i);
TValue *rc = RKC(i);
settableProtected(L, ra, rb, rc);
vmbreak; vmbreak;
} }
vmcase(OP_NEWTABLE) { vmcase(OP_NEWTABLE) {
@@ -841,9 +866,15 @@ void luaV_execute (lua_State *L) {
vmbreak; vmbreak;
} }
vmcase(OP_SELF) { vmcase(OP_SELF) {
const TValue *aux;
StkId rb = RB(i); StkId rb = RB(i);
setobjs2s(L, ra+1, rb); TValue *rc = RKC(i);
Protect(luaV_gettable(L, rb, RKC(i), ra)); TString *key = tsvalue(rc); /* key must be a string */
setobjs2s(L, ra + 1, rb);
if (luaV_fastget(L, rb, key, aux, luaH_getstr)) {
setobj2s(L, ra, aux);
}
else Protect(luaV_finishget(L, rb, rc, ra, aux));
vmbreak; vmbreak;
} }
vmcase(OP_ADD) { vmcase(OP_ADD) {
@@ -1030,7 +1061,7 @@ void luaV_execute (lua_State *L) {
StkId rb; StkId rb;
L->top = base + c + 1; /* mark the end of concat operands */ L->top = base + c + 1; /* mark the end of concat operands */
Protect(luaV_concat(L, c - b + 1)); Protect(luaV_concat(L, c - b + 1));
ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */ ra = RA(i); /* 'luaV_concat' may invoke TMs and move the stack */
rb = base + b; rb = base + b;
setobjs2s(L, ra, rb); setobjs2s(L, ra, rb);
checkGC(L, (ra >= rb ? ra + 1 : rb)); checkGC(L, (ra >= rb ? ra + 1 : rb));
@@ -1046,7 +1077,7 @@ void luaV_execute (lua_State *L) {
TValue *rb = RKB(i); TValue *rb = RKB(i);
TValue *rc = RKC(i); TValue *rc = RKC(i);
Protect( Protect(
if (cast_int(luaV_equalobj(L, rb, rc)) != GETARG_A(i)) if (luaV_equalobj(L, rb, rc) != GETARG_A(i))
ci->u.l.savedpc++; ci->u.l.savedpc++;
else else
donextjump(ci); donextjump(ci);
@@ -1094,12 +1125,12 @@ void luaV_execute (lua_State *L) {
lua_checksig(L); lua_checksig(L);
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
if (luaD_precall(L, ra, nresults)) { /* C function? */ if (luaD_precall(L, ra, nresults)) { /* C function? */
if (nresults >= 0) L->top = ci->top; /* adjust results */ if (nresults >= 0)
base = ci->u.l.base; L->top = ci->top; /* adjust results */
Protect((void)0); /* update 'base' */
} }
else { /* Lua function */ else { /* Lua function */
ci = L->ci; ci = L->ci;
ci->callstatus |= CIST_REENTRY;
goto newframe; /* restart luaV_execute over new Lua function */ goto newframe; /* restart luaV_execute over new Lua function */
} }
vmbreak; vmbreak;
@@ -1109,8 +1140,9 @@ void luaV_execute (lua_State *L) {
lua_checksig(L); lua_checksig(L);
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */ if (luaD_precall(L, ra, LUA_MULTRET)) { /* C function? */
base = ci->u.l.base; Protect((void)0); /* update 'base' */
}
else { else {
/* tail call: put called frame (n) in place of caller one (o) */ /* tail call: put called frame (n) in place of caller one (o) */
CallInfo *nci = L->ci; /* called frame */ CallInfo *nci = L->ci; /* called frame */
@@ -1138,8 +1170,8 @@ void luaV_execute (lua_State *L) {
vmcase(OP_RETURN) { vmcase(OP_RETURN) {
int b = GETARG_B(i); int b = GETARG_B(i);
if (cl->p->sp->sizep > 0) luaF_close(L, base); if (cl->p->sp->sizep > 0) luaF_close(L, base);
b = luaD_poscall(L, ra, (b != 0 ? b - 1 : L->top - ra)); b = luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra)));
if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */ if (ci->callstatus & CIST_FRESH) /* local 'ci' still from callee */
return; /* external invocation: return */ return; /* external invocation: return */
else { /* invocation via reentry: continue execution */ else { /* invocation via reentry: continue execution */
ci = L->ci; ci = L->ci;
@@ -1152,7 +1184,7 @@ void luaV_execute (lua_State *L) {
vmcase(OP_FORLOOP) { vmcase(OP_FORLOOP) {
if (ttisinteger(ra)) { /* integer loop? */ if (ttisinteger(ra)) { /* integer loop? */
lua_Integer step = ivalue(ra + 2); lua_Integer step = ivalue(ra + 2);
lua_Integer idx = ivalue(ra) + step; /* increment index */ lua_Integer idx = intop(+, ivalue(ra), step); /* increment index */
lua_Integer limit = ivalue(ra + 1); lua_Integer limit = ivalue(ra + 1);
if ((0 < step) ? (idx <= limit) : (limit <= idx)) { if ((0 < step) ? (idx <= limit) : (limit <= idx)) {
ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ ci->u.l.savedpc += GETARG_sBx(i); /* jump back */
@@ -1184,7 +1216,7 @@ void luaV_execute (lua_State *L) {
/* all values are integer */ /* all values are integer */
lua_Integer initv = (stopnow ? 0 : ivalue(init)); lua_Integer initv = (stopnow ? 0 : ivalue(init));
setivalue(plimit, ilimit); setivalue(plimit, ilimit);
setivalue(init, initv - ivalue(pstep)); setivalue(init, intop(-, initv, ivalue(pstep)));
} }
else { /* try making all values floats */ else { /* try making all values floats */
lua_Number ninit; lua_Number nlimit; lua_Number nstep; lua_Number ninit; lua_Number nlimit; lua_Number nstep;
@@ -1207,7 +1239,7 @@ void luaV_execute (lua_State *L) {
setobjs2s(L, cb+1, ra+1); setobjs2s(L, cb+1, ra+1);
setobjs2s(L, cb, ra); setobjs2s(L, cb, ra);
L->top = cb + 3; /* func. + 2 args (state and index) */ L->top = cb + 3; /* func. + 2 args (state and index) */
Protect(luaD_call(L, cb, GETARG_C(i), 1)); Protect(luaD_call(L, cb, GETARG_C(i)));
L->top = ci->top; L->top = ci->top;
i = *(ci->u.l.savedpc++); /* go to next instruction */ i = *(ci->u.l.savedpc++); /* go to next instruction */
ra = RA(i); ra = RA(i);
@@ -1233,11 +1265,10 @@ void luaV_execute (lua_State *L) {
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
c = GETARG_Ax(*ci->u.l.savedpc++); c = GETARG_Ax(*ci->u.l.savedpc++);
} }
luai_runtimecheck(L, ttistable(ra));
h = hvalue(ra); h = hvalue(ra);
last = ((c-1)*LFIELDS_PER_FLUSH) + n; last = ((c-1)*LFIELDS_PER_FLUSH) + n;
if (last > h->sizearray) /* needs more space? */ if (last > h->sizearray) /* needs more space? */
luaH_resizearray(L, h, last); /* pre-allocate it at once */ luaH_resizearray(L, h, last); /* preallocate it at once */
for (; n > 0; n--) { for (; n > 0; n--) {
TValue *val = ra+n; TValue *val = ra+n;
luaH_setint(L, h, last--, val); luaH_setint(L, h, last--, val);
@@ -1257,23 +1288,21 @@ void luaV_execute (lua_State *L) {
vmbreak; vmbreak;
} }
vmcase(OP_VARARG) { vmcase(OP_VARARG) {
int b = GETARG_B(i) - 1; int b = GETARG_B(i) - 1; /* required results */
int j; int j;
int n = cast_int(base - ci->func) - cl->p->sp->numparams - 1; int n = cast_int(base - ci->func) - cl->p->sp->numparams - 1;
if (n < 0) /* less arguments than parameters? */
n = 0; /* no vararg arguments */
if (b < 0) { /* B == 0? */ if (b < 0) { /* B == 0? */
b = n; /* get all var. arguments */ b = n; /* get all var. arguments */
Protect(luaD_checkstack(L, n)); Protect(luaD_checkstack(L, n));
ra = RA(i); /* previous call may change the stack */ ra = RA(i); /* previous call may change the stack */
L->top = ra + n; L->top = ra + n;
} }
for (j = 0; j < b; j++) { for (j = 0; j < b && j < n; j++)
if (j < n) { setobjs2s(L, ra + j, base - n + j);
setobjs2s(L, ra + j, base - n + j); for (; j < b; j++) /* complete required results with nil */
} setnilvalue(ra + j);
else {
setnilvalue(ra + j);
}
}
vmbreak; vmbreak;
} }
vmcase(OP_EXTRAARG) { vmcase(OP_EXTRAARG) {

56
3rd/lua/lvm.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lvm.h,v 2.35 2015/02/20 14:27:53 roberto Exp $ ** $Id: lvm.h,v 2.39 2015/09/09 13:44:07 roberto Exp $
** Lua virtual machine ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -48,15 +48,61 @@
#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) #define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2)
/*
** fast track for 'gettable': 1 means 'aux' points to resulted value;
** 0 means 'aux' is metamethod (if 't' is a table) or NULL. 'f' is
** the raw get function to use.
*/
#define luaV_fastget(L,t,k,aux,f) \
(!ttistable(t) \
? (aux = NULL, 0) /* not a table; 'aux' is NULL and result is 0 */ \
: (aux = f(hvalue(t), k), /* else, do raw access */ \
!ttisnil(aux) ? 1 /* result not nil? 'aux' has it */ \
: (aux = fasttm(L, hvalue(t)->metatable, TM_INDEX), /* get metamethod */\
aux != NULL ? 0 /* has metamethod? must call it */ \
: (aux = luaO_nilobject, 1)))) /* else, final result is nil */
/*
** standard implementation for 'gettable'
*/
#define luaV_gettable(L,t,k,v) { const TValue *aux; \
if (luaV_fastget(L,t,k,aux,luaH_get)) { setobj2s(L, v, aux); } \
else luaV_finishget(L,t,k,v,aux); }
/*
** Fast track for set table. If 't' is a table and 't[k]' is not nil,
** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
** return false with 'slot' equal to NULL (if 't' is not a table) or
** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
** returns true, there is no need to 'invalidateTMcache', because the
** call is not creating a new entry.
*/
#define luaV_fastset(L,t,k,slot,f,v) \
(!ttistable(t) \
? (slot = NULL, 0) \
: (slot = f(hvalue(t), k), \
ttisnil(slot) ? 0 \
: (luaC_barrierback(L, hvalue(t), v), \
setobj2t(L, cast(TValue *,slot), v), \
1)))
#define luaV_settable(L,t,k,v) { const TValue *slot; \
if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
luaV_finishset(L,t,k,v,slot); }
LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2); LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r); LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r); LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n); LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode); LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);
LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key, LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
StkId val); StkId val, const TValue *tm);
LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key, LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
StkId val); StkId val, const TValue *oldval);
LUAI_FUNC void luaV_finishOp (lua_State *L); LUAI_FUNC void luaV_finishOp (lua_State *L);
LUAI_FUNC void luaV_execute (lua_State *L); LUAI_FUNC void luaV_execute (lua_State *L);
LUAI_FUNC void luaV_concat (lua_State *L, int total); LUAI_FUNC void luaV_concat (lua_State *L, int total);

12
3rd/lua/lzio.c
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lzio.c,v 1.36 2014/11/02 19:19:04 roberto Exp $ ** $Id: lzio.c,v 1.37 2015/09/08 15:41:05 roberto Exp $
** Buffered streams ** Buffered streams
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -66,13 +66,3 @@ size_t luaZ_read (ZIO *z, void *b, size_t n) {
return 0; return 0;
} }
/* ------------------------------------------------------------------------ */
char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
if (n > buff->buffsize) {
if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
luaZ_resizebuffer(L, buff, n);
}
return buff->buffer;
}

3
3rd/lua/lzio.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: lzio.h,v 1.30 2014/12/19 17:26:14 roberto Exp $ ** $Id: lzio.h,v 1.31 2015/09/08 15:41:05 roberto Exp $
** Buffered streams ** Buffered streams
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -44,7 +44,6 @@ typedef struct Mbuffer {
#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) #define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0)
LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
void *data); void *data);
LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */ LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n); /* read next n bytes */