From ea7d7ba19f80f0470c90a9b3c03484a843ad03a5 Mon Sep 17 00:00:00 2001 From: Raimon Zamora Date: Tue, 12 May 2026 22:56:20 +0200 Subject: [PATCH] =?UTF-8?q?VERSI=C3=93=201.5.5:=20-=20Ningun=20canvi=20en?= =?UTF-8?q?=20el=20codi,=20es=20equivalent=20a=20la=201.5.4=20-=20Llevades?= =?UTF-8?q?=20les=20llibreries=20est=C3=A0tiques,=20que=20en=20Windows=20(?= =?UTF-8?q?como=20no)=20dona=20pel=20cul?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lagueirtofile | 8 +- source/external/lua/lapi.c | 1473 +++++++++++++++ source/external/lua/lauxlib.c | 1202 ++++++++++++ source/external/lua/lbaselib.c | 559 ++++++ source/external/lua/lcode.c | 1971 +++++++++++++++++++ source/external/lua/lcorolib.c | 225 +++ source/external/lua/lctype.c | 64 + source/external/lua/ldblib.c | 477 +++++ source/external/lua/ldebug.c | 979 ++++++++++ source/external/lua/ldo.c | 1164 ++++++++++++ source/external/lua/ldump.c | 307 +++ source/external/lua/lfunc.c | 314 ++++ source/external/lua/lgc.c | 1804 ++++++++++++++++++ source/external/lua/lib/linux/liblua.a | Bin 606438 -> 0 bytes source/external/lua/lib/windows/liblua.a | Bin 422758 -> 0 bytes source/external/lua/linit.c | 63 + source/external/lua/liolib.c | 841 +++++++++ source/external/lua/llex.c | 604 ++++++ source/external/lua/lmathlib.c | 765 ++++++++ source/external/lua/lmem.c | 215 +++ source/external/lua/loadlib.c | 858 +++++++++ source/external/lua/lobject.c | 718 +++++++ source/external/lua/lopcodes.c | 140 ++ source/external/lua/loslib.c | 432 +++++ source/external/lua/lparser.c | 2193 ++++++++++++++++++++++ source/external/lua/lstate.c | 420 +++++ source/external/lua/lstring.c | 353 ++++ source/external/lua/lstrlib.c | 1894 +++++++++++++++++++ source/external/lua/ltable.c | 1355 +++++++++++++ source/external/lua/ltablib.c | 426 +++++ source/external/lua/ltm.c | 364 ++++ source/external/lua/lua.hpp | 4 +- source/external/lua/lundump.c | 424 +++++ source/external/lua/lutf8lib.c | 291 +++ source/external/lua/lvm.c | 1972 +++++++++++++++++++ source/external/lua/lzio.c | 89 + source/mini/version.h | 2 +- 37 files changed, 24963 insertions(+), 7 deletions(-) create mode 100644 source/external/lua/lapi.c create mode 100644 source/external/lua/lauxlib.c create mode 100644 source/external/lua/lbaselib.c create mode 100644 source/external/lua/lcode.c create mode 100644 source/external/lua/lcorolib.c create mode 100644 source/external/lua/lctype.c create mode 100644 source/external/lua/ldblib.c create mode 100644 source/external/lua/ldebug.c create mode 100644 source/external/lua/ldo.c create mode 100644 source/external/lua/ldump.c create mode 100644 source/external/lua/lfunc.c create mode 100644 source/external/lua/lgc.c delete mode 100644 source/external/lua/lib/linux/liblua.a delete mode 100644 source/external/lua/lib/windows/liblua.a create mode 100644 source/external/lua/linit.c create mode 100644 source/external/lua/liolib.c create mode 100644 source/external/lua/llex.c create mode 100644 source/external/lua/lmathlib.c create mode 100644 source/external/lua/lmem.c create mode 100644 source/external/lua/loadlib.c create mode 100644 source/external/lua/lobject.c create mode 100644 source/external/lua/lopcodes.c create mode 100644 source/external/lua/loslib.c create mode 100644 source/external/lua/lparser.c create mode 100644 source/external/lua/lstate.c create mode 100644 source/external/lua/lstring.c create mode 100644 source/external/lua/lstrlib.c create mode 100644 source/external/lua/ltable.c create mode 100644 source/external/lua/ltablib.c create mode 100644 source/external/lua/ltm.c create mode 100644 source/external/lua/lundump.c create mode 100644 source/external/lua/lutf8lib.c create mode 100644 source/external/lua/lvm.c create mode 100644 source/external/lua/lzio.c diff --git a/lagueirtofile b/lagueirtofile index e9e8b89..c744835 100644 --- a/lagueirtofile +++ b/lagueirtofile @@ -1,27 +1,27 @@ [linux] cppflags = -D LUA_USE_LINUX -Wall -Os -ffunction-sections -fdata-sections -std=c++20 -Isource -libs = -Wl,--gc-sections -lSDL3 -lGL -Lsource/external/lua/lib/linux -llua -ldl -lm +libs = -Wl,--gc-sections -lSDL3 -lGL executable = mini sourcepath = source+ buildpath = build [linux_debug] default cppflags = -D LUA_USE_LINUX -D DEBUG -g -Wall -std=c++20 -Isource -libs = -lSDL3 -lGL -Lsource/external/lua/lib/linux -llua -ldl -lm +libs = -lSDL3 -lGL executable = mini_debug sourcepath = source+ buildpath = build [windows] cppflags = -Wall -Os -ffunction-sections -fdata-sections -std=c++20 -Isource -libs = icon.res -Wl,--gc-sections -lmingw32 -lSDL3 -lopengl32 -static-libstdc++ -static-libgcc -lpthread -mwindows -Lsource/external/lua/lib/windows -llua +libs = icon.res -Wl,--gc-sections -lmingw32 -lSDL3 -lopengl32 -static-libstdc++ -static-libgcc -lpthread -mwindows executable = mini.exe sourcepath = source+ buildpath = build [windows_debug] cppflags = -D DEBUG -g -Wall -std=c++20 -Isource -libs = -lmingw32 -lSDL3 -lopengl32 -Lsource/external/lua/lib/windows -llua +libs = -lmingw32 -lSDL3 -lopengl32 executable = mini_debug.exe sourcepath = source+ buildpath = build diff --git a/source/external/lua/lapi.c b/source/external/lua/lapi.c new file mode 100644 index 0000000..27fa524 --- /dev/null +++ b/source/external/lua/lapi.c @@ -0,0 +1,1473 @@ +/* +** $Id: lapi.c $ +** Lua API +** See Copyright Notice in lua.h +*/ + +#define lapi_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lundump.h" +#include "lvm.h" + + + +const char lua_ident[] = + "$LuaVersion: " LUA_COPYRIGHT " $" + "$LuaAuthors: " LUA_AUTHORS " $"; + + + +/* +** Test for a valid index (one that is not the 'nilvalue'). +*/ +#define isvalid(L, o) ((o) != &G(L)->nilvalue) + + +/* test for pseudo index */ +#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) + +/* test for upvalue */ +#define isupvalue(i) ((i) < LUA_REGISTRYINDEX) + + +/* +** Convert an acceptable index to a pointer to its respective value. +** Non-valid indices return the special nil value 'G(L)->nilvalue'. +*/ +static TValue *index2value (lua_State *L, int idx) { + CallInfo *ci = L->ci; + if (idx > 0) { + StkId o = ci->func.p + idx; + api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); + if (o >= L->top.p) return &G(L)->nilvalue; + else return s2v(o); + } + else if (!ispseudo(idx)) { /* negative index */ + api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), + "invalid index"); + return s2v(L->top.p + idx); + } + else if (idx == LUA_REGISTRYINDEX) + return &G(L)->l_registry; + else { /* upvalues */ + idx = LUA_REGISTRYINDEX - idx; + api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large"); + if (ttisCclosure(s2v(ci->func.p))) { /* C closure? */ + CClosure *func = clCvalue(s2v(ci->func.p)); + return (idx <= func->nupvalues) ? &func->upvalue[idx-1] + : &G(L)->nilvalue; + } + else { /* light C function or Lua function (through a hook)?) */ + api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function"); + return &G(L)->nilvalue; /* no upvalues */ + } + } +} + + + +/* +** Convert a valid actual index (not a pseudo-index) to its address. +*/ +static StkId index2stack (lua_State *L, int idx) { + CallInfo *ci = L->ci; + if (idx > 0) { + StkId o = ci->func.p + idx; + api_check(L, o < L->top.p, "invalid index"); + return o; + } + else { /* non-positive index */ + api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), + "invalid index"); + api_check(L, !ispseudo(idx), "invalid index"); + return L->top.p + idx; + } +} + + +LUA_API int lua_checkstack (lua_State *L, int n) { + int res; + CallInfo *ci; + lua_lock(L); + ci = L->ci; + api_check(L, n >= 0, "negative 'n'"); + if (L->stack_last.p - L->top.p > n) /* stack large enough? */ + res = 1; /* yes; check is OK */ + else /* need to grow stack */ + res = luaD_growstack(L, n, 0); + if (res && ci->top.p < L->top.p + n) + ci->top.p = L->top.p + n; /* adjust frame top */ + lua_unlock(L); + return res; +} + + +LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) { + int i; + if (from == to) return; + lua_lock(to); + api_checkpop(from, n); + api_check(from, G(from) == G(to), "moving among independent states"); + api_check(from, to->ci->top.p - to->top.p >= n, "stack overflow"); + from->top.p -= n; + for (i = 0; i < n; i++) { + setobjs2s(to, to->top.p, from->top.p + i); + to->top.p++; /* stack already checked by previous 'api_check' */ + } + lua_unlock(to); +} + + +LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { + lua_CFunction old; + lua_lock(L); + old = G(L)->panic; + G(L)->panic = panicf; + lua_unlock(L); + return old; +} + + +LUA_API lua_Number lua_version (lua_State *L) { + UNUSED(L); + return LUA_VERSION_NUM; +} + + + +/* +** basic stack manipulation +*/ + + +/* +** convert an acceptable stack index into an absolute index +*/ +LUA_API int lua_absindex (lua_State *L, int idx) { + return (idx > 0 || ispseudo(idx)) + ? idx + : cast_int(L->top.p - L->ci->func.p) + idx; +} + + +LUA_API int lua_gettop (lua_State *L) { + return cast_int(L->top.p - (L->ci->func.p + 1)); +} + + +LUA_API void lua_settop (lua_State *L, int idx) { + CallInfo *ci; + StkId func, newtop; + ptrdiff_t diff; /* difference for new top */ + lua_lock(L); + ci = L->ci; + func = ci->func.p; + if (idx >= 0) { + api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); + diff = ((func + 1) + idx) - L->top.p; + for (; diff > 0; diff--) + setnilvalue(s2v(L->top.p++)); /* clear new slots */ + } + else { + api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); + diff = idx + 1; /* will "subtract" index (as it is negative) */ + } + newtop = L->top.p + diff; + if (diff < 0 && L->tbclist.p >= newtop) { + lua_assert(ci->callstatus & CIST_TBC); + newtop = luaF_close(L, newtop, CLOSEKTOP, 0); + } + L->top.p = newtop; /* correct top only after closing any upvalue */ + lua_unlock(L); +} + + +LUA_API void lua_closeslot (lua_State *L, int idx) { + StkId level; + lua_lock(L); + level = index2stack(L, idx); + api_check(L, (L->ci->callstatus & CIST_TBC) && (L->tbclist.p == level), + "no variable to close at given level"); + level = luaF_close(L, level, CLOSEKTOP, 0); + setnilvalue(s2v(level)); + lua_unlock(L); +} + + +/* +** Reverse the stack segment from 'from' to 'to' +** (auxiliary to 'lua_rotate') +** Note that we move(copy) only the value inside the stack. +** (We do not move additional fields that may exist.) +*/ +static void reverse (lua_State *L, StkId from, StkId to) { + for (; from < to; from++, to--) { + TValue temp; + setobj(L, &temp, s2v(from)); + setobjs2s(L, from, to); + setobj2s(L, to, &temp); + } +} + + +/* +** Let x = AB, where A is a prefix of length 'n'. Then, +** rotate x n == BA. But BA == (A^r . B^r)^r. +*/ +LUA_API void lua_rotate (lua_State *L, int idx, int n) { + StkId p, t, m; + lua_lock(L); + t = L->top.p - 1; /* end of stack segment being rotated */ + p = index2stack(L, idx); /* start of segment */ + api_check(L, L->tbclist.p < p, "moving a to-be-closed slot"); + api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); + m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ + reverse(L, p, m); /* reverse the prefix with length 'n' */ + reverse(L, m + 1, t); /* reverse the suffix */ + reverse(L, p, t); /* reverse the entire segment */ + lua_unlock(L); +} + + +LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) { + TValue *fr, *to; + lua_lock(L); + fr = index2value(L, fromidx); + to = index2value(L, toidx); + api_check(L, isvalid(L, to), "invalid index"); + setobj(L, to, fr); + if (isupvalue(toidx)) /* function upvalue? */ + luaC_barrier(L, clCvalue(s2v(L->ci->func.p)), fr); + /* LUA_REGISTRYINDEX does not need gc barrier + (collector revisits it before finishing collection) */ + lua_unlock(L); +} + + +LUA_API void lua_pushvalue (lua_State *L, int idx) { + lua_lock(L); + setobj2s(L, L->top.p, index2value(L, idx)); + api_incr_top(L); + lua_unlock(L); +} + + + +/* +** access functions (stack -> C) +*/ + + +LUA_API int lua_type (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return (isvalid(L, o) ? ttype(o) : LUA_TNONE); +} + + +LUA_API const char *lua_typename (lua_State *L, int t) { + UNUSED(L); + api_check(L, LUA_TNONE <= t && t < LUA_NUMTYPES, "invalid type"); + return ttypename(t); +} + + +LUA_API int lua_iscfunction (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return (ttislcf(o) || (ttisCclosure(o))); +} + + +LUA_API int lua_isinteger (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return ttisinteger(o); +} + + +LUA_API int lua_isnumber (lua_State *L, int idx) { + lua_Number n; + const TValue *o = index2value(L, idx); + return tonumber(o, &n); +} + + +LUA_API int lua_isstring (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return (ttisstring(o) || cvt2str(o)); +} + + +LUA_API int lua_isuserdata (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return (ttisfulluserdata(o) || ttislightuserdata(o)); +} + + +LUA_API int lua_rawequal (lua_State *L, int index1, int index2) { + const TValue *o1 = index2value(L, index1); + const TValue *o2 = index2value(L, index2); + return (isvalid(L, o1) && isvalid(L, o2)) ? luaV_rawequalobj(o1, o2) : 0; +} + + +LUA_API void lua_arith (lua_State *L, int op) { + lua_lock(L); + if (op != LUA_OPUNM && op != LUA_OPBNOT) + api_checkpop(L, 2); /* all other operations expect two operands */ + else { /* for unary operations, add fake 2nd operand */ + api_checkpop(L, 1); + setobjs2s(L, L->top.p, L->top.p - 1); + api_incr_top(L); + } + /* first operand at top - 2, second at top - 1; result go to top - 2 */ + luaO_arith(L, op, s2v(L->top.p - 2), s2v(L->top.p - 1), L->top.p - 2); + L->top.p--; /* pop second operand */ + lua_unlock(L); +} + + +LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) { + const TValue *o1; + const TValue *o2; + int i = 0; + lua_lock(L); /* may call tag method */ + o1 = index2value(L, index1); + o2 = index2value(L, index2); + if (isvalid(L, o1) && isvalid(L, o2)) { + switch (op) { + case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break; + case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break; + case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break; + default: api_check(L, 0, "invalid option"); + } + } + lua_unlock(L); + return i; +} + + +LUA_API unsigned (lua_numbertocstring) (lua_State *L, int idx, char *buff) { + const TValue *o = index2value(L, idx); + if (ttisnumber(o)) { + unsigned len = luaO_tostringbuff(o, buff); + buff[len++] = '\0'; /* add final zero */ + return len; + } + else + return 0; +} + + +LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) { + size_t sz = luaO_str2num(s, s2v(L->top.p)); + if (sz != 0) + api_incr_top(L); + return sz; +} + + +LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) { + lua_Number n = 0; + const TValue *o = index2value(L, idx); + int isnum = tonumber(o, &n); + if (pisnum) + *pisnum = isnum; + return n; +} + + +LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) { + lua_Integer res = 0; + const TValue *o = index2value(L, idx); + int isnum = tointeger(o, &res); + if (pisnum) + *pisnum = isnum; + return res; +} + + +LUA_API int lua_toboolean (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return !l_isfalse(o); +} + + +LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { + TValue *o; + lua_lock(L); + o = index2value(L, idx); + if (!ttisstring(o)) { + if (!cvt2str(o)) { /* not convertible? */ + if (len != NULL) *len = 0; + lua_unlock(L); + return NULL; + } + luaO_tostring(L, o); + luaC_checkGC(L); + o = index2value(L, idx); /* previous call may reallocate the stack */ + } + lua_unlock(L); + if (len != NULL) + return getlstr(tsvalue(o), *len); + else + return getstr(tsvalue(o)); +} + + +LUA_API lua_Unsigned lua_rawlen (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + switch (ttypetag(o)) { + case LUA_VSHRSTR: return cast(lua_Unsigned, tsvalue(o)->shrlen); + case LUA_VLNGSTR: return cast(lua_Unsigned, tsvalue(o)->u.lnglen); + case LUA_VUSERDATA: return cast(lua_Unsigned, uvalue(o)->len); + case LUA_VTABLE: { + lua_Unsigned res; + lua_lock(L); + res = luaH_getn(L, hvalue(o)); + lua_unlock(L); + return res; + } + default: return 0; + } +} + + +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + if (ttislcf(o)) return fvalue(o); + else if (ttisCclosure(o)) + return clCvalue(o)->f; + else return NULL; /* not a C function */ +} + + +l_sinline void *touserdata (const TValue *o) { + switch (ttype(o)) { + case LUA_TUSERDATA: return getudatamem(uvalue(o)); + case LUA_TLIGHTUSERDATA: return pvalue(o); + default: return NULL; + } +} + + +LUA_API void *lua_touserdata (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return touserdata(o); +} + + +LUA_API lua_State *lua_tothread (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + return (!ttisthread(o)) ? NULL : thvalue(o); +} + + +/* +** Returns a pointer to the internal representation of an object. +** Note that ISO C does not allow the conversion of a pointer to +** function to a 'void*', so the conversion here goes through +** a 'size_t'. (As the returned pointer is only informative, this +** conversion should not be a problem.) +*/ +LUA_API const void *lua_topointer (lua_State *L, int idx) { + const TValue *o = index2value(L, idx); + switch (ttypetag(o)) { + case LUA_VLCF: return cast_voidp(cast_sizet(fvalue(o))); + case LUA_VUSERDATA: case LUA_VLIGHTUSERDATA: + return touserdata(o); + default: { + if (iscollectable(o)) + return gcvalue(o); + else + return NULL; + } + } +} + + + +/* +** push functions (C -> stack) +*/ + + +LUA_API void lua_pushnil (lua_State *L) { + lua_lock(L); + setnilvalue(s2v(L->top.p)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { + lua_lock(L); + setfltvalue(s2v(L->top.p), n); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) { + lua_lock(L); + setivalue(s2v(L->top.p), n); + api_incr_top(L); + lua_unlock(L); +} + + +/* +** 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) { + TString *ts; + lua_lock(L); + ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); + setsvalue2s(L, L->top.p, ts); + api_incr_top(L); + luaC_checkGC(L); + lua_unlock(L); + return getstr(ts); +} + + +LUA_API const char *lua_pushexternalstring (lua_State *L, + const char *s, size_t len, lua_Alloc falloc, void *ud) { + TString *ts; + lua_lock(L); + api_check(L, len <= MAX_SIZE, "string too large"); + api_check(L, s[len] == '\0', "string not ending with zero"); + ts = luaS_newextlstr (L, s, len, falloc, ud); + setsvalue2s(L, L->top.p, ts); + api_incr_top(L); + luaC_checkGC(L); + lua_unlock(L); + return getstr(ts); +} + + +LUA_API const char *lua_pushstring (lua_State *L, const char *s) { + lua_lock(L); + if (s == NULL) + setnilvalue(s2v(L->top.p)); + else { + TString *ts; + ts = luaS_new(L, s); + setsvalue2s(L, L->top.p, ts); + s = getstr(ts); /* internal copy's address */ + } + api_incr_top(L); + luaC_checkGC(L); + lua_unlock(L); + return s; +} + + +LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt, + va_list argp) { + const char *ret; + lua_lock(L); + ret = luaO_pushvfstring(L, fmt, argp); + luaC_checkGC(L); + lua_unlock(L); + return ret; +} + + +LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { + const char *ret; + va_list argp; + lua_lock(L); + pushvfstring(L, argp, fmt, ret); + luaC_checkGC(L); + lua_unlock(L); + return ret; +} + + +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { + lua_lock(L); + if (n == 0) { + setfvalue(s2v(L->top.p), fn); + api_incr_top(L); + } + else { + int i; + CClosure *cl; + api_checkpop(L, n); + api_check(L, n <= MAXUPVAL, "upvalue index too large"); + cl = luaF_newCclosure(L, n); + cl->f = fn; + for (i = 0; i < n; i++) { + setobj2n(L, &cl->upvalue[i], s2v(L->top.p - n + i)); + /* does not need barrier because closure is white */ + lua_assert(iswhite(cl)); + } + L->top.p -= n; + setclCvalue(L, s2v(L->top.p), cl); + api_incr_top(L); + luaC_checkGC(L); + } + lua_unlock(L); +} + + +LUA_API void lua_pushboolean (lua_State *L, int b) { + lua_lock(L); + if (b) + setbtvalue(s2v(L->top.p)); + else + setbfvalue(s2v(L->top.p)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { + lua_lock(L); + setpvalue(s2v(L->top.p), p); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API int lua_pushthread (lua_State *L) { + lua_lock(L); + setthvalue(L, s2v(L->top.p), L); + api_incr_top(L); + lua_unlock(L); + return (mainthread(G(L)) == L); +} + + + +/* +** get functions (Lua -> stack) +*/ + + +static int auxgetstr (lua_State *L, const TValue *t, const char *k) { + lu_byte tag; + TString *str = luaS_new(L, k); + luaV_fastget(t, str, s2v(L->top.p), luaH_getstr, tag); + if (!tagisempty(tag)) + api_incr_top(L); + else { + setsvalue2s(L, L->top.p, str); + api_incr_top(L); + tag = luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, tag); + } + lua_unlock(L); + return novariant(tag); +} + + +/* +** The following function assumes that the registry cannot be a weak +** table; so, an emergency collection while using the global table +** cannot collect it. +*/ +static void getGlobalTable (lua_State *L, TValue *gt) { + Table *registry = hvalue(&G(L)->l_registry); + lu_byte tag = luaH_getint(registry, LUA_RIDX_GLOBALS, gt); + (void)tag; /* avoid not-used warnings when checks are off */ + api_check(L, novariant(tag) == LUA_TTABLE, "global table must exist"); +} + + +LUA_API int lua_getglobal (lua_State *L, const char *name) { + TValue gt; + lua_lock(L); + getGlobalTable(L, >); + return auxgetstr(L, >, name); +} + + +LUA_API int lua_gettable (lua_State *L, int idx) { + lu_byte tag; + TValue *t; + lua_lock(L); + api_checkpop(L, 1); + t = index2value(L, idx); + luaV_fastget(t, s2v(L->top.p - 1), s2v(L->top.p - 1), luaH_get, tag); + if (tagisempty(tag)) + tag = luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, tag); + lua_unlock(L); + return novariant(tag); +} + + +LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { + lua_lock(L); + return auxgetstr(L, index2value(L, idx), k); +} + + +LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) { + TValue *t; + lu_byte tag; + lua_lock(L); + t = index2value(L, idx); + luaV_fastgeti(t, n, s2v(L->top.p), tag); + if (tagisempty(tag)) { + TValue key; + setivalue(&key, n); + tag = luaV_finishget(L, t, &key, L->top.p, tag); + } + api_incr_top(L); + lua_unlock(L); + return novariant(tag); +} + + +static int finishrawget (lua_State *L, lu_byte tag) { + if (tagisempty(tag)) /* avoid copying empty items to the stack */ + setnilvalue(s2v(L->top.p)); + api_incr_top(L); + lua_unlock(L); + return novariant(tag); +} + + +l_sinline Table *gettable (lua_State *L, int idx) { + TValue *t = index2value(L, idx); + api_check(L, ttistable(t), "table expected"); + return hvalue(t); +} + + +LUA_API int lua_rawget (lua_State *L, int idx) { + Table *t; + lu_byte tag; + lua_lock(L); + api_checkpop(L, 1); + t = gettable(L, idx); + tag = luaH_get(t, s2v(L->top.p - 1), s2v(L->top.p - 1)); + L->top.p--; /* pop key */ + return finishrawget(L, tag); +} + + +LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) { + Table *t; + lu_byte tag; + lua_lock(L); + t = gettable(L, idx); + luaH_fastgeti(t, n, s2v(L->top.p), tag); + return finishrawget(L, tag); +} + + +LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) { + Table *t; + TValue k; + lua_lock(L); + t = gettable(L, idx); + setpvalue(&k, cast_voidp(p)); + return finishrawget(L, luaH_get(t, &k, s2v(L->top.p))); +} + + +LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { + Table *t; + lua_lock(L); + t = luaH_new(L); + sethvalue2s(L, L->top.p, t); + api_incr_top(L); + if (narray > 0 || nrec > 0) + luaH_resize(L, t, cast_uint(narray), cast_uint(nrec)); + luaC_checkGC(L); + lua_unlock(L); +} + + +LUA_API int lua_getmetatable (lua_State *L, int objindex) { + const TValue *obj; + Table *mt; + int res = 0; + lua_lock(L); + obj = index2value(L, objindex); + switch (ttype(obj)) { + case LUA_TTABLE: + mt = hvalue(obj)->metatable; + break; + case LUA_TUSERDATA: + mt = uvalue(obj)->metatable; + break; + default: + mt = G(L)->mt[ttype(obj)]; + break; + } + if (mt != NULL) { + sethvalue2s(L, L->top.p, mt); + api_incr_top(L); + res = 1; + } + lua_unlock(L); + return res; +} + + +LUA_API int lua_getiuservalue (lua_State *L, int idx, int n) { + TValue *o; + int t; + lua_lock(L); + o = index2value(L, idx); + api_check(L, ttisfulluserdata(o), "full userdata expected"); + if (n <= 0 || n > uvalue(o)->nuvalue) { + setnilvalue(s2v(L->top.p)); + t = LUA_TNONE; + } + else { + setobj2s(L, L->top.p, &uvalue(o)->uv[n - 1].uv); + t = ttype(s2v(L->top.p)); + } + api_incr_top(L); + lua_unlock(L); + return t; +} + + +/* +** 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) { + int hres; + TString *str = luaS_new(L, k); + api_checkpop(L, 1); + luaV_fastset(t, str, s2v(L->top.p - 1), hres, luaH_psetstr); + if (hres == HOK) { + luaV_finishfastset(L, t, s2v(L->top.p - 1)); + L->top.p--; /* pop value */ + } + else { + setsvalue2s(L, L->top.p, str); /* push 'str' (to make it a TValue) */ + api_incr_top(L); + luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), hres); + L->top.p -= 2; /* pop value and key */ + } + lua_unlock(L); /* lock done by caller */ +} + + +LUA_API void lua_setglobal (lua_State *L, const char *name) { + TValue gt; + lua_lock(L); /* unlock done in 'auxsetstr' */ + getGlobalTable(L, >); + auxsetstr(L, >, name); +} + + +LUA_API void lua_settable (lua_State *L, int idx) { + TValue *t; + int hres; + lua_lock(L); + api_checkpop(L, 2); + t = index2value(L, idx); + luaV_fastset(t, s2v(L->top.p - 2), s2v(L->top.p - 1), hres, luaH_pset); + if (hres == HOK) + luaV_finishfastset(L, t, s2v(L->top.p - 1)); + else + luaV_finishset(L, t, s2v(L->top.p - 2), s2v(L->top.p - 1), hres); + L->top.p -= 2; /* pop index and value */ + lua_unlock(L); +} + + +LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { + lua_lock(L); /* unlock done in 'auxsetstr' */ + auxsetstr(L, index2value(L, idx), k); +} + + +LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) { + TValue *t; + int hres; + lua_lock(L); + api_checkpop(L, 1); + t = index2value(L, idx); + luaV_fastseti(t, n, s2v(L->top.p - 1), hres); + if (hres == HOK) + luaV_finishfastset(L, t, s2v(L->top.p - 1)); + else { + TValue temp; + setivalue(&temp, n); + luaV_finishset(L, t, &temp, s2v(L->top.p - 1), hres); + } + L->top.p--; /* pop value */ + lua_unlock(L); +} + + +static void aux_rawset (lua_State *L, int idx, TValue *key, int n) { + Table *t; + lua_lock(L); + api_checkpop(L, n); + t = gettable(L, idx); + luaH_set(L, t, key, s2v(L->top.p - 1)); + invalidateTMcache(t); + luaC_barrierback(L, obj2gco(t), s2v(L->top.p - 1)); + L->top.p -= n; + lua_unlock(L); +} + + +LUA_API void lua_rawset (lua_State *L, int idx) { + aux_rawset(L, idx, s2v(L->top.p - 2), 2); +} + + +LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) { + TValue k; + setpvalue(&k, cast_voidp(p)); + aux_rawset(L, idx, &k, 1); +} + + +LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) { + Table *t; + lua_lock(L); + api_checkpop(L, 1); + t = gettable(L, idx); + luaH_setint(L, t, n, s2v(L->top.p - 1)); + luaC_barrierback(L, obj2gco(t), s2v(L->top.p - 1)); + L->top.p--; + lua_unlock(L); +} + + +LUA_API int lua_setmetatable (lua_State *L, int objindex) { + TValue *obj; + Table *mt; + lua_lock(L); + api_checkpop(L, 1); + obj = index2value(L, objindex); + if (ttisnil(s2v(L->top.p - 1))) + mt = NULL; + else { + api_check(L, ttistable(s2v(L->top.p - 1)), "table expected"); + mt = hvalue(s2v(L->top.p - 1)); + } + switch (ttype(obj)) { + case LUA_TTABLE: { + hvalue(obj)->metatable = mt; + if (mt) { + luaC_objbarrier(L, gcvalue(obj), mt); + luaC_checkfinalizer(L, gcvalue(obj), mt); + } + break; + } + case LUA_TUSERDATA: { + uvalue(obj)->metatable = mt; + if (mt) { + luaC_objbarrier(L, uvalue(obj), mt); + luaC_checkfinalizer(L, gcvalue(obj), mt); + } + break; + } + default: { + G(L)->mt[ttype(obj)] = mt; + break; + } + } + L->top.p--; + lua_unlock(L); + return 1; +} + + +LUA_API int lua_setiuservalue (lua_State *L, int idx, int n) { + TValue *o; + int res; + lua_lock(L); + api_checkpop(L, 1); + o = index2value(L, idx); + api_check(L, ttisfulluserdata(o), "full userdata expected"); + if (!(cast_uint(n) - 1u < cast_uint(uvalue(o)->nuvalue))) + res = 0; /* 'n' not in [1, uvalue(o)->nuvalue] */ + else { + setobj(L, &uvalue(o)->uv[n - 1].uv, s2v(L->top.p - 1)); + luaC_barrierback(L, gcvalue(o), s2v(L->top.p - 1)); + res = 1; + } + L->top.p--; + lua_unlock(L); + return res; +} + + +/* +** 'load' and 'call' functions (run Lua code) +*/ + + +#define checkresults(L,na,nr) \ + (api_check(L, (nr) == LUA_MULTRET \ + || (L->ci->top.p - L->top.p >= (nr) - (na)), \ + "results from function overflow current stack size"), \ + api_check(L, LUA_MULTRET <= (nr) && (nr) <= MAXRESULTS, \ + "invalid number of results")) + + +LUA_API void lua_callk (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k) { + StkId func; + lua_lock(L); + api_check(L, k == NULL || !isLua(L->ci), + "cannot use continuations inside hooks"); + api_checkpop(L, nargs + 1); + api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); + checkresults(L, nargs, nresults); + func = L->top.p - (nargs+1); + if (k != NULL && yieldable(L)) { /* need to prepare continuation? */ + L->ci->u.c.k = k; /* save continuation */ + L->ci->u.c.ctx = ctx; /* save context */ + luaD_call(L, func, nresults); /* do the call */ + } + else /* no continuation or no yieldable */ + luaD_callnoyield(L, func, nresults); /* just do the call */ + adjustresults(L, nresults); + lua_unlock(L); +} + + + +/* +** Execute a protected call. +*/ +struct CallS { /* data to 'f_call' */ + StkId func; + int nresults; +}; + + +static void f_call (lua_State *L, void *ud) { + struct CallS *c = cast(struct CallS *, ud); + luaD_callnoyield(L, c->func, c->nresults); +} + + + +LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k) { + struct CallS c; + TStatus status; + ptrdiff_t func; + lua_lock(L); + api_check(L, k == NULL || !isLua(L->ci), + "cannot use continuations inside hooks"); + api_checkpop(L, nargs + 1); + api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); + checkresults(L, nargs, nresults); + if (errfunc == 0) + func = 0; + else { + StkId o = index2stack(L, errfunc); + api_check(L, ttisfunction(s2v(o)), "error handler must be a function"); + func = savestack(L, o); + } + c.func = L->top.p - (nargs+1); /* function to be called */ + if (k == NULL || !yieldable(L)) { /* no continuation or no yieldable? */ + c.nresults = nresults; /* do a 'conventional' protected call */ + status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); + } + else { /* prepare continuation (call is already protected by 'resume') */ + CallInfo *ci = L->ci; + ci->u.c.k = k; /* save continuation */ + ci->u.c.ctx = ctx; /* save context */ + /* save information for error recovery */ + ci->u2.funcidx = cast_int(savestack(L, c.func)); + ci->u.c.old_errfunc = L->errfunc; + L->errfunc = func; + setoah(ci, L->allowhook); /* save value of 'allowhook' */ + ci->callstatus |= CIST_YPCALL; /* function can do error recovery */ + luaD_call(L, c.func, nresults); /* do the call */ + ci->callstatus &= ~CIST_YPCALL; + L->errfunc = ci->u.c.old_errfunc; + status = LUA_OK; /* if it is here, there were no errors */ + } + adjustresults(L, nresults); + lua_unlock(L); + return APIstatus(status); +} + + +LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data, + const char *chunkname, const char *mode) { + ZIO z; + TStatus status; + lua_lock(L); + if (!chunkname) chunkname = "?"; + luaZ_init(L, &z, reader, data); + status = luaD_protectedparser(L, &z, chunkname, mode); + if (status == LUA_OK) { /* no errors? */ + LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ + if (f->nupvalues >= 1) { /* does it have an upvalue? */ + /* get global table from registry */ + TValue gt; + getGlobalTable(L, >); + /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ + setobj(L, f->upvals[0]->v.p, >); + luaC_barrier(L, f->upvals[0], >); + } + } + lua_unlock(L); + return APIstatus(status); +} + + +/* +** Dump a Lua function, calling 'writer' to write its parts. Ensure +** the stack returns with its original size. +*/ +LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) { + int status; + ptrdiff_t otop = savestack(L, L->top.p); /* original top */ + TValue *f = s2v(L->top.p - 1); /* function to be dumped */ + lua_lock(L); + api_checkpop(L, 1); + api_check(L, isLfunction(f), "Lua function expected"); + status = luaU_dump(L, clLvalue(f)->p, writer, data, strip); + L->top.p = restorestack(L, otop); /* restore top */ + lua_unlock(L); + return status; +} + + +LUA_API int lua_status (lua_State *L) { + return APIstatus(L->status); +} + + +/* +** Garbage-collection function +*/ +LUA_API int lua_gc (lua_State *L, int what, ...) { + va_list argp; + int res = 0; + global_State *g = G(L); + if (g->gcstp & (GCSTPGC | GCSTPCLS)) /* internal stop? */ + return -1; /* all options are invalid when stopped */ + lua_lock(L); + va_start(argp, what); + switch (what) { + case LUA_GCSTOP: { + g->gcstp = GCSTPUSR; /* stopped by the user */ + break; + } + case LUA_GCRESTART: { + luaE_setdebt(g, 0); + g->gcstp = 0; /* (other bits must be zero here) */ + break; + } + case LUA_GCCOLLECT: { + luaC_fullgc(L, 0); + break; + } + case LUA_GCCOUNT: { + /* GC values are expressed in Kbytes: #bytes/2^10 */ + res = cast_int(gettotalbytes(g) >> 10); + break; + } + case LUA_GCCOUNTB: { + res = cast_int(gettotalbytes(g) & 0x3ff); + break; + } + case LUA_GCSTEP: { + lu_byte oldstp = g->gcstp; + l_mem n = cast(l_mem, va_arg(argp, size_t)); + int work = 0; /* true if GC did some work */ + g->gcstp = 0; /* allow GC to run (other bits must be zero here) */ + if (n <= 0) + n = g->GCdebt; /* force to run one basic step */ + luaE_setdebt(g, g->GCdebt - n); + luaC_condGC(L, (void)0, work = 1); + if (work && g->gcstate == GCSpause) /* end of cycle? */ + res = 1; /* signal it */ + g->gcstp = oldstp; /* restore previous state */ + break; + } + case LUA_GCISRUNNING: { + res = gcrunning(g); + break; + } + case LUA_GCGEN: { + res = (g->gckind == KGC_INC) ? LUA_GCINC : LUA_GCGEN; + luaC_changemode(L, KGC_GENMINOR); + break; + } + case LUA_GCINC: { + res = (g->gckind == KGC_INC) ? LUA_GCINC : LUA_GCGEN; + luaC_changemode(L, KGC_INC); + break; + } + case LUA_GCPARAM: { + int param = va_arg(argp, int); + int value = va_arg(argp, int); + api_check(L, 0 <= param && param < LUA_GCPN, "invalid parameter"); + res = cast_int(luaO_applyparam(g->gcparams[param], 100)); + if (value >= 0) + g->gcparams[param] = luaO_codeparam(cast_uint(value)); + break; + } + default: res = -1; /* invalid option */ + } + va_end(argp); + lua_unlock(L); + return res; +} + + + +/* +** miscellaneous functions +*/ + + +LUA_API int lua_error (lua_State *L) { + TValue *errobj; + lua_lock(L); + errobj = s2v(L->top.p - 1); + api_checkpop(L, 1); + /* error object is the memory error message? */ + if (ttisshrstring(errobj) && eqshrstr(tsvalue(errobj), G(L)->memerrmsg)) + luaM_error(L); /* raise a memory error */ + else + luaG_errormsg(L); /* raise a regular error */ + /* code unreachable; will unlock when control actually leaves the kernel */ + return 0; /* to avoid warnings */ +} + + +LUA_API int lua_next (lua_State *L, int idx) { + Table *t; + int more; + lua_lock(L); + api_checkpop(L, 1); + t = gettable(L, idx); + more = luaH_next(L, t, L->top.p - 1); + if (more) + api_incr_top(L); + else /* no more elements */ + L->top.p--; /* pop key */ + lua_unlock(L); + return more; +} + + +LUA_API void lua_toclose (lua_State *L, int idx) { + StkId o; + lua_lock(L); + o = index2stack(L, idx); + api_check(L, L->tbclist.p < o, "given index below or equal a marked one"); + luaF_newtbcupval(L, o); /* create new to-be-closed upvalue */ + L->ci->callstatus |= CIST_TBC; /* mark that function has TBC slots */ + lua_unlock(L); +} + + +LUA_API void lua_concat (lua_State *L, int n) { + lua_lock(L); + api_checknelems(L, n); + if (n > 0) { + luaV_concat(L, n); + luaC_checkGC(L); + } + else { /* nothing to concatenate */ + setsvalue2s(L, L->top.p, luaS_newlstr(L, "", 0)); /* push empty string */ + api_incr_top(L); + } + lua_unlock(L); +} + + +LUA_API void lua_len (lua_State *L, int idx) { + TValue *t; + lua_lock(L); + t = index2value(L, idx); + luaV_objlen(L, L->top.p, t); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { + lua_Alloc f; + lua_lock(L); + if (ud) *ud = G(L)->ud; + f = G(L)->frealloc; + lua_unlock(L); + return f; +} + + +LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) { + lua_lock(L); + G(L)->ud = ud; + G(L)->frealloc = f; + lua_unlock(L); +} + + +void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { + lua_lock(L); + G(L)->ud_warn = ud; + G(L)->warnf = f; + lua_unlock(L); +} + + +void lua_warning (lua_State *L, const char *msg, int tocont) { + lua_lock(L); + luaE_warning(L, msg, tocont); + lua_unlock(L); +} + + + +LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) { + Udata *u; + lua_lock(L); + api_check(L, 0 <= nuvalue && nuvalue < SHRT_MAX, "invalid value"); + u = luaS_newudata(L, size, cast(unsigned short, nuvalue)); + setuvalue(L, s2v(L->top.p), u); + api_incr_top(L); + luaC_checkGC(L); + lua_unlock(L); + return getudatamem(u); +} + + + +static const char *aux_upvalue (TValue *fi, int n, TValue **val, + GCObject **owner) { + switch (ttypetag(fi)) { + case LUA_VCCL: { /* C closure */ + CClosure *f = clCvalue(fi); + if (!(cast_uint(n) - 1u < cast_uint(f->nupvalues))) + return NULL; /* 'n' not in [1, f->nupvalues] */ + *val = &f->upvalue[n-1]; + if (owner) *owner = obj2gco(f); + return ""; + } + case LUA_VLCL: { /* Lua closure */ + LClosure *f = clLvalue(fi); + TString *name; + Proto *p = f->p; + if (!(cast_uint(n) - 1u < cast_uint(p->sizeupvalues))) + return NULL; /* 'n' not in [1, p->sizeupvalues] */ + *val = f->upvals[n-1]->v.p; + if (owner) *owner = obj2gco(f->upvals[n - 1]); + name = p->upvalues[n-1].name; + return (name == NULL) ? "(no name)" : getstr(name); + } + default: return NULL; /* not a closure */ + } +} + + +LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TValue *val = NULL; /* to avoid warnings */ + lua_lock(L); + name = aux_upvalue(index2value(L, funcindex), n, &val, NULL); + if (name) { + setobj2s(L, L->top.p, val); + api_incr_top(L); + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TValue *val = NULL; /* to avoid warnings */ + GCObject *owner = NULL; /* to avoid warnings */ + TValue *fi; + lua_lock(L); + fi = index2value(L, funcindex); + api_checknelems(L, 1); + name = aux_upvalue(fi, n, &val, &owner); + if (name) { + L->top.p--; + setobj(L, val, s2v(L->top.p)); + luaC_barrier(L, owner, val); + } + lua_unlock(L); + return name; +} + + +static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) { + static const UpVal *const nullup = NULL; + LClosure *f; + TValue *fi = index2value(L, fidx); + api_check(L, ttisLclosure(fi), "Lua function expected"); + f = clLvalue(fi); + if (pf) *pf = f; + if (1 <= n && n <= f->p->sizeupvalues) + return &f->upvals[n - 1]; /* get its upvalue pointer */ + else + return (UpVal**)&nullup; +} + + +LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) { + TValue *fi = index2value(L, fidx); + switch (ttypetag(fi)) { + case LUA_VLCL: { /* lua closure */ + return *getupvalref(L, fidx, n, NULL); + } + case LUA_VCCL: { /* C closure */ + CClosure *f = clCvalue(fi); + if (1 <= n && n <= f->nupvalues) + return &f->upvalue[n - 1]; + /* else */ + } /* FALLTHROUGH */ + case LUA_VLCF: + return NULL; /* light C functions have no upvalues */ + default: { + api_check(L, 0, "function expected"); + return NULL; + } + } +} + + +LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1, + int fidx2, int n2) { + LClosure *f1; + UpVal **up1 = getupvalref(L, fidx1, n1, &f1); + UpVal **up2 = getupvalref(L, fidx2, n2, NULL); + api_check(L, *up1 != NULL && *up2 != NULL, "invalid upvalue index"); + *up1 = *up2; + luaC_objbarrier(L, f1, *up1); +} + + diff --git a/source/external/lua/lauxlib.c b/source/external/lua/lauxlib.c new file mode 100644 index 0000000..7cf90cb --- /dev/null +++ b/source/external/lua/lauxlib.c @@ -0,0 +1,1202 @@ +/* +** $Id: lauxlib.c $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + +#define lauxlib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include +#include + + +/* +** This file uses only the official API of Lua. +** Any function declared here could be written as an application function. +*/ + +#include "lua.h" + +#include "lauxlib.h" +#include "llimits.h" + + +/* +** {====================================================== +** Traceback +** ======================================================= +*/ + + +#define LEVELS1 10 /* size of the first part of the stack */ +#define LEVELS2 11 /* size of the second part of the stack */ + + + +/* +** Search for 'objidx' in table at index -1. ('objidx' must be an +** absolute index.) Return 1 + string at top if it found a good name. +*/ +static int findfield (lua_State *L, int objidx, int level) { + if (level == 0 || !lua_istable(L, -1)) + return 0; /* not found */ + lua_pushnil(L); /* start 'next' loop */ + while (lua_next(L, -2)) { /* for each pair in table */ + if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */ + if (lua_rawequal(L, objidx, -1)) { /* found object? */ + lua_pop(L, 1); /* remove value (but keep name) */ + return 1; + } + else if (findfield(L, objidx, level - 1)) { /* try recursively */ + /* stack: lib_name, lib_table, field_name (top) */ + lua_pushliteral(L, "."); /* place '.' between the two names */ + lua_replace(L, -3); /* (in the slot occupied by table) */ + lua_concat(L, 3); /* lib_name.field_name */ + return 1; + } + } + lua_pop(L, 1); /* remove value */ + } + return 0; /* not found */ +} + + +/* +** Search for a name for a function in all loaded modules +*/ +static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { + int top = lua_gettop(L); + lua_getinfo(L, "f", ar); /* push function */ + lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + luaL_checkstack(L, 6, "not enough stack"); /* slots for 'findfield' */ + if (findfield(L, top + 1, 2)) { + const char *name = lua_tostring(L, -1); + if (strncmp(name, LUA_GNAME ".", 3) == 0) { /* name start with '_G.'? */ + lua_pushstring(L, name + 3); /* push name without prefix */ + lua_remove(L, -2); /* remove original name */ + } + lua_copy(L, -1, top + 1); /* copy name to proper place */ + lua_settop(L, top + 1); /* remove table "loaded" and name copy */ + return 1; + } + else { + lua_settop(L, top); /* remove function and global table */ + return 0; + } +} + + +static void pushfuncname (lua_State *L, lua_Debug *ar) { + if (*ar->namewhat != '\0') /* is there a name from code? */ + lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ + else if (*ar->what == 'm') /* main? */ + lua_pushliteral(L, "main chunk"); + else if (pushglobalfuncname(L, ar)) { /* try a global name */ + lua_pushfstring(L, "function '%s'", lua_tostring(L, -1)); + lua_remove(L, -2); /* remove name */ + } + else if (*ar->what != 'C') /* for Lua functions, use */ + lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined); + else /* nothing left... */ + lua_pushliteral(L, "?"); +} + + +static int lastlevel (lua_State *L) { + lua_Debug ar; + int li = 1, le = 1; + /* find an upper bound */ + while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } + /* do a binary search */ + while (li < le) { + int m = (li + le)/2; + if (lua_getstack(L, m, &ar)) li = m + 1; + else le = m; + } + return le - 1; +} + + +LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1, + const char *msg, int level) { + luaL_Buffer b; + lua_Debug ar; + int last = lastlevel(L1); + int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; + luaL_buffinit(L, &b); + if (msg) { + luaL_addstring(&b, msg); + luaL_addchar(&b, '\n'); + } + luaL_addstring(&b, "stack traceback:"); + while (lua_getstack(L1, level++, &ar)) { + if (limit2show-- == 0) { /* too many levels? */ + int n = last - level - LEVELS2 + 1; /* number of levels to skip */ + lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n); + luaL_addvalue(&b); /* add warning about skip */ + level += n; /* and skip to last levels */ + } + else { + lua_getinfo(L1, "Slnt", &ar); + if (ar.currentline <= 0) + lua_pushfstring(L, "\n\t%s: in ", ar.short_src); + else + lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline); + luaL_addvalue(&b); + pushfuncname(L, &ar); + luaL_addvalue(&b); + if (ar.istailcall) + luaL_addstring(&b, "\n\t(...tail calls...)"); + } + } + luaL_pushresult(&b); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Error-report functions +** ======================================================= +*/ + +LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) { + lua_Debug ar; + const char *argword; + if (!lua_getstack(L, 0, &ar)) /* no stack frame? */ + return luaL_error(L, "bad argument #%d (%s)", arg, extramsg); + lua_getinfo(L, "nt", &ar); + if (arg <= ar.extraargs) /* error in an extra argument? */ + argword = "extra argument"; + else { + arg -= ar.extraargs; /* do not count extra arguments */ + if (strcmp(ar.namewhat, "method") == 0) { /* colon syntax? */ + arg--; /* do not count (extra) self argument */ + if (arg == 0) /* error in self argument? */ + return luaL_error(L, "calling '%s' on bad self (%s)", + ar.name, extramsg); + /* else go through; error in a regular argument */ + } + argword = "argument"; + } + if (ar.name == NULL) + ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?"; + return luaL_error(L, "bad %s #%d to '%s' (%s)", + argword, arg, ar.name, extramsg); +} + + +LUALIB_API int luaL_typeerror (lua_State *L, int arg, const char *tname) { + const char *msg; + const char *typearg; /* name for the type of the actual argument */ + if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING) + typearg = lua_tostring(L, -1); /* use the given type name */ + else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA) + typearg = "light userdata"; /* special name for messages */ + else + typearg = luaL_typename(L, arg); /* standard name */ + msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg); + return luaL_argerror(L, arg, msg); +} + + +static void tag_error (lua_State *L, int arg, int tag) { + luaL_typeerror(L, arg, lua_typename(L, tag)); +} + + +/* +** The use of 'lua_pushfstring' ensures this function does not +** need reserved stack space when called. +*/ +LUALIB_API void luaL_where (lua_State *L, int level) { + lua_Debug ar; + if (lua_getstack(L, level, &ar)) { /* check function at level */ + lua_getinfo(L, "Sl", &ar); /* get info about it */ + if (ar.currentline > 0) { /* is there info? */ + lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline); + return; + } + } + lua_pushfstring(L, ""); /* else, no information available... */ +} + + +/* +** Again, the use of 'lua_pushvfstring' ensures this function does +** not need reserved stack space when called. (At worst, it generates +** a memory error instead of the given message.) +*/ +LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); + return lua_error(L); +} + + +LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) { + int en = errno; /* calls to Lua API may change this value */ + if (stat) { + lua_pushboolean(L, 1); + return 1; + } + else { + const char *msg; + luaL_pushfail(L); + msg = (en != 0) ? strerror(en) : "(no extra info)"; + if (fname) + lua_pushfstring(L, "%s: %s", fname, msg); + else + lua_pushstring(L, msg); + lua_pushinteger(L, en); + return 3; + } +} + + +#if !defined(l_inspectstat) /* { */ + +#if defined(LUA_USE_POSIX) + +#include + +/* +** use appropriate macros to interpret 'pclose' return status +*/ +#define l_inspectstat(stat,what) \ + if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \ + else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; } + +#else + +#define l_inspectstat(stat,what) /* no op */ + +#endif + +#endif /* } */ + + +LUALIB_API int luaL_execresult (lua_State *L, int stat) { + if (stat != 0 && errno != 0) /* error with an 'errno'? */ + return luaL_fileresult(L, 0, NULL); + else { + const char *what = "exit"; /* type of termination */ + l_inspectstat(stat, what); /* interpret result */ + if (*what == 'e' && stat == 0) /* successful termination? */ + lua_pushboolean(L, 1); + else + luaL_pushfail(L); + lua_pushstring(L, what); + lua_pushinteger(L, stat); + return 3; /* return true/fail,what,code */ + } +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Userdata's metatable manipulation +** ======================================================= +*/ + +LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { + if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ + return 0; /* leave previous value on top, but return 0 */ + lua_pop(L, 1); + lua_createtable(L, 0, 2); /* create metatable */ + lua_pushstring(L, tname); + lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ + lua_pushvalue(L, -1); + lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ + return 1; +} + + +LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) { + luaL_getmetatable(L, tname); + lua_setmetatable(L, -2); +} + + +LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) { + void *p = lua_touserdata(L, ud); + if (p != NULL) { /* value is a userdata? */ + if (lua_getmetatable(L, ud)) { /* does it have a metatable? */ + luaL_getmetatable(L, tname); /* get correct metatable */ + if (!lua_rawequal(L, -1, -2)) /* not the same? */ + p = NULL; /* value is a userdata with wrong metatable */ + lua_pop(L, 2); /* remove both metatables */ + return p; + } + } + return NULL; /* value is not a userdata with a metatable */ +} + + +LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) { + void *p = luaL_testudata(L, ud, tname); + luaL_argexpected(L, p != NULL, ud, tname); + return p; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Argument check functions +** ======================================================= +*/ + +LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def, + const char *const lst[]) { + const char *name = (def) ? luaL_optstring(L, arg, def) : + luaL_checkstring(L, arg); + int i; + for (i=0; lst[i]; i++) + if (strcmp(lst[i], name) == 0) + return i; + return luaL_argerror(L, arg, + lua_pushfstring(L, "invalid option '%s'", name)); +} + + +/* +** Ensures the stack has at least 'space' extra slots, raising an error +** if it cannot fulfill the request. (The error handling needs a few +** extra slots to format the error message. In case of an error without +** this extra space, Lua will generate the same 'stack overflow' error, +** but without 'msg'.) +*/ +LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { + if (l_unlikely(!lua_checkstack(L, space))) { + if (msg) + luaL_error(L, "stack overflow (%s)", msg); + else + luaL_error(L, "stack overflow"); + } +} + + +LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) { + if (l_unlikely(lua_type(L, arg) != t)) + tag_error(L, arg, t); +} + + +LUALIB_API void luaL_checkany (lua_State *L, int arg) { + if (l_unlikely(lua_type(L, arg) == LUA_TNONE)) + luaL_argerror(L, arg, "value expected"); +} + + +LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) { + const char *s = lua_tolstring(L, arg, len); + if (l_unlikely(!s)) tag_error(L, arg, LUA_TSTRING); + return s; +} + + +LUALIB_API const char *luaL_optlstring (lua_State *L, int arg, + const char *def, size_t *len) { + if (lua_isnoneornil(L, arg)) { + if (len) + *len = (def ? strlen(def) : 0); + return def; + } + else return luaL_checklstring(L, arg, len); +} + + +LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) { + int isnum; + lua_Number d = lua_tonumberx(L, arg, &isnum); + if (l_unlikely(!isnum)) + tag_error(L, arg, LUA_TNUMBER); + return d; +} + + +LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) { + return luaL_opt(L, luaL_checknumber, arg, def); +} + + +static void interror (lua_State *L, int arg) { + if (lua_isnumber(L, arg)) + luaL_argerror(L, arg, "number has no integer representation"); + else + tag_error(L, arg, LUA_TNUMBER); +} + + +LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) { + int isnum; + lua_Integer d = lua_tointegerx(L, arg, &isnum); + if (l_unlikely(!isnum)) { + interror(L, arg); + } + return d; +} + + +LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg, + lua_Integer def) { + return luaL_opt(L, luaL_checkinteger, arg, def); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +/* userdata to box arbitrary data */ +typedef struct UBox { + void *box; + size_t bsize; +} UBox; + + +/* Resize the buffer used by a box. Optimize for the common case of +** resizing to the old size. (For instance, __gc will resize the box +** to 0 even after it was closed. 'pushresult' may also resize it to a +** final size that is equal to the one set when the buffer was created.) +*/ +static void *resizebox (lua_State *L, int idx, size_t newsize) { + UBox *box = (UBox *)lua_touserdata(L, idx); + if (box->bsize == newsize) /* not changing size? */ + return box->box; /* keep the buffer */ + else { + void *ud; + lua_Alloc allocf = lua_getallocf(L, &ud); + void *temp = allocf(ud, box->box, box->bsize, newsize); + if (l_unlikely(temp == NULL && newsize > 0)) { /* allocation error? */ + lua_pushliteral(L, "not enough memory"); + lua_error(L); /* raise a memory error */ + } + box->box = temp; + box->bsize = newsize; + return temp; + } +} + + +static int boxgc (lua_State *L) { + resizebox(L, 1, 0); + return 0; +} + + +static const luaL_Reg boxmt[] = { /* box metamethods */ + {"__gc", boxgc}, + {"__close", boxgc}, + {NULL, NULL} +}; + + +static void newbox (lua_State *L) { + UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0); + box->box = NULL; + box->bsize = 0; + if (luaL_newmetatable(L, "_UBOX*")) /* creating metatable? */ + luaL_setfuncs(L, boxmt, 0); /* set its metamethods */ + lua_setmetatable(L, -2); +} + + +/* +** check whether buffer is using a userdata on the stack as a temporary +** buffer +*/ +#define buffonstack(B) ((B)->b != (B)->init.b) + + +/* +** Whenever buffer is accessed, slot 'idx' must either be a box (which +** cannot be NULL) or it is a placeholder for the buffer. +*/ +#define checkbufferlevel(B,idx) \ + lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ + : lua_touserdata(B->L, idx) == (void*)B) + + +/* +** Compute new size for buffer 'B', enough to accommodate extra 'sz' +** bytes plus one for a terminating zero. +*/ +static size_t newbuffsize (luaL_Buffer *B, size_t sz) { + size_t newsize = B->size; + if (l_unlikely(sz >= MAX_SIZE - B->n)) + return cast_sizet(luaL_error(B->L, "resulting string too large")); + /* else B->n + sz + 1 <= MAX_SIZE */ + if (newsize <= MAX_SIZE/3 * 2) /* no overflow? */ + newsize += (newsize >> 1); /* new size *= 1.5 */ + if (newsize < B->n + sz + 1) /* not big enough? */ + newsize = B->n + sz + 1; + return newsize; +} + + +/* +** Returns a pointer to a free area with at least 'sz' bytes in buffer +** 'B'. 'boxidx' is the relative position in the stack where is the +** buffer's box or its placeholder. +*/ +static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) { + checkbufferlevel(B, boxidx); + if (B->size - B->n >= sz) /* enough space? */ + return B->b + B->n; + else { + lua_State *L = B->L; + char *newbuff; + size_t newsize = newbuffsize(B, sz); + /* create larger buffer */ + if (buffonstack(B)) /* buffer already has a box? */ + newbuff = (char *)resizebox(L, boxidx, newsize); /* resize it */ + else { /* no box yet */ + lua_remove(L, boxidx); /* remove placeholder */ + newbox(L); /* create a new box */ + lua_insert(L, boxidx); /* move box to its intended position */ + lua_toclose(L, boxidx); + newbuff = (char *)resizebox(L, boxidx, newsize); + memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ + } + B->b = newbuff; + B->size = newsize; + return newbuff + B->n; + } +} + +/* +** returns a pointer to a free area with at least 'sz' bytes +*/ +LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { + return prepbuffsize(B, sz, -1); +} + + +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { + if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ + char *b = prepbuffsize(B, l, -1); + memcpy(b, s, l * sizeof(char)); + luaL_addsize(B, l); + } +} + + +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { + luaL_addlstring(B, s, strlen(s)); +} + + +LUALIB_API void luaL_pushresult (luaL_Buffer *B) { + lua_State *L = B->L; + checkbufferlevel(B, -1); + if (!buffonstack(B)) /* using static buffer? */ + lua_pushlstring(L, B->b, B->n); /* save result as regular string */ + else { /* reuse buffer already allocated */ + UBox *box = (UBox *)lua_touserdata(L, -1); + void *ud; + lua_Alloc allocf = lua_getallocf(L, &ud); /* function to free buffer */ + size_t len = B->n; /* final string length */ + char *s; + resizebox(L, -1, len + 1); /* adjust box size to content size */ + s = (char*)box->box; /* final buffer address */ + s[len] = '\0'; /* add ending zero */ + /* clear box, as Lua will take control of the buffer */ + box->bsize = 0; box->box = NULL; + lua_pushexternalstring(L, s, len, allocf, ud); + lua_closeslot(L, -2); /* close the box */ + lua_gc(L, LUA_GCSTEP, len); + } + lua_remove(L, -2); /* remove box or placeholder from the stack */ +} + + +LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) { + luaL_addsize(B, sz); + luaL_pushresult(B); +} + + +/* +** 'luaL_addvalue' is the only function in the Buffer system where the +** box (if existent) is not on the top of the stack. So, instead of +** calling 'luaL_addlstring', it replicates the code using -2 as the +** last argument to 'prepbuffsize', signaling that the box is (or will +** be) below the string being added to the buffer. (Box creation can +** trigger an emergency GC, so we should not remove the string from the +** stack before we have the space guaranteed.) +*/ +LUALIB_API void luaL_addvalue (luaL_Buffer *B) { + lua_State *L = B->L; + size_t len; + const char *s = lua_tolstring(L, -1, &len); + char *b = prepbuffsize(B, len, -2); + memcpy(b, s, len * sizeof(char)); + luaL_addsize(B, len); + lua_pop(L, 1); /* pop string */ +} + + +LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { + B->L = L; + B->b = B->init.b; + B->n = 0; + B->size = LUAL_BUFFERSIZE; + lua_pushlightuserdata(L, (void*)B); /* push placeholder */ +} + + +LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) { + luaL_buffinit(L, B); + return prepbuffsize(B, sz, -1); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Reference system +** ======================================================= +*/ + +/* +** The previously freed references form a linked list: t[1] is the index +** of a first free index, t[t[1]] is the index of the second element, +** etc. A zero signals the end of the list. +*/ +LUALIB_API int luaL_ref (lua_State *L, int t) { + int ref; + if (lua_isnil(L, -1)) { + lua_pop(L, 1); /* remove from stack */ + return LUA_REFNIL; /* 'nil' has a unique fixed reference */ + } + t = lua_absindex(L, t); + if (lua_rawgeti(L, t, 1) == LUA_TNUMBER) /* already initialized? */ + ref = (int)lua_tointeger(L, -1); /* ref = t[1] */ + else { /* first access */ + lua_assert(!lua_toboolean(L, -1)); /* must be nil or false */ + ref = 0; /* list is empty */ + lua_pushinteger(L, 0); /* initialize as an empty list */ + lua_rawseti(L, t, 1); /* ref = t[1] = 0 */ + } + lua_pop(L, 1); /* remove element from stack */ + if (ref != 0) { /* any free element? */ + lua_rawgeti(L, t, ref); /* remove it from list */ + lua_rawseti(L, t, 1); /* (t[1] = t[ref]) */ + } + else /* no free elements */ + ref = (int)lua_rawlen(L, t) + 1; /* get a new reference */ + lua_rawseti(L, t, ref); + return ref; +} + + +LUALIB_API void luaL_unref (lua_State *L, int t, int ref) { + if (ref >= 0) { + t = lua_absindex(L, t); + lua_rawgeti(L, t, 1); + lua_assert(lua_isinteger(L, -1)); + lua_rawseti(L, t, ref); /* t[ref] = t[1] */ + lua_pushinteger(L, ref); + lua_rawseti(L, t, 1); /* t[1] = ref */ + } +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Load functions +** ======================================================= +*/ + +typedef struct LoadF { + unsigned n; /* number of pre-read characters */ + FILE *f; /* file being read */ + char buff[BUFSIZ]; /* area for reading file */ +} LoadF; + + +static const char *getF (lua_State *L, void *ud, size_t *size) { + LoadF *lf = (LoadF *)ud; + UNUSED(L); + if (lf->n > 0) { /* are there pre-read characters to be read? */ + *size = lf->n; /* return them (chars already in buffer) */ + lf->n = 0; /* no more pre-read characters */ + } + else { /* read a block from file */ + /* 'fread' can return > 0 *and* set the EOF flag. If next call to + 'getF' called 'fread', it might still wait for user input. + The next check avoids this problem. */ + if (feof(lf->f)) return NULL; + *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */ + } + return lf->buff; +} + + +static int errfile (lua_State *L, const char *what, int fnameindex) { + int err = errno; + const char *filename = lua_tostring(L, fnameindex) + 1; + if (err != 0) + lua_pushfstring(L, "cannot %s %s: %s", what, filename, strerror(err)); + else + lua_pushfstring(L, "cannot %s %s", what, filename); + lua_remove(L, fnameindex); + return LUA_ERRFILE; +} + + +/* +** Skip an optional BOM at the start of a stream. If there is an +** incomplete BOM (the first character is correct but the rest is +** not), returns the first character anyway to force an error +** (as no chunk can start with 0xEF). +*/ +static int skipBOM (FILE *f) { + int c = getc(f); /* read first character */ + if (c == 0xEF && getc(f) == 0xBB && getc(f) == 0xBF) /* correct BOM? */ + return getc(f); /* ignore BOM and return next char */ + else /* no (valid) BOM */ + return c; /* return first character */ +} + + +/* +** reads the first character of file 'f' and skips an optional BOM mark +** in its beginning plus its first line if it starts with '#'. Returns +** true if it skipped the first line. In any case, '*cp' has the +** first "valid" character of the file (after the optional BOM and +** a first-line comment). +*/ +static int skipcomment (FILE *f, int *cp) { + int c = *cp = skipBOM(f); + if (c == '#') { /* first line is a comment (Unix exec. file)? */ + do { /* skip first line */ + c = getc(f); + } while (c != EOF && c != '\n'); + *cp = getc(f); /* next character after comment, if present */ + return 1; /* there was a comment */ + } + else return 0; /* no comment */ +} + + +LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename, + const char *mode) { + LoadF lf; + int status, readstatus; + int c; + int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */ + if (filename == NULL) { + lua_pushliteral(L, "=stdin"); + lf.f = stdin; + } + else { + lua_pushfstring(L, "@%s", filename); + errno = 0; + lf.f = fopen(filename, "r"); + if (lf.f == NULL) return errfile(L, "open", fnameindex); + } + lf.n = 0; + if (skipcomment(lf.f, &c)) /* read initial portion */ + lf.buff[lf.n++] = '\n'; /* add newline to correct line numbers */ + if (c == LUA_SIGNATURE[0]) { /* binary file? */ + lf.n = 0; /* remove possible newline */ + if (filename) { /* "real" file? */ + errno = 0; + lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */ + if (lf.f == NULL) return errfile(L, "reopen", fnameindex); + skipcomment(lf.f, &c); /* re-read initial portion */ + } + } + if (c != EOF) + lf.buff[lf.n++] = cast_char(c); /* 'c' is the first character */ + status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode); + readstatus = ferror(lf.f); + errno = 0; /* no useful error number until here */ + if (filename) fclose(lf.f); /* close file (even in case of errors) */ + if (readstatus) { + lua_settop(L, fnameindex); /* ignore results from 'lua_load' */ + return errfile(L, "read", fnameindex); + } + lua_remove(L, fnameindex); + return status; +} + + +typedef struct LoadS { + const char *s; + size_t size; +} LoadS; + + +static const char *getS (lua_State *L, void *ud, size_t *size) { + LoadS *ls = (LoadS *)ud; + UNUSED(L); + if (ls->size == 0) return NULL; + *size = ls->size; + ls->size = 0; + return ls->s; +} + + +LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size, + const char *name, const char *mode) { + LoadS ls; + ls.s = buff; + ls.size = size; + return lua_load(L, getS, &ls, name, mode); +} + + +LUALIB_API int luaL_loadstring (lua_State *L, const char *s) { + return luaL_loadbuffer(L, s, strlen(s), s); +} + +/* }====================================================== */ + + + +LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) { + if (!lua_getmetatable(L, obj)) /* no metatable? */ + return LUA_TNIL; + else { + int tt; + lua_pushstring(L, event); + tt = lua_rawget(L, -2); + if (tt == LUA_TNIL) /* is metafield nil? */ + lua_pop(L, 2); /* remove metatable and metafield */ + else + lua_remove(L, -2); /* remove only metatable */ + return tt; /* return metafield type */ + } +} + + +LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) { + obj = lua_absindex(L, obj); + if (luaL_getmetafield(L, obj, event) == LUA_TNIL) /* no metafield? */ + return 0; + lua_pushvalue(L, obj); + lua_call(L, 1, 1); + return 1; +} + + +LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) { + lua_Integer l; + int isnum; + lua_len(L, idx); + l = lua_tointegerx(L, -1, &isnum); + if (l_unlikely(!isnum)) + luaL_error(L, "object length is not an integer"); + lua_pop(L, 1); /* remove object */ + return l; +} + + +LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) { + idx = lua_absindex(L,idx); + if (luaL_callmeta(L, idx, "__tostring")) { /* metafield? */ + if (!lua_isstring(L, -1)) + luaL_error(L, "'__tostring' must return a string"); + } + else { + switch (lua_type(L, idx)) { + case LUA_TNUMBER: { + char buff[LUA_N2SBUFFSZ]; + lua_numbertocstring(L, idx, buff); + lua_pushstring(L, buff); + break; + } + case LUA_TSTRING: + lua_pushvalue(L, idx); + break; + case LUA_TBOOLEAN: + lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false")); + break; + case LUA_TNIL: + lua_pushliteral(L, "nil"); + break; + default: { + int tt = luaL_getmetafield(L, idx, "__name"); /* try name */ + const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : + luaL_typename(L, idx); + lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx)); + if (tt != LUA_TNIL) + lua_remove(L, -2); /* remove '__name' */ + break; + } + } + } + return lua_tolstring(L, -1, len); +} + + +/* +** set functions from list 'l' into table at top - 'nup'; each +** function gets the 'nup' elements at the top as upvalues. +** Returns with only the table at the stack. +*/ +LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { + luaL_checkstack(L, nup, "too many upvalues"); + for (; l->name != NULL; l++) { /* fill the table with given functions */ + if (l->func == NULL) /* placeholder? */ + lua_pushboolean(L, 0); + else { + int i; + for (i = 0; i < nup; i++) /* copy upvalues to the top */ + lua_pushvalue(L, -nup); + lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ + } + lua_setfield(L, -(nup + 2), l->name); + } + lua_pop(L, nup); /* remove upvalues */ +} + + +/* +** ensure that stack[idx][fname] has a table and push that table +** into the stack +*/ +LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) { + if (lua_getfield(L, idx, fname) == LUA_TTABLE) + return 1; /* table already there */ + else { + lua_pop(L, 1); /* remove previous result */ + idx = lua_absindex(L, idx); + lua_newtable(L); + lua_pushvalue(L, -1); /* copy to be left at top */ + lua_setfield(L, idx, fname); /* assign new table to field */ + return 0; /* false, because did not find table there */ + } +} + + +/* +** Stripped-down 'require': After checking "loaded" table, calls 'openf' +** to open a module, registers the result in 'package.loaded' table and, +** if 'glb' is true, also registers the result in the global table. +** Leaves resulting module on the top. +*/ +LUALIB_API void luaL_requiref (lua_State *L, const char *modname, + lua_CFunction openf, int glb) { + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + lua_getfield(L, -1, modname); /* LOADED[modname] */ + if (!lua_toboolean(L, -1)) { /* package not already loaded? */ + lua_pop(L, 1); /* remove field */ + lua_pushcfunction(L, openf); + lua_pushstring(L, modname); /* argument to open function */ + lua_call(L, 1, 1); /* call 'openf' to open module */ + lua_pushvalue(L, -1); /* make copy of module (call result) */ + lua_setfield(L, -3, modname); /* LOADED[modname] = module */ + } + lua_remove(L, -2); /* remove LOADED table */ + if (glb) { + lua_pushvalue(L, -1); /* copy of module */ + lua_setglobal(L, modname); /* _G[modname] = module */ + } +} + + +LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, + const char *p, const char *r) { + const char *wild; + size_t l = strlen(p); + while ((wild = strstr(s, p)) != NULL) { + luaL_addlstring(b, s, ct_diff2sz(wild - s)); /* push prefix */ + luaL_addstring(b, r); /* push replacement in place of pattern */ + s = wild + l; /* continue after 'p' */ + } + luaL_addstring(b, s); /* push last suffix */ +} + + +LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, + const char *p, const char *r) { + luaL_Buffer b; + luaL_buffinit(L, &b); + luaL_addgsub(&b, s, p, r); + luaL_pushresult(&b); + return lua_tostring(L, -1); +} + + +void *luaL_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { + UNUSED(ud); UNUSED(osize); + if (nsize == 0) { + free(ptr); + return NULL; + } + else + return realloc(ptr, nsize); +} + + +/* +** Standard panic function just prints an error message. The test +** with 'lua_type' avoids possible memory errors in 'lua_tostring'. +*/ +static int panic (lua_State *L) { + const char *msg = (lua_type(L, -1) == LUA_TSTRING) + ? lua_tostring(L, -1) + : "error object is not a string"; + lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n", + msg); + return 0; /* return to Lua to abort */ +} + + +/* +** Warning functions: +** warnfoff: warning system is off +** warnfon: ready to start a new message +** warnfcont: previous message is to be continued +*/ +static void warnfoff (void *ud, const char *message, int tocont); +static void warnfon (void *ud, const char *message, int tocont); +static void warnfcont (void *ud, const char *message, int tocont); + + +/* +** Check whether message is a control message. If so, execute the +** control or ignore it if unknown. +*/ +static int checkcontrol (lua_State *L, const char *message, int tocont) { + if (tocont || *(message++) != '@') /* not a control message? */ + return 0; + else { + if (strcmp(message, "off") == 0) + lua_setwarnf(L, warnfoff, L); /* turn warnings off */ + else if (strcmp(message, "on") == 0) + lua_setwarnf(L, warnfon, L); /* turn warnings on */ + return 1; /* it was a control message */ + } +} + + +static void warnfoff (void *ud, const char *message, int tocont) { + checkcontrol((lua_State *)ud, message, tocont); +} + + +/* +** Writes the message and handle 'tocont', finishing the message +** if needed and setting the next warn function. +*/ +static void warnfcont (void *ud, const char *message, int tocont) { + lua_State *L = (lua_State *)ud; + lua_writestringerror("%s", message); /* write message */ + if (tocont) /* not the last part? */ + lua_setwarnf(L, warnfcont, L); /* to be continued */ + else { /* last part */ + lua_writestringerror("%s", "\n"); /* finish message with end-of-line */ + lua_setwarnf(L, warnfon, L); /* next call is a new message */ + } +} + + +static void warnfon (void *ud, const char *message, int tocont) { + if (checkcontrol((lua_State *)ud, message, tocont)) /* control message? */ + return; /* nothing else to be done */ + lua_writestringerror("%s", "Lua warning: "); /* start a new warning */ + warnfcont(ud, message, tocont); /* finish processing */ +} + + + +/* +** A function to compute an unsigned int with some level of +** randomness. Rely on Address Space Layout Randomization (if present) +** and the current time. +*/ +#if !defined(luai_makeseed) + +#include + + +/* Size for the buffer, in bytes */ +#define BUFSEEDB (sizeof(void*) + sizeof(time_t)) + +/* Size for the buffer in int's, rounded up */ +#define BUFSEED ((BUFSEEDB + sizeof(int) - 1) / sizeof(int)) + +/* +** Copy the contents of variable 'v' into the buffer pointed by 'b'. +** (The '&b[0]' disguises 'b' to fix an absurd warning from clang.) +*/ +#define addbuff(b,v) (memcpy(&b[0], &(v), sizeof(v)), b += sizeof(v)) + + +static unsigned int luai_makeseed (void) { + unsigned int buff[BUFSEED]; + unsigned int res; + unsigned int i; + time_t t = time(NULL); + char *b = (char*)buff; + addbuff(b, b); /* local variable's address */ + addbuff(b, t); /* time */ + /* fill (rare but possible) remain of the buffer with zeros */ + memset(b, 0, sizeof(buff) - BUFSEEDB); + res = buff[0]; + for (i = 1; i < BUFSEED; i++) + res ^= (res >> 3) + (res << 7) + buff[i]; + return res; +} + +#endif + + +LUALIB_API unsigned int luaL_makeseed (lua_State *L) { + UNUSED(L); + return luai_makeseed(); +} + + +/* +** Use the name with parentheses so that headers can redefine it +** as a macro. +*/ +LUALIB_API lua_State *(luaL_newstate) (void) { + lua_State *L = lua_newstate(luaL_alloc, NULL, luaL_makeseed(NULL)); + if (l_likely(L)) { + lua_atpanic(L, &panic); + lua_setwarnf(L, warnfon, L); + } + return L; +} + + +LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) { + lua_Number v = lua_version(L); + if (sz != LUAL_NUMSIZES) /* check numeric types */ + luaL_error(L, "core and library have incompatible numeric types"); + else if (v != ver) + luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f", + (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)v); +} + diff --git a/source/external/lua/lbaselib.c b/source/external/lua/lbaselib.c new file mode 100644 index 0000000..891bb90 --- /dev/null +++ b/source/external/lua/lbaselib.c @@ -0,0 +1,559 @@ +/* +** $Id: lbaselib.c $ +** Basic library +** See Copyright Notice in lua.h +*/ + +#define lbaselib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +static int luaB_print (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + for (i = 1; i <= n; i++) { /* for each argument */ + size_t l; + const char *s = luaL_tolstring(L, i, &l); /* convert it to string */ + if (i > 1) /* not the first element? */ + lua_writestring("\t", 1); /* add a tab before it */ + lua_writestring(s, l); /* print it */ + lua_pop(L, 1); /* pop result */ + } + lua_writeline(); + return 0; +} + + +/* +** Creates a warning with all given arguments. +** Check first for errors; otherwise an error may interrupt +** the composition of a warning, leaving it unfinished. +*/ +static int luaB_warn (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + luaL_checkstring(L, 1); /* at least one argument */ + for (i = 2; i <= n; i++) + luaL_checkstring(L, i); /* make sure all arguments are strings */ + for (i = 1; i < n; i++) /* compose warning */ + lua_warning(L, lua_tostring(L, i), 1); + lua_warning(L, lua_tostring(L, n), 0); /* close warning */ + return 0; +} + + +#define SPACECHARS " \f\n\r\t\v" + +static const char *b_str2int (const char *s, unsigned base, lua_Integer *pn) { + lua_Unsigned n = 0; + int neg = 0; + s += strspn(s, SPACECHARS); /* skip initial spaces */ + if (*s == '-') { s++; neg = 1; } /* handle sign */ + else if (*s == '+') s++; + if (!isalnum(cast_uchar(*s))) /* no digit? */ + return NULL; + do { + unsigned digit = cast_uint(isdigit(cast_uchar(*s)) + ? *s - '0' + : (toupper(cast_uchar(*s)) - 'A') + 10); + if (digit >= base) return NULL; /* invalid numeral */ + n = n * base + digit; + s++; + } while (isalnum(cast_uchar(*s))); + s += strspn(s, SPACECHARS); /* skip trailing spaces */ + *pn = (lua_Integer)((neg) ? (0u - n) : n); + return s; +} + + +static int luaB_tonumber (lua_State *L) { + if (lua_isnoneornil(L, 2)) { /* standard conversion? */ + if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */ + lua_settop(L, 1); /* yes; return it */ + return 1; + } + else { + size_t l; + const char *s = lua_tolstring(L, 1, &l); + if (s != NULL && lua_stringtonumber(L, s) == l + 1) + return 1; /* successful conversion to number */ + /* else not a number */ + luaL_checkany(L, 1); /* (but there must be some parameter) */ + } + } + else { + size_t l; + const char *s; + lua_Integer n = 0; /* to avoid warnings */ + lua_Integer base = luaL_checkinteger(L, 2); + luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */ + s = lua_tolstring(L, 1, &l); + luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range"); + if (b_str2int(s, cast_uint(base), &n) == s + l) { + lua_pushinteger(L, n); + return 1; + } /* else not a number */ + } /* else not a number */ + luaL_pushfail(L); /* not a number */ + return 1; +} + + +static int luaB_error (lua_State *L) { + int level = (int)luaL_optinteger(L, 2, 1); + lua_settop(L, 1); + if (lua_type(L, 1) == LUA_TSTRING && level > 0) { + luaL_where(L, level); /* add extra information */ + lua_pushvalue(L, 1); + lua_concat(L, 2); + } + return lua_error(L); +} + + +static int luaB_getmetatable (lua_State *L) { + luaL_checkany(L, 1); + if (!lua_getmetatable(L, 1)) { + lua_pushnil(L); + return 1; /* no metatable */ + } + luaL_getmetafield(L, 1, "__metatable"); + return 1; /* returns either __metatable field (if present) or metatable */ +} + + +static int luaB_setmetatable (lua_State *L) { + int t = lua_type(L, 2); + luaL_checktype(L, 1, LUA_TTABLE); + luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table"); + if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)) + return luaL_error(L, "cannot change a protected metatable"); + lua_settop(L, 2); + lua_setmetatable(L, 1); + return 1; +} + + +static int luaB_rawequal (lua_State *L) { + luaL_checkany(L, 1); + luaL_checkany(L, 2); + lua_pushboolean(L, lua_rawequal(L, 1, 2)); + return 1; +} + + +static int luaB_rawlen (lua_State *L) { + int t = lua_type(L, 1); + luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1, + "table or string"); + lua_pushinteger(L, l_castU2S(lua_rawlen(L, 1))); + return 1; +} + + +static int luaB_rawget (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + lua_settop(L, 2); + lua_rawget(L, 1); + return 1; +} + +static int luaB_rawset (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checkany(L, 2); + luaL_checkany(L, 3); + lua_settop(L, 3); + lua_rawset(L, 1); + return 1; +} + + +static int pushmode (lua_State *L, int oldmode) { + if (oldmode == -1) + luaL_pushfail(L); /* invalid call to 'lua_gc' */ + else + lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental" + : "generational"); + return 1; +} + + +/* +** check whether call to 'lua_gc' was valid (not inside a finalizer) +*/ +#define checkvalres(res) { if (res == -1) break; } + +static int luaB_collectgarbage (lua_State *L) { + static const char *const opts[] = {"stop", "restart", "collect", + "count", "step", "isrunning", "generational", "incremental", + "param", NULL}; + static const char optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT, + LUA_GCCOUNT, LUA_GCSTEP, LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC, + LUA_GCPARAM}; + int o = optsnum[luaL_checkoption(L, 1, "collect", opts)]; + switch (o) { + case LUA_GCCOUNT: { + int k = lua_gc(L, o); + int b = lua_gc(L, LUA_GCCOUNTB); + checkvalres(k); + lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024)); + return 1; + } + case LUA_GCSTEP: { + lua_Integer n = luaL_optinteger(L, 2, 0); + int res = lua_gc(L, o, cast_sizet(n)); + checkvalres(res); + lua_pushboolean(L, res); + return 1; + } + case LUA_GCISRUNNING: { + int res = lua_gc(L, o); + checkvalres(res); + lua_pushboolean(L, res); + return 1; + } + case LUA_GCGEN: { + return pushmode(L, lua_gc(L, o)); + } + case LUA_GCINC: { + return pushmode(L, lua_gc(L, o)); + } + case LUA_GCPARAM: { + static const char *const params[] = { + "minormul", "majorminor", "minormajor", + "pause", "stepmul", "stepsize", NULL}; + static const char pnum[] = { + LUA_GCPMINORMUL, LUA_GCPMAJORMINOR, LUA_GCPMINORMAJOR, + LUA_GCPPAUSE, LUA_GCPSTEPMUL, LUA_GCPSTEPSIZE}; + int p = pnum[luaL_checkoption(L, 2, NULL, params)]; + lua_Integer value = luaL_optinteger(L, 3, -1); + lua_pushinteger(L, lua_gc(L, o, p, (int)value)); + return 1; + } + default: { + int res = lua_gc(L, o); + checkvalres(res); + lua_pushinteger(L, res); + return 1; + } + } + luaL_pushfail(L); /* invalid call (inside a finalizer) */ + return 1; +} + + +static int luaB_type (lua_State *L) { + int t = lua_type(L, 1); + luaL_argcheck(L, t != LUA_TNONE, 1, "value expected"); + lua_pushstring(L, lua_typename(L, t)); + return 1; +} + + +static int luaB_next (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 2); /* create a 2nd argument if there isn't one */ + if (lua_next(L, 1)) + return 2; + else { + lua_pushnil(L); + return 1; + } +} + + +static int pairscont (lua_State *L, int status, lua_KContext k) { + (void)L; (void)status; (void)k; /* unused */ + return 4; /* __pairs did all the work, just return its results */ +} + +static int luaB_pairs (lua_State *L) { + luaL_checkany(L, 1); + if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) { /* no metamethod? */ + lua_pushcfunction(L, luaB_next); /* will return generator and */ + lua_pushvalue(L, 1); /* state */ + lua_pushnil(L); /* initial value */ + lua_pushnil(L); /* to-be-closed object */ + } + else { + lua_pushvalue(L, 1); /* argument 'self' to metamethod */ + lua_callk(L, 1, 4, 0, pairscont); /* get 4 values from metamethod */ + } + return 4; +} + + +/* +** Traversal function for 'ipairs' +*/ +static int ipairsaux (lua_State *L) { + lua_Integer i = luaL_checkinteger(L, 2); + i = luaL_intop(+, i, 1); + lua_pushinteger(L, i); + return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2; +} + + +/* +** 'ipairs' function. Returns 'ipairsaux', given "table", 0. +** (The given "table" may not be a table.) +*/ +static int luaB_ipairs (lua_State *L) { + luaL_checkany(L, 1); + lua_pushcfunction(L, ipairsaux); /* iteration function */ + lua_pushvalue(L, 1); /* state */ + lua_pushinteger(L, 0); /* initial value */ + return 3; +} + + +static int load_aux (lua_State *L, int status, int envidx) { + if (l_likely(status == LUA_OK)) { + if (envidx != 0) { /* 'env' parameter? */ + lua_pushvalue(L, envidx); /* environment for loaded function */ + if (!lua_setupvalue(L, -2, 1)) /* set it as 1st upvalue */ + lua_pop(L, 1); /* remove 'env' if not used by previous call */ + } + return 1; + } + else { /* error (message is on top of the stack) */ + luaL_pushfail(L); + lua_insert(L, -2); /* put before error message */ + return 2; /* return fail plus error message */ + } +} + + +static const char *getMode (lua_State *L, int idx) { + const char *mode = luaL_optstring(L, idx, "bt"); + if (strchr(mode, 'B') != NULL) /* Lua code cannot use fixed buffers */ + luaL_argerror(L, idx, "invalid mode"); + return mode; +} + + +static int luaB_loadfile (lua_State *L) { + const char *fname = luaL_optstring(L, 1, NULL); + const char *mode = getMode(L, 2); + int env = (!lua_isnone(L, 3) ? 3 : 0); /* 'env' index or 0 if no 'env' */ + int status = luaL_loadfilex(L, fname, mode); + return load_aux(L, status, env); +} + + +/* +** {====================================================== +** Generic Read function +** ======================================================= +*/ + + +/* +** reserved slot, above all arguments, to hold a copy of the returned +** string to avoid it being collected while parsed. 'load' has four +** optional arguments (chunk, source name, mode, and environment). +*/ +#define RESERVEDSLOT 5 + + +/* +** Reader for generic 'load' function: 'lua_load' uses the +** stack for internal stuff, so the reader cannot change the +** stack top. Instead, it keeps its resulting string in a +** reserved slot inside the stack. +*/ +static const char *generic_reader (lua_State *L, void *ud, size_t *size) { + (void)(ud); /* not used */ + luaL_checkstack(L, 2, "too many nested functions"); + lua_pushvalue(L, 1); /* get function */ + lua_call(L, 0, 1); /* call it */ + if (lua_isnil(L, -1)) { + lua_pop(L, 1); /* pop result */ + *size = 0; + return NULL; + } + else if (l_unlikely(!lua_isstring(L, -1))) + luaL_error(L, "reader function must return a string"); + lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */ + return lua_tolstring(L, RESERVEDSLOT, size); +} + + +static int luaB_load (lua_State *L) { + int status; + size_t l; + const char *s = lua_tolstring(L, 1, &l); + const char *mode = getMode(L, 3); + int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */ + if (s != NULL) { /* loading a string? */ + const char *chunkname = luaL_optstring(L, 2, s); + status = luaL_loadbufferx(L, s, l, chunkname, mode); + } + else { /* loading from a reader function */ + const char *chunkname = luaL_optstring(L, 2, "=(load)"); + luaL_checktype(L, 1, LUA_TFUNCTION); + lua_settop(L, RESERVEDSLOT); /* create reserved slot */ + status = lua_load(L, generic_reader, NULL, chunkname, mode); + } + return load_aux(L, status, env); +} + +/* }====================================================== */ + + +static int dofilecont (lua_State *L, int d1, lua_KContext d2) { + (void)d1; (void)d2; /* only to match 'lua_Kfunction' prototype */ + return lua_gettop(L) - 1; +} + + +static int luaB_dofile (lua_State *L) { + const char *fname = luaL_optstring(L, 1, NULL); + lua_settop(L, 1); + if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK)) + return lua_error(L); + lua_callk(L, 0, LUA_MULTRET, 0, dofilecont); + return dofilecont(L, 0, 0); +} + + +static int luaB_assert (lua_State *L) { + if (l_likely(lua_toboolean(L, 1))) /* condition is true? */ + return lua_gettop(L); /* return all arguments */ + else { /* error */ + luaL_checkany(L, 1); /* there must be a condition */ + lua_remove(L, 1); /* remove it */ + lua_pushliteral(L, "assertion failed!"); /* default message */ + lua_settop(L, 1); /* leave only message (default if no other one) */ + return luaB_error(L); /* call 'error' */ + } +} + + +static int luaB_select (lua_State *L) { + int n = lua_gettop(L); + if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') { + lua_pushinteger(L, n-1); + return 1; + } + else { + lua_Integer i = luaL_checkinteger(L, 1); + if (i < 0) i = n + i; + else if (i > n) i = n; + luaL_argcheck(L, 1 <= i, 1, "index out of range"); + return n - (int)i; + } +} + + +/* +** Continuation function for 'pcall' and 'xpcall'. Both functions +** already pushed a 'true' before doing the call, so in case of success +** 'finishpcall' only has to return everything in the stack minus +** 'extra' values (where 'extra' is exactly the number of items to be +** ignored). +*/ +static int finishpcall (lua_State *L, int status, lua_KContext extra) { + if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) { /* error? */ + lua_pushboolean(L, 0); /* first result (false) */ + lua_pushvalue(L, -2); /* error message */ + return 2; /* return false, msg */ + } + else + return lua_gettop(L) - (int)extra; /* return all results */ +} + + +static int luaB_pcall (lua_State *L) { + int status; + luaL_checkany(L, 1); + lua_pushboolean(L, 1); /* first result if no errors */ + lua_insert(L, 1); /* put it in place */ + status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall); + return finishpcall(L, status, 0); +} + + +/* +** Do a protected call with error handling. After 'lua_rotate', the +** stack will have ; so, the function passes +** 2 to 'finishpcall' to skip the 2 first values when returning results. +*/ +static int luaB_xpcall (lua_State *L) { + int status; + int n = lua_gettop(L); + luaL_checktype(L, 2, LUA_TFUNCTION); /* check error function */ + lua_pushboolean(L, 1); /* first result */ + lua_pushvalue(L, 1); /* function */ + lua_rotate(L, 3, 2); /* move them below function's arguments */ + status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall); + return finishpcall(L, status, 2); +} + + +static int luaB_tostring (lua_State *L) { + luaL_checkany(L, 1); + luaL_tolstring(L, 1, NULL); + return 1; +} + + +static const luaL_Reg base_funcs[] = { + {"assert", luaB_assert}, + {"collectgarbage", luaB_collectgarbage}, + {"dofile", luaB_dofile}, + {"error", luaB_error}, + {"getmetatable", luaB_getmetatable}, + {"ipairs", luaB_ipairs}, + {"loadfile", luaB_loadfile}, + {"load", luaB_load}, + {"next", luaB_next}, + {"pairs", luaB_pairs}, + {"pcall", luaB_pcall}, + {"print", luaB_print}, + {"warn", luaB_warn}, + {"rawequal", luaB_rawequal}, + {"rawlen", luaB_rawlen}, + {"rawget", luaB_rawget}, + {"rawset", luaB_rawset}, + {"select", luaB_select}, + {"setmetatable", luaB_setmetatable}, + {"tonumber", luaB_tonumber}, + {"tostring", luaB_tostring}, + {"type", luaB_type}, + {"xpcall", luaB_xpcall}, + /* placeholders */ + {LUA_GNAME, NULL}, + {"_VERSION", NULL}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_base (lua_State *L) { + /* open lib into global table */ + lua_pushglobaltable(L); + luaL_setfuncs(L, base_funcs, 0); + /* set global _G */ + lua_pushvalue(L, -1); + lua_setfield(L, -2, LUA_GNAME); + /* set global _VERSION */ + lua_pushliteral(L, LUA_VERSION); + lua_setfield(L, -2, "_VERSION"); + return 1; +} + diff --git a/source/external/lua/lcode.c b/source/external/lua/lcode.c new file mode 100644 index 0000000..4caa804 --- /dev/null +++ b/source/external/lua/lcode.c @@ -0,0 +1,1971 @@ +/* +** $Id: lcode.c $ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + +#define lcode_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include +#include +#include + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstring.h" +#include "ltable.h" +#include "lvm.h" + + +/* (note that expressions VJMP also have jumps.) */ +#define hasjumps(e) ((e)->t != (e)->f) + + +static int codesJ (FuncState *fs, OpCode o, int sj, int k); + + + +/* semantic error */ +l_noret luaK_semerror (LexState *ls, const char *fmt, ...) { + const char *msg; + va_list argp; + pushvfstring(ls->L, argp, fmt, msg); + ls->t.token = 0; /* remove "near " from final message */ + ls->linenumber = ls->lastline; /* back to line of last used token */ + luaX_syntaxerror(ls, msg); +} + + +/* +** If expression is a numeric constant, fills 'v' with its value +** and returns 1. Otherwise, returns 0. +*/ +static int tonumeral (const expdesc *e, TValue *v) { + if (hasjumps(e)) + return 0; /* not a numeral */ + switch (e->k) { + case VKINT: + if (v) setivalue(v, e->u.ival); + return 1; + case VKFLT: + if (v) setfltvalue(v, e->u.nval); + return 1; + default: return 0; + } +} + + +/* +** Get the constant value from a constant expression +*/ +static TValue *const2val (FuncState *fs, const expdesc *e) { + lua_assert(e->k == VCONST); + return &fs->ls->dyd->actvar.arr[e->u.info].k; +} + + +/* +** If expression is a constant, fills 'v' with its value +** and returns 1. Otherwise, returns 0. +*/ +int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { + if (hasjumps(e)) + return 0; /* not a constant */ + switch (e->k) { + case VFALSE: + setbfvalue(v); + return 1; + case VTRUE: + setbtvalue(v); + return 1; + case VNIL: + setnilvalue(v); + return 1; + case VKSTR: { + setsvalue(fs->ls->L, v, e->u.strval); + return 1; + } + case VCONST: { + setobj(fs->ls->L, v, const2val(fs, e)); + return 1; + } + default: return tonumeral(e, v); + } +} + + +/* +** Return the previous instruction of the current code. If there +** may be a jump target between the current instruction and the +** previous one, return an invalid instruction (to avoid wrong +** optimizations). +*/ +static Instruction *previousinstruction (FuncState *fs) { + static const Instruction invalidinstruction = ~(Instruction)0; + if (fs->pc > fs->lasttarget) + return &fs->f->code[fs->pc - 1]; /* previous instruction */ + else + return cast(Instruction*, &invalidinstruction); +} + + +/* +** Create a OP_LOADNIL instruction, but try to optimize: if the previous +** instruction is also OP_LOADNIL and ranges are compatible, adjust +** range of previous instruction instead of emitting a new one. (For +** instance, 'local a; local b' will generate a single opcode.) +*/ +void luaK_nil (FuncState *fs, int from, int n) { + int l = from + n - 1; /* last register to set nil */ + Instruction *previous = previousinstruction(fs); + if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ + int pfrom = GETARG_A(*previous); /* get previous range */ + int pl = pfrom + GETARG_B(*previous); + if ((pfrom <= from && from <= pl + 1) || + (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ + if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ + if (pl > l) l = pl; /* l = max(l, pl) */ + SETARG_A(*previous, from); + SETARG_B(*previous, l - from); + return; + } /* else go through */ + } + luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0); /* else no optimization */ +} + + +/* +** Gets the destination address of a jump instruction. Used to traverse +** a list of jumps. +*/ +static int getjump (FuncState *fs, int pc) { + int offset = GETARG_sJ(fs->f->code[pc]); + if (offset == NO_JUMP) /* point to itself represents end of list */ + return NO_JUMP; /* end of list */ + else + return (pc+1)+offset; /* turn offset into absolute position */ +} + + +/* +** Fix jump instruction at position 'pc' to jump to 'dest'. +** (Jump addresses are relative in Lua) +*/ +static void fixjump (FuncState *fs, int pc, int dest) { + Instruction *jmp = &fs->f->code[pc]; + int offset = dest - (pc + 1); + lua_assert(dest != NO_JUMP); + if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) + luaX_syntaxerror(fs->ls, "control structure too long"); + lua_assert(GET_OPCODE(*jmp) == OP_JMP); + SETARG_sJ(*jmp, offset); +} + + +/* +** Concatenate jump-list 'l2' into jump-list 'l1' +*/ +void luaK_concat (FuncState *fs, int *l1, int l2) { + if (l2 == NO_JUMP) return; /* nothing to concatenate? */ + else if (*l1 == NO_JUMP) /* no original list? */ + *l1 = l2; /* 'l1' points to 'l2' */ + else { + int list = *l1; + int next; + while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ + list = next; + fixjump(fs, list, l2); /* last element links to 'l2' */ + } +} + + +/* +** Create a jump instruction and return its position, so its destination +** can be fixed later (with 'fixjump'). +*/ +int luaK_jump (FuncState *fs) { + return codesJ(fs, OP_JMP, NO_JUMP, 0); +} + + +/* +** Code a 'return' instruction +*/ +void luaK_ret (FuncState *fs, int first, int nret) { + OpCode op; + switch (nret) { + case 0: op = OP_RETURN0; break; + case 1: op = OP_RETURN1; break; + default: op = OP_RETURN; break; + } + luaY_checklimit(fs, nret + 1, MAXARG_B, "returns"); + luaK_codeABC(fs, op, first, nret + 1, 0); +} + + +/* +** Code a "conditional jump", that is, a test or comparison opcode +** followed by a jump. Return jump position. +*/ +static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { + luaK_codeABCk(fs, op, A, B, C, k); + return luaK_jump(fs); +} + + +/* +** returns current 'pc' and marks it as a jump target (to avoid wrong +** optimizations with consecutive instructions not in the same basic block). +*/ +int luaK_getlabel (FuncState *fs) { + fs->lasttarget = fs->pc; + return fs->pc; +} + + +/* +** Returns the position of the instruction "controlling" a given +** jump (that is, its condition), or the jump itself if it is +** unconditional. +*/ +static Instruction *getjumpcontrol (FuncState *fs, int pc) { + Instruction *pi = &fs->f->code[pc]; + if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) + return pi-1; + else + return pi; +} + + +/* +** Patch destination register for a TESTSET instruction. +** If instruction in position 'node' is not a TESTSET, return 0 ("fails"). +** Otherwise, if 'reg' is not 'NO_REG', set it as the destination +** register. Otherwise, change instruction to a simple 'TEST' (produces +** no register value) +*/ +static int patchtestreg (FuncState *fs, int node, int reg) { + Instruction *i = getjumpcontrol(fs, node); + if (GET_OPCODE(*i) != OP_TESTSET) + return 0; /* cannot patch other instructions */ + if (reg != NO_REG && reg != GETARG_B(*i)) + SETARG_A(*i, reg); + else { + /* no register to put value or register already has the value; + change instruction to simple test */ + *i = CREATE_ABCk(OP_TEST, GETARG_B(*i), 0, 0, GETARG_k(*i)); + } + return 1; +} + + +/* +** Traverse a list of tests ensuring no one produces a value +*/ +static void removevalues (FuncState *fs, int list) { + for (; list != NO_JUMP; list = getjump(fs, list)) + patchtestreg(fs, list, NO_REG); +} + + +/* +** Traverse a list of tests, patching their destination address and +** registers: tests producing values jump to 'vtarget' (and put their +** values in 'reg'), other tests jump to 'dtarget'. +*/ +static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, + int dtarget) { + while (list != NO_JUMP) { + int next = getjump(fs, list); + if (patchtestreg(fs, list, reg)) + fixjump(fs, list, vtarget); + else + fixjump(fs, list, dtarget); /* jump to default target */ + list = next; + } +} + + +/* +** Path all jumps in 'list' to jump to 'target'. +** (The assert means that we cannot fix a jump to a forward address +** because we only know addresses once code is generated.) +*/ +void luaK_patchlist (FuncState *fs, int list, int target) { + lua_assert(target <= fs->pc); + patchlistaux(fs, list, target, NO_REG, target); +} + + +void luaK_patchtohere (FuncState *fs, int list) { + int hr = luaK_getlabel(fs); /* mark "here" as a jump target */ + luaK_patchlist(fs, list, hr); +} + + +/* limit for difference between lines in relative line info. */ +#define LIMLINEDIFF 0x80 + + +/* +** Save line info for a new instruction. If difference from last line +** does not fit in a byte, of after that many instructions, save a new +** absolute line info; (in that case, the special value 'ABSLINEINFO' +** in 'lineinfo' signals the existence of this absolute information.) +** Otherwise, store the difference from last line in 'lineinfo'. +*/ +static void savelineinfo (FuncState *fs, Proto *f, int line) { + int linedif = line - fs->previousline; + int pc = fs->pc - 1; /* last instruction coded */ + if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { + luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, + f->sizeabslineinfo, AbsLineInfo, INT_MAX, "lines"); + f->abslineinfo[fs->nabslineinfo].pc = pc; + f->abslineinfo[fs->nabslineinfo++].line = line; + linedif = ABSLINEINFO; /* signal that there is absolute information */ + fs->iwthabs = 1; /* restart counter */ + } + luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, + INT_MAX, "opcodes"); + f->lineinfo[pc] = cast(ls_byte, linedif); + fs->previousline = line; /* last line saved */ +} + + +/* +** Remove line information from the last instruction. +** If line information for that instruction is absolute, set 'iwthabs' +** above its max to force the new (replacing) instruction to have +** absolute line info, too. +*/ +static void removelastlineinfo (FuncState *fs) { + Proto *f = fs->f; + int pc = fs->pc - 1; /* last instruction coded */ + if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ + fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ + fs->iwthabs--; /* undo previous increment */ + } + else { /* absolute line information */ + lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); + fs->nabslineinfo--; /* remove it */ + fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ + } +} + + +/* +** Remove the last instruction created, correcting line information +** accordingly. +*/ +static void removelastinstruction (FuncState *fs) { + removelastlineinfo(fs); + fs->pc--; +} + + +/* +** Emit instruction 'i', checking for array sizes and saving also its +** line information. Return 'i' position. +*/ +int luaK_code (FuncState *fs, Instruction i) { + Proto *f = fs->f; + /* put new instruction in code array */ + luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, + INT_MAX, "opcodes"); + f->code[fs->pc++] = i; + savelineinfo(fs, f, fs->ls->lastline); + return fs->pc - 1; /* index of new instruction */ +} + + +/* +** Format and emit an 'iABC' instruction. (Assertions check consistency +** of parameters versus opcode.) +*/ +int luaK_codeABCk (FuncState *fs, OpCode o, int A, int B, int C, int k) { + lua_assert(getOpMode(o) == iABC); + lua_assert(A <= MAXARG_A && B <= MAXARG_B && + C <= MAXARG_C && (k & ~1) == 0); + return luaK_code(fs, CREATE_ABCk(o, A, B, C, k)); +} + + +int luaK_codevABCk (FuncState *fs, OpCode o, int A, int B, int C, int k) { + lua_assert(getOpMode(o) == ivABC); + lua_assert(A <= MAXARG_A && B <= MAXARG_vB && + C <= MAXARG_vC && (k & ~1) == 0); + return luaK_code(fs, CREATE_vABCk(o, A, B, C, k)); +} + + +/* +** Format and emit an 'iABx' instruction. +*/ +int luaK_codeABx (FuncState *fs, OpCode o, int A, int Bc) { + lua_assert(getOpMode(o) == iABx); + lua_assert(A <= MAXARG_A && Bc <= MAXARG_Bx); + return luaK_code(fs, CREATE_ABx(o, A, Bc)); +} + + +/* +** Format and emit an 'iAsBx' instruction. +*/ +static int codeAsBx (FuncState *fs, OpCode o, int A, int Bc) { + int b = Bc + OFFSET_sBx; + lua_assert(getOpMode(o) == iAsBx); + lua_assert(A <= MAXARG_A && b <= MAXARG_Bx); + return luaK_code(fs, CREATE_ABx(o, A, b)); +} + + +/* +** Format and emit an 'isJ' instruction. +*/ +static int codesJ (FuncState *fs, OpCode o, int sj, int k) { + int j = sj + OFFSET_sJ; + lua_assert(getOpMode(o) == isJ); + lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); + return luaK_code(fs, CREATE_sJ(o, j, k)); +} + + +/* +** Emit an "extra argument" instruction (format 'iAx') +*/ +static int codeextraarg (FuncState *fs, int A) { + lua_assert(A <= MAXARG_Ax); + return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, A)); +} + + +/* +** Emit a "load constant" instruction, using either 'OP_LOADK' +** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX' +** instruction with "extra argument". +*/ +static int luaK_codek (FuncState *fs, int reg, int k) { + if (k <= MAXARG_Bx) + return luaK_codeABx(fs, OP_LOADK, reg, k); + else { + int p = luaK_codeABx(fs, OP_LOADKX, reg, 0); + codeextraarg(fs, k); + return p; + } +} + + +/* +** Check register-stack level, keeping track of its maximum size +** in field 'maxstacksize' +*/ +void luaK_checkstack (FuncState *fs, int n) { + int newstack = fs->freereg + n; + if (newstack > fs->f->maxstacksize) { + luaY_checklimit(fs, newstack, MAX_FSTACK, "registers"); + fs->f->maxstacksize = cast_byte(newstack); + } +} + + +/* +** Reserve 'n' registers in register stack +*/ +void luaK_reserveregs (FuncState *fs, int n) { + luaK_checkstack(fs, n); + fs->freereg = cast_byte(fs->freereg + n); +} + + +/* +** Free register 'reg', if it is neither a constant index nor +** a local variable. +) +*/ +static void freereg (FuncState *fs, int reg) { + if (reg >= luaY_nvarstack(fs)) { + fs->freereg--; + lua_assert(reg == fs->freereg); + } +} + + +/* +** Free two registers in proper order +*/ +static void freeregs (FuncState *fs, int r1, int r2) { + if (r1 > r2) { + freereg(fs, r1); + freereg(fs, r2); + } + else { + freereg(fs, r2); + freereg(fs, r1); + } +} + + +/* +** Free register used by expression 'e' (if any) +*/ +static void freeexp (FuncState *fs, expdesc *e) { + if (e->k == VNONRELOC) + freereg(fs, e->u.info); +} + + +/* +** Free registers used by expressions 'e1' and 'e2' (if any) in proper +** order. +*/ +static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { + int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; + int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; + freeregs(fs, r1, r2); +} + + +/* +** Add constant 'v' to prototype's list of constants (field 'k'). +*/ +static int addk (FuncState *fs, Proto *f, TValue *v) { + lua_State *L = fs->ls->L; + int oldsize = f->sizek; + int k = fs->nk; + luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); + while (oldsize < f->sizek) + setnilvalue(&f->k[oldsize++]); + setobj(L, &f->k[k], v); + fs->nk++; + luaC_barrier(L, f, v); + return k; +} + + +/* +** Use scanner's table to cache position of constants in constant list +** and try to reuse constants. Because some values should not be used +** as keys (nil cannot be a key, integer keys can collapse with float +** keys), the caller must provide a useful 'key' for indexing the cache. +*/ +static int k2proto (FuncState *fs, TValue *key, TValue *v) { + TValue val; + Proto *f = fs->f; + int tag = luaH_get(fs->kcache, key, &val); /* query scanner table */ + if (!tagisempty(tag)) { /* is there an index there? */ + int k = cast_int(ivalue(&val)); + /* collisions can happen only for float keys */ + lua_assert(ttisfloat(key) || luaV_rawequalobj(&f->k[k], v)); + return k; /* reuse index */ + } + else { /* constant not found; create a new entry */ + int k = addk(fs, f, v); + /* cache it for reuse; numerical value does not need GC barrier; + table is not a metatable, so it does not need to invalidate cache */ + setivalue(&val, k); + luaH_set(fs->ls->L, fs->kcache, key, &val); + return k; + } +} + + +/* +** Add a string to list of constants and return its index. +*/ +static int stringK (FuncState *fs, TString *s) { + TValue o; + setsvalue(fs->ls->L, &o, s); + return k2proto(fs, &o, &o); /* use string itself as key */ +} + + +/* +** Add an integer to list of constants and return its index. +*/ +static int luaK_intK (FuncState *fs, lua_Integer n) { + TValue o; + setivalue(&o, n); + return k2proto(fs, &o, &o); /* use integer itself as key */ +} + +/* +** Add a float to list of constants and return its index. Floats +** with integral values need a different key, to avoid collision +** with actual integers. To that end, we add to the number its smaller +** power-of-two fraction that is still significant in its scale. +** (For doubles, the fraction would be 2^-52). +** This method is not bulletproof: different numbers may generate the +** same key (e.g., very large numbers will overflow to 'inf') and for +** floats larger than 2^53 the result is still an integer. For those +** cases, just generate a new entry. At worst, this only wastes an entry +** with a duplicate. +*/ +static int luaK_numberK (FuncState *fs, lua_Number r) { + TValue o, kv; + setfltvalue(&o, r); /* value as a TValue */ + if (r == 0) { /* handle zero as a special case */ + setpvalue(&kv, fs); /* use FuncState as index */ + return k2proto(fs, &kv, &o); /* cannot collide */ + } + else { + const int nbm = l_floatatt(MANT_DIG); + const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); + const lua_Number k = r * (1 + q); /* key */ + lua_Integer ik; + setfltvalue(&kv, k); /* key as a TValue */ + if (!luaV_flttointeger(k, &ik, F2Ieq)) { /* not an integer value? */ + int n = k2proto(fs, &kv, &o); /* use key */ + if (luaV_rawequalobj(&fs->f->k[n], &o)) /* correct value? */ + return n; + } + /* else, either key is still an integer or there was a collision; + anyway, do not try to reuse constant; instead, create a new one */ + return addk(fs, fs->f, &o); + } +} + + +/* +** Add a false to list of constants and return its index. +*/ +static int boolF (FuncState *fs) { + TValue o; + setbfvalue(&o); + return k2proto(fs, &o, &o); /* use boolean itself as key */ +} + + +/* +** Add a true to list of constants and return its index. +*/ +static int boolT (FuncState *fs) { + TValue o; + setbtvalue(&o); + return k2proto(fs, &o, &o); /* use boolean itself as key */ +} + + +/* +** Add nil to list of constants and return its index. +*/ +static int nilK (FuncState *fs) { + TValue k, v; + setnilvalue(&v); + /* cannot use nil as key; instead use table itself */ + sethvalue(fs->ls->L, &k, fs->kcache); + return k2proto(fs, &k, &v); +} + + +/* +** Check whether 'i' can be stored in an 'sC' operand. Equivalent to +** (0 <= int2sC(i) && int2sC(i) <= MAXARG_C) but without risk of +** overflows in the hidden addition inside 'int2sC'. +*/ +static int fitsC (lua_Integer i) { + return (l_castS2U(i) + OFFSET_sC <= cast_uint(MAXARG_C)); +} + + +/* +** Check whether 'i' can be stored in an 'sBx' operand. +*/ +static int fitsBx (lua_Integer i) { + return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); +} + + +void luaK_int (FuncState *fs, int reg, lua_Integer i) { + if (fitsBx(i)) + codeAsBx(fs, OP_LOADI, reg, cast_int(i)); + else + luaK_codek(fs, reg, luaK_intK(fs, i)); +} + + +static void luaK_float (FuncState *fs, int reg, lua_Number f) { + lua_Integer fi; + if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) + codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); + else + luaK_codek(fs, reg, luaK_numberK(fs, f)); +} + + +/* +** Get the value of 'var' in a register and generate an opcode to check +** whether that register is nil. 'k' is the index of the variable name +** in the list of constants. If its value cannot be encoded in Bx, a 0 +** will use '?' for the name. +*/ +void luaK_codecheckglobal (FuncState *fs, expdesc *var, int k, int line) { + luaK_exp2anyreg(fs, var); + luaK_fixline(fs, line); + k = (k >= MAXARG_Bx) ? 0 : k + 1; + luaK_codeABx(fs, OP_ERRNNIL, var->u.info, k); + luaK_fixline(fs, line); + freeexp(fs, var); +} + + +/* +** Convert a constant in 'v' into an expression description 'e' +*/ +static void const2exp (TValue *v, expdesc *e) { + switch (ttypetag(v)) { + case LUA_VNUMINT: + e->k = VKINT; e->u.ival = ivalue(v); + break; + case LUA_VNUMFLT: + e->k = VKFLT; e->u.nval = fltvalue(v); + break; + case LUA_VFALSE: + e->k = VFALSE; + break; + case LUA_VTRUE: + e->k = VTRUE; + break; + case LUA_VNIL: + e->k = VNIL; + break; + case LUA_VSHRSTR: case LUA_VLNGSTR: + e->k = VKSTR; e->u.strval = tsvalue(v); + break; + default: lua_assert(0); + } +} + + +/* +** Fix an expression to return the number of results 'nresults'. +** 'e' must be a multi-ret expression (function call or vararg). +*/ +void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { + Instruction *pc = &getinstruction(fs, e); + luaY_checklimit(fs, nresults + 1, MAXARG_C, "multiple results"); + if (e->k == VCALL) /* expression is an open function call? */ + SETARG_C(*pc, nresults + 1); + else { + lua_assert(e->k == VVARARG); + SETARG_C(*pc, nresults + 1); + SETARG_A(*pc, fs->freereg); + luaK_reserveregs(fs, 1); + } +} + + +/* +** Convert a VKSTR to a VK +*/ +static int str2K (FuncState *fs, expdesc *e) { + lua_assert(e->k == VKSTR); + e->u.info = stringK(fs, e->u.strval); + e->k = VK; + return e->u.info; +} + + +/* +** Fix an expression to return one result. +** If expression is not a multi-ret expression (function call or +** vararg), it already returns one result, so nothing needs to be done. +** Function calls become VNONRELOC expressions (as its result comes +** fixed in the base register of the call), while vararg expressions +** become VRELOC (as OP_VARARG puts its results where it wants). +** (Calls are created returning one result, so that does not need +** to be fixed.) +*/ +void luaK_setoneret (FuncState *fs, expdesc *e) { + if (e->k == VCALL) { /* expression is an open function call? */ + /* already returns 1 value */ + lua_assert(GETARG_C(getinstruction(fs, e)) == 2); + e->k = VNONRELOC; /* result has fixed position */ + e->u.info = GETARG_A(getinstruction(fs, e)); + } + else if (e->k == VVARARG) { + SETARG_C(getinstruction(fs, e), 2); + e->k = VRELOC; /* can relocate its simple result */ + } +} + +/* +** Change a vararg parameter into a regular local variable +*/ +void luaK_vapar2local (FuncState *fs, expdesc *var) { + needvatab(fs->f); /* function will need a vararg table */ + /* now a vararg parameter is equivalent to a regular local variable */ + var->k = VLOCAL; +} + + +/* +** Ensure that expression 'e' is not a variable (nor a ). +** (Expression still may have jump lists.) +*/ +void luaK_dischargevars (FuncState *fs, expdesc *e) { + switch (e->k) { + case VCONST: { + const2exp(const2val(fs, e), e); + break; + } + case VVARGVAR: { + luaK_vapar2local(fs, e); /* turn it into a local variable */ + } /* FALLTHROUGH */ + case VLOCAL: { /* already in a register */ + int temp = e->u.var.ridx; + e->u.info = temp; /* (can't do a direct assignment; values overlap) */ + e->k = VNONRELOC; /* becomes a non-relocatable value */ + break; + } + case VUPVAL: { /* move value to some (pending) register */ + e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); + e->k = VRELOC; + break; + } + case VINDEXUP: { + e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOC; + break; + } + case VINDEXI: { + freereg(fs, e->u.ind.t); + e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOC; + break; + } + case VINDEXSTR: { + freereg(fs, e->u.ind.t); + e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOC; + break; + } + case VINDEXED: { + freeregs(fs, e->u.ind.t, e->u.ind.idx); + e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOC; + break; + } + case VVARGIND: { + freeregs(fs, e->u.ind.t, e->u.ind.idx); + e->u.info = luaK_codeABC(fs, OP_GETVARG, 0, e->u.ind.t, e->u.ind.idx); + e->k = VRELOC; + break; + } + case VVARARG: case VCALL: { + luaK_setoneret(fs, e); + break; + } + default: break; /* there is one value available (somewhere) */ + } +} + + +/* +** Ensure expression value is in register 'reg', making 'e' a +** non-relocatable expression. +** (Expression still may have jump lists.) +*/ +static void discharge2reg (FuncState *fs, expdesc *e, int reg) { + luaK_dischargevars(fs, e); + switch (e->k) { + case VNIL: { + luaK_nil(fs, reg, 1); + break; + } + case VFALSE: { + luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); + break; + } + case VTRUE: { + luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); + break; + } + case VKSTR: { + str2K(fs, e); + } /* FALLTHROUGH */ + case VK: { + luaK_codek(fs, reg, e->u.info); + break; + } + case VKFLT: { + luaK_float(fs, reg, e->u.nval); + break; + } + case VKINT: { + luaK_int(fs, reg, e->u.ival); + break; + } + case VRELOC: { + Instruction *pc = &getinstruction(fs, e); + SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ + break; + } + case VNONRELOC: { + if (reg != e->u.info) + luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); + break; + } + default: { + lua_assert(e->k == VJMP); + return; /* nothing to do... */ + } + } + e->u.info = reg; + e->k = VNONRELOC; +} + + +/* +** Ensure expression value is in a register, making 'e' a +** non-relocatable expression. +** (Expression still may have jump lists.) +*/ +static void discharge2anyreg (FuncState *fs, expdesc *e) { + if (e->k != VNONRELOC) { /* no fixed register yet? */ + luaK_reserveregs(fs, 1); /* get a register */ + discharge2reg(fs, e, fs->freereg-1); /* put value there */ + } +} + + +static int code_loadbool (FuncState *fs, int A, OpCode op) { + luaK_getlabel(fs); /* those instructions may be jump targets */ + return luaK_codeABC(fs, op, A, 0, 0); +} + + +/* +** check whether list has any jump that do not produce a value +** or produce an inverted value +*/ +static int need_value (FuncState *fs, int list) { + for (; list != NO_JUMP; list = getjump(fs, list)) { + Instruction i = *getjumpcontrol(fs, list); + if (GET_OPCODE(i) != OP_TESTSET) return 1; + } + return 0; /* not found */ +} + + +/* +** Ensures final expression result (which includes results from its +** jump lists) is in register 'reg'. +** If expression has jumps, need to patch these jumps either to +** its final position or to "load" instructions (for those tests +** that do not produce values). +*/ +static void exp2reg (FuncState *fs, expdesc *e, int reg) { + discharge2reg(fs, e, reg); + if (e->k == VJMP) /* expression itself is a test? */ + luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ + if (hasjumps(e)) { + int final; /* position after whole expression */ + int p_f = NO_JUMP; /* position of an eventual LOAD false */ + int p_t = NO_JUMP; /* position of an eventual LOAD true */ + if (need_value(fs, e->t) || need_value(fs, e->f)) { + int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); + p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ + p_t = code_loadbool(fs, reg, OP_LOADTRUE); + /* jump around these booleans if 'e' is not a test */ + luaK_patchtohere(fs, fj); + } + final = luaK_getlabel(fs); + patchlistaux(fs, e->f, final, reg, p_f); + patchlistaux(fs, e->t, final, reg, p_t); + } + e->f = e->t = NO_JUMP; + e->u.info = reg; + e->k = VNONRELOC; +} + + +/* +** Ensures final expression result is in next available register. +*/ +void luaK_exp2nextreg (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + freeexp(fs, e); + luaK_reserveregs(fs, 1); + exp2reg(fs, e, fs->freereg - 1); +} + + +/* +** Ensures final expression result is in some (any) register +** and return that register. +*/ +int luaK_exp2anyreg (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + if (e->k == VNONRELOC) { /* expression already has a register? */ + if (!hasjumps(e)) /* no jumps? */ + return e->u.info; /* result is already in a register */ + if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ + exp2reg(fs, e, e->u.info); /* put final result in it */ + return e->u.info; + } + /* else expression has jumps and cannot change its register + to hold the jump values, because it is a local variable. + Go through to the default case. */ + } + luaK_exp2nextreg(fs, e); /* default: use next available register */ + return e->u.info; +} + + +/* +** Ensures final expression result is either in a register, +** in an upvalue, or it is the vararg parameter. +*/ +void luaK_exp2anyregup (FuncState *fs, expdesc *e) { + if ((e->k != VUPVAL && e->k != VVARGVAR) || hasjumps(e)) + luaK_exp2anyreg(fs, e); +} + + +/* +** Ensures final expression result is either in a register +** or it is a constant. +*/ +void luaK_exp2val (FuncState *fs, expdesc *e) { + if (e->k == VJMP || hasjumps(e)) + luaK_exp2anyreg(fs, e); + else + luaK_dischargevars(fs, e); +} + + +/* +** Try to make 'e' a K expression with an index in the range of R/K +** indices. Return true iff succeeded. +*/ +static int luaK_exp2K (FuncState *fs, expdesc *e) { + if (!hasjumps(e)) { + int info; + switch (e->k) { /* move constants to 'k' */ + case VTRUE: info = boolT(fs); break; + case VFALSE: info = boolF(fs); break; + case VNIL: info = nilK(fs); break; + case VKINT: info = luaK_intK(fs, e->u.ival); break; + case VKFLT: info = luaK_numberK(fs, e->u.nval); break; + case VKSTR: info = stringK(fs, e->u.strval); break; + case VK: info = e->u.info; break; + default: return 0; /* not a constant */ + } + if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ + e->k = VK; /* make expression a 'K' expression */ + e->u.info = info; + return 1; + } + } + /* else, expression doesn't fit; leave it unchanged */ + return 0; +} + + +/* +** Ensures final expression result is in a valid R/K index +** (that is, it is either in a register or in 'k' with an index +** in the range of R/K indices). +** Returns 1 iff expression is K. +*/ +static int exp2RK (FuncState *fs, expdesc *e) { + if (luaK_exp2K(fs, e)) + return 1; + else { /* not a constant in the right range: put it in a register */ + luaK_exp2anyreg(fs, e); + return 0; + } +} + + +static void codeABRK (FuncState *fs, OpCode o, int A, int B, + expdesc *ec) { + int k = exp2RK(fs, ec); + luaK_codeABCk(fs, o, A, B, ec->u.info, k); +} + + +/* +** Generate code to store result of expression 'ex' into variable 'var'. +*/ +void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { + switch (var->k) { + case VLOCAL: { + freeexp(fs, ex); + exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ + return; + } + case VUPVAL: { + int e = luaK_exp2anyreg(fs, ex); + luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); + break; + } + case VINDEXUP: { + codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); + break; + } + case VINDEXI: { + codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); + break; + } + case VINDEXSTR: { + codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); + break; + } + case VVARGIND: { + needvatab(fs->f); /* function will need a vararg table */ + /* now, assignment is to a regular table */ + } /* FALLTHROUGH */ + case VINDEXED: { + codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); + break; + } + default: lua_assert(0); /* invalid var kind to store */ + } + freeexp(fs, ex); +} + + +/* +** Negate condition 'e' (where 'e' is a comparison). +*/ +static void negatecondition (FuncState *fs, expdesc *e) { + Instruction *pc = getjumpcontrol(fs, e->u.info); + lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && + GET_OPCODE(*pc) != OP_TEST); + SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); +} + + +/* +** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond' +** is true, code will jump if 'e' is true.) Return jump position. +** Optimize when 'e' is 'not' something, inverting the condition +** and removing the 'not'. +*/ +static int jumponcond (FuncState *fs, expdesc *e, int cond) { + if (e->k == VRELOC) { + Instruction ie = getinstruction(fs, e); + if (GET_OPCODE(ie) == OP_NOT) { + removelastinstruction(fs); /* remove previous OP_NOT */ + return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); + } + /* else go through */ + } + discharge2anyreg(fs, e); + freeexp(fs, e); + return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); +} + + +/* +** Emit code to go through if 'e' is true, jump otherwise. +*/ +void luaK_goiftrue (FuncState *fs, expdesc *e) { + int pc; /* pc of new jump */ + luaK_dischargevars(fs, e); + switch (e->k) { + case VJMP: { /* condition? */ + negatecondition(fs, e); /* jump when it is false */ + pc = e->u.info; /* save jump position */ + break; + } + case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { + pc = NO_JUMP; /* always true; do nothing */ + break; + } + default: { + pc = jumponcond(fs, e, 0); /* jump when false */ + break; + } + } + luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ + luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ + e->t = NO_JUMP; +} + + +/* +** Emit code to go through if 'e' is false, jump otherwise. +*/ +static void luaK_goiffalse (FuncState *fs, expdesc *e) { + int pc; /* pc of new jump */ + luaK_dischargevars(fs, e); + switch (e->k) { + case VJMP: { + pc = e->u.info; /* already jump if true */ + break; + } + case VNIL: case VFALSE: { + pc = NO_JUMP; /* always false; do nothing */ + break; + } + default: { + pc = jumponcond(fs, e, 1); /* jump if true */ + break; + } + } + luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ + luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ + e->f = NO_JUMP; +} + + +/* +** Code 'not e', doing constant folding. +*/ +static void codenot (FuncState *fs, expdesc *e) { + switch (e->k) { + case VNIL: case VFALSE: { + e->k = VTRUE; /* true == not nil == not false */ + break; + } + case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { + e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ + break; + } + case VJMP: { + negatecondition(fs, e); + break; + } + case VRELOC: + case VNONRELOC: { + discharge2anyreg(fs, e); + freeexp(fs, e); + e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); + e->k = VRELOC; + break; + } + default: lua_assert(0); /* cannot happen */ + } + /* interchange true and false lists */ + { int temp = e->f; e->f = e->t; e->t = temp; } + removevalues(fs, e->f); /* values are useless when negated */ + removevalues(fs, e->t); +} + + +/* +** Check whether expression 'e' is a short literal string +*/ +static int isKstr (FuncState *fs, expdesc *e) { + return (e->k == VK && !hasjumps(e) && e->u.info <= MAXINDEXRK && + ttisshrstring(&fs->f->k[e->u.info])); +} + +/* +** Check whether expression 'e' is a literal integer. +*/ +static int isKint (expdesc *e) { + return (e->k == VKINT && !hasjumps(e)); +} + + +/* +** Check whether expression 'e' is a literal integer in +** proper range to fit in register C +*/ +static int isCint (expdesc *e) { + return isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); +} + + +/* +** Check whether expression 'e' is a literal integer in +** proper range to fit in register sC +*/ +static int isSCint (expdesc *e) { + return isKint(e) && fitsC(e->u.ival); +} + + +/* +** Check whether expression 'e' is a literal integer or float in +** proper range to fit in a register (sB or sC). +*/ +static int isSCnumber (expdesc *e, int *pi, int *isfloat) { + lua_Integer i; + if (e->k == VKINT) + i = e->u.ival; + else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) + *isfloat = 1; + else + return 0; /* not a number */ + if (!hasjumps(e) && fitsC(i)) { + *pi = int2sC(cast_int(i)); + return 1; + } + else + return 0; +} + + +/* +** Emit SELF instruction or equivalent: the code will convert +** expression 'e' into 'e.key(e,'. +*/ +void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { + int ereg, base; + luaK_exp2anyreg(fs, e); + ereg = e->u.info; /* register where 'e' (the receiver) was placed */ + freeexp(fs, e); + base = e->u.info = fs->freereg; /* base register for op_self */ + e->k = VNONRELOC; /* self expression has a fixed register */ + luaK_reserveregs(fs, 2); /* method and 'self' produced by op_self */ + lua_assert(key->k == VKSTR); + /* is method name a short string in a valid K index? */ + if (strisshr(key->u.strval) && luaK_exp2K(fs, key)) { + /* can use 'self' opcode */ + luaK_codeABCk(fs, OP_SELF, base, ereg, key->u.info, 0); + } + else { /* cannot use 'self' opcode; use move+gettable */ + luaK_exp2anyreg(fs, key); /* put method name in a register */ + luaK_codeABC(fs, OP_MOVE, base + 1, ereg, 0); /* copy self to base+1 */ + luaK_codeABC(fs, OP_GETTABLE, base, ereg, key->u.info); /* get method */ + } + freeexp(fs, key); +} + + +/* auxiliary function to define indexing expressions */ +static void fillidxk (expdesc *t, int idx, expkind k) { + t->u.ind.idx = cast_byte(idx); + t->k = k; +} + + +/* +** Create expression 't[k]'. 't' must have its final result already in a +** register or upvalue. Upvalues can only be indexed by literal strings. +** Keys can be literal strings in the constant table or arbitrary +** values in registers. +*/ +void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { + int keystr = -1; + if (k->k == VKSTR) + keystr = str2K(fs, k); + lua_assert(!hasjumps(t) && + (t->k == VLOCAL || t->k == VVARGVAR || + t->k == VNONRELOC || t->k == VUPVAL)); + if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ + luaK_exp2anyreg(fs, t); /* put it in a register */ + if (t->k == VUPVAL) { + lu_byte temp = cast_byte(t->u.info); /* upvalue index */ + t->u.ind.t = temp; /* (can't do a direct assignment; values overlap) */ + lua_assert(isKstr(fs, k)); + fillidxk(t, k->u.info, VINDEXUP); /* literal short string */ + } + else if (t->k == VVARGVAR) { /* indexing the vararg parameter? */ + int kreg = luaK_exp2anyreg(fs, k); /* put key in some register */ + lu_byte vreg = cast_byte(t->u.var.ridx); /* register with vararg param. */ + lua_assert(vreg == fs->f->numparams); + t->u.ind.t = vreg; /* (avoid a direct assignment; values may overlap) */ + fillidxk(t, kreg, VVARGIND); /* 't' represents 'vararg[k]' */ + } + else { + /* register index of the table */ + t->u.ind.t = cast_byte((t->k == VLOCAL) ? t->u.var.ridx: t->u.info); + if (isKstr(fs, k)) + fillidxk(t, k->u.info, VINDEXSTR); /* literal short string */ + else if (isCint(k)) /* int. constant in proper range? */ + fillidxk(t, cast_int(k->u.ival), VINDEXI); + else + fillidxk(t, luaK_exp2anyreg(fs, k), VINDEXED); /* register */ + } + t->u.ind.keystr = keystr; /* string index in 'k' */ + t->u.ind.ro = 0; /* by default, not read-only */ +} + + +/* +** Return false if folding can raise an error. +** Bitwise operations need operands convertible to integers; division +** operations cannot have 0 as divisor. +*/ +static int validop (int op, TValue *v1, TValue *v2) { + switch (op) { + case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: + case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ + lua_Integer i; + return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && + luaV_tointegerns(v2, &i, LUA_FLOORN2I)); + } + case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ + return (nvalue(v2) != 0); + default: return 1; /* everything else is valid */ + } +} + + +/* +** Try to "constant-fold" an operation; return 1 iff successful. +** (In this case, 'e1' has the final result.) +*/ +static int constfolding (FuncState *fs, int op, expdesc *e1, + const expdesc *e2) { + TValue v1, v2, res; + if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) + return 0; /* non-numeric operands or not safe to fold */ + luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ + if (ttisinteger(&res)) { + e1->k = VKINT; + e1->u.ival = ivalue(&res); + } + else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ + lua_Number n = fltvalue(&res); + if (luai_numisnan(n) || n == 0) + return 0; + e1->k = VKFLT; + e1->u.nval = n; + } + return 1; +} + + +/* +** Convert a BinOpr to an OpCode (ORDER OPR - ORDER OP) +*/ +l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) { + lua_assert(baser <= opr && + ((baser == OPR_ADD && opr <= OPR_SHR) || + (baser == OPR_LT && opr <= OPR_LE))); + return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base)); +} + + +/* +** Convert a UnOpr to an OpCode (ORDER OPR - ORDER OP) +*/ +l_sinline OpCode unopr2op (UnOpr opr) { + return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) + + cast_int(OP_UNM)); +} + + +/* +** Convert a BinOpr to a tag method (ORDER OPR - ORDER TM) +*/ +l_sinline TMS binopr2TM (BinOpr opr) { + lua_assert(OPR_ADD <= opr && opr <= OPR_SHR); + return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD)); +} + + +/* +** Emit code for unary expressions that "produce values" +** (everything but 'not'). +** Expression to produce final result will be encoded in 'e'. +*/ +static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { + int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ + freeexp(fs, e); + e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ + e->k = VRELOC; /* all those operations are relocatable */ + luaK_fixline(fs, line); +} + + +/* +** Emit code for binary expressions that "produce values" +** (everything but logical operators 'and'/'or' and comparison +** operators). +** Expression to produce final result will be encoded in 'e1'. +*/ +static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2, + OpCode op, int v2, int flip, int line, + OpCode mmop, TMS event) { + int v1 = luaK_exp2anyreg(fs, e1); + int pc = luaK_codeABCk(fs, op, 0, v1, v2, 0); + freeexps(fs, e1, e2); + e1->u.info = pc; + e1->k = VRELOC; /* all those operations are relocatable */ + luaK_fixline(fs, line); + luaK_codeABCk(fs, mmop, v1, v2, cast_int(event), flip); /* metamethod */ + luaK_fixline(fs, line); +} + + +/* +** Emit code for binary expressions that "produce values" over +** two registers. +*/ +static void codebinexpval (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int line) { + OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); + int v2 = luaK_exp2anyreg(fs, e2); /* make sure 'e2' is in a register */ + /* 'e1' must be already in a register or it is a constant */ + lua_assert((VNIL <= e1->k && e1->k <= VKSTR) || + e1->k == VNONRELOC || e1->k == VRELOC); + lua_assert(OP_ADD <= op && op <= OP_SHR); + finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr)); +} + + +/* +** Code binary operators with immediate operands. +*/ +static void codebini (FuncState *fs, OpCode op, + expdesc *e1, expdesc *e2, int flip, int line, + TMS event) { + int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ + lua_assert(e2->k == VKINT); + finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); +} + + +/* +** Code binary operators with K operand. +*/ +static void codebinK (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int flip, int line) { + TMS event = binopr2TM(opr); + int v2 = e2->u.info; /* K index */ + OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK); + finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); +} + + +/* Try to code a binary operator negating its second operand. +** For the metamethod, 2nd operand must keep its original value. +*/ +static int finishbinexpneg (FuncState *fs, expdesc *e1, expdesc *e2, + OpCode op, int line, TMS event) { + if (!isKint(e2)) + return 0; /* not an integer constant */ + else { + lua_Integer i2 = e2->u.ival; + if (!(fitsC(i2) && fitsC(-i2))) + return 0; /* not in the proper range */ + else { /* operating a small integer constant */ + int v2 = cast_int(i2); + finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); + /* correct metamethod argument */ + SETARG_B(fs->f->code[fs->pc - 1], int2sC(v2)); + return 1; /* successfully coded */ + } + } +} + + +static void swapexps (expdesc *e1, expdesc *e2) { + expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ +} + + +/* +** Code binary operators with no constant operand. +*/ +static void codebinNoK (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int flip, int line) { + if (flip) + swapexps(e1, e2); /* back to original order */ + codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ +} + + +/* +** Code arithmetic operators ('+', '-', ...). If second operand is a +** constant in the proper range, use variant opcodes with K operands. +*/ +static void codearith (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int flip, int line) { + if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ + codebinK(fs, opr, e1, e2, flip, line); + else /* 'e2' is neither an immediate nor a K operand */ + codebinNoK(fs, opr, e1, e2, flip, line); +} + + +/* +** Code commutative operators ('+', '*'). If first operand is a +** numeric constant, change order of operands to try to use an +** immediate or K operator. +*/ +static void codecommutative (FuncState *fs, BinOpr op, + expdesc *e1, expdesc *e2, int line) { + int flip = 0; + if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ + swapexps(e1, e2); /* change order */ + flip = 1; + } + if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ + codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD); + else + codearith(fs, op, e1, e2, flip, line); +} + + +/* +** Code bitwise operations; they are all commutative, so the function +** tries to put an integer constant as the 2nd operand (a K operand). +*/ +static void codebitwise (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int line) { + int flip = 0; + if (e1->k == VKINT) { + swapexps(e1, e2); /* 'e2' will be the constant operand */ + flip = 1; + } + if (e2->k == VKINT && luaK_exp2K(fs, e2)) /* K operand? */ + codebinK(fs, opr, e1, e2, flip, line); + else /* no constants */ + codebinNoK(fs, opr, e1, e2, flip, line); +} + + +/* +** Emit code for order comparisons. When using an immediate operand, +** 'isfloat' tells whether the original value was a float. +*/ +static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { + int r1, r2; + int im; + int isfloat = 0; + OpCode op; + if (isSCnumber(e2, &im, &isfloat)) { + /* use immediate operand */ + r1 = luaK_exp2anyreg(fs, e1); + r2 = im; + op = binopr2op(opr, OPR_LT, OP_LTI); + } + else if (isSCnumber(e1, &im, &isfloat)) { + /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ + r1 = luaK_exp2anyreg(fs, e2); + r2 = im; + op = binopr2op(opr, OPR_LT, OP_GTI); + } + else { /* regular case, compare two registers */ + r1 = luaK_exp2anyreg(fs, e1); + r2 = luaK_exp2anyreg(fs, e2); + op = binopr2op(opr, OPR_LT, OP_LT); + } + freeexps(fs, e1, e2); + e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); + e1->k = VJMP; +} + + +/* +** Emit code for equality comparisons ('==', '~='). +** 'e1' was already put as RK by 'luaK_infix'. +*/ +static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { + int r1, r2; + int im; + int isfloat = 0; /* not needed here, but kept for symmetry */ + OpCode op; + if (e1->k != VNONRELOC) { + lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); + swapexps(e1, e2); + } + r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ + if (isSCnumber(e2, &im, &isfloat)) { + op = OP_EQI; + r2 = im; /* immediate operand */ + } + else if (exp2RK(fs, e2)) { /* 2nd expression is constant? */ + op = OP_EQK; + r2 = e2->u.info; /* constant index */ + } + else { + op = OP_EQ; /* will compare two registers */ + r2 = luaK_exp2anyreg(fs, e2); + } + freeexps(fs, e1, e2); + e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); + e1->k = VJMP; +} + + +/* +** Apply prefix operation 'op' to expression 'e'. +*/ +void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { + static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; + luaK_dischargevars(fs, e); + switch (opr) { + case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ + if (constfolding(fs, cast_int(opr + LUA_OPUNM), e, &ef)) + break; + /* else */ /* FALLTHROUGH */ + case OPR_LEN: + codeunexpval(fs, unopr2op(opr), e, line); + break; + case OPR_NOT: codenot(fs, e); break; + default: lua_assert(0); + } +} + + +/* +** Process 1st operand 'v' of binary operation 'op' before reading +** 2nd operand. +*/ +void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { + luaK_dischargevars(fs, v); + switch (op) { + case OPR_AND: { + luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ + break; + } + case OPR_OR: { + luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ + break; + } + case OPR_CONCAT: { + luaK_exp2nextreg(fs, v); /* operand must be on the stack */ + break; + } + case OPR_ADD: case OPR_SUB: + case OPR_MUL: case OPR_DIV: case OPR_IDIV: + case OPR_MOD: case OPR_POW: + case OPR_BAND: case OPR_BOR: case OPR_BXOR: + case OPR_SHL: case OPR_SHR: { + if (!tonumeral(v, NULL)) + luaK_exp2anyreg(fs, v); + /* else keep numeral, which may be folded or used as an immediate + operand */ + break; + } + case OPR_EQ: case OPR_NE: { + if (!tonumeral(v, NULL)) + exp2RK(fs, v); + /* else keep numeral, which may be an immediate operand */ + break; + } + case OPR_LT: case OPR_LE: + case OPR_GT: case OPR_GE: { + int dummy, dummy2; + if (!isSCnumber(v, &dummy, &dummy2)) + luaK_exp2anyreg(fs, v); + /* else keep numeral, which may be an immediate operand */ + break; + } + default: lua_assert(0); + } +} + +/* +** Create code for '(e1 .. e2)'. +** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))', +** because concatenation is right associative), merge both CONCATs. +*/ +static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) { + Instruction *ie2 = previousinstruction(fs); + if (GET_OPCODE(*ie2) == OP_CONCAT) { /* is 'e2' a concatenation? */ + int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ + lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); + freeexp(fs, e2); + SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ + SETARG_B(*ie2, n + 1); /* will concatenate one more element */ + } + else { /* 'e2' is not a concatenation */ + luaK_codeABC(fs, OP_CONCAT, e1->u.info, 2, 0); /* new concat opcode */ + freeexp(fs, e2); + luaK_fixline(fs, line); + } +} + + +/* +** Finalize code for binary operation, after reading 2nd operand. +*/ +void luaK_posfix (FuncState *fs, BinOpr opr, + expdesc *e1, expdesc *e2, int line) { + luaK_dischargevars(fs, e2); + if (foldbinop(opr) && constfolding(fs, cast_int(opr + LUA_OPADD), e1, e2)) + return; /* done by folding */ + switch (opr) { + case OPR_AND: { + lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ + luaK_concat(fs, &e2->f, e1->f); + *e1 = *e2; + break; + } + case OPR_OR: { + lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ + luaK_concat(fs, &e2->t, e1->t); + *e1 = *e2; + break; + } + case OPR_CONCAT: { /* e1 .. e2 */ + luaK_exp2nextreg(fs, e2); + codeconcat(fs, e1, e2, line); + break; + } + case OPR_ADD: case OPR_MUL: { + codecommutative(fs, opr, e1, e2, line); + break; + } + case OPR_SUB: { + if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) + break; /* coded as (r1 + -I) */ + /* ELSE */ + } /* FALLTHROUGH */ + case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { + codearith(fs, opr, e1, e2, 0, line); + break; + } + case OPR_BAND: case OPR_BOR: case OPR_BXOR: { + codebitwise(fs, opr, e1, e2, line); + break; + } + case OPR_SHL: { + if (isSCint(e1)) { + swapexps(e1, e2); + codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ + } + else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { + /* coded as (r1 >> -I) */; + } + else /* regular case (two registers) */ + codebinexpval(fs, opr, e1, e2, line); + break; + } + case OPR_SHR: { + if (isSCint(e2)) + codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ + else /* regular case (two registers) */ + codebinexpval(fs, opr, e1, e2, line); + break; + } + case OPR_EQ: case OPR_NE: { + codeeq(fs, opr, e1, e2); + break; + } + case OPR_GT: case OPR_GE: { + /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ + swapexps(e1, e2); + opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT); + } /* FALLTHROUGH */ + case OPR_LT: case OPR_LE: { + codeorder(fs, opr, e1, e2); + break; + } + default: lua_assert(0); + } +} + + +/* +** Change line information associated with current position, by removing +** previous info and adding it again with new line. +*/ +void luaK_fixline (FuncState *fs, int line) { + removelastlineinfo(fs); + savelineinfo(fs, fs->f, line); +} + + +void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { + Instruction *inst = &fs->f->code[pc]; + int extra = asize / (MAXARG_vC + 1); /* higher bits of array size */ + int rc = asize % (MAXARG_vC + 1); /* lower bits of array size */ + int k = (extra > 0); /* true iff needs extra argument */ + hsize = (hsize != 0) ? luaO_ceillog2(cast_uint(hsize)) + 1 : 0; + *inst = CREATE_vABCk(OP_NEWTABLE, ra, hsize, rc, k); + *(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra); +} + + +/* +** Emit a SETLIST instruction. +** 'base' is register that keeps table; +** 'nelems' is #table plus those to be stored now; +** 'tostore' is number of values (in registers 'base + 1',...) to add to +** table (or LUA_MULTRET to add up to stack top). +*/ +void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { + lua_assert(tostore != 0); + if (tostore == LUA_MULTRET) + tostore = 0; + if (nelems <= MAXARG_vC) + luaK_codevABCk(fs, OP_SETLIST, base, tostore, nelems, 0); + else { + int extra = nelems / (MAXARG_vC + 1); + nelems %= (MAXARG_vC + 1); + luaK_codevABCk(fs, OP_SETLIST, base, tostore, nelems, 1); + codeextraarg(fs, extra); + } + fs->freereg = cast_byte(base + 1); /* free registers with list values */ +} + + +/* +** return the final target of a jump (skipping jumps to jumps) +*/ +static int finaltarget (Instruction *code, int i) { + int count; + for (count = 0; count < 100; count++) { /* avoid infinite loops */ + Instruction pc = code[i]; + if (GET_OPCODE(pc) != OP_JMP) + break; + else + i += GETARG_sJ(pc) + 1; + } + return i; +} + + +/* +** Do a final pass over the code of a function, doing small peephole +** optimizations and adjustments. +*/ +#include "lopnames.h" +void luaK_finish (FuncState *fs) { + int i; + Proto *p = fs->f; + if (p->flag & PF_VATAB) /* will it use a vararg table? */ + p->flag &= cast_byte(~PF_VAHID); /* then it will not use hidden args. */ + for (i = 0; i < fs->pc; i++) { + Instruction *pc = &p->code[i]; + /* avoid "not used" warnings when assert is off (for 'onelua.c') */ + (void)luaP_isOT; (void)luaP_isIT; + lua_assert(i == 0 || luaP_isOT(*(pc - 1)) == luaP_isIT(*pc)); + switch (GET_OPCODE(*pc)) { + case OP_RETURN0: case OP_RETURN1: { + if (!(fs->needclose || (p->flag & PF_VAHID))) + break; /* no extra work */ + /* else use OP_RETURN to do the extra work */ + SET_OPCODE(*pc, OP_RETURN); + } /* FALLTHROUGH */ + case OP_RETURN: case OP_TAILCALL: { + if (fs->needclose) + SETARG_k(*pc, 1); /* signal that it needs to close */ + if (p->flag & PF_VAHID) /* does it use hidden arguments? */ + SETARG_C(*pc, p->numparams + 1); /* signal that */ + break; + } + case OP_GETVARG: { + if (p->flag & PF_VATAB) /* function has a vararg table? */ + SET_OPCODE(*pc, OP_GETTABLE); /* must get vararg there */ + break; + } + case OP_VARARG: { + if (p->flag & PF_VATAB) /* function has a vararg table? */ + SETARG_k(*pc, 1); /* must get vararg there */ + break; + } + case OP_JMP: { /* to optimize jumps to jumps */ + int target = finaltarget(p->code, i); + fixjump(fs, i, target); /* jump directly to final target */ + break; + } + default: break; + } + } +} diff --git a/source/external/lua/lcorolib.c b/source/external/lua/lcorolib.c new file mode 100644 index 0000000..eb30bf4 --- /dev/null +++ b/source/external/lua/lcorolib.c @@ -0,0 +1,225 @@ +/* +** $Id: lcorolib.c $ +** Coroutine Library +** See Copyright Notice in lua.h +*/ + +#define lcorolib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +static lua_State *getco (lua_State *L) { + lua_State *co = lua_tothread(L, 1); + luaL_argexpected(L, co, 1, "thread"); + return co; +} + + +/* +** Resumes a coroutine. Returns the number of results for non-error +** cases or -1 for errors. +*/ +static int auxresume (lua_State *L, lua_State *co, int narg) { + int status, nres; + if (l_unlikely(!lua_checkstack(co, narg))) { + lua_pushliteral(L, "too many arguments to resume"); + return -1; /* error flag */ + } + lua_xmove(L, co, narg); + status = lua_resume(co, L, narg, &nres); + if (l_likely(status == LUA_OK || status == LUA_YIELD)) { + if (l_unlikely(!lua_checkstack(L, nres + 1))) { + lua_pop(co, nres); /* remove results anyway */ + lua_pushliteral(L, "too many results to resume"); + return -1; /* error flag */ + } + lua_xmove(co, L, nres); /* move yielded values */ + return nres; + } + else { + lua_xmove(co, L, 1); /* move error message */ + return -1; /* error flag */ + } +} + + +static int luaB_coresume (lua_State *L) { + lua_State *co = getco(L); + int r; + r = auxresume(L, co, lua_gettop(L) - 1); + if (l_unlikely(r < 0)) { + lua_pushboolean(L, 0); + lua_insert(L, -2); + return 2; /* return false + error message */ + } + else { + lua_pushboolean(L, 1); + lua_insert(L, -(r + 1)); + return r + 1; /* return true + 'resume' returns */ + } +} + + +static int luaB_auxwrap (lua_State *L) { + lua_State *co = lua_tothread(L, lua_upvalueindex(1)); + int r = auxresume(L, co, lua_gettop(L)); + if (l_unlikely(r < 0)) { /* error? */ + int stat = lua_status(co); + if (stat != LUA_OK && stat != LUA_YIELD) { /* error in the coroutine? */ + stat = lua_closethread(co, L); /* close its tbc variables */ + lua_assert(stat != LUA_OK); + lua_xmove(co, L, 1); /* move error message to the caller */ + } + if (stat != LUA_ERRMEM && /* not a memory error and ... */ + lua_type(L, -1) == LUA_TSTRING) { /* ... error object is a string? */ + luaL_where(L, 1); /* add extra info, if available */ + lua_insert(L, -2); + lua_concat(L, 2); + } + return lua_error(L); /* propagate error */ + } + return r; +} + + +static int luaB_cocreate (lua_State *L) { + lua_State *NL; + luaL_checktype(L, 1, LUA_TFUNCTION); + NL = lua_newthread(L); + lua_pushvalue(L, 1); /* move function to top */ + lua_xmove(L, NL, 1); /* move function from L to NL */ + return 1; +} + + +static int luaB_cowrap (lua_State *L) { + luaB_cocreate(L); + lua_pushcclosure(L, luaB_auxwrap, 1); + return 1; +} + + +static int luaB_yield (lua_State *L) { + return lua_yield(L, lua_gettop(L)); +} + + +#define COS_RUN 0 +#define COS_DEAD 1 +#define COS_YIELD 2 +#define COS_NORM 3 + + +static const char *const statname[] = + {"running", "dead", "suspended", "normal"}; + + +static int auxstatus (lua_State *L, lua_State *co) { + if (L == co) return COS_RUN; + else { + switch (lua_status(co)) { + case LUA_YIELD: + return COS_YIELD; + case LUA_OK: { + lua_Debug ar; + if (lua_getstack(co, 0, &ar)) /* does it have frames? */ + return COS_NORM; /* it is running */ + else if (lua_gettop(co) == 0) + return COS_DEAD; + else + return COS_YIELD; /* initial state */ + } + default: /* some error occurred */ + return COS_DEAD; + } + } +} + + +static int luaB_costatus (lua_State *L) { + lua_State *co = getco(L); + lua_pushstring(L, statname[auxstatus(L, co)]); + return 1; +} + + +static lua_State *getoptco (lua_State *L) { + return (lua_isnone(L, 1) ? L : getco(L)); +} + + +static int luaB_yieldable (lua_State *L) { + lua_State *co = getoptco(L); + lua_pushboolean(L, lua_isyieldable(co)); + return 1; +} + + +static int luaB_corunning (lua_State *L) { + int ismain = lua_pushthread(L); + lua_pushboolean(L, ismain); + return 2; +} + + +static int luaB_close (lua_State *L) { + lua_State *co = getoptco(L); + int status = auxstatus(L, co); + switch (status) { + case COS_DEAD: case COS_YIELD: { + status = lua_closethread(co, L); + if (status == LUA_OK) { + lua_pushboolean(L, 1); + return 1; + } + else { + lua_pushboolean(L, 0); + lua_xmove(co, L, 1); /* move error message */ + return 2; + } + } + case COS_NORM: + return luaL_error(L, "cannot close a %s coroutine", statname[status]); + case COS_RUN: + lua_geti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD); /* get main */ + if (lua_tothread(L, -1) == co) + return luaL_error(L, "cannot close main thread"); + lua_closethread(co, L); /* close itself */ + /* previous call does not return *//* FALLTHROUGH */ + default: + lua_assert(0); + return 0; + } +} + + +static const luaL_Reg co_funcs[] = { + {"create", luaB_cocreate}, + {"resume", luaB_coresume}, + {"running", luaB_corunning}, + {"status", luaB_costatus}, + {"wrap", luaB_cowrap}, + {"yield", luaB_yield}, + {"isyieldable", luaB_yieldable}, + {"close", luaB_close}, + {NULL, NULL} +}; + + + +LUAMOD_API int luaopen_coroutine (lua_State *L) { + luaL_newlib(L, co_funcs); + return 1; +} + diff --git a/source/external/lua/lctype.c b/source/external/lua/lctype.c new file mode 100644 index 0000000..b1a43e4 --- /dev/null +++ b/source/external/lua/lctype.c @@ -0,0 +1,64 @@ +/* +** $Id: lctype.c $ +** 'ctype' functions for Lua +** See Copyright Notice in lua.h +*/ + +#define lctype_c +#define LUA_CORE + +#include "lprefix.h" + + +#include "lctype.h" + +#if !LUA_USE_CTYPE /* { */ + +#include + + +#if defined (LUA_UCID) /* accept UniCode IDentifiers? */ +/* consider all non-ASCII codepoints to be alphabetic */ +#define NONA 0x01 +#else +#define NONA 0x00 /* default */ +#endif + + +LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = { + 0x00, /* EOZ */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */ + 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */ + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */ + 0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */ + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */ + 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05, + 0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */ + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */ + 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 8. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 9. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* a. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* b. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + 0x00, 0x00, NONA, NONA, NONA, NONA, NONA, NONA, /* c. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* d. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* e. */ + NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, + NONA, NONA, NONA, NONA, NONA, 0x00, 0x00, 0x00, /* f. */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +#endif /* } */ diff --git a/source/external/lua/ldblib.c b/source/external/lua/ldblib.c new file mode 100644 index 0000000..c7b7481 --- /dev/null +++ b/source/external/lua/ldblib.c @@ -0,0 +1,477 @@ +/* +** $Id: ldblib.c $ +** Interface from Lua to its debug API +** See Copyright Notice in lua.h +*/ + +#define ldblib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** The hook table at registry[HOOKKEY] maps threads to their current +** hook function. +*/ +static const char *const HOOKKEY = "_HOOKKEY"; + + +/* +** If L1 != L, L1 can be in any state, and therefore there are no +** guarantees about its stack space; any push in L1 must be +** checked. +*/ +static void checkstack (lua_State *L, lua_State *L1, int n) { + if (l_unlikely(L != L1 && !lua_checkstack(L1, n))) + luaL_error(L, "stack overflow"); +} + + +static int db_getregistry (lua_State *L) { + lua_pushvalue(L, LUA_REGISTRYINDEX); + return 1; +} + + +static int db_getmetatable (lua_State *L) { + luaL_checkany(L, 1); + if (!lua_getmetatable(L, 1)) { + lua_pushnil(L); /* no metatable */ + } + return 1; +} + + +static int db_setmetatable (lua_State *L) { + int t = lua_type(L, 2); + luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table"); + lua_settop(L, 2); + lua_setmetatable(L, 1); + return 1; /* return 1st argument */ +} + + +static int db_getuservalue (lua_State *L) { + int n = (int)luaL_optinteger(L, 2, 1); + if (lua_type(L, 1) != LUA_TUSERDATA) + luaL_pushfail(L); + else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) { + lua_pushboolean(L, 1); + return 2; + } + return 1; +} + + +static int db_setuservalue (lua_State *L) { + int n = (int)luaL_optinteger(L, 3, 1); + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checkany(L, 2); + lua_settop(L, 2); + if (!lua_setiuservalue(L, 1, n)) + luaL_pushfail(L); + return 1; +} + + +/* +** Auxiliary function used by several library functions: check for +** an optional thread as function's first argument and set 'arg' with +** 1 if this argument is present (so that functions can skip it to +** access their other arguments) +*/ +static lua_State *getthread (lua_State *L, int *arg) { + if (lua_isthread(L, 1)) { + *arg = 1; + return lua_tothread(L, 1); + } + else { + *arg = 0; + return L; /* function will operate over current thread */ + } +} + + +/* +** Variations of 'lua_settable', used by 'db_getinfo' to put results +** from 'lua_getinfo' into result table. Key is always a string; +** value can be a string, an int, or a boolean. +*/ +static void settabss (lua_State *L, const char *k, const char *v) { + lua_pushstring(L, v); + lua_setfield(L, -2, k); +} + +static void settabsi (lua_State *L, const char *k, int v) { + lua_pushinteger(L, v); + lua_setfield(L, -2, k); +} + +static void settabsb (lua_State *L, const char *k, int v) { + lua_pushboolean(L, v); + lua_setfield(L, -2, k); +} + + +/* +** In function 'db_getinfo', the call to 'lua_getinfo' may push +** results on the stack; later it creates the result table to put +** these objects. Function 'treatstackoption' puts the result from +** 'lua_getinfo' on top of the result table so that it can call +** 'lua_setfield'. +*/ +static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) { + if (L == L1) + lua_rotate(L, -2, 1); /* exchange object and table */ + else + lua_xmove(L1, L, 1); /* move object to the "main" stack */ + lua_setfield(L, -2, fname); /* put object into table */ +} + + +/* +** Calls 'lua_getinfo' and collects all results in a new table. +** L1 needs stack space for an optional input (function) plus +** two optional outputs (function and line table) from function +** 'lua_getinfo'. +*/ +static int db_getinfo (lua_State *L) { + lua_Debug ar; + int arg; + lua_State *L1 = getthread(L, &arg); + const char *options = luaL_optstring(L, arg+2, "flnSrtu"); + checkstack(L, L1, 3); + luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'"); + if (lua_isfunction(L, arg + 1)) { /* info about a function? */ + options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */ + lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */ + lua_xmove(L, L1, 1); + } + else { /* stack level */ + if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) { + luaL_pushfail(L); /* level out of range */ + return 1; + } + } + if (!lua_getinfo(L1, options, &ar)) + return luaL_argerror(L, arg+2, "invalid option"); + lua_newtable(L); /* table to collect results */ + if (strchr(options, 'S')) { + lua_pushlstring(L, ar.source, ar.srclen); + lua_setfield(L, -2, "source"); + settabss(L, "short_src", ar.short_src); + settabsi(L, "linedefined", ar.linedefined); + settabsi(L, "lastlinedefined", ar.lastlinedefined); + settabss(L, "what", ar.what); + } + if (strchr(options, 'l')) + settabsi(L, "currentline", ar.currentline); + if (strchr(options, 'u')) { + settabsi(L, "nups", ar.nups); + settabsi(L, "nparams", ar.nparams); + settabsb(L, "isvararg", ar.isvararg); + } + if (strchr(options, 'n')) { + settabss(L, "name", ar.name); + settabss(L, "namewhat", ar.namewhat); + } + if (strchr(options, 'r')) { + settabsi(L, "ftransfer", ar.ftransfer); + settabsi(L, "ntransfer", ar.ntransfer); + } + if (strchr(options, 't')) { + settabsb(L, "istailcall", ar.istailcall); + settabsi(L, "extraargs", ar.extraargs); + } + if (strchr(options, 'L')) + treatstackoption(L, L1, "activelines"); + if (strchr(options, 'f')) + treatstackoption(L, L1, "func"); + return 1; /* return table */ +} + + +static int db_getlocal (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */ + if (lua_isfunction(L, arg + 1)) { /* function argument? */ + lua_pushvalue(L, arg + 1); /* push function */ + lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */ + return 1; /* return only name (there is no value) */ + } + else { /* stack-level argument */ + lua_Debug ar; + const char *name; + int level = (int)luaL_checkinteger(L, arg + 1); + if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */ + return luaL_argerror(L, arg+1, "level out of range"); + checkstack(L, L1, 1); + name = lua_getlocal(L1, &ar, nvar); + if (name) { + lua_xmove(L1, L, 1); /* move local value */ + lua_pushstring(L, name); /* push name */ + lua_rotate(L, -2, 1); /* re-order */ + return 2; + } + else { + luaL_pushfail(L); /* no name (nor value) */ + return 1; + } + } +} + + +static int db_setlocal (lua_State *L) { + int arg; + const char *name; + lua_State *L1 = getthread(L, &arg); + lua_Debug ar; + int level = (int)luaL_checkinteger(L, arg + 1); + int nvar = (int)luaL_checkinteger(L, arg + 2); + if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */ + return luaL_argerror(L, arg+1, "level out of range"); + luaL_checkany(L, arg+3); + lua_settop(L, arg+3); + checkstack(L, L1, 1); + lua_xmove(L, L1, 1); + name = lua_setlocal(L1, &ar, nvar); + if (name == NULL) + lua_pop(L1, 1); /* pop value (if not popped by 'lua_setlocal') */ + lua_pushstring(L, name); + return 1; +} + + +/* +** get (if 'get' is true) or set an upvalue from a closure +*/ +static int auxupvalue (lua_State *L, int get) { + const char *name; + int n = (int)luaL_checkinteger(L, 2); /* upvalue index */ + luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */ + name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n); + if (name == NULL) return 0; + lua_pushstring(L, name); + lua_insert(L, -(get+1)); /* no-op if get is false */ + return get + 1; +} + + +static int db_getupvalue (lua_State *L) { + return auxupvalue(L, 1); +} + + +static int db_setupvalue (lua_State *L) { + luaL_checkany(L, 3); + return auxupvalue(L, 0); +} + + +/* +** Check whether a given upvalue from a given closure exists and +** returns its index +*/ +static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) { + void *id; + int nup = (int)luaL_checkinteger(L, argnup); /* upvalue index */ + luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */ + id = lua_upvalueid(L, argf, nup); + if (pnup) { + luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index"); + *pnup = nup; + } + return id; +} + + +static int db_upvalueid (lua_State *L) { + void *id = checkupval(L, 1, 2, NULL); + if (id != NULL) + lua_pushlightuserdata(L, id); + else + luaL_pushfail(L); + return 1; +} + + +static int db_upvaluejoin (lua_State *L) { + int n1, n2; + checkupval(L, 1, 2, &n1); + checkupval(L, 3, 4, &n2); + luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected"); + luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected"); + lua_upvaluejoin(L, 1, n1, 3, n2); + return 0; +} + + +/* +** Call hook function registered at hook table for the current +** thread (if there is one) +*/ +static void hookf (lua_State *L, lua_Debug *ar) { + static const char *const hooknames[] = + {"call", "return", "line", "count", "tail call"}; + lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY); + lua_pushthread(L); + if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */ + lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */ + if (ar->currentline >= 0) + lua_pushinteger(L, ar->currentline); /* push current line */ + else lua_pushnil(L); + lua_assert(lua_getinfo(L, "lS", ar)); + lua_call(L, 2, 0); /* call hook function */ + } +} + + +/* +** Convert a string mask (for 'sethook') into a bit mask +*/ +static int makemask (const char *smask, int count) { + int mask = 0; + if (strchr(smask, 'c')) mask |= LUA_MASKCALL; + if (strchr(smask, 'r')) mask |= LUA_MASKRET; + if (strchr(smask, 'l')) mask |= LUA_MASKLINE; + if (count > 0) mask |= LUA_MASKCOUNT; + return mask; +} + + +/* +** Convert a bit mask (for 'gethook') into a string mask +*/ +static char *unmakemask (int mask, char *smask) { + int i = 0; + if (mask & LUA_MASKCALL) smask[i++] = 'c'; + if (mask & LUA_MASKRET) smask[i++] = 'r'; + if (mask & LUA_MASKLINE) smask[i++] = 'l'; + smask[i] = '\0'; + return smask; +} + + +static int db_sethook (lua_State *L) { + int arg, mask, count; + lua_Hook func; + lua_State *L1 = getthread(L, &arg); + if (lua_isnoneornil(L, arg+1)) { /* no hook? */ + lua_settop(L, arg+1); + func = NULL; mask = 0; count = 0; /* turn off hooks */ + } + else { + const char *smask = luaL_checkstring(L, arg+2); + luaL_checktype(L, arg+1, LUA_TFUNCTION); + count = (int)luaL_optinteger(L, arg + 3, 0); + func = hookf; mask = makemask(smask, count); + } + if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) { + /* table just created; initialize it */ + lua_pushliteral(L, "k"); + lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */ + lua_pushvalue(L, -1); + lua_setmetatable(L, -2); /* metatable(hooktable) = hooktable */ + } + checkstack(L, L1, 1); + lua_pushthread(L1); lua_xmove(L1, L, 1); /* key (thread) */ + lua_pushvalue(L, arg + 1); /* value (hook function) */ + lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */ + lua_sethook(L1, func, mask, count); + return 0; +} + + +static int db_gethook (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + char buff[5]; + int mask = lua_gethookmask(L1); + lua_Hook hook = lua_gethook(L1); + if (hook == NULL) { /* no hook? */ + luaL_pushfail(L); + return 1; + } + else if (hook != hookf) /* external hook? */ + lua_pushliteral(L, "external hook"); + else { /* hook table must exist */ + lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY); + checkstack(L, L1, 1); + lua_pushthread(L1); lua_xmove(L1, L, 1); + lua_rawget(L, -2); /* 1st result = hooktable[L1] */ + lua_remove(L, -2); /* remove hook table */ + } + lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */ + lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */ + return 3; +} + + +static int db_debug (lua_State *L) { + for (;;) { + char buffer[250]; + lua_writestringerror("%s", "lua_debug> "); + if (fgets(buffer, sizeof(buffer), stdin) == NULL || + strcmp(buffer, "cont\n") == 0) + return 0; + if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") || + lua_pcall(L, 0, 0, 0)) + lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL)); + lua_settop(L, 0); /* remove eventual returns */ + } +} + + +static int db_traceback (lua_State *L) { + int arg; + lua_State *L1 = getthread(L, &arg); + const char *msg = lua_tostring(L, arg + 1); + if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */ + lua_pushvalue(L, arg + 1); /* return it untouched */ + else { + int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0); + luaL_traceback(L, L1, msg, level); + } + return 1; +} + + +static const luaL_Reg dblib[] = { + {"debug", db_debug}, + {"getuservalue", db_getuservalue}, + {"gethook", db_gethook}, + {"getinfo", db_getinfo}, + {"getlocal", db_getlocal}, + {"getregistry", db_getregistry}, + {"getmetatable", db_getmetatable}, + {"getupvalue", db_getupvalue}, + {"upvaluejoin", db_upvaluejoin}, + {"upvalueid", db_upvalueid}, + {"setuservalue", db_setuservalue}, + {"sethook", db_sethook}, + {"setlocal", db_setlocal}, + {"setmetatable", db_setmetatable}, + {"setupvalue", db_setupvalue}, + {"traceback", db_traceback}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_debug (lua_State *L) { + luaL_newlib(L, dblib); + return 1; +} + diff --git a/source/external/lua/ldebug.c b/source/external/lua/ldebug.c new file mode 100644 index 0000000..8df5f5f --- /dev/null +++ b/source/external/lua/ldebug.c @@ -0,0 +1,979 @@ +/* +** $Id: ldebug.c $ +** Debug Interface +** See Copyright Notice in lua.h +*/ + +#define ldebug_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + + +#define LuaClosure(f) ((f) != NULL && (f)->c.tt == LUA_VLCL) + +static const char strlocal[] = "local"; +static const char strupval[] = "upvalue"; + +static const char *funcnamefromcall (lua_State *L, CallInfo *ci, + const char **name); + + +static int currentpc (CallInfo *ci) { + lua_assert(isLua(ci)); + return pcRel(ci->u.l.savedpc, ci_func(ci)->p); +} + + +/* +** Get a "base line" to find the line corresponding to an instruction. +** Base lines are regularly placed at MAXIWTHABS intervals, so usually +** an integer division gets the right place. When the source file has +** large sequences of empty/comment lines, it may need extra entries, +** so the original estimate needs a correction. +** If the original estimate is -1, the initial 'if' ensures that the +** 'while' will run at least once. +** The assertion that the estimate is a lower bound for the correct base +** is valid as long as the debug info has been generated with the same +** value for MAXIWTHABS or smaller. (Previous releases use a little +** smaller value.) +*/ +static int getbaseline (const Proto *f, int pc, int *basepc) { + if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { + *basepc = -1; /* start from the beginning */ + return f->linedefined; + } + else { + int i = pc / MAXIWTHABS - 1; /* get an estimate */ + /* estimate must be a lower bound of the correct base */ + lua_assert(i < 0 || + (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); + while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) + i++; /* low estimate; adjust it */ + *basepc = f->abslineinfo[i].pc; + return f->abslineinfo[i].line; + } +} + + +/* +** Get the line corresponding to instruction 'pc' in function 'f'; +** first gets a base line and from there does the increments until +** the desired instruction. +*/ +int luaG_getfuncline (const Proto *f, int pc) { + if (f->lineinfo == NULL) /* no debug information? */ + return -1; + else { + int basepc; + int baseline = getbaseline(f, pc, &basepc); + while (basepc++ < pc) { /* walk until given instruction */ + lua_assert(f->lineinfo[basepc] != ABSLINEINFO); + baseline += f->lineinfo[basepc]; /* correct line */ + } + return baseline; + } +} + + +static int getcurrentline (CallInfo *ci) { + return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); +} + + +/* +** Set 'trap' for all active Lua frames. +** This function can be called during a signal, under "reasonable" +** assumptions. A new 'ci' is completely linked in the list before it +** becomes part of the "active" list, and we assume that pointers are +** atomic; see comment in next function. +** (A compiler doing interprocedural optimizations could, theoretically, +** reorder memory writes in such a way that the list could be +** temporarily broken while inserting a new element. We simply assume it +** has no good reasons to do that.) +*/ +static void settraps (CallInfo *ci) { + for (; ci != NULL; ci = ci->previous) + if (isLua(ci)) + ci->u.l.trap = 1; +} + + +/* +** This function can be called during a signal, under "reasonable" +** assumptions. +** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount') +** are for debug only, and it is no problem if they get arbitrary +** values (causes at most one wrong hook call). 'hookmask' is an atomic +** value. We assume that pointers are atomic too (e.g., gcc ensures that +** for all platforms where it runs). Moreover, 'hook' is always checked +** before being called (see 'luaD_hook'). +*/ +LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) { + if (func == NULL || mask == 0) { /* turn off hooks? */ + mask = 0; + func = NULL; + } + L->hook = func; + L->basehookcount = count; + resethookcount(L); + L->hookmask = cast_byte(mask); + if (mask) + settraps(L->ci); /* to trace inside 'luaV_execute' */ +} + + +LUA_API lua_Hook lua_gethook (lua_State *L) { + return L->hook; +} + + +LUA_API int lua_gethookmask (lua_State *L) { + return L->hookmask; +} + + +LUA_API int lua_gethookcount (lua_State *L) { + return L->basehookcount; +} + + +LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { + int status; + CallInfo *ci; + if (level < 0) return 0; /* invalid (negative) level */ + lua_lock(L); + for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) + level--; + if (level == 0 && ci != &L->base_ci) { /* level found? */ + status = 1; + ar->i_ci = ci; + } + else status = 0; /* no such level */ + lua_unlock(L); + return status; +} + + +static const char *upvalname (const Proto *p, int uv) { + TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); + if (s == NULL) return "?"; + else return getstr(s); +} + + +static const char *findvararg (CallInfo *ci, int n, StkId *pos) { + if (clLvalue(s2v(ci->func.p))->p->flag & PF_VAHID) { + int nextra = ci->u.l.nextraargs; + if (n >= -nextra) { /* 'n' is negative */ + *pos = ci->func.p - nextra - (n + 1); + return "(vararg)"; /* generic name for any vararg */ + } + } + return NULL; /* no such vararg */ +} + + +const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) { + StkId base = ci->func.p + 1; + const char *name = NULL; + if (isLua(ci)) { + if (n < 0) /* access to vararg values? */ + return findvararg(ci, n, pos); + else + name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)); + } + if (name == NULL) { /* no 'standard' name? */ + StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p; + if (limit - base >= n && n > 0) { /* is 'n' inside 'ci' stack? */ + /* generic name for any valid slot */ + name = isLua(ci) ? "(temporary)" : "(C temporary)"; + } + else + return NULL; /* no name */ + } + if (pos) + *pos = base + (n - 1); + return name; +} + + +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + lua_lock(L); + if (ar == NULL) { /* information about non-active function? */ + if (!isLfunction(s2v(L->top.p - 1))) /* not a Lua function? */ + name = NULL; + else /* consider live variables at function start (parameters) */ + name = luaF_getlocalname(clLvalue(s2v(L->top.p - 1))->p, n, 0); + } + else { /* active function; get information through 'ar' */ + StkId pos = NULL; /* to avoid warnings */ + name = luaG_findlocal(L, ar->i_ci, n, &pos); + if (name) { + setobjs2s(L, L->top.p, pos); + api_incr_top(L); + } + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { + StkId pos = NULL; /* to avoid warnings */ + const char *name; + lua_lock(L); + name = luaG_findlocal(L, ar->i_ci, n, &pos); + if (name) { + api_checkpop(L, 1); + setobjs2s(L, pos, L->top.p - 1); + L->top.p--; /* pop value */ + } + lua_unlock(L); + return name; +} + + +static void funcinfo (lua_Debug *ar, Closure *cl) { + if (!LuaClosure(cl)) { + ar->source = "=[C]"; + ar->srclen = LL("=[C]"); + ar->linedefined = -1; + ar->lastlinedefined = -1; + ar->what = "C"; + } + else { + const Proto *p = cl->l.p; + if (p->source) { + ar->source = getlstr(p->source, ar->srclen); + } + else { + ar->source = "=?"; + ar->srclen = LL("=?"); + } + ar->linedefined = p->linedefined; + ar->lastlinedefined = p->lastlinedefined; + ar->what = (ar->linedefined == 0) ? "main" : "Lua"; + } + luaO_chunkid(ar->short_src, ar->source, ar->srclen); +} + + +static int nextline (const Proto *p, int currentline, int pc) { + if (p->lineinfo[pc] != ABSLINEINFO) + return currentline + p->lineinfo[pc]; + else + return luaG_getfuncline(p, pc); +} + + +static void collectvalidlines (lua_State *L, Closure *f) { + if (!LuaClosure(f)) { + setnilvalue(s2v(L->top.p)); + api_incr_top(L); + } + else { + const Proto *p = f->l.p; + int currentline = p->linedefined; + Table *t = luaH_new(L); /* new table to store active lines */ + sethvalue2s(L, L->top.p, t); /* push it on stack */ + api_incr_top(L); + if (p->lineinfo != NULL) { /* proto with debug information? */ + int i; + TValue v; + setbtvalue(&v); /* boolean 'true' to be the value of all indices */ + if (!(isvararg(p))) /* regular function? */ + i = 0; /* consider all instructions */ + else { /* vararg function */ + lua_assert(GET_OPCODE(p->code[0]) == OP_VARARGPREP); + currentline = nextline(p, currentline, 0); + i = 1; /* skip first instruction (OP_VARARGPREP) */ + } + for (; i < p->sizelineinfo; i++) { /* for each instruction */ + currentline = nextline(p, currentline, i); /* get its line */ + luaH_setint(L, t, currentline, &v); /* table[line] = true */ + } + } + } +} + + +static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { + /* calling function is a known function? */ + if (ci != NULL && !(ci->callstatus & CIST_TAIL)) + return funcnamefromcall(L, ci->previous, name); + else return NULL; /* no way to find a name */ +} + + +static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, + Closure *f, CallInfo *ci) { + int status = 1; + for (; *what; what++) { + switch (*what) { + case 'S': { + funcinfo(ar, f); + break; + } + case 'l': { + ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; + break; + } + case 'u': { + ar->nups = (f == NULL) ? 0 : f->c.nupvalues; + if (!LuaClosure(f)) { + ar->isvararg = 1; + ar->nparams = 0; + } + else { + ar->isvararg = (isvararg(f->l.p)) ? 1 : 0; + ar->nparams = f->l.p->numparams; + } + break; + } + case 't': { + if (ci != NULL) { + ar->istailcall = !!(ci->callstatus & CIST_TAIL); + ar->extraargs = + cast_uchar((ci->callstatus & MAX_CCMT) >> CIST_CCMT); + } + else { + ar->istailcall = 0; + ar->extraargs = 0; + } + break; + } + case 'n': { + ar->namewhat = getfuncname(L, ci, &ar->name); + if (ar->namewhat == NULL) { + ar->namewhat = ""; /* not found */ + ar->name = NULL; + } + break; + } + case 'r': { + if (ci == NULL || !(ci->callstatus & CIST_HOOKED)) + ar->ftransfer = ar->ntransfer = 0; + else { + ar->ftransfer = L->transferinfo.ftransfer; + ar->ntransfer = L->transferinfo.ntransfer; + } + break; + } + case 'L': + case 'f': /* handled by lua_getinfo */ + break; + default: status = 0; /* invalid option */ + } + } + return status; +} + + +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { + int status; + Closure *cl; + CallInfo *ci; + TValue *func; + lua_lock(L); + if (*what == '>') { + ci = NULL; + func = s2v(L->top.p - 1); + api_check(L, ttisfunction(func), "function expected"); + what++; /* skip the '>' */ + L->top.p--; /* pop function */ + } + else { + ci = ar->i_ci; + func = s2v(ci->func.p); + lua_assert(ttisfunction(func)); + } + cl = ttisclosure(func) ? clvalue(func) : NULL; + status = auxgetinfo(L, what, ar, cl, ci); + if (strchr(what, 'f')) { + setobj2s(L, L->top.p, func); + api_incr_top(L); + } + if (strchr(what, 'L')) + collectvalidlines(L, cl); + lua_unlock(L); + return status; +} + + +/* +** {====================================================== +** Symbolic Execution +** ======================================================= +*/ + + +static int filterpc (int pc, int jmptarget) { + if (pc < jmptarget) /* is code conditional (inside a jump)? */ + return -1; /* cannot know who sets that register */ + else return pc; /* current position sets that register */ +} + + +/* +** Try to find last instruction before 'lastpc' that modified register 'reg'. +*/ +static int findsetreg (const Proto *p, int lastpc, int reg) { + int pc; + int setreg = -1; /* keep last instruction that changed 'reg' */ + int jmptarget = 0; /* any code before this address is conditional */ + if (testMMMode(GET_OPCODE(p->code[lastpc]))) + lastpc--; /* previous instruction was not actually executed */ + for (pc = 0; pc < lastpc; pc++) { + Instruction i = p->code[pc]; + OpCode op = GET_OPCODE(i); + int a = GETARG_A(i); + int change; /* true if current instruction changed 'reg' */ + switch (op) { + case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ + int b = GETARG_B(i); + change = (a <= reg && reg <= a + b); + break; + } + case OP_TFORCALL: { /* affect all regs above its base */ + change = (reg >= a + 2); + break; + } + case OP_CALL: + case OP_TAILCALL: { /* affect all registers above base */ + change = (reg >= a); + break; + } + case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ + int b = GETARG_sJ(i); + int dest = pc + 1 + b; + /* jump does not skip 'lastpc' and is larger than current one? */ + if (dest <= lastpc && dest > jmptarget) + jmptarget = dest; /* update 'jmptarget' */ + change = 0; + break; + } + default: /* any instruction that sets A */ + change = (testAMode(op) && reg == a); + break; + } + if (change) + setreg = filterpc(pc, jmptarget); + } + return setreg; +} + + +/* +** Find a "name" for the constant 'c'. +*/ +static const char *kname (const Proto *p, int index, const char **name) { + TValue *kvalue = &p->k[index]; + if (ttisstring(kvalue)) { + *name = getstr(tsvalue(kvalue)); + return "constant"; + } + else { + *name = "?"; + return NULL; + } +} + + +static const char *basicgetobjname (const Proto *p, int *ppc, int reg, + const char **name) { + int pc = *ppc; + *name = luaF_getlocalname(p, reg + 1, pc); + if (*name) /* is a local? */ + return strlocal; + /* else try symbolic execution */ + *ppc = pc = findsetreg(p, pc, reg); + if (pc != -1) { /* could find instruction? */ + Instruction i = p->code[pc]; + OpCode op = GET_OPCODE(i); + switch (op) { + case OP_MOVE: { + int b = GETARG_B(i); /* move from 'b' to 'a' */ + if (b < GETARG_A(i)) + return basicgetobjname(p, ppc, b, name); /* get name for 'b' */ + break; + } + case OP_GETUPVAL: { + *name = upvalname(p, GETARG_B(i)); + return strupval; + } + case OP_LOADK: return kname(p, GETARG_Bx(i), name); + case OP_LOADKX: return kname(p, GETARG_Ax(p->code[pc + 1]), name); + default: break; + } + } + return NULL; /* could not find reasonable name */ +} + + +/* +** Find a "name" for the register 'c'. +*/ +static void rname (const Proto *p, int pc, int c, const char **name) { + const char *what = basicgetobjname(p, &pc, c, name); /* search for 'c' */ + if (!(what && *what == 'c')) /* did not find a constant name? */ + *name = "?"; +} + + +/* +** Check whether table being indexed by instruction 'i' is the +** environment '_ENV' +*/ +static const char *isEnv (const Proto *p, int pc, Instruction i, int isup) { + int t = GETARG_B(i); /* table index */ + const char *name; /* name of indexed variable */ + if (isup) /* is 't' an upvalue? */ + name = upvalname(p, t); + else { /* 't' is a register */ + const char *what = basicgetobjname(p, &pc, t, &name); + /* 'name' must be the name of a local variable (at the current + level or an upvalue) */ + if (what != strlocal && what != strupval) + name = NULL; /* cannot be the variable _ENV */ + } + return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; +} + + +/* +** Extend 'basicgetobjname' to handle table accesses +*/ +static const char *getobjname (const Proto *p, int lastpc, int reg, + const char **name) { + const char *kind = basicgetobjname(p, &lastpc, reg, name); + if (kind != NULL) + return kind; + else if (lastpc != -1) { /* could find instruction? */ + Instruction i = p->code[lastpc]; + OpCode op = GET_OPCODE(i); + switch (op) { + case OP_GETTABUP: { + int k = GETARG_C(i); /* key index */ + kname(p, k, name); + return isEnv(p, lastpc, i, 1); + } + case OP_GETTABLE: { + int k = GETARG_C(i); /* key index */ + rname(p, lastpc, k, name); + return isEnv(p, lastpc, i, 0); + } + case OP_GETI: { + *name = "integer index"; + return "field"; + } + case OP_GETFIELD: { + int k = GETARG_C(i); /* key index */ + kname(p, k, name); + return isEnv(p, lastpc, i, 0); + } + case OP_SELF: { + int k = GETARG_C(i); /* key index */ + kname(p, k, name); + return "method"; + } + default: break; /* go through to return NULL */ + } + } + return NULL; /* could not find reasonable name */ +} + + +/* +** Try to find a name for a function based on the code that called it. +** (Only works when function was called by a Lua function.) +** Returns what the name is (e.g., "for iterator", "method", +** "metamethod") and sets '*name' to point to the name. +*/ +static const char *funcnamefromcode (lua_State *L, const Proto *p, + int pc, const char **name) { + TMS tm = (TMS)0; /* (initial value avoids warnings) */ + Instruction i = p->code[pc]; /* calling instruction */ + switch (GET_OPCODE(i)) { + case OP_CALL: + case OP_TAILCALL: + return getobjname(p, pc, GETARG_A(i), name); /* get function name */ + case OP_TFORCALL: { /* for iterator */ + *name = "for iterator"; + return "for iterator"; + } + /* other instructions can do calls through metamethods */ + case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: + case OP_GETI: case OP_GETFIELD: + tm = TM_INDEX; + break; + case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD: + tm = TM_NEWINDEX; + break; + case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { + tm = cast(TMS, GETARG_C(i)); + break; + } + case OP_UNM: tm = TM_UNM; break; + case OP_BNOT: tm = TM_BNOT; break; + case OP_LEN: tm = TM_LEN; break; + case OP_CONCAT: tm = TM_CONCAT; break; + case OP_EQ: tm = TM_EQ; break; + /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */ + case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break; + case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break; + case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break; + default: + return NULL; /* cannot find a reasonable name */ + } + *name = getshrstr(G(L)->tmname[tm]) + 2; + return "metamethod"; +} + + +/* +** Try to find a name for a function based on how it was called. +*/ +static const char *funcnamefromcall (lua_State *L, CallInfo *ci, + const char **name) { + if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ + *name = "?"; + return "hook"; + } + else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ + *name = "__gc"; + return "metamethod"; /* report it as such */ + } + else if (isLua(ci)) + return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); + else + return NULL; +} + +/* }====================================================== */ + + + +/* +** Check whether pointer 'o' points to some value in the stack frame of +** the current function and, if so, returns its index. Because 'o' may +** not point to a value in this stack, we cannot compare it with the +** region boundaries (undefined behavior in ISO C). +*/ +static int instack (CallInfo *ci, const TValue *o) { + int pos; + StkId base = ci->func.p + 1; + for (pos = 0; base + pos < ci->top.p; pos++) { + if (o == s2v(base + pos)) + return pos; + } + return -1; /* not found */ +} + + +/* +** Checks whether value 'o' came from an upvalue. (That can only happen +** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on +** upvalues.) +*/ +static const char *getupvalname (CallInfo *ci, const TValue *o, + const char **name) { + LClosure *c = ci_func(ci); + int i; + for (i = 0; i < c->nupvalues; i++) { + if (c->upvals[i]->v.p == o) { + *name = upvalname(c->p, i); + return strupval; + } + } + return NULL; +} + + +static const char *formatvarinfo (lua_State *L, const char *kind, + const char *name) { + if (kind == NULL) + return ""; /* no information */ + else + return luaO_pushfstring(L, " (%s '%s')", kind, name); +} + +/* +** Build a string with a "description" for the value 'o', such as +** "variable 'x'" or "upvalue 'y'". +*/ +static const char *varinfo (lua_State *L, const TValue *o) { + CallInfo *ci = L->ci; + const char *name = NULL; /* to avoid warnings */ + const char *kind = NULL; + if (isLua(ci)) { + kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ + if (!kind) { /* not an upvalue? */ + int reg = instack(ci, o); /* try a register */ + if (reg >= 0) /* is 'o' a register? */ + kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); + } + } + return formatvarinfo(L, kind, name); +} + + +/* +** Raise a type error +*/ +static l_noret typeerror (lua_State *L, const TValue *o, const char *op, + const char *extra) { + const char *t = luaT_objtypename(L, o); + luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra); +} + + +/* +** Raise a type error with "standard" information about the faulty +** object 'o' (using 'varinfo'). +*/ +l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { + typeerror(L, o, op, varinfo(L, o)); +} + + +/* +** Raise an error for calling a non-callable object. Try to find a name +** for the object based on how it was called ('funcnamefromcall'); if it +** cannot get a name there, try 'varinfo'. +*/ +l_noret luaG_callerror (lua_State *L, const TValue *o) { + CallInfo *ci = L->ci; + const char *name = NULL; /* to avoid warnings */ + const char *kind = funcnamefromcall(L, ci, &name); + const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o); + typeerror(L, o, "call", extra); +} + + +l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) { + luaG_runerror(L, "bad 'for' %s (number expected, got %s)", + what, luaT_objtypename(L, o)); +} + + +l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) { + if (ttisstring(p1) || cvt2str(p1)) p1 = p2; + luaG_typeerror(L, p1, "concatenate"); +} + + +l_noret luaG_opinterror (lua_State *L, const TValue *p1, + const TValue *p2, const char *msg) { + if (!ttisnumber(p1)) /* first operand is wrong? */ + p2 = p1; /* now second is wrong */ + luaG_typeerror(L, p2, msg); +} + + +/* +** Error when both values are convertible to numbers, but not to integers +*/ +l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) { + lua_Integer temp; + if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I)) + p2 = p1; + luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2)); +} + + +l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { + const char *t1 = luaT_objtypename(L, p1); + const char *t2 = luaT_objtypename(L, p2); + if (strcmp(t1, t2) == 0) + luaG_runerror(L, "attempt to compare two %s values", t1); + else + luaG_runerror(L, "attempt to compare %s with %s", t1, t2); +} + + +l_noret luaG_errnnil (lua_State *L, LClosure *cl, int k) { + const char *globalname = "?"; /* default name if k == 0 */ + if (k > 0) + kname(cl->p, k - 1, &globalname); + luaG_runerror(L, "global '%s' already defined", globalname); +} + + +/* add src:line information to 'msg' */ +const char *luaG_addinfo (lua_State *L, const char *msg, TString *src, + int line) { + if (src == NULL) /* no debug information? */ + return luaO_pushfstring(L, "?:?: %s", msg); + else { + char buff[LUA_IDSIZE]; + size_t idlen; + const char *id = getlstr(src, idlen); + luaO_chunkid(buff, id, idlen); + return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); + } +} + + +l_noret luaG_errormsg (lua_State *L) { + if (L->errfunc != 0) { /* is there an error handling function? */ + StkId errfunc = restorestack(L, L->errfunc); + lua_assert(ttisfunction(s2v(errfunc))); + setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ + setobjs2s(L, L->top.p - 1, errfunc); /* push function */ + L->top.p++; /* assume EXTRA_STACK */ + luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ + } + if (ttisnil(s2v(L->top.p - 1))) { /* error object is nil? */ + /* change it to a proper message */ + setsvalue2s(L, L->top.p - 1, luaS_newliteral(L, "")); + } + luaD_throw(L, LUA_ERRRUN); +} + + +l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { + CallInfo *ci = L->ci; + const char *msg; + va_list argp; + luaC_checkGC(L); /* error message uses memory */ + pushvfstring(L, argp, fmt, msg); + if (isLua(ci)) { /* Lua function? */ + /* add source:line information */ + luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); + setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ + L->top.p--; + } + luaG_errormsg(L); +} + + +/* +** Check whether new instruction 'newpc' is in a different line from +** previous instruction 'oldpc'. More often than not, 'newpc' is only +** one or a few instructions after 'oldpc' (it must be after, see +** caller), so try to avoid calling 'luaG_getfuncline'. If they are +** too far apart, there is a good chance of a ABSLINEINFO in the way, +** so it goes directly to 'luaG_getfuncline'. +*/ +static int changedline (const Proto *p, int oldpc, int newpc) { + if (p->lineinfo == NULL) /* no debug information? */ + return 0; + if (newpc - oldpc < MAXIWTHABS / 2) { /* not too far apart? */ + int delta = 0; /* line difference */ + int pc = oldpc; + for (;;) { + int lineinfo = p->lineinfo[++pc]; + if (lineinfo == ABSLINEINFO) + break; /* cannot compute delta; fall through */ + delta += lineinfo; + if (pc == newpc) + return (delta != 0); /* delta computed successfully */ + } + } + /* either instructions are too far apart or there is an absolute line + info in the way; compute line difference explicitly */ + return (luaG_getfuncline(p, oldpc) != luaG_getfuncline(p, newpc)); +} + + +/* +** Traces Lua calls. If code is running the first instruction of a function, +** and function is not vararg, and it is not coming from an yield, +** calls 'luaD_hookcall'. (Vararg functions will call 'luaD_hookcall' +** after adjusting its variable arguments; otherwise, they could call +** a line/count hook before the call hook. Functions coming from +** an yield already called 'luaD_hookcall' before yielding.) +*/ +int luaG_tracecall (lua_State *L) { + CallInfo *ci = L->ci; + Proto *p = ci_func(ci)->p; + ci->u.l.trap = 1; /* ensure hooks will be checked */ + if (ci->u.l.savedpc == p->code) { /* first instruction (not resuming)? */ + if (isvararg(p)) + return 0; /* hooks will start at VARARGPREP instruction */ + else if (!(ci->callstatus & CIST_HOOKYIELD)) /* not yielded? */ + luaD_hookcall(L, ci); /* check 'call' hook */ + } + return 1; /* keep 'trap' on */ +} + + +/* +** Traces the execution of a Lua function. Called before the execution +** of each opcode, when debug is on. 'L->oldpc' stores the last +** instruction traced, to detect line changes. When entering a new +** function, 'npci' will be zero and will test as a new line whatever +** the value of 'oldpc'. Some exceptional conditions may return to +** a function without setting 'oldpc'. In that case, 'oldpc' may be +** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc' +** at most causes an extra call to a line hook.) +** This function is not "Protected" when called, so it should correct +** 'L->top.p' before calling anything that can run the GC. +*/ +int luaG_traceexec (lua_State *L, const Instruction *pc) { + CallInfo *ci = L->ci; + lu_byte mask = cast_byte(L->hookmask); + const Proto *p = ci_func(ci)->p; + int counthook; + if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ + ci->u.l.trap = 0; /* don't need to stop again */ + return 0; /* turn off 'trap' */ + } + pc++; /* reference is always next instruction */ + ci->u.l.savedpc = pc; /* save 'pc' */ + counthook = (mask & LUA_MASKCOUNT) && (--L->hookcount == 0); + if (counthook) + resethookcount(L); /* reset count */ + else if (!(mask & LUA_MASKLINE)) + return 1; /* no line hook and count != 0; nothing to be done now */ + if (ci->callstatus & CIST_HOOKYIELD) { /* hook yielded last time? */ + ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ + return 1; /* do not call hook again (VM yielded, so it did not move) */ + } + if (!luaP_isIT(*(ci->u.l.savedpc - 1))) /* top not being used? */ + L->top.p = ci->top.p; /* correct top */ + if (counthook) + luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */ + if (mask & LUA_MASKLINE) { + /* 'L->oldpc' may be invalid; use zero in this case */ + int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0; + int npci = pcRel(pc, p); + if (npci <= oldpc || /* call hook when jump back (loop), */ + changedline(p, oldpc, npci)) { /* or when enter new line */ + int newline = luaG_getfuncline(p, npci); + luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */ + } + L->oldpc = npci; /* 'pc' of last call to line hook */ + } + if (L->status == LUA_YIELD) { /* did hook yield? */ + if (counthook) + L->hookcount = 1; /* undo decrement to zero */ + ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ + luaD_throw(L, LUA_YIELD); + } + return 1; /* keep 'trap' on */ +} + diff --git a/source/external/lua/ldo.c b/source/external/lua/ldo.c new file mode 100644 index 0000000..6d0184e --- /dev/null +++ b/source/external/lua/ldo.c @@ -0,0 +1,1164 @@ +/* +** $Id: ldo.c $ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + +#define ldo_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lundump.h" +#include "lvm.h" +#include "lzio.h" + + + +#define errorstatus(s) ((s) > LUA_YIELD) + + +/* +** these macros allow user-specific actions when a thread is +** resumed/yielded. +*/ +#if !defined(luai_userstateresume) +#define luai_userstateresume(L,n) ((void)L) +#endif + +#if !defined(luai_userstateyield) +#define luai_userstateyield(L,n) ((void)L) +#endif + + +/* +** {====================================================== +** Error-recovery functions +** ======================================================= +*/ + +/* chained list of long jump buffers */ +typedef struct lua_longjmp { + struct lua_longjmp *previous; + jmp_buf b; + volatile TStatus status; /* error code */ +} lua_longjmp; + + +/* +** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By +** default, Lua handles errors with exceptions when compiling as +** C++ code, with _longjmp/_setjmp when available (POSIX), and with +** longjmp/setjmp otherwise. +*/ +#if !defined(LUAI_THROW) /* { */ + +#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */ + +/* C++ exceptions */ +#define LUAI_THROW(L,c) throw(c) + +static void LUAI_TRY (lua_State *L, lua_longjmp *c, Pfunc f, void *ud) { + try { + f(L, ud); /* call function protected */ + } + catch (lua_longjmp *c1) { /* Lua error */ + if (c1 != c) /* not the correct level? */ + throw; /* rethrow to upper level */ + } + catch (...) { /* non-Lua exception */ + c->status = -1; /* create some error code */ + } +} + + +#elif defined(LUA_USE_POSIX) /* }{ */ + +/* in POSIX, use _longjmp/_setjmp (more efficient) */ +#define LUAI_THROW(L,c) _longjmp((c)->b, 1) +#define LUAI_TRY(L,c,f,ud) if (_setjmp((c)->b) == 0) ((f)(L, ud)) + +#else /* }{ */ + +/* ISO C handling with long jumps */ +#define LUAI_THROW(L,c) longjmp((c)->b, 1) +#define LUAI_TRY(L,c,f,ud) if (setjmp((c)->b) == 0) ((f)(L, ud)) + +#endif /* } */ + +#endif /* } */ + + +void luaD_seterrorobj (lua_State *L, TStatus errcode, StkId oldtop) { + if (errcode == LUA_ERRMEM) { /* memory error? */ + setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ + } + else { + lua_assert(errorstatus(errcode)); /* must be a real error */ + lua_assert(!ttisnil(s2v(L->top.p - 1))); /* with a non-nil object */ + setobjs2s(L, oldtop, L->top.p - 1); /* move it to 'oldtop' */ + } + L->top.p = oldtop + 1; /* top goes back to old top plus error object */ +} + + +l_noret luaD_throw (lua_State *L, TStatus errcode) { + if (L->errorJmp) { /* thread has an error handler? */ + L->errorJmp->status = errcode; /* set status */ + LUAI_THROW(L, L->errorJmp); /* jump to it */ + } + else { /* thread has no error handler */ + global_State *g = G(L); + lua_State *mainth = mainthread(g); + errcode = luaE_resetthread(L, errcode); /* close all upvalues */ + L->status = errcode; + if (mainth->errorJmp) { /* main thread has a handler? */ + setobjs2s(L, mainth->top.p++, L->top.p - 1); /* copy error obj. */ + luaD_throw(mainth, errcode); /* re-throw in main thread */ + } + else { /* no handler at all; abort */ + if (g->panic) { /* panic function? */ + lua_unlock(L); + g->panic(L); /* call panic function (last chance to jump out) */ + } + abort(); + } + } +} + + +l_noret luaD_throwbaselevel (lua_State *L, TStatus errcode) { + if (L->errorJmp) { + /* unroll error entries up to the first level */ + while (L->errorJmp->previous != NULL) + L->errorJmp = L->errorJmp->previous; + } + luaD_throw(L, errcode); +} + + +TStatus luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { + l_uint32 oldnCcalls = L->nCcalls; + lua_longjmp lj; + lj.status = LUA_OK; + lj.previous = L->errorJmp; /* chain new error handler */ + L->errorJmp = &lj; + LUAI_TRY(L, &lj, f, ud); /* call 'f' catching errors */ + L->errorJmp = lj.previous; /* restore old error handler */ + L->nCcalls = oldnCcalls; + return lj.status; +} + +/* }====================================================== */ + + +/* +** {================================================================== +** Stack reallocation +** =================================================================== +*/ + +/* some stack space for error handling */ +#define STACKERRSPACE 200 + + +/* +** LUAI_MAXSTACK limits the size of the Lua stack. +** It must fit into INT_MAX/2. +*/ + +#if !defined(LUAI_MAXSTACK) +#if 1000000 < (INT_MAX / 2) +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK (INT_MAX / 2u) +#endif +#endif + + +/* maximum stack size that respects size_t */ +#define MAXSTACK_BYSIZET ((MAX_SIZET / sizeof(StackValue)) - STACKERRSPACE) + +/* +** Minimum between LUAI_MAXSTACK and MAXSTACK_BYSIZET +** (Maximum size for the stack must respect size_t.) +*/ +#define MAXSTACK cast_int(LUAI_MAXSTACK < MAXSTACK_BYSIZET \ + ? LUAI_MAXSTACK : MAXSTACK_BYSIZET) + + +/* stack size with extra space for error handling */ +#define ERRORSTACKSIZE (MAXSTACK + STACKERRSPACE) + + +/* raise a stack error while running the message handler */ +l_noret luaD_errerr (lua_State *L) { + TString *msg = luaS_newliteral(L, "error in error handling"); + setsvalue2s(L, L->top.p, msg); + L->top.p++; /* assume EXTRA_STACK */ + luaD_throw(L, LUA_ERRERR); +} + + +/* +** Check whether stack has enough space to run a simple function (such +** as a finalizer): At least BASIC_STACK_SIZE in the Lua stack and +** 2 slots in the C stack. +*/ +int luaD_checkminstack (lua_State *L) { + return ((stacksize(L) < MAXSTACK - BASIC_STACK_SIZE) && + (getCcalls(L) < LUAI_MAXCCALLS - 2)); +} + + +/* +** In ISO C, any pointer use after the pointer has been deallocated is +** undefined behavior. So, before a stack reallocation, all pointers +** should be changed to offsets, and after the reallocation they should +** be changed back to pointers. As during the reallocation the pointers +** are invalid, the reallocation cannot run emergency collections. +** Alternatively, we can use the old address after the deallocation. +** That is not strict ISO C, but seems to work fine everywhere. +** The following macro chooses how strict is the code. +*/ +#if !defined(LUAI_STRICT_ADDRESS) +#define LUAI_STRICT_ADDRESS 1 +#endif + +#if LUAI_STRICT_ADDRESS +/* +** Change all pointers to the stack into offsets. +*/ +static void relstack (lua_State *L) { + CallInfo *ci; + UpVal *up; + L->top.offset = savestack(L, L->top.p); + L->tbclist.offset = savestack(L, L->tbclist.p); + for (up = L->openupval; up != NULL; up = up->u.open.next) + up->v.offset = savestack(L, uplevel(up)); + for (ci = L->ci; ci != NULL; ci = ci->previous) { + ci->top.offset = savestack(L, ci->top.p); + ci->func.offset = savestack(L, ci->func.p); + } +} + + +/* +** Change back all offsets into pointers. +*/ +static void correctstack (lua_State *L, StkId oldstack) { + CallInfo *ci; + UpVal *up; + UNUSED(oldstack); + L->top.p = restorestack(L, L->top.offset); + L->tbclist.p = restorestack(L, L->tbclist.offset); + for (up = L->openupval; up != NULL; up = up->u.open.next) + up->v.p = s2v(restorestack(L, up->v.offset)); + for (ci = L->ci; ci != NULL; ci = ci->previous) { + ci->top.p = restorestack(L, ci->top.offset); + ci->func.p = restorestack(L, ci->func.offset); + if (isLua(ci)) + ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ + } +} + +#else +/* +** Assume that it is fine to use an address after its deallocation, +** as long as we do not dereference it. +*/ + +static void relstack (lua_State *L) { UNUSED(L); } /* do nothing */ + + +/* +** Correct pointers into 'oldstack' to point into 'L->stack'. +*/ +static void correctstack (lua_State *L, StkId oldstack) { + CallInfo *ci; + UpVal *up; + StkId newstack = L->stack.p; + if (oldstack == newstack) + return; + L->top.p = L->top.p - oldstack + newstack; + L->tbclist.p = L->tbclist.p - oldstack + newstack; + for (up = L->openupval; up != NULL; up = up->u.open.next) + up->v.p = s2v(uplevel(up) - oldstack + newstack); + for (ci = L->ci; ci != NULL; ci = ci->previous) { + ci->top.p = ci->top.p - oldstack + newstack; + ci->func.p = ci->func.p - oldstack + newstack; + if (isLua(ci)) + ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ + } +} +#endif + + +/* +** Reallocate the stack to a new size, correcting all pointers into it. +** In case of allocation error, raise an error or return false according +** to 'raiseerror'. +*/ +int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { + int oldsize = stacksize(L); + int i; + StkId newstack; + StkId oldstack = L->stack.p; + lu_byte oldgcstop = G(L)->gcstopem; + lua_assert(newsize <= MAXSTACK || newsize == ERRORSTACKSIZE); + relstack(L); /* change pointers to offsets */ + G(L)->gcstopem = 1; /* stop emergency collection */ + newstack = luaM_reallocvector(L, oldstack, oldsize + EXTRA_STACK, + newsize + EXTRA_STACK, StackValue); + G(L)->gcstopem = oldgcstop; /* restore emergency collection */ + if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ + correctstack(L, oldstack); /* change offsets back to pointers */ + if (raiseerror) + luaM_error(L); + else return 0; /* do not raise an error */ + } + L->stack.p = newstack; + correctstack(L, oldstack); /* change offsets back to pointers */ + L->stack_last.p = L->stack.p + newsize; + for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) + setnilvalue(s2v(newstack + i)); /* erase new segment */ + return 1; +} + + +/* +** Try to grow the stack by at least 'n' elements. When 'raiseerror' +** is true, raises any error; otherwise, return 0 in case of errors. +*/ +int luaD_growstack (lua_State *L, int n, int raiseerror) { + int size = stacksize(L); + if (l_unlikely(size > MAXSTACK)) { + /* if stack is larger than maximum, thread is already using the + extra space reserved for errors, that is, thread is handling + a stack error; cannot grow further than that. */ + lua_assert(stacksize(L) == ERRORSTACKSIZE); + if (raiseerror) + luaD_errerr(L); /* stack error inside message handler */ + return 0; /* if not 'raiseerror', just signal it */ + } + else if (n < MAXSTACK) { /* avoids arithmetic overflows */ + int newsize = size + (size >> 1); /* tentative new size (size * 1.5) */ + int needed = cast_int(L->top.p - L->stack.p) + n; + if (newsize > MAXSTACK) /* cannot cross the limit */ + newsize = MAXSTACK; + if (newsize < needed) /* but must respect what was asked for */ + newsize = needed; + if (l_likely(newsize <= MAXSTACK)) + return luaD_reallocstack(L, newsize, raiseerror); + } + /* else stack overflow */ + /* add extra size to be able to handle the error message */ + luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror); + if (raiseerror) + luaG_runerror(L, "stack overflow"); + return 0; +} + + +/* +** Compute how much of the stack is being used, by computing the +** maximum top of all call frames in the stack and the current top. +*/ +static int stackinuse (lua_State *L) { + CallInfo *ci; + int res; + StkId lim = L->top.p; + for (ci = L->ci; ci != NULL; ci = ci->previous) { + if (lim < ci->top.p) lim = ci->top.p; + } + lua_assert(lim <= L->stack_last.p + EXTRA_STACK); + res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ + if (res < LUA_MINSTACK) + res = LUA_MINSTACK; /* ensure a minimum size */ + return res; +} + + +/* +** If stack size is more than 3 times the current use, reduce that size +** to twice the current use. (So, the final stack size is at most 2/3 the +** previous size, and half of its entries are empty.) +** As a particular case, if stack was handling a stack overflow and now +** it is not, 'max' (limited by MAXSTACK) will be smaller than +** stacksize (equal to ERRORSTACKSIZE in this case), and so the stack +** will be reduced to a "regular" size. +*/ +void luaD_shrinkstack (lua_State *L) { + int inuse = stackinuse(L); + int max = (inuse > MAXSTACK / 3) ? MAXSTACK : inuse * 3; + /* if thread is currently not handling a stack overflow and its + size is larger than maximum "reasonable" size, shrink it */ + if (inuse <= MAXSTACK && stacksize(L) > max) { + int nsize = (inuse > MAXSTACK / 2) ? MAXSTACK : inuse * 2; + luaD_reallocstack(L, nsize, 0); /* ok if that fails */ + } + else /* don't change stack */ + condmovestack(L,(void)0,(void)0); /* (change only for debugging) */ + luaE_shrinkCI(L); /* shrink CI list */ +} + + +void luaD_inctop (lua_State *L) { + L->top.p++; + luaD_checkstack(L, 1); +} + +/* }================================================================== */ + + +/* +** Call a hook for the given event. Make sure there is a hook to be +** called. (Both 'L->hook' and 'L->hookmask', which trigger this +** function, can be changed asynchronously by signals.) +*/ +void luaD_hook (lua_State *L, int event, int line, + int ftransfer, int ntransfer) { + lua_Hook hook = L->hook; + if (hook && L->allowhook) { /* make sure there is a hook */ + CallInfo *ci = L->ci; + ptrdiff_t top = savestack(L, L->top.p); /* preserve original 'top' */ + ptrdiff_t ci_top = savestack(L, ci->top.p); /* idem for 'ci->top' */ + lua_Debug ar; + ar.event = event; + ar.currentline = line; + ar.i_ci = ci; + L->transferinfo.ftransfer = ftransfer; + L->transferinfo.ntransfer = ntransfer; + if (isLua(ci) && L->top.p < ci->top.p) + L->top.p = ci->top.p; /* protect entire activation register */ + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + if (ci->top.p < L->top.p + LUA_MINSTACK) + ci->top.p = L->top.p + LUA_MINSTACK; + L->allowhook = 0; /* cannot call hooks inside a hook */ + ci->callstatus |= CIST_HOOKED; + lua_unlock(L); + (*hook)(L, &ar); + lua_lock(L); + lua_assert(!L->allowhook); + L->allowhook = 1; + ci->top.p = restorestack(L, ci_top); + L->top.p = restorestack(L, top); + ci->callstatus &= ~CIST_HOOKED; + } +} + + +/* +** Executes a call hook for Lua functions. This function is called +** whenever 'hookmask' is not zero, so it checks whether call hooks are +** active. +*/ +void luaD_hookcall (lua_State *L, CallInfo *ci) { + L->oldpc = 0; /* set 'oldpc' for new function */ + if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ + int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL + : LUA_HOOKCALL; + Proto *p = ci_func(ci)->p; + ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ + luaD_hook(L, event, -1, 1, p->numparams); + ci->u.l.savedpc--; /* correct 'pc' */ + } +} + + +/* +** Executes a return hook for Lua and C functions and sets/corrects +** 'oldpc'. (Note that this correction is needed by the line hook, so it +** is done even when return hooks are off.) +*/ +static void rethook (lua_State *L, CallInfo *ci, int nres) { + if (L->hookmask & LUA_MASKRET) { /* is return hook on? */ + StkId firstres = L->top.p - nres; /* index of first result */ + int delta = 0; /* correction for vararg functions */ + int ftransfer; + if (isLua(ci)) { + Proto *p = ci_func(ci)->p; + if (p->flag & PF_VAHID) + delta = ci->u.l.nextraargs + p->numparams + 1; + } + ci->func.p += delta; /* if vararg, back to virtual 'func' */ + ftransfer = cast_int(firstres - ci->func.p); + luaD_hook(L, LUA_HOOKRET, -1, ftransfer, nres); /* call it */ + ci->func.p -= delta; + } + if (isLua(ci = ci->previous)) + L->oldpc = pcRel(ci->u.l.savedpc, ci_func(ci)->p); /* set 'oldpc' */ +} + + +/* +** Check whether 'func' has a '__call' metafield. If so, put it in the +** stack, below original 'func', so that 'luaD_precall' can call it. +** Raise an error if there is no '__call' metafield. +** Bits CIST_CCMT in status count how many _call metamethods were +** invoked and how many corresponding extra arguments were pushed. +** (This count will be saved in the 'callstatus' of the call). +** Raise an error if this counter overflows. +*/ +static unsigned tryfuncTM (lua_State *L, StkId func, unsigned status) { + const TValue *tm; + StkId p; + tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); + if (l_unlikely(ttisnil(tm))) /* no metamethod? */ + luaG_callerror(L, s2v(func)); + for (p = L->top.p; p > func; p--) /* open space for metamethod */ + setobjs2s(L, p, p-1); + L->top.p++; /* stack space pre-allocated by the caller */ + setobj2s(L, func, tm); /* metamethod is the new function to be called */ + if ((status & MAX_CCMT) == MAX_CCMT) /* is counter full? */ + luaG_runerror(L, "'__call' chain too long"); + return status + (1u << CIST_CCMT); /* increment counter */ +} + + +/* Generic case for 'moveresult' */ +l_sinline void genmoveresults (lua_State *L, StkId res, int nres, + int wanted) { + StkId firstresult = L->top.p - nres; /* index of first result */ + int i; + if (nres > wanted) /* extra results? */ + nres = wanted; /* don't need them */ + 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(s2v(res + i)); + L->top.p = res + wanted; /* top points after the last result */ +} + + +/* +** Given 'nres' results at 'firstResult', move 'fwanted-1' of them +** to 'res'. Handle most typical cases (zero results for commands, +** one result for expressions, multiple results for tail calls/single +** parameters) separated. The flag CIST_TBC in 'fwanted', if set, +** forces the switch to go to the default case. +*/ +l_sinline void moveresults (lua_State *L, StkId res, int nres, + l_uint32 fwanted) { + switch (fwanted) { /* handle typical cases separately */ + case 0 + 1: /* no values needed */ + L->top.p = res; + return; + case 1 + 1: /* one value needed */ + if (nres == 0) /* no results? */ + setnilvalue(s2v(res)); /* adjust with nil */ + else /* at least one result */ + setobjs2s(L, res, L->top.p - nres); /* move it to proper place */ + L->top.p = res + 1; + return; + case LUA_MULTRET + 1: + genmoveresults(L, res, nres, nres); /* we want all results */ + break; + default: { /* two/more results and/or to-be-closed variables */ + int wanted = get_nresults(fwanted); + if (fwanted & CIST_TBC) { /* to-be-closed variables? */ + L->ci->u2.nres = nres; + L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ + res = luaF_close(L, res, CLOSEKTOP, 1); + L->ci->callstatus &= ~CIST_CLSRET; + if (L->hookmask) { /* if needed, call hook after '__close's */ + ptrdiff_t savedres = savestack(L, res); + rethook(L, L->ci, nres); + res = restorestack(L, savedres); /* hook can move stack */ + } + if (wanted == LUA_MULTRET) + wanted = nres; /* we want all results */ + } + genmoveresults(L, res, nres, wanted); + break; + } + } +} + + +/* +** Finishes a function call: calls hook if necessary, moves current +** number of results to proper place, and returns to previous call +** info. If function has to close variables, hook must be called after +** that. +*/ +void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { + l_uint32 fwanted = ci->callstatus & (CIST_TBC | CIST_NRESULTS); + if (l_unlikely(L->hookmask) && !(fwanted & CIST_TBC)) + rethook(L, ci, nres); + /* move results to proper place */ + moveresults(L, ci->func.p, nres, fwanted); + /* function cannot be in any of these cases when returning */ + lua_assert(!(ci->callstatus & + (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_CLSRET))); + L->ci = ci->previous; /* back to caller (after closing variables) */ +} + + + +#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) + + +/* +** Allocate and initialize CallInfo structure. At this point, the +** only valid fields in the call status are number of results, +** CIST_C (if it's a C function), and number of extra arguments. +** (All these bit-fields fit in 16-bit values.) +*/ +l_sinline CallInfo *prepCallInfo (lua_State *L, StkId func, unsigned status, + StkId top) { + CallInfo *ci = L->ci = next_ci(L); /* new frame */ + ci->func.p = func; + lua_assert((status & ~(CIST_NRESULTS | CIST_C | MAX_CCMT)) == 0); + ci->callstatus = status; + ci->top.p = top; + return ci; +} + + +/* +** precall for C functions +*/ +l_sinline int precallC (lua_State *L, StkId func, unsigned status, + lua_CFunction f) { + int n; /* number of returns */ + CallInfo *ci; + checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ + L->ci = ci = prepCallInfo(L, func, status | CIST_C, + L->top.p + LUA_MINSTACK); + lua_assert(ci->top.p <= L->stack_last.p); + if (l_unlikely(L->hookmask & LUA_MASKCALL)) { + int narg = cast_int(L->top.p - func) - 1; + luaD_hook(L, LUA_HOOKCALL, -1, 1, narg); + } + lua_unlock(L); + n = (*f)(L); /* do the actual call */ + lua_lock(L); + api_checknelems(L, n); + luaD_poscall(L, ci, n); + return n; +} + + +/* +** Prepare a function for a tail call, building its call info on top +** of the current call info. 'narg1' is the number of arguments plus 1 +** (so that it includes the function itself). Return the number of +** results, if it was a C function, or -1 for a Lua function. +*/ +int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, + int narg1, int delta) { + unsigned status = LUA_MULTRET + 1; + retry: + switch (ttypetag(s2v(func))) { + case LUA_VCCL: /* C closure */ + return precallC(L, func, status, clCvalue(s2v(func))->f); + case LUA_VLCF: /* light C function */ + return precallC(L, func, status, fvalue(s2v(func))); + case LUA_VLCL: { /* Lua function */ + Proto *p = clLvalue(s2v(func))->p; + int fsize = p->maxstacksize; /* frame size */ + int nfixparams = p->numparams; + int i; + checkstackp(L, fsize - delta, func); + ci->func.p -= delta; /* restore 'func' (if vararg) */ + for (i = 0; i < narg1; i++) /* move down function and arguments */ + setobjs2s(L, ci->func.p + i, func + i); + func = ci->func.p; /* moved-down function */ + for (; narg1 <= nfixparams; narg1++) + setnilvalue(s2v(func + narg1)); /* complete missing arguments */ + ci->top.p = func + 1 + fsize; /* top for new function */ + lua_assert(ci->top.p <= L->stack_last.p); + ci->u.l.savedpc = p->code; /* starting point */ + ci->callstatus |= CIST_TAIL; + L->top.p = func + narg1; /* set top */ + return -1; + } + default: { /* not a function */ + checkstackp(L, 1, func); /* space for metamethod */ + status = tryfuncTM(L, func, status); /* try '__call' metamethod */ + narg1++; + goto retry; /* try again */ + } + } +} + + +/* +** Prepares the call to a function (C or Lua). For C functions, also do +** the call. The function to be called is at '*func'. The arguments +** are on the stack, right after the function. Returns the CallInfo +** to be executed, if it was a Lua function. Otherwise (a C function) +** returns NULL, with all the results on the stack, starting at the +** original function position. +*/ +CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { + unsigned status = cast_uint(nresults + 1); + lua_assert(status <= MAXRESULTS + 1); + retry: + switch (ttypetag(s2v(func))) { + case LUA_VCCL: /* C closure */ + precallC(L, func, status, clCvalue(s2v(func))->f); + return NULL; + case LUA_VLCF: /* light C function */ + precallC(L, func, status, fvalue(s2v(func))); + return NULL; + case LUA_VLCL: { /* Lua function */ + CallInfo *ci; + Proto *p = clLvalue(s2v(func))->p; + int narg = cast_int(L->top.p - func) - 1; /* number of real arguments */ + int nfixparams = p->numparams; + int fsize = p->maxstacksize; /* frame size */ + checkstackp(L, fsize, func); + L->ci = ci = prepCallInfo(L, func, status, func + 1 + fsize); + ci->u.l.savedpc = p->code; /* starting point */ + for (; narg < nfixparams; narg++) + setnilvalue(s2v(L->top.p++)); /* complete missing arguments */ + lua_assert(ci->top.p <= L->stack_last.p); + return ci; + } + default: { /* not a function */ + checkstackp(L, 1, func); /* space for metamethod */ + status = tryfuncTM(L, func, status); /* try '__call' metamethod */ + goto retry; /* try again with metamethod */ + } + } +} + + +/* +** Call a function (C or Lua) through C. 'inc' can be 1 (increment +** number of recursive invocations in the C stack) or nyci (the same +** plus increment number of non-yieldable calls). +** This function can be called with some use of EXTRA_STACK, so it should +** check the stack before doing anything else. 'luaD_precall' already +** does that. +*/ +l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) { + CallInfo *ci; + L->nCcalls += inc; + if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) { + checkstackp(L, 0, func); /* free any use of EXTRA_STACK */ + luaE_checkcstack(L); + } + if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ + ci->callstatus |= CIST_FRESH; /* mark that it is a "fresh" execute */ + luaV_execute(L, ci); /* call it */ + } + L->nCcalls -= inc; +} + + +/* +** External interface for 'ccall' +*/ +void luaD_call (lua_State *L, StkId func, int nResults) { + ccall(L, func, nResults, 1); +} + + +/* +** Similar to 'luaD_call', but does not allow yields during the call. +*/ +void luaD_callnoyield (lua_State *L, StkId func, int nResults) { + ccall(L, func, nResults, nyci); +} + + +/* +** Finish the job of 'lua_pcallk' after it was interrupted by an yield. +** (The caller, 'finishCcall', does the final call to 'adjustresults'.) +** The main job is to complete the 'luaD_pcall' called by 'lua_pcallk'. +** If a '__close' method yields here, eventually control will be back +** to 'finishCcall' (when that '__close' method finally returns) and +** 'finishpcallk' will run again and close any still pending '__close' +** methods. Similarly, if a '__close' method errs, 'precover' calls +** 'unroll' which calls ''finishCcall' and we are back here again, to +** close any pending '__close' methods. +** Note that, up to the call to 'luaF_close', the corresponding +** 'CallInfo' is not modified, so that this repeated run works like the +** first one (except that it has at least one less '__close' to do). In +** particular, field CIST_RECST preserves the error status across these +** multiple runs, changing only if there is a new error. +*/ +static TStatus finishpcallk (lua_State *L, CallInfo *ci) { + TStatus status = getcistrecst(ci); /* get original status */ + if (l_likely(status == LUA_OK)) /* no error? */ + status = LUA_YIELD; /* was interrupted by an yield */ + else { /* error */ + StkId func = restorestack(L, ci->u2.funcidx); + L->allowhook = getoah(ci); /* restore 'allowhook' */ + func = luaF_close(L, func, status, 1); /* can yield or raise an error */ + luaD_seterrorobj(L, status, func); + luaD_shrinkstack(L); /* restore stack size in case of overflow */ + setcistrecst(ci, LUA_OK); /* clear original status */ + } + ci->callstatus &= ~CIST_YPCALL; + L->errfunc = ci->u.c.old_errfunc; + /* if it is here, there were errors or yields; unlike 'lua_pcallk', + do not change status */ + return status; +} + + +/* +** Completes the execution of a C function interrupted by an yield. +** The interruption must have happened while the function was either +** closing its tbc variables in 'moveresults' or executing +** 'lua_callk'/'lua_pcallk'. In the first case, it just redoes +** 'luaD_poscall'. In the second case, the call to 'finishpcallk' +** finishes the interrupted execution of 'lua_pcallk'. After that, it +** calls the continuation of the interrupted function and finally it +** completes the job of the 'luaD_call' that called the function. In +** the call to 'adjustresults', we do not know the number of results +** of the function called by 'lua_callk'/'lua_pcallk', so we are +** conservative and use LUA_MULTRET (always adjust). +*/ +static void finishCcall (lua_State *L, CallInfo *ci) { + int n; /* actual number of results from C function */ + if (ci->callstatus & CIST_CLSRET) { /* was closing TBC variable? */ + lua_assert(ci->callstatus & CIST_TBC); + n = ci->u2.nres; /* just redo 'luaD_poscall' */ + /* don't need to reset CIST_CLSRET, as it will be set again anyway */ + } + else { + TStatus status = LUA_YIELD; /* default if there were no errors */ + lua_KFunction kf = ci->u.c.k; /* continuation function */ + /* must have a continuation and must be able to call it */ + lua_assert(kf != NULL && yieldable(L)); + if (ci->callstatus & CIST_YPCALL) /* was inside a 'lua_pcallk'? */ + status = finishpcallk(L, ci); /* finish it */ + adjustresults(L, LUA_MULTRET); /* finish 'lua_callk' */ + lua_unlock(L); + n = (*kf)(L, APIstatus(status), ci->u.c.ctx); /* call continuation */ + lua_lock(L); + api_checknelems(L, n); + } + luaD_poscall(L, ci, n); /* finish 'luaD_call' */ +} + + +/* +** Executes "full continuation" (everything in the stack) of a +** previously interrupted coroutine until the stack is empty (or another +** interruption long-jumps out of the loop). +*/ +static void unroll (lua_State *L, void *ud) { + CallInfo *ci; + UNUSED(ud); + while ((ci = L->ci) != &L->base_ci) { /* something in the stack */ + if (!isLua(ci)) /* C function? */ + finishCcall(L, ci); /* complete its execution */ + else { /* Lua function */ + luaV_finishOp(L); /* finish interrupted instruction */ + luaV_execute(L, ci); /* execute down to higher C 'boundary' */ + } + } +} + + +/* +** Try to find a suspended protected call (a "recover point") for the +** given thread. +*/ +static CallInfo *findpcall (lua_State *L) { + CallInfo *ci; + for (ci = L->ci; ci != NULL; ci = ci->previous) { /* search for a pcall */ + if (ci->callstatus & CIST_YPCALL) + return ci; + } + return NULL; /* no pending pcall */ +} + + +/* +** Signal an error in the call to 'lua_resume', not in the execution +** of the coroutine itself. (Such errors should not be handled by any +** coroutine error handler and should not kill the coroutine.) +*/ +static int resume_error (lua_State *L, const char *msg, int narg) { + api_checkpop(L, narg); + L->top.p -= narg; /* remove args from the stack */ + setsvalue2s(L, L->top.p, luaS_new(L, msg)); /* push error message */ + api_incr_top(L); + lua_unlock(L); + return LUA_ERRRUN; +} + + +/* +** Do the work for 'lua_resume' in protected mode. Most of the work +** depends on the status of the coroutine: initial state, suspended +** inside a hook, or regularly suspended (optionally with a continuation +** function), plus erroneous cases: non-suspended coroutine or dead +** coroutine. +*/ +static void resume (lua_State *L, void *ud) { + int n = *(cast(int*, ud)); /* number of arguments */ + StkId firstArg = L->top.p - n; /* first argument */ + CallInfo *ci = L->ci; + if (L->status == LUA_OK) /* starting a coroutine? */ + ccall(L, firstArg - 1, LUA_MULTRET, 0); /* just call its body */ + else { /* resuming from previous yield */ + lua_assert(L->status == LUA_YIELD); + L->status = LUA_OK; /* mark that it is running (again) */ + if (isLua(ci)) { /* yielded inside a hook? */ + /* undo increment made by 'luaG_traceexec': instruction was not + executed yet */ + lua_assert(ci->callstatus & CIST_HOOKYIELD); + ci->u.l.savedpc--; + L->top.p = firstArg; /* discard arguments */ + luaV_execute(L, ci); /* just continue running Lua code */ + } + else { /* 'common' yield */ + if (ci->u.c.k != NULL) { /* does it have a continuation function? */ + lua_unlock(L); + n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */ + lua_lock(L); + api_checknelems(L, n); + } + luaD_poscall(L, ci, n); /* finish 'luaD_call' */ + } + unroll(L, NULL); /* run continuation */ + } +} + + +/* +** Unrolls a coroutine in protected mode while there are recoverable +** errors, that is, errors inside a protected call. (Any error +** interrupts 'unroll', and this loop protects it again so it can +** continue.) Stops with a normal end (status == LUA_OK), an yield +** (status == LUA_YIELD), or an unprotected error ('findpcall' doesn't +** find a recover point). +*/ +static TStatus precover (lua_State *L, TStatus status) { + CallInfo *ci; + while (errorstatus(status) && (ci = findpcall(L)) != NULL) { + L->ci = ci; /* go down to recovery functions */ + setcistrecst(ci, status); /* status to finish 'pcall' */ + status = luaD_rawrunprotected(L, unroll, NULL); + } + return status; +} + + +LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs, + int *nresults) { + TStatus status; + lua_lock(L); + if (L->status == LUA_OK) { /* may be starting a coroutine */ + if (L->ci != &L->base_ci) /* not in base level? */ + return resume_error(L, "cannot resume non-suspended coroutine", nargs); + else if (L->top.p - (L->ci->func.p + 1) == nargs) /* no function? */ + return resume_error(L, "cannot resume dead coroutine", nargs); + } + else if (L->status != LUA_YIELD) /* ended with errors? */ + return resume_error(L, "cannot resume dead coroutine", nargs); + L->nCcalls = (from) ? getCcalls(from) : 0; + if (getCcalls(L) >= LUAI_MAXCCALLS) + return resume_error(L, "C stack overflow", nargs); + L->nCcalls++; + luai_userstateresume(L, nargs); + api_checkpop(L, (L->status == LUA_OK) ? nargs + 1 : nargs); + status = luaD_rawrunprotected(L, resume, &nargs); + /* continue running after recoverable errors */ + status = precover(L, status); + if (l_likely(!errorstatus(status))) + lua_assert(status == L->status); /* normal end or yield */ + else { /* unrecoverable error */ + L->status = status; /* mark thread as 'dead' */ + luaD_seterrorobj(L, status, L->top.p); /* push error message */ + L->ci->top.p = L->top.p; + } + *nresults = (status == LUA_YIELD) ? L->ci->u2.nyield + : cast_int(L->top.p - (L->ci->func.p + 1)); + lua_unlock(L); + return APIstatus(status); +} + + +LUA_API int lua_isyieldable (lua_State *L) { + return yieldable(L); +} + + +LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k) { + CallInfo *ci; + luai_userstateyield(L, nresults); + lua_lock(L); + ci = L->ci; + api_checkpop(L, nresults); + if (l_unlikely(!yieldable(L))) { + if (L != mainthread(G(L))) + luaG_runerror(L, "attempt to yield across a C-call boundary"); + else + luaG_runerror(L, "attempt to yield from outside a coroutine"); + } + L->status = LUA_YIELD; + ci->u2.nyield = nresults; /* save number of results */ + if (isLua(ci)) { /* inside a hook? */ + lua_assert(!isLuacode(ci)); + api_check(L, nresults == 0, "hooks cannot yield values"); + api_check(L, k == NULL, "hooks cannot continue after yielding"); + } + else { + if ((ci->u.c.k = k) != NULL) /* is there a continuation? */ + ci->u.c.ctx = ctx; /* save context */ + luaD_throw(L, LUA_YIELD); + } + lua_assert(ci->callstatus & CIST_HOOKED); /* must be inside a hook */ + lua_unlock(L); + return 0; /* return to 'luaD_hook' */ +} + + +/* +** Auxiliary structure to call 'luaF_close' in protected mode. +*/ +struct CloseP { + StkId level; + TStatus status; +}; + + +/* +** Auxiliary function to call 'luaF_close' in protected mode. +*/ +static void closepaux (lua_State *L, void *ud) { + struct CloseP *pcl = cast(struct CloseP *, ud); + luaF_close(L, pcl->level, pcl->status, 0); +} + + +/* +** Calls 'luaF_close' in protected mode. Return the original status +** or, in case of errors, the new status. +*/ +TStatus luaD_closeprotected (lua_State *L, ptrdiff_t level, TStatus status) { + CallInfo *old_ci = L->ci; + lu_byte old_allowhooks = L->allowhook; + for (;;) { /* keep closing upvalues until no more errors */ + struct CloseP pcl; + pcl.level = restorestack(L, level); pcl.status = status; + status = luaD_rawrunprotected(L, &closepaux, &pcl); + if (l_likely(status == LUA_OK)) /* no more errors? */ + return pcl.status; + else { /* an error occurred; restore saved state and repeat */ + L->ci = old_ci; + L->allowhook = old_allowhooks; + } + } +} + + +/* +** Call the C function 'func' in protected mode, restoring basic +** thread information ('allowhook', etc.) and in particular +** its stack level in case of errors. +*/ +TStatus luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t old_top, + ptrdiff_t ef) { + TStatus status; + CallInfo *old_ci = L->ci; + lu_byte old_allowhooks = L->allowhook; + ptrdiff_t old_errfunc = L->errfunc; + L->errfunc = ef; + status = luaD_rawrunprotected(L, func, u); + if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ + L->ci = old_ci; + L->allowhook = old_allowhooks; + status = luaD_closeprotected(L, old_top, status); + luaD_seterrorobj(L, status, restorestack(L, old_top)); + luaD_shrinkstack(L); /* restore stack size in case of overflow */ + } + L->errfunc = old_errfunc; + return status; +} + + + +/* +** Execute a protected parser. +*/ +struct SParser { /* data to 'f_parser' */ + ZIO *z; + Mbuffer buff; /* dynamic structure used by the scanner */ + Dyndata dyd; /* dynamic structures used by the parser */ + const char *mode; + const char *name; +}; + + +static void checkmode (lua_State *L, const char *mode, const char *x) { + if (strchr(mode, x[0]) == NULL) { + luaO_pushfstring(L, + "attempt to load a %s chunk (mode is '%s')", x, mode); + luaD_throw(L, LUA_ERRSYNTAX); + } +} + + +static void f_parser (lua_State *L, void *ud) { + LClosure *cl; + struct SParser *p = cast(struct SParser *, ud); + const char *mode = p->mode ? p->mode : "bt"; + int c = zgetc(p->z); /* read first character */ + if (c == LUA_SIGNATURE[0]) { + int fixed = 0; + if (strchr(mode, 'B') != NULL) + fixed = 1; + else + checkmode(L, mode, "binary"); + cl = luaU_undump(L, p->z, p->name, fixed); + } + else { + checkmode(L, mode, "text"); + cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); + } + lua_assert(cl->nupvalues == cl->p->sizeupvalues); + luaF_initupvals(L, cl); +} + + +TStatus luaD_protectedparser (lua_State *L, ZIO *z, const char *name, + const char *mode) { + struct SParser p; + TStatus status; + incnny(L); /* cannot yield during parsing */ + p.z = z; p.name = name; p.mode = mode; + p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; + p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; + p.dyd.label.arr = NULL; p.dyd.label.size = 0; + luaZ_initbuffer(L, &p.buff); + status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); + luaZ_freebuffer(L, &p.buff); + luaM_freearray(L, p.dyd.actvar.arr, cast_sizet(p.dyd.actvar.size)); + luaM_freearray(L, p.dyd.gt.arr, cast_sizet(p.dyd.gt.size)); + luaM_freearray(L, p.dyd.label.arr, cast_sizet(p.dyd.label.size)); + decnny(L); + return status; +} + + diff --git a/source/external/lua/ldump.c b/source/external/lua/ldump.c new file mode 100644 index 0000000..5795788 --- /dev/null +++ b/source/external/lua/ldump.c @@ -0,0 +1,307 @@ +/* +** $Id: ldump.c $ +** save precompiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#define ldump_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "lgc.h" +#include "lobject.h" +#include "lstate.h" +#include "ltable.h" +#include "lundump.h" + + +typedef struct { + lua_State *L; + lua_Writer writer; + void *data; + size_t offset; /* current position relative to beginning of dump */ + int strip; + int status; + Table *h; /* table to track saved strings */ + lua_Unsigned nstr; /* counter for counting saved strings */ +} DumpState; + + +/* +** All high-level dumps go through dumpVector; you can change it to +** change the endianness of the result +*/ +#define dumpVector(D,v,n) dumpBlock(D,v,(n)*sizeof((v)[0])) + +#define dumpLiteral(D, s) dumpBlock(D,s,sizeof(s) - sizeof(char)) + + +/* +** Dump the block of memory pointed by 'b' with given 'size'. +** 'b' should not be NULL, except for the last call signaling the end +** of the dump. +*/ +static void dumpBlock (DumpState *D, const void *b, size_t size) { + if (D->status == 0) { /* do not write anything after an error */ + lua_unlock(D->L); + D->status = (*D->writer)(D->L, b, size, D->data); + lua_lock(D->L); + D->offset += size; + } +} + + +/* +** Dump enough zeros to ensure that current position is a multiple of +** 'align'. +*/ +static void dumpAlign (DumpState *D, unsigned align) { + unsigned padding = align - cast_uint(D->offset % align); + if (padding < align) { /* padding == align means no padding */ + static lua_Integer paddingContent = 0; + lua_assert(align <= sizeof(lua_Integer)); + dumpBlock(D, &paddingContent, padding); + } + lua_assert(D->offset % align == 0); +} + + +#define dumpVar(D,x) dumpVector(D,&x,1) + + +static void dumpByte (DumpState *D, int y) { + lu_byte x = (lu_byte)y; + dumpVar(D, x); +} + + +/* +** size for 'dumpVarint' buffer: each byte can store up to 7 bits. +** (The "+6" rounds up the division.) +*/ +#define DIBS ((l_numbits(lua_Unsigned) + 6) / 7) + +/* +** Dumps an unsigned integer using the MSB Varint encoding +*/ +static void dumpVarint (DumpState *D, lua_Unsigned x) { + lu_byte buff[DIBS]; + unsigned n = 1; + buff[DIBS - 1] = x & 0x7f; /* fill least-significant byte */ + while ((x >>= 7) != 0) /* fill other bytes in reverse order */ + buff[DIBS - (++n)] = cast_byte((x & 0x7f) | 0x80); + dumpVector(D, buff + DIBS - n, n); +} + + +static void dumpSize (DumpState *D, size_t sz) { + dumpVarint(D, cast(lua_Unsigned, sz)); +} + + +static void dumpInt (DumpState *D, int x) { + lua_assert(x >= 0); + dumpVarint(D, cast_uint(x)); +} + + +static void dumpNumber (DumpState *D, lua_Number x) { + dumpVar(D, x); +} + + +/* +** Signed integers are coded to keep small values small. (Coding -1 as +** 0xfff...fff would use too many bytes to save a quite common value.) +** A non-negative x is coded as 2x; a negative x is coded as -2x - 1. +** (0 => 0; -1 => 1; 1 => 2; -2 => 3; 2 => 4; ...) +*/ +static void dumpInteger (DumpState *D, lua_Integer x) { + lua_Unsigned cx = (x >= 0) ? 2u * l_castS2U(x) + : (2u * ~l_castS2U(x)) + 1; + dumpVarint(D, cx); +} + + +/* +** Dump a String. First dump its "size": +** size==0 is followed by an index and means "reuse saved string with +** that index"; index==0 means NULL. +** size>=1 is followed by the string contents with real size==size-1 and +** means that string, which will be saved with the next available index. +** The real size does not include the ending '\0' (which is not dumped), +** so adding 1 to it cannot overflow a size_t. +*/ +static void dumpString (DumpState *D, TString *ts) { + if (ts == NULL) { + dumpVarint(D, 0); /* will "reuse" NULL */ + dumpVarint(D, 0); /* special index for NULL */ + } + else { + TValue idx; + int tag = luaH_getstr(D->h, ts, &idx); + if (!tagisempty(tag)) { /* string already saved? */ + dumpVarint(D, 0); /* reuse a saved string */ + dumpVarint(D, l_castS2U(ivalue(&idx))); /* index of saved string */ + } + else { /* must write and save the string */ + TValue key, value; /* to save the string in the hash */ + size_t size; + const char *s = getlstr(ts, size); + dumpSize(D, size + 1); + dumpVector(D, s, size + 1); /* include ending '\0' */ + D->nstr++; /* one more saved string */ + setsvalue(D->L, &key, ts); /* the string is the key */ + setivalue(&value, l_castU2S(D->nstr)); /* its index is the value */ + luaH_set(D->L, D->h, &key, &value); /* h[ts] = nstr */ + /* integer value does not need barrier */ + } + } +} + + +static void dumpCode (DumpState *D, const Proto *f) { + dumpInt(D, f->sizecode); + dumpAlign(D, sizeof(f->code[0])); + lua_assert(f->code != NULL); + dumpVector(D, f->code, cast_uint(f->sizecode)); +} + + +static void dumpFunction (DumpState *D, const Proto *f); + +static void dumpConstants (DumpState *D, const Proto *f) { + int i; + int n = f->sizek; + dumpInt(D, n); + for (i = 0; i < n; i++) { + const TValue *o = &f->k[i]; + int tt = ttypetag(o); + dumpByte(D, tt); + switch (tt) { + case LUA_VNUMFLT: + dumpNumber(D, fltvalue(o)); + break; + case LUA_VNUMINT: + dumpInteger(D, ivalue(o)); + break; + case LUA_VSHRSTR: + case LUA_VLNGSTR: + dumpString(D, tsvalue(o)); + break; + default: + lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE); + } + } +} + + +static void dumpProtos (DumpState *D, const Proto *f) { + int i; + int n = f->sizep; + dumpInt(D, n); + for (i = 0; i < n; i++) + dumpFunction(D, f->p[i]); +} + + +static void dumpUpvalues (DumpState *D, const Proto *f) { + int i, n = f->sizeupvalues; + dumpInt(D, n); + for (i = 0; i < n; i++) { + dumpByte(D, f->upvalues[i].instack); + dumpByte(D, f->upvalues[i].idx); + dumpByte(D, f->upvalues[i].kind); + } +} + + +static void dumpDebug (DumpState *D, const Proto *f) { + int i, n; + n = (D->strip) ? 0 : f->sizelineinfo; + dumpInt(D, n); + if (f->lineinfo != NULL) + dumpVector(D, f->lineinfo, cast_uint(n)); + n = (D->strip) ? 0 : f->sizeabslineinfo; + dumpInt(D, n); + if (n > 0) { + /* 'abslineinfo' is an array of structures of int's */ + dumpAlign(D, sizeof(int)); + dumpVector(D, f->abslineinfo, cast_uint(n)); + } + n = (D->strip) ? 0 : f->sizelocvars; + dumpInt(D, n); + for (i = 0; i < n; i++) { + dumpString(D, f->locvars[i].varname); + dumpInt(D, f->locvars[i].startpc); + dumpInt(D, f->locvars[i].endpc); + } + n = (D->strip) ? 0 : f->sizeupvalues; + dumpInt(D, n); + for (i = 0; i < n; i++) + dumpString(D, f->upvalues[i].name); +} + + +static void dumpFunction (DumpState *D, const Proto *f) { + dumpInt(D, f->linedefined); + dumpInt(D, f->lastlinedefined); + dumpByte(D, f->numparams); + dumpByte(D, f->flag); + dumpByte(D, f->maxstacksize); + dumpCode(D, f); + dumpConstants(D, f); + dumpUpvalues(D, f); + dumpProtos(D, f); + dumpString(D, D->strip ? NULL : f->source); + dumpDebug(D, f); +} + + +#define dumpNumInfo(D, tvar, value) \ + { tvar i = value; dumpByte(D, sizeof(tvar)); dumpVar(D, i); } + + +static void dumpHeader (DumpState *D) { + dumpLiteral(D, LUA_SIGNATURE); + dumpByte(D, LUAC_VERSION); + dumpByte(D, LUAC_FORMAT); + dumpLiteral(D, LUAC_DATA); + dumpNumInfo(D, int, LUAC_INT); + dumpNumInfo(D, Instruction, LUAC_INST); + dumpNumInfo(D, lua_Integer, LUAC_INT); + dumpNumInfo(D, lua_Number, LUAC_NUM); +} + + +/* +** dump Lua function as precompiled chunk +*/ +int luaU_dump (lua_State *L, const Proto *f, lua_Writer w, void *data, + int strip) { + DumpState D; + D.h = luaH_new(L); /* aux. table to keep strings already dumped */ + sethvalue2s(L, L->top.p, D.h); /* anchor it */ + L->top.p++; + D.L = L; + D.writer = w; + D.offset = 0; + D.data = data; + D.strip = strip; + D.status = 0; + D.nstr = 0; + dumpHeader(&D); + dumpByte(&D, f->sizeupvalues); + dumpFunction(&D, f); + dumpBlock(&D, NULL, 0); /* signal end of dump */ + return D.status; +} + diff --git a/source/external/lua/lfunc.c b/source/external/lua/lfunc.c new file mode 100644 index 0000000..b6fd9ce --- /dev/null +++ b/source/external/lua/lfunc.c @@ -0,0 +1,314 @@ +/* +** $Id: lfunc.c $ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + +#define lfunc_c +#define LUA_CORE + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +CClosure *luaF_newCclosure (lua_State *L, int nupvals) { + GCObject *o = luaC_newobj(L, LUA_VCCL, sizeCclosure(nupvals)); + CClosure *c = gco2ccl(o); + c->nupvalues = cast_byte(nupvals); + return c; +} + + +LClosure *luaF_newLclosure (lua_State *L, int nupvals) { + GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); + LClosure *c = gco2lcl(o); + c->p = NULL; + c->nupvalues = cast_byte(nupvals); + while (nupvals--) c->upvals[nupvals] = NULL; + return c; +} + + +/* +** fill a closure with new closed upvalues +*/ +void luaF_initupvals (lua_State *L, LClosure *cl) { + int i; + for (i = 0; i < cl->nupvalues; i++) { + GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); + UpVal *uv = gco2upv(o); + uv->v.p = &uv->u.value; /* make it closed */ + setnilvalue(uv->v.p); + cl->upvals[i] = uv; + luaC_objbarrier(L, cl, uv); + } +} + + +/* +** Create a new upvalue at the given level, and link it to the list of +** open upvalues of 'L' after entry 'prev'. +**/ +static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) { + GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); + UpVal *uv = gco2upv(o); + UpVal *next = *prev; + uv->v.p = s2v(level); /* current value lives in the stack */ + uv->u.open.next = next; /* link it to list of open upvalues */ + uv->u.open.previous = prev; + if (next) + next->u.open.previous = &uv->u.open.next; + *prev = uv; + if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ + L->twups = G(L)->twups; /* link it to the list */ + G(L)->twups = L; + } + return uv; +} + + +/* +** Find and reuse, or create if it does not exist, an upvalue +** at the given level. +*/ +UpVal *luaF_findupval (lua_State *L, StkId level) { + UpVal **pp = &L->openupval; + UpVal *p; + lua_assert(isintwups(L) || L->openupval == NULL); + while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ + lua_assert(!isdead(G(L), p)); + if (uplevel(p) == level) /* corresponding upvalue? */ + return p; /* return it */ + pp = &p->u.open.next; + } + /* not found: create a new upvalue after 'pp' */ + return newupval(L, level, pp); +} + + +/* +** Call closing method for object 'obj' with error object 'err'. The +** boolean 'yy' controls whether the call is yieldable. +** (This function assumes EXTRA_STACK.) +*/ +static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) { + StkId top = L->top.p; + StkId func = top; + const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE); + setobj2s(L, top++, tm); /* will call metamethod... */ + setobj2s(L, top++, obj); /* with 'self' as the 1st argument */ + if (err != NULL) /* if there was an error... */ + setobj2s(L, top++, err); /* then error object will be 2nd argument */ + L->top.p = top; /* add function and arguments */ + if (yy) + luaD_call(L, func, 0); + else + luaD_callnoyield(L, func, 0); +} + + +/* +** Check whether object at given level has a close metamethod and raise +** an error if not. +*/ +static void checkclosemth (lua_State *L, StkId level) { + const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE); + if (ttisnil(tm)) { /* no metamethod? */ + int idx = cast_int(level - L->ci->func.p); /* variable index */ + const char *vname = luaG_findlocal(L, L->ci, idx, NULL); + if (vname == NULL) vname = "?"; + luaG_runerror(L, "variable '%s' got a non-closable value", vname); + } +} + + +/* +** Prepare and call a closing method. +** If status is CLOSEKTOP, the call to the closing method will be pushed +** at the top of the stack. Otherwise, values can be pushed right after +** the 'level' of the upvalue being closed, as everything after that +** won't be used again. +*/ +static void prepcallclosemth (lua_State *L, StkId level, TStatus status, + int yy) { + TValue *uv = s2v(level); /* value being closed */ + TValue *errobj; + switch (status) { + case LUA_OK: + L->top.p = level + 1; /* call will be at this level */ + /* FALLTHROUGH */ + case CLOSEKTOP: /* don't need to change top */ + errobj = NULL; /* no error object */ + break; + default: /* 'luaD_seterrorobj' will set top to level + 2 */ + errobj = s2v(level + 1); /* error object goes after 'uv' */ + luaD_seterrorobj(L, status, level + 1); /* set error object */ + break; + } + callclosemethod(L, uv, errobj, yy); +} + + +/* Maximum value for deltas in 'tbclist' */ +#define MAXDELTA USHRT_MAX + + +/* +** Insert a variable in the list of to-be-closed variables. +*/ +void luaF_newtbcupval (lua_State *L, StkId level) { + lua_assert(level > L->tbclist.p); + if (l_isfalse(s2v(level))) + return; /* false doesn't need to be closed */ + checkclosemth(L, level); /* value must have a close method */ + while (cast_uint(level - L->tbclist.p) > MAXDELTA) { + L->tbclist.p += MAXDELTA; /* create a dummy node at maximum delta */ + L->tbclist.p->tbclist.delta = 0; + } + level->tbclist.delta = cast(unsigned short, level - L->tbclist.p); + L->tbclist.p = level; +} + + +void luaF_unlinkupval (UpVal *uv) { + lua_assert(upisopen(uv)); + *uv->u.open.previous = uv->u.open.next; + if (uv->u.open.next) + uv->u.open.next->u.open.previous = uv->u.open.previous; +} + + +/* +** Close all upvalues up to the given stack level. +*/ +void luaF_closeupval (lua_State *L, StkId level) { + UpVal *uv; + while ((uv = L->openupval) != NULL && uplevel(uv) >= level) { + TValue *slot = &uv->u.value; /* new position for value */ + lua_assert(uplevel(uv) < L->top.p); + luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ + setobj(L, slot, uv->v.p); /* move value to upvalue slot */ + uv->v.p = slot; /* now current value lives here */ + if (!iswhite(uv)) { /* neither white nor dead? */ + nw2black(uv); /* closed upvalues cannot be gray */ + luaC_barrier(L, uv, slot); + } + } +} + + +/* +** Remove first element from the tbclist plus its dummy nodes. +*/ +static void poptbclist (lua_State *L) { + StkId tbc = L->tbclist.p; + lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */ + tbc -= tbc->tbclist.delta; + while (tbc > L->stack.p && tbc->tbclist.delta == 0) + tbc -= MAXDELTA; /* remove dummy nodes */ + L->tbclist.p = tbc; +} + + +/* +** Close all upvalues and to-be-closed variables up to the given stack +** level. Return restored 'level'. +*/ +StkId luaF_close (lua_State *L, StkId level, TStatus status, int yy) { + ptrdiff_t levelrel = savestack(L, level); + luaF_closeupval(L, level); /* first, close the upvalues */ + while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ + StkId tbc = L->tbclist.p; /* get variable index */ + poptbclist(L); /* remove it from list */ + prepcallclosemth(L, tbc, status, yy); /* close variable */ + level = restorestack(L, levelrel); + } + return level; +} + + +Proto *luaF_newproto (lua_State *L) { + GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); + Proto *f = gco2p(o); + f->k = NULL; + f->sizek = 0; + f->p = NULL; + f->sizep = 0; + f->code = NULL; + f->sizecode = 0; + f->lineinfo = NULL; + f->sizelineinfo = 0; + f->abslineinfo = NULL; + f->sizeabslineinfo = 0; + f->upvalues = NULL; + f->sizeupvalues = 0; + f->numparams = 0; + f->flag = 0; + f->maxstacksize = 0; + f->locvars = NULL; + f->sizelocvars = 0; + f->linedefined = 0; + f->lastlinedefined = 0; + f->source = NULL; + return f; +} + + +lu_mem luaF_protosize (Proto *p) { + lu_mem sz = cast(lu_mem, sizeof(Proto)) + + cast_uint(p->sizep) * sizeof(Proto*) + + cast_uint(p->sizek) * sizeof(TValue) + + cast_uint(p->sizelocvars) * sizeof(LocVar) + + cast_uint(p->sizeupvalues) * sizeof(Upvaldesc); + if (!(p->flag & PF_FIXED)) { + sz += cast_uint(p->sizecode) * sizeof(Instruction); + sz += cast_uint(p->sizelineinfo) * sizeof(lu_byte); + sz += cast_uint(p->sizeabslineinfo) * sizeof(AbsLineInfo); + } + return sz; +} + + +void luaF_freeproto (lua_State *L, Proto *f) { + if (!(f->flag & PF_FIXED)) { + luaM_freearray(L, f->code, cast_sizet(f->sizecode)); + luaM_freearray(L, f->lineinfo, cast_sizet(f->sizelineinfo)); + luaM_freearray(L, f->abslineinfo, cast_sizet(f->sizeabslineinfo)); + } + luaM_freearray(L, f->p, cast_sizet(f->sizep)); + luaM_freearray(L, f->k, cast_sizet(f->sizek)); + luaM_freearray(L, f->locvars, cast_sizet(f->sizelocvars)); + luaM_freearray(L, f->upvalues, cast_sizet(f->sizeupvalues)); + luaM_free(L, f); +} + + +/* +** Look for n-th local variable at line 'line' in function 'func'. +** Returns NULL if not found. +*/ +const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { + int i; + for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { + if (pc < f->locvars[i].endpc) { /* is variable active? */ + local_number--; + if (local_number == 0) + return getstr(f->locvars[i].varname); + } + } + return NULL; /* not found */ +} + diff --git a/source/external/lua/lgc.c b/source/external/lua/lgc.c new file mode 100644 index 0000000..c64d74b --- /dev/null +++ b/source/external/lua/lgc.c @@ -0,0 +1,1804 @@ +/* +** $Id: lgc.c $ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#define lgc_c +#define LUA_CORE + +#include "lprefix.h" + +#include + + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +/* +** Maximum number of elements to sweep in each single step. +** (Large enough to dissipate fixed overheads but small enough +** to allow small steps for the collector.) +*/ +#define GCSWEEPMAX 20 + + +/* +** Cost (in work units) of running one finalizer. +*/ +#define CWUFIN 10 + + +/* mask with all color bits */ +#define maskcolors (bitmask(BLACKBIT) | WHITEBITS) + +/* mask with all GC bits */ +#define maskgcbits (maskcolors | AGEBITS) + + +/* macro to erase all color bits then set only the current white bit */ +#define makewhite(g,x) \ + (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) + +/* make an object gray (neither white nor black) */ +#define set2gray(x) resetbits(x->marked, maskcolors) + + +/* make an object black (coming from any color) */ +#define set2black(x) \ + (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) + + +#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) + +#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) + + +/* +** Protected access to objects in values +*/ +#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) + + +/* +** Access to collectable objects in array part of tables +*/ +#define gcvalarr(t,i) \ + ((*getArrTag(t,i) & BIT_ISCOLLECTABLE) ? getArrVal(t,i)->gc : NULL) + + +#define markvalue(g,o) { checkliveness(mainthread(g),o); \ + if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } + +#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } + +#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } + +/* +** mark an object that can be NULL (either because it is really optional, +** or it was stripped as debug info, or inside an uncompleted structure) +*/ +#define markobjectN(g,t) { if (t) markobject(g,t); } + + +static void reallymarkobject (global_State *g, GCObject *o); +static void atomic (lua_State *L); +static void entersweep (lua_State *L); + + +/* +** {====================================================== +** Generic functions +** ======================================================= +*/ + + +/* +** one after last element in a hash array +*/ +#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) + + +static l_mem objsize (GCObject *o) { + lu_mem res; + switch (o->tt) { + case LUA_VTABLE: { + res = luaH_size(gco2t(o)); + break; + } + case LUA_VLCL: { + LClosure *cl = gco2lcl(o); + res = sizeLclosure(cl->nupvalues); + break; + } + case LUA_VCCL: { + CClosure *cl = gco2ccl(o); + res = sizeCclosure(cl->nupvalues); + break; + } + case LUA_VUSERDATA: { + Udata *u = gco2u(o); + res = sizeudata(u->nuvalue, u->len); + break; + } + case LUA_VPROTO: { + res = luaF_protosize(gco2p(o)); + break; + } + case LUA_VTHREAD: { + res = luaE_threadsize(gco2th(o)); + break; + } + case LUA_VSHRSTR: { + TString *ts = gco2ts(o); + res = sizestrshr(cast_uint(ts->shrlen)); + break; + } + case LUA_VLNGSTR: { + TString *ts = gco2ts(o); + res = luaS_sizelngstr(ts->u.lnglen, ts->shrlen); + break; + } + case LUA_VUPVAL: { + res = sizeof(UpVal); + break; + } + default: res = 0; lua_assert(0); + } + return cast(l_mem, res); +} + + +static GCObject **getgclist (GCObject *o) { + switch (o->tt) { + case LUA_VTABLE: return &gco2t(o)->gclist; + case LUA_VLCL: return &gco2lcl(o)->gclist; + case LUA_VCCL: return &gco2ccl(o)->gclist; + case LUA_VTHREAD: return &gco2th(o)->gclist; + case LUA_VPROTO: return &gco2p(o)->gclist; + case LUA_VUSERDATA: { + Udata *u = gco2u(o); + lua_assert(u->nuvalue > 0); + return &u->gclist; + } + default: lua_assert(0); return 0; + } +} + + +/* +** Link a collectable object 'o' with a known type into the list 'p'. +** (Must be a macro to access the 'gclist' field in different types.) +*/ +#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) + +static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { + lua_assert(!isgray(o)); /* cannot be in a gray list */ + *pnext = *list; + *list = o; + set2gray(o); /* now it is */ +} + + +/* +** Link a generic collectable object 'o' into the list 'p'. +*/ +#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) + + + +/* +** Clear keys for empty entries in tables. If entry is empty, mark its +** entry as dead. This allows the collection of the key, but keeps its +** entry in the table: its removal could break a chain and could break +** a table traversal. Other places never manipulate dead keys, because +** its associated empty value is enough to signal that the entry is +** logically empty. +*/ +static void clearkey (Node *n) { + lua_assert(isempty(gval(n))); + if (keyiscollectable(n)) + setdeadkey(n); /* unused key; remove it */ +} + + +/* +** tells whether a key or value can be cleared from a weak +** table. Non-collectable objects are never removed from weak +** tables. Strings behave as 'values', so are never removed too. for +** other objects: if really collected, cannot keep them; for objects +** being finalized, keep them in keys, but not in values +*/ +static int iscleared (global_State *g, const GCObject *o) { + if (o == NULL) return 0; /* non-collectable value */ + else if (novariant(o->tt) == LUA_TSTRING) { + markobject(g, o); /* strings are 'values', so are never weak */ + return 0; + } + else return iswhite(o); +} + + +/* +** Barrier that moves collector forward, that is, marks the white object +** 'v' being pointed by the black object 'o'. In the generational +** mode, 'v' must also become old, if 'o' is old; however, it cannot +** be changed directly to OLD, because it may still point to non-old +** objects. So, it is marked as OLD0. In the next cycle it will become +** OLD1, and in the next it will finally become OLD (regular old). By +** then, any object it points to will also be old. If called in the +** incremental sweep phase, it clears the black object to white (sweep +** it) to avoid other barrier calls for this same object. (That cannot +** be done is generational mode, as its sweep does not distinguish +** white from dead.) +*/ +void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) { + global_State *g = G(L); + lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o)); + if (keepinvariant(g)) { /* must keep invariant? */ + reallymarkobject(g, v); /* restore invariant */ + if (isold(o)) { + lua_assert(!isold(v)); /* white object could not be old */ + setage(v, G_OLD0); /* restore generational invariant */ + } + } + else { /* sweep phase */ + lua_assert(issweepphase(g)); + if (g->gckind != KGC_GENMINOR) /* incremental mode? */ + makewhite(g, o); /* mark 'o' as white to avoid other barriers */ + } +} + + +/* +** barrier that moves collector backward, that is, mark the black object +** pointing to a white object as gray again. +*/ +void luaC_barrierback_ (lua_State *L, GCObject *o) { + global_State *g = G(L); + lua_assert(isblack(o) && !isdead(g, o)); + lua_assert((g->gckind != KGC_GENMINOR) + || (isold(o) && getage(o) != G_TOUCHED1)); + if (getage(o) == G_TOUCHED2) /* already in gray list? */ + set2gray(o); /* make it gray to become touched1 */ + else /* link it in 'grayagain' and paint it gray */ + linkobjgclist(o, g->grayagain); + if (isold(o)) /* generational mode? */ + setage(o, G_TOUCHED1); /* touched in current cycle */ +} + + +void luaC_fix (lua_State *L, GCObject *o) { + global_State *g = G(L); + lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ + set2gray(o); /* they will be gray forever */ + setage(o, G_OLD); /* and old forever */ + g->allgc = o->next; /* remove object from 'allgc' list */ + o->next = g->fixedgc; /* link it to 'fixedgc' list */ + g->fixedgc = o; +} + + +/* +** create a new collectable object (with given type, size, and offset) +** and link it to 'allgc' list. +*/ +GCObject *luaC_newobjdt (lua_State *L, lu_byte tt, size_t sz, size_t offset) { + global_State *g = G(L); + char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); + GCObject *o = cast(GCObject *, p + offset); + o->marked = luaC_white(g); + o->tt = tt; + o->next = g->allgc; + g->allgc = o; + return o; +} + + +/* +** create a new collectable object with no offset. +*/ +GCObject *luaC_newobj (lua_State *L, lu_byte tt, size_t sz) { + return luaC_newobjdt(L, tt, sz, 0); +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Mark functions +** ======================================================= +*/ + + +/* +** Mark an object. Userdata with no user values, strings, and closed +** upvalues are visited and turned black here. Open upvalues are +** already indirectly linked through their respective threads in the +** 'twups' list, so they don't go to the gray list; nevertheless, they +** are kept gray to avoid barriers, as their values will be revisited +** by the thread or by 'remarkupvals'. Other objects are added to the +** gray list to be visited (and turned black) later. Both userdata and +** upvalues can call this function recursively, but this recursion goes +** for at most two levels: An upvalue cannot refer to another upvalue +** (only closures can), and a userdata's metatable must be a table. +*/ +static void reallymarkobject (global_State *g, GCObject *o) { + g->GCmarked += objsize(o); + switch (o->tt) { + case LUA_VSHRSTR: + case LUA_VLNGSTR: { + set2black(o); /* nothing to visit */ + break; + } + case LUA_VUPVAL: { + UpVal *uv = gco2upv(o); + if (upisopen(uv)) + set2gray(uv); /* open upvalues are kept gray */ + else + set2black(uv); /* closed upvalues are visited here */ + markvalue(g, uv->v.p); /* mark its content */ + break; + } + case LUA_VUSERDATA: { + Udata *u = gco2u(o); + if (u->nuvalue == 0) { /* no user values? */ + markobjectN(g, u->metatable); /* mark its metatable */ + set2black(u); /* nothing else to mark */ + break; + } + /* else... */ + } /* FALLTHROUGH */ + case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: + case LUA_VTHREAD: case LUA_VPROTO: { + linkobjgclist(o, g->gray); /* to be visited later */ + break; + } + default: lua_assert(0); break; + } +} + + +/* +** mark metamethods for basic types +*/ +static void markmt (global_State *g) { + int i; + for (i=0; i < LUA_NUMTYPES; i++) + markobjectN(g, g->mt[i]); +} + + +/* +** mark all objects in list of being-finalized +*/ +static void markbeingfnz (global_State *g) { + GCObject *o; + for (o = g->tobefnz; o != NULL; o = o->next) + markobject(g, o); +} + + +/* +** For each non-marked thread, simulates a barrier between each open +** upvalue and its value. (If the thread is collected, the value will be +** assigned to the upvalue, but then it can be too late for the barrier +** to act. The "barrier" does not need to check colors: A non-marked +** thread must be young; upvalues cannot be older than their threads; so +** any visited upvalue must be young too.) Also removes the thread from +** the list, as it was already visited. Removes also threads with no +** upvalues, as they have nothing to be checked. (If the thread gets an +** upvalue later, it will be linked in the list again.) +*/ +static void remarkupvals (global_State *g) { + lua_State *thread; + lua_State **p = &g->twups; + while ((thread = *p) != NULL) { + if (!iswhite(thread) && thread->openupval != NULL) + p = &thread->twups; /* keep marked thread with upvalues in the list */ + else { /* thread is not marked or without upvalues */ + UpVal *uv; + lua_assert(!isold(thread) || thread->openupval == NULL); + *p = thread->twups; /* remove thread from the list */ + thread->twups = thread; /* mark that it is out of list */ + for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { + lua_assert(getage(uv) <= getage(thread)); + if (!iswhite(uv)) { /* upvalue already visited? */ + lua_assert(upisopen(uv) && isgray(uv)); + markvalue(g, uv->v.p); /* mark its value */ + } + } + } + } +} + + +static void cleargraylists (global_State *g) { + g->gray = g->grayagain = NULL; + g->weak = g->allweak = g->ephemeron = NULL; +} + + +/* +** mark root set and reset all gray lists, to start a new collection. +** 'GCmarked' is initialized to count the total number of live bytes +** during a cycle. +*/ +static void restartcollection (global_State *g) { + cleargraylists(g); + g->GCmarked = 0; + markobject(g, mainthread(g)); + markvalue(g, &g->l_registry); + markmt(g); + markbeingfnz(g); /* mark any finalizing object left from previous cycle */ +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Traverse functions +** ======================================================= +*/ + + +/* +** Check whether object 'o' should be kept in the 'grayagain' list for +** post-processing by 'correctgraylist'. (It could put all old objects +** in the list and leave all the work to 'correctgraylist', but it is +** more efficient to avoid adding elements that will be removed.) Only +** TOUCHED1 objects need to be in the list. TOUCHED2 doesn't need to go +** back to a gray list, but then it must become OLD. (That is what +** 'correctgraylist' does when it finds a TOUCHED2 object.) +** This function is a no-op in incremental mode, as objects cannot be +** marked as touched in that mode. +*/ +static void genlink (global_State *g, GCObject *o) { + lua_assert(isblack(o)); + if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ + linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ + } /* everything else do not need to be linked back */ + else if (getage(o) == G_TOUCHED2) + setage(o, G_OLD); /* advance age */ +} + + +/* +** Traverse a table with weak values and link it to proper list. During +** propagate phase, keep it in 'grayagain' list, to be revisited in the +** atomic phase. In the atomic phase, if table has any white value, +** put it in 'weak' list, to be cleared; otherwise, call 'genlink' +** to check table age in generational mode. +*/ +static void traverseweakvalue (global_State *g, Table *h) { + Node *n, *limit = gnodelast(h); + /* if there is array part, assume it may have white values (it is not + worth traversing it now just to check) */ + int hasclears = (h->asize > 0); + for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ + if (isempty(gval(n))) /* entry is empty? */ + clearkey(n); /* clear its key */ + else { + lua_assert(!keyisnil(n)); + markkey(g, n); + if (!hasclears && iscleared(g, gcvalueN(gval(n)))) /* a white value? */ + hasclears = 1; /* table will have to be cleared */ + } + } + if (g->gcstate == GCSpropagate) + linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */ + else if (hasclears) + linkgclist(h, g->weak); /* has to be cleared later */ + else + genlink(g, obj2gco(h)); +} + + +/* +** Traverse the array part of a table. +*/ +static int traversearray (global_State *g, Table *h) { + unsigned asize = h->asize; + int marked = 0; /* true if some object is marked in this traversal */ + unsigned i; + for (i = 0; i < asize; i++) { + GCObject *o = gcvalarr(h, i); + if (o != NULL && iswhite(o)) { + marked = 1; + reallymarkobject(g, o); + } + } + return marked; +} + + +/* +** Traverse an ephemeron table and link it to proper list. Returns true +** iff any object was marked during this traversal (which implies that +** convergence has to continue). During propagation phase, keep table +** in 'grayagain' list, to be visited again in the atomic phase. In +** the atomic phase, if table has any white->white entry, it has to +** be revisited during ephemeron convergence (as that key may turn +** black). Otherwise, if it has any white key, table has to be cleared +** (in the atomic phase). In generational mode, some tables +** must be kept in some gray list for post-processing; this is done +** by 'genlink'. +*/ +static int traverseephemeron (global_State *g, Table *h, int inv) { + int hasclears = 0; /* true if table has white keys */ + int hasww = 0; /* true if table has entry "white-key -> white-value" */ + unsigned int i; + unsigned int nsize = sizenode(h); + int marked = traversearray(g, h); /* traverse array part */ + /* traverse hash part; if 'inv', traverse descending + (see 'convergeephemerons') */ + for (i = 0; i < nsize; i++) { + Node *n = inv ? gnode(h, nsize - 1 - i) : gnode(h, i); + if (isempty(gval(n))) /* entry is empty? */ + clearkey(n); /* clear its key */ + else if (iscleared(g, gckeyN(n))) { /* key is not marked (yet)? */ + hasclears = 1; /* table must be cleared */ + if (valiswhite(gval(n))) /* value not marked yet? */ + hasww = 1; /* white-white entry */ + } + else if (valiswhite(gval(n))) { /* value not marked yet? */ + marked = 1; + reallymarkobject(g, gcvalue(gval(n))); /* mark it now */ + } + } + /* link table into proper list */ + if (g->gcstate == GCSpropagate) + linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */ + else if (hasww) /* table has white->white entries? */ + linkgclist(h, g->ephemeron); /* have to propagate again */ + else if (hasclears) /* table has white keys? */ + linkgclist(h, g->allweak); /* may have to clean white keys */ + else + genlink(g, obj2gco(h)); /* check whether collector still needs to see it */ + return marked; +} + + +static void traversestrongtable (global_State *g, Table *h) { + Node *n, *limit = gnodelast(h); + traversearray(g, h); + for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ + if (isempty(gval(n))) /* entry is empty? */ + clearkey(n); /* clear its key */ + else { + lua_assert(!keyisnil(n)); + markkey(g, n); + markvalue(g, gval(n)); + } + } + genlink(g, obj2gco(h)); +} + + +/* +** (result & 1) iff weak values; (result & 2) iff weak keys. +*/ +static int getmode (global_State *g, Table *h) { + const TValue *mode = gfasttm(g, h->metatable, TM_MODE); + if (mode == NULL || !ttisstring(mode)) + return 0; /* ignore non-string modes */ + else { + const char *smode = getstr(tsvalue(mode)); + const char *weakkey = strchr(smode, 'k'); + const char *weakvalue = strchr(smode, 'v'); + return ((weakkey != NULL) << 1) | (weakvalue != NULL); + } +} + + +static l_mem traversetable (global_State *g, Table *h) { + markobjectN(g, h->metatable); + switch (getmode(g, h)) { + case 0: /* not weak */ + traversestrongtable(g, h); + break; + case 1: /* weak values */ + traverseweakvalue(g, h); + break; + case 2: /* weak keys */ + traverseephemeron(g, h, 0); + break; + case 3: /* all weak; nothing to traverse */ + if (g->gcstate == GCSpropagate) + linkgclist(h, g->grayagain); /* must visit again its metatable */ + else + linkgclist(h, g->allweak); /* must clear collected entries */ + break; + } + return cast(l_mem, 1 + 2*sizenode(h) + h->asize); +} + + +static l_mem traverseudata (global_State *g, Udata *u) { + int i; + markobjectN(g, u->metatable); /* mark its metatable */ + for (i = 0; i < u->nuvalue; i++) + markvalue(g, &u->uv[i].uv); + genlink(g, obj2gco(u)); + return 1 + u->nuvalue; +} + + +/* +** Traverse a prototype. (While a prototype is being build, its +** arrays can be larger than needed; the extra slots are filled with +** NULL, so the use of 'markobjectN') +*/ +static l_mem traverseproto (global_State *g, Proto *f) { + int i; + markobjectN(g, f->source); + for (i = 0; i < f->sizek; i++) /* mark literals */ + markvalue(g, &f->k[i]); + for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ + markobjectN(g, f->upvalues[i].name); + for (i = 0; i < f->sizep; i++) /* mark nested protos */ + markobjectN(g, f->p[i]); + for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ + markobjectN(g, f->locvars[i].varname); + return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars; +} + + +static l_mem traverseCclosure (global_State *g, CClosure *cl) { + int i; + for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */ + markvalue(g, &cl->upvalue[i]); + return 1 + cl->nupvalues; +} + +/* +** Traverse a Lua closure, marking its prototype and its upvalues. +** (Both can be NULL while closure is being created.) +*/ +static l_mem traverseLclosure (global_State *g, LClosure *cl) { + int i; + markobjectN(g, cl->p); /* mark its prototype */ + for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ + UpVal *uv = cl->upvals[i]; + markobjectN(g, uv); /* mark upvalue */ + } + return 1 + cl->nupvalues; +} + + +/* +** Traverse a thread, marking the elements in the stack up to its top +** and cleaning the rest of the stack in the final traversal. That +** ensures that the entire stack have valid (non-dead) objects. +** Threads have no barriers. In gen. mode, old threads must be visited +** at every cycle, because they might point to young objects. In inc. +** mode, the thread can still be modified before the end of the cycle, +** and therefore it must be visited again in the atomic phase. To ensure +** these visits, threads must return to a gray list if they are not new +** (which can only happen in generational mode) or if the traverse is in +** the propagate phase (which can only happen in incremental mode). +*/ +static l_mem traversethread (global_State *g, lua_State *th) { + UpVal *uv; + StkId o = th->stack.p; + if (isold(th) || g->gcstate == GCSpropagate) + linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ + if (o == NULL) + return 0; /* stack not completely built yet */ + lua_assert(g->gcstate == GCSatomic || + th->openupval == NULL || isintwups(th)); + for (; o < th->top.p; o++) /* mark live elements in the stack */ + markvalue(g, s2v(o)); + for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) + markobject(g, uv); /* open upvalues cannot be collected */ + if (g->gcstate == GCSatomic) { /* final traversal? */ + if (!g->gcemergency) + luaD_shrinkstack(th); /* do not change stack in emergency cycle */ + for (o = th->top.p; o < th->stack_last.p + EXTRA_STACK; o++) + setnilvalue(s2v(o)); /* clear dead stack slice */ + /* 'remarkupvals' may have removed thread from 'twups' list */ + if (!isintwups(th) && th->openupval != NULL) { + th->twups = g->twups; /* link it back to the list */ + g->twups = th; + } + } + return 1 + (th->top.p - th->stack.p); +} + + +/* +** traverse one gray object, turning it to black. Return an estimate +** of the number of slots traversed. +*/ +static l_mem propagatemark (global_State *g) { + GCObject *o = g->gray; + nw2black(o); + g->gray = *getgclist(o); /* remove from 'gray' list */ + switch (o->tt) { + case LUA_VTABLE: return traversetable(g, gco2t(o)); + case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); + case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); + case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); + case LUA_VPROTO: return traverseproto(g, gco2p(o)); + case LUA_VTHREAD: return traversethread(g, gco2th(o)); + default: lua_assert(0); return 0; + } +} + + +static void propagateall (global_State *g) { + while (g->gray) + propagatemark(g); +} + + +/* +** Traverse all ephemeron tables propagating marks from keys to values. +** Repeat until it converges, that is, nothing new is marked. 'dir' +** inverts the direction of the traversals, trying to speed up +** convergence on chains in the same table. +*/ +static void convergeephemerons (global_State *g) { + int changed; + int dir = 0; + do { + GCObject *w; + GCObject *next = g->ephemeron; /* get ephemeron list */ + g->ephemeron = NULL; /* tables may return to this list when traversed */ + changed = 0; + while ((w = next) != NULL) { /* for each ephemeron table */ + Table *h = gco2t(w); + next = h->gclist; /* list is rebuilt during loop */ + nw2black(h); /* out of the list (for now) */ + if (traverseephemeron(g, h, dir)) { /* marked some value? */ + propagateall(g); /* propagate changes */ + changed = 1; /* will have to revisit all ephemeron tables */ + } + } + dir = !dir; /* invert direction next time */ + } while (changed); /* repeat until no more changes */ +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Sweep Functions +** ======================================================= +*/ + + +/* +** clear entries with unmarked keys from all weaktables in list 'l' +*/ +static void clearbykeys (global_State *g, GCObject *l) { + for (; l; l = gco2t(l)->gclist) { + Table *h = gco2t(l); + Node *limit = gnodelast(h); + Node *n; + for (n = gnode(h, 0); n < limit; n++) { + if (iscleared(g, gckeyN(n))) /* unmarked key? */ + setempty(gval(n)); /* remove entry */ + if (isempty(gval(n))) /* is entry empty? */ + clearkey(n); /* clear its key */ + } + } +} + + +/* +** clear entries with unmarked values from all weaktables in list 'l' up +** to element 'f' +*/ +static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) { + for (; l != f; l = gco2t(l)->gclist) { + Table *h = gco2t(l); + Node *n, *limit = gnodelast(h); + unsigned int i; + unsigned int asize = h->asize; + for (i = 0; i < asize; i++) { + GCObject *o = gcvalarr(h, i); + if (iscleared(g, o)) /* value was collected? */ + *getArrTag(h, i) = LUA_VEMPTY; /* remove entry */ + } + for (n = gnode(h, 0); n < limit; n++) { + if (iscleared(g, gcvalueN(gval(n)))) /* unmarked value? */ + setempty(gval(n)); /* remove entry */ + if (isempty(gval(n))) /* is entry empty? */ + clearkey(n); /* clear its key */ + } + } +} + + +static void freeupval (lua_State *L, UpVal *uv) { + if (upisopen(uv)) + luaF_unlinkupval(uv); + luaM_free(L, uv); +} + + +static void freeobj (lua_State *L, GCObject *o) { + assert_code(l_mem newmem = gettotalbytes(G(L)) - objsize(o)); + switch (o->tt) { + case LUA_VPROTO: + luaF_freeproto(L, gco2p(o)); + break; + case LUA_VUPVAL: + freeupval(L, gco2upv(o)); + break; + case LUA_VLCL: { + LClosure *cl = gco2lcl(o); + luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); + break; + } + case LUA_VCCL: { + CClosure *cl = gco2ccl(o); + luaM_freemem(L, cl, sizeCclosure(cl->nupvalues)); + break; + } + case LUA_VTABLE: + luaH_free(L, gco2t(o)); + break; + case LUA_VTHREAD: + luaE_freethread(L, gco2th(o)); + break; + case LUA_VUSERDATA: { + Udata *u = gco2u(o); + luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); + break; + } + case LUA_VSHRSTR: { + TString *ts = gco2ts(o); + luaS_remove(L, ts); /* remove it from hash table */ + luaM_freemem(L, ts, sizestrshr(cast_uint(ts->shrlen))); + break; + } + case LUA_VLNGSTR: { + TString *ts = gco2ts(o); + if (ts->shrlen == LSTRMEM) /* must free external string? */ + (*ts->falloc)(ts->ud, ts->contents, ts->u.lnglen + 1, 0); + luaM_freemem(L, ts, luaS_sizelngstr(ts->u.lnglen, ts->shrlen)); + break; + } + default: lua_assert(0); + } + lua_assert(gettotalbytes(G(L)) == newmem); +} + + +/* +** sweep at most 'countin' elements from a list of GCObjects erasing dead +** objects, where a dead object is one marked with the old (non current) +** white; change all non-dead objects back to white (and new), preparing +** for next collection cycle. Return where to continue the traversal or +** NULL if list is finished. +*/ +static GCObject **sweeplist (lua_State *L, GCObject **p, l_mem countin) { + global_State *g = G(L); + int ow = otherwhite(g); + int white = luaC_white(g); /* current white */ + while (*p != NULL && countin-- > 0) { + GCObject *curr = *p; + int marked = curr->marked; + if (isdeadm(ow, marked)) { /* is 'curr' dead? */ + *p = curr->next; /* remove 'curr' from list */ + freeobj(L, curr); /* erase 'curr' */ + } + else { /* change mark to 'white' and age to 'new' */ + curr->marked = cast_byte((marked & ~maskgcbits) | white | G_NEW); + p = &curr->next; /* go to next element */ + } + } + return (*p == NULL) ? NULL : p; +} + + +/* +** sweep a list until a live object (or end of list) +*/ +static GCObject **sweeptolive (lua_State *L, GCObject **p) { + GCObject **old = p; + do { + p = sweeplist(L, p, 1); + } while (p == old); + return p; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Finalization +** ======================================================= +*/ + +/* +** If possible, shrink string table. +*/ +static void checkSizes (lua_State *L, global_State *g) { + if (!g->gcemergency) { + if (g->strt.nuse < g->strt.size / 4) /* string table too big? */ + luaS_resize(L, g->strt.size / 2); + } +} + + +/* +** Get the next udata to be finalized from the 'tobefnz' list, and +** link it back into the 'allgc' list. +*/ +static GCObject *udata2finalize (global_State *g) { + GCObject *o = g->tobefnz; /* get first element */ + lua_assert(tofinalize(o)); + g->tobefnz = o->next; /* remove it from 'tobefnz' list */ + o->next = g->allgc; /* return it to 'allgc' list */ + g->allgc = o; + resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ + if (issweepphase(g)) + makewhite(g, o); /* "sweep" object */ + else if (getage(o) == G_OLD1) + g->firstold1 = o; /* it is the first OLD1 object in the list */ + return o; +} + + +static void dothecall (lua_State *L, void *ud) { + UNUSED(ud); + luaD_callnoyield(L, L->top.p - 2, 0); +} + + +static void GCTM (lua_State *L) { + global_State *g = G(L); + const TValue *tm; + TValue v; + lua_assert(!g->gcemergency); + setgcovalue(L, &v, udata2finalize(g)); + tm = luaT_gettmbyobj(L, &v, TM_GC); + if (!notm(tm)) { /* is there a finalizer? */ + TStatus status; + lu_byte oldah = L->allowhook; + lu_byte oldgcstp = g->gcstp; + g->gcstp |= GCSTPGC; /* avoid GC steps */ + L->allowhook = 0; /* stop debug hooks during GC metamethod */ + setobj2s(L, L->top.p++, tm); /* push finalizer... */ + setobj2s(L, L->top.p++, &v); /* ... and its argument */ + L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ + status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0); + L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ + L->allowhook = oldah; /* restore hooks */ + g->gcstp = oldgcstp; /* restore state */ + if (l_unlikely(status != LUA_OK)) { /* error while running __gc? */ + luaE_warnerror(L, "__gc"); + L->top.p--; /* pops error object */ + } + } +} + + +/* +** call all pending finalizers +*/ +static void callallpendingfinalizers (lua_State *L) { + global_State *g = G(L); + while (g->tobefnz) + GCTM(L); +} + + +/* +** find last 'next' field in list 'p' list (to add elements in its end) +*/ +static GCObject **findlast (GCObject **p) { + while (*p != NULL) + p = &(*p)->next; + return p; +} + + +/* +** Move all unreachable objects (or 'all' objects) that need +** finalization from list 'finobj' to list 'tobefnz' (to be finalized). +** (Note that objects after 'finobjold1' cannot be white, so they +** don't need to be traversed. In incremental mode, 'finobjold1' is NULL, +** so the whole list is traversed.) +*/ +static void separatetobefnz (global_State *g, int all) { + GCObject *curr; + GCObject **p = &g->finobj; + GCObject **lastnext = findlast(&g->tobefnz); + while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ + lua_assert(tofinalize(curr)); + if (!(iswhite(curr) || all)) /* not being collected? */ + p = &curr->next; /* don't bother with it */ + else { + if (curr == g->finobjsur) /* removing 'finobjsur'? */ + g->finobjsur = curr->next; /* correct it */ + *p = curr->next; /* remove 'curr' from 'finobj' list */ + curr->next = *lastnext; /* link at the end of 'tobefnz' list */ + *lastnext = curr; + lastnext = &curr->next; + } + } +} + + +/* +** If pointer 'p' points to 'o', move it to the next element. +*/ +static void checkpointer (GCObject **p, GCObject *o) { + if (o == *p) + *p = o->next; +} + + +/* +** Correct pointers to objects inside 'allgc' list when +** object 'o' is being removed from the list. +*/ +static void correctpointers (global_State *g, GCObject *o) { + checkpointer(&g->survival, o); + checkpointer(&g->old1, o); + checkpointer(&g->reallyold, o); + checkpointer(&g->firstold1, o); +} + + +/* +** if object 'o' has a finalizer, remove it from 'allgc' list (must +** search the list to find it) and link it in 'finobj' list. +*/ +void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { + global_State *g = G(L); + if (tofinalize(o) || /* obj. is already marked... */ + gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ + (g->gcstp & GCSTPCLS)) /* or closing state? */ + return; /* nothing to be done */ + else { /* move 'o' to 'finobj' list */ + GCObject **p; + if (issweepphase(g)) { + makewhite(g, o); /* "sweep" object 'o' */ + if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */ + g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ + } + else + correctpointers(g, o); + /* search for pointer pointing to 'o' */ + for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } + *p = o->next; /* remove 'o' from 'allgc' list */ + o->next = g->finobj; /* link it in 'finobj' list */ + g->finobj = o; + l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ + } +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Generational Collector +** ======================================================= +*/ + +/* +** Fields 'GCmarked' and 'GCmajorminor' are used to control the pace and +** the mode of the collector. They play several roles, depending on the +** mode of the collector: +** * KGC_INC: +** GCmarked: number of marked bytes during a cycle. +** GCmajorminor: not used. +** * KGC_GENMINOR +** GCmarked: number of bytes that became old since last major collection. +** GCmajorminor: number of bytes marked in last major collection. +** * KGC_GENMAJOR +** GCmarked: number of bytes that became old since last major collection. +** GCmajorminor: number of bytes marked in last major collection. +*/ + + +/* +** Set the "time" to wait before starting a new incremental cycle; +** cycle will start when number of bytes in use hits the threshold of +** approximately (marked * pause / 100). +*/ +static void setpause (global_State *g) { + l_mem threshold = applygcparam(g, PAUSE, g->GCmarked); + l_mem debt = threshold - gettotalbytes(g); + if (debt < 0) debt = 0; + luaE_setdebt(g, debt); +} + + +/* +** Sweep a list of objects to enter generational mode. Deletes dead +** objects and turns the non dead to old. All non-dead threads---which +** are now old---must be in a gray list. Everything else is not in a +** gray list. Open upvalues are also kept gray. +*/ +static void sweep2old (lua_State *L, GCObject **p) { + GCObject *curr; + global_State *g = G(L); + while ((curr = *p) != NULL) { + if (iswhite(curr)) { /* is 'curr' dead? */ + lua_assert(isdead(g, curr)); + *p = curr->next; /* remove 'curr' from list */ + freeobj(L, curr); /* erase 'curr' */ + } + else { /* all surviving objects become old */ + setage(curr, G_OLD); + if (curr->tt == LUA_VTHREAD) { /* threads must be watched */ + lua_State *th = gco2th(curr); + linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ + } + else if (curr->tt == LUA_VUPVAL && upisopen(gco2upv(curr))) + set2gray(curr); /* open upvalues are always gray */ + else /* everything else is black */ + nw2black(curr); + p = &curr->next; /* go to next element */ + } + } +} + + +/* +** Sweep for generational mode. Delete dead objects. (Because the +** collection is not incremental, there are no "new white" objects +** during the sweep. So, any white object must be dead.) For +** non-dead objects, advance their ages and clear the color of +** new objects. (Old objects keep their colors.) +** The ages of G_TOUCHED1 and G_TOUCHED2 objects cannot be advanced +** here, because these old-generation objects are usually not swept +** here. They will all be advanced in 'correctgraylist'. That function +** will also remove objects turned white here from any gray list. +*/ +static GCObject **sweepgen (lua_State *L, global_State *g, GCObject **p, + GCObject *limit, GCObject **pfirstold1, + l_mem *paddedold) { + static const lu_byte nextage[] = { + G_SURVIVAL, /* from G_NEW */ + G_OLD1, /* from G_SURVIVAL */ + G_OLD1, /* from G_OLD0 */ + G_OLD, /* from G_OLD1 */ + G_OLD, /* from G_OLD (do not change) */ + G_TOUCHED1, /* from G_TOUCHED1 (do not change) */ + G_TOUCHED2 /* from G_TOUCHED2 (do not change) */ + }; + l_mem addedold = 0; + int white = luaC_white(g); + GCObject *curr; + while ((curr = *p) != limit) { + if (iswhite(curr)) { /* is 'curr' dead? */ + lua_assert(!isold(curr) && isdead(g, curr)); + *p = curr->next; /* remove 'curr' from list */ + freeobj(L, curr); /* erase 'curr' */ + } + else { /* correct mark and age */ + int age = getage(curr); + if (age == G_NEW) { /* new objects go back to white */ + int marked = curr->marked & ~maskgcbits; /* erase GC bits */ + curr->marked = cast_byte(marked | G_SURVIVAL | white); + } + else { /* all other objects will be old, and so keep their color */ + lua_assert(age != G_OLD1); /* advanced in 'markold' */ + setage(curr, nextage[age]); + if (getage(curr) == G_OLD1) { + addedold += objsize(curr); /* bytes becoming old */ + if (*pfirstold1 == NULL) + *pfirstold1 = curr; /* first OLD1 object in the list */ + } + } + p = &curr->next; /* go to next element */ + } + } + *paddedold += addedold; + return p; +} + + +/* +** Correct a list of gray objects. Return a pointer to the last element +** left on the list, so that we can link another list to the end of +** this one. +** Because this correction is done after sweeping, young objects might +** be turned white and still be in the list. They are only removed. +** 'TOUCHED1' objects are advanced to 'TOUCHED2' and remain on the list; +** Non-white threads also remain on the list. 'TOUCHED2' objects and +** anything else become regular old, are marked black, and are removed +** from the list. +*/ +static GCObject **correctgraylist (GCObject **p) { + GCObject *curr; + while ((curr = *p) != NULL) { + GCObject **next = getgclist(curr); + if (iswhite(curr)) + goto remove; /* remove all white objects */ + else if (getage(curr) == G_TOUCHED1) { /* touched in this cycle? */ + lua_assert(isgray(curr)); + nw2black(curr); /* make it black, for next barrier */ + setage(curr, G_TOUCHED2); + goto remain; /* keep it in the list and go to next element */ + } + else if (curr->tt == LUA_VTHREAD) { + lua_assert(isgray(curr)); + goto remain; /* keep non-white threads on the list */ + } + else { /* everything else is removed */ + lua_assert(isold(curr)); /* young objects should be white here */ + if (getage(curr) == G_TOUCHED2) /* advance from TOUCHED2... */ + setage(curr, G_OLD); /* ... to OLD */ + nw2black(curr); /* make object black (to be removed) */ + goto remove; + } + remove: *p = *next; continue; + remain: p = next; continue; + } + return p; +} + + +/* +** Correct all gray lists, coalescing them into 'grayagain'. +*/ +static void correctgraylists (global_State *g) { + GCObject **list = correctgraylist(&g->grayagain); + *list = g->weak; g->weak = NULL; + list = correctgraylist(list); + *list = g->allweak; g->allweak = NULL; + list = correctgraylist(list); + *list = g->ephemeron; g->ephemeron = NULL; + correctgraylist(list); +} + + +/* +** Mark black 'OLD1' objects when starting a new young collection. +** Gray objects are already in some gray list, and so will be visited in +** the atomic step. +*/ +static void markold (global_State *g, GCObject *from, GCObject *to) { + GCObject *p; + for (p = from; p != to; p = p->next) { + if (getage(p) == G_OLD1) { + lua_assert(!iswhite(p)); + setage(p, G_OLD); /* now they are old */ + if (isblack(p)) + reallymarkobject(g, p); + } + } +} + + +/* +** Finish a young-generation collection. +*/ +static void finishgencycle (lua_State *L, global_State *g) { + correctgraylists(g); + checkSizes(L, g); + g->gcstate = GCSpropagate; /* skip restart */ + if (!g->gcemergency && luaD_checkminstack(L)) + callallpendingfinalizers(L); +} + + +/* +** Shifts from a minor collection to major collections. It starts in +** the "sweep all" state to clear all objects, which are mostly black +** in generational mode. +*/ +static void minor2inc (lua_State *L, global_State *g, lu_byte kind) { + g->GCmajorminor = g->GCmarked; /* number of live bytes */ + g->gckind = kind; + g->reallyold = g->old1 = g->survival = NULL; + g->finobjrold = g->finobjold1 = g->finobjsur = NULL; + entersweep(L); /* continue as an incremental cycle */ + /* set a debt equal to the step size */ + luaE_setdebt(g, applygcparam(g, STEPSIZE, 100)); +} + + +/* +** Decide whether to shift to major mode. It shifts if the accumulated +** number of added old bytes (counted in 'GCmarked') is larger than +** 'minormajor'% of the number of lived bytes after the last major +** collection. (This number is kept in 'GCmajorminor'.) +*/ +static int checkminormajor (global_State *g) { + l_mem limit = applygcparam(g, MINORMAJOR, g->GCmajorminor); + if (limit == 0) + return 0; /* special case: 'minormajor' 0 stops major collections */ + return (g->GCmarked >= limit); +} + +/* +** Does a young collection. First, mark 'OLD1' objects. Then does the +** atomic step. Then, check whether to continue in minor mode. If so, +** sweep all lists and advance pointers. Finally, finish the collection. +*/ +static void youngcollection (lua_State *L, global_State *g) { + l_mem addedold1 = 0; + l_mem marked = g->GCmarked; /* preserve 'g->GCmarked' */ + GCObject **psurvival; /* to point to first non-dead survival object */ + GCObject *dummy; /* dummy out parameter to 'sweepgen' */ + lua_assert(g->gcstate == GCSpropagate); + if (g->firstold1) { /* are there regular OLD1 objects? */ + markold(g, g->firstold1, g->reallyold); /* mark them */ + g->firstold1 = NULL; /* no more OLD1 objects (for now) */ + } + markold(g, g->finobj, g->finobjrold); + markold(g, g->tobefnz, NULL); + + atomic(L); /* will lose 'g->marked' */ + + /* sweep nursery and get a pointer to its last live element */ + g->gcstate = GCSswpallgc; + psurvival = sweepgen(L, g, &g->allgc, g->survival, &g->firstold1, &addedold1); + /* sweep 'survival' */ + sweepgen(L, g, psurvival, g->old1, &g->firstold1, &addedold1); + g->reallyold = g->old1; + g->old1 = *psurvival; /* 'survival' survivals are old now */ + g->survival = g->allgc; /* all news are survivals */ + + /* repeat for 'finobj' lists */ + dummy = NULL; /* no 'firstold1' optimization for 'finobj' lists */ + psurvival = sweepgen(L, g, &g->finobj, g->finobjsur, &dummy, &addedold1); + /* sweep 'survival' */ + sweepgen(L, g, psurvival, g->finobjold1, &dummy, &addedold1); + g->finobjrold = g->finobjold1; + g->finobjold1 = *psurvival; /* 'survival' survivals are old now */ + g->finobjsur = g->finobj; /* all news are survivals */ + + sweepgen(L, g, &g->tobefnz, NULL, &dummy, &addedold1); + + /* keep total number of added old1 bytes */ + g->GCmarked = marked + addedold1; + + /* decide whether to shift to major mode */ + if (checkminormajor(g)) { + minor2inc(L, g, KGC_GENMAJOR); /* go to major mode */ + g->GCmarked = 0; /* avoid pause in first major cycle (see 'setpause') */ + } + else + finishgencycle(L, g); /* still in minor mode; finish it */ +} + + +/* +** Clears all gray lists, sweeps objects, and prepare sublists to enter +** generational mode. The sweeps remove dead objects and turn all +** surviving objects to old. Threads go back to 'grayagain'; everything +** else is turned black (not in any gray list). +*/ +static void atomic2gen (lua_State *L, global_State *g) { + cleargraylists(g); + /* sweep all elements making them old */ + g->gcstate = GCSswpallgc; + sweep2old(L, &g->allgc); + /* everything alive now is old */ + g->reallyold = g->old1 = g->survival = g->allgc; + g->firstold1 = NULL; /* there are no OLD1 objects anywhere */ + + /* repeat for 'finobj' lists */ + sweep2old(L, &g->finobj); + g->finobjrold = g->finobjold1 = g->finobjsur = g->finobj; + + sweep2old(L, &g->tobefnz); + + g->gckind = KGC_GENMINOR; + g->GCmajorminor = g->GCmarked; /* "base" for number of bytes */ + g->GCmarked = 0; /* to count the number of added old1 bytes */ + finishgencycle(L, g); +} + + +/* +** Set debt for the next minor collection, which will happen when +** total number of bytes grows 'genminormul'% in relation to +** the base, GCmajorminor, which is the number of bytes being used +** after the last major collection. +*/ +static void setminordebt (global_State *g) { + luaE_setdebt(g, applygcparam(g, MINORMUL, g->GCmajorminor)); +} + + +/* +** Enter generational mode. Must go until the end of an atomic cycle +** to ensure that all objects are correctly marked and weak tables +** are cleared. Then, turn all objects into old and finishes the +** collection. +*/ +static void entergen (lua_State *L, global_State *g) { + luaC_runtilstate(L, GCSpause, 1); /* prepare to start a new cycle */ + luaC_runtilstate(L, GCSpropagate, 1); /* start new cycle */ + atomic(L); /* propagates all and then do the atomic stuff */ + atomic2gen(L, g); + setminordebt(g); /* set debt assuming next cycle will be minor */ +} + + +/* +** Change collector mode to 'newmode'. +*/ +void luaC_changemode (lua_State *L, int newmode) { + global_State *g = G(L); + if (g->gckind == KGC_GENMAJOR) /* doing major collections? */ + g->gckind = KGC_INC; /* already incremental but in name */ + if (newmode != g->gckind) { /* does it need to change? */ + if (newmode == KGC_INC) /* entering incremental mode? */ + minor2inc(L, g, KGC_INC); /* entering incremental mode */ + else { + lua_assert(newmode == KGC_GENMINOR); + entergen(L, g); + } + } +} + + +/* +** Does a full collection in generational mode. +*/ +static void fullgen (lua_State *L, global_State *g) { + minor2inc(L, g, KGC_INC); + entergen(L, g); +} + + +/* +** After an atomic incremental step from a major collection, +** check whether collector could return to minor collections. +** It checks whether the number of bytes 'tobecollected' +** is greater than 'majorminor'% of the number of bytes added +** since the last collection ('addedbytes'). +*/ +static int checkmajorminor (lua_State *L, global_State *g) { + if (g->gckind == KGC_GENMAJOR) { /* generational mode? */ + l_mem numbytes = gettotalbytes(g); + l_mem addedbytes = numbytes - g->GCmajorminor; + l_mem limit = applygcparam(g, MAJORMINOR, addedbytes); + l_mem tobecollected = numbytes - g->GCmarked; + if (tobecollected > limit) { + atomic2gen(L, g); /* return to generational mode */ + setminordebt(g); + return 1; /* exit incremental collection */ + } + } + g->GCmajorminor = g->GCmarked; /* prepare for next collection */ + return 0; /* stay doing incremental collections */ +} + +/* }====================================================== */ + + +/* +** {====================================================== +** GC control +** ======================================================= +*/ + + +/* +** Enter first sweep phase. +** The call to 'sweeptolive' makes the pointer point to an object +** inside the list (instead of to the header), so that the real sweep do +** not need to skip objects created between "now" and the start of the +** real sweep. +*/ +static void entersweep (lua_State *L) { + global_State *g = G(L); + g->gcstate = GCSswpallgc; + lua_assert(g->sweepgc == NULL); + g->sweepgc = sweeptolive(L, &g->allgc); +} + + +/* +** Delete all objects in list 'p' until (but not including) object +** 'limit'. +*/ +static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { + while (p != limit) { + GCObject *next = p->next; + freeobj(L, p); + p = next; + } +} + + +/* +** Call all finalizers of the objects in the given Lua state, and +** then free all objects, except for the main thread. +*/ +void luaC_freeallobjects (lua_State *L) { + global_State *g = G(L); + g->gcstp = GCSTPCLS; /* no extra finalizers after here */ + luaC_changemode(L, KGC_INC); + separatetobefnz(g, 1); /* separate all objects with finalizers */ + lua_assert(g->finobj == NULL); + callallpendingfinalizers(L); + deletelist(L, g->allgc, obj2gco(mainthread(g))); + lua_assert(g->finobj == NULL); /* no new finalizers */ + deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ + lua_assert(g->strt.nuse == 0); +} + + +static void atomic (lua_State *L) { + global_State *g = G(L); + GCObject *origweak, *origall; + GCObject *grayagain = g->grayagain; /* save original list */ + g->grayagain = NULL; + lua_assert(g->ephemeron == NULL && g->weak == NULL); + lua_assert(!iswhite(mainthread(g))); + g->gcstate = GCSatomic; + markobject(g, L); /* mark running thread */ + /* registry and global metatables may be changed by API */ + markvalue(g, &g->l_registry); + markmt(g); /* mark global metatables */ + propagateall(g); /* empties 'gray' list */ + /* remark occasional upvalues of (maybe) dead threads */ + remarkupvals(g); + propagateall(g); /* propagate changes */ + g->gray = grayagain; + propagateall(g); /* traverse 'grayagain' list */ + convergeephemerons(g); + /* at this point, all strongly accessible objects are marked. */ + /* Clear values from weak tables, before checking finalizers */ + clearbyvalues(g, g->weak, NULL); + clearbyvalues(g, g->allweak, NULL); + origweak = g->weak; origall = g->allweak; + separatetobefnz(g, 0); /* separate objects to be finalized */ + markbeingfnz(g); /* mark objects that will be finalized */ + propagateall(g); /* remark, to propagate 'resurrection' */ + convergeephemerons(g); + /* at this point, all resurrected objects are marked. */ + /* remove dead objects from weak tables */ + clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron */ + clearbykeys(g, g->allweak); /* clear keys from all 'allweak' */ + /* clear values from resurrected weak tables */ + clearbyvalues(g, g->weak, origweak); + clearbyvalues(g, g->allweak, origall); + luaS_clearcache(g); + g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ + lua_assert(g->gray == NULL); +} + + +/* +** Do a sweep step. The normal case (not fast) sweeps at most GCSWEEPMAX +** elements. The fast case sweeps the whole list. +*/ +static void sweepstep (lua_State *L, global_State *g, + lu_byte nextstate, GCObject **nextlist, int fast) { + if (g->sweepgc) + g->sweepgc = sweeplist(L, g->sweepgc, fast ? MAX_LMEM : GCSWEEPMAX); + else { /* enter next state */ + g->gcstate = nextstate; + g->sweepgc = nextlist; + } +} + + +/* +** Performs one incremental "step" in an incremental garbage collection. +** For indivisible work, a step goes to the next state. When marking +** (propagating), a step traverses one object. When sweeping, a step +** sweeps GCSWEEPMAX objects, to avoid a big overhead for sweeping +** objects one by one. (Sweeping is inexpensive, no matter the +** object.) When 'fast' is true, 'singlestep' tries to finish a state +** "as fast as possible". In particular, it skips the propagation +** phase and leaves all objects to be traversed by the atomic phase: +** That avoids traversing twice some objects, such as threads and +** weak tables. +*/ + +#define step2pause -3 /* finished collection; entered pause state */ +#define atomicstep -2 /* atomic step */ +#define step2minor -1 /* moved to minor collections */ + + +static l_mem singlestep (lua_State *L, int fast) { + global_State *g = G(L); + l_mem stepresult; + lua_assert(!g->gcstopem); /* collector is not reentrant */ + g->gcstopem = 1; /* no emergency collections while collecting */ + switch (g->gcstate) { + case GCSpause: { + restartcollection(g); + g->gcstate = GCSpropagate; + stepresult = 1; + break; + } + case GCSpropagate: { + if (fast || g->gray == NULL) { + g->gcstate = GCSenteratomic; /* finish propagate phase */ + stepresult = 1; + } + else + stepresult = propagatemark(g); /* traverse one gray object */ + break; + } + case GCSenteratomic: { + atomic(L); + if (checkmajorminor(L, g)) + stepresult = step2minor; + else { + entersweep(L); + stepresult = atomicstep; + } + break; + } + case GCSswpallgc: { /* sweep "regular" objects */ + sweepstep(L, g, GCSswpfinobj, &g->finobj, fast); + stepresult = GCSWEEPMAX; + break; + } + case GCSswpfinobj: { /* sweep objects with finalizers */ + sweepstep(L, g, GCSswptobefnz, &g->tobefnz, fast); + stepresult = GCSWEEPMAX; + break; + } + case GCSswptobefnz: { /* sweep objects to be finalized */ + sweepstep(L, g, GCSswpend, NULL, fast); + stepresult = GCSWEEPMAX; + break; + } + case GCSswpend: { /* finish sweeps */ + checkSizes(L, g); + g->gcstate = GCScallfin; + stepresult = GCSWEEPMAX; + break; + } + case GCScallfin: { /* call finalizers */ + if (g->tobefnz && !g->gcemergency && luaD_checkminstack(L)) { + g->gcstopem = 0; /* ok collections during finalizers */ + GCTM(L); /* call one finalizer */ + stepresult = CWUFIN; + } + else { /* no more finalizers or emergency mode or no enough stack + to run finalizers */ + g->gcstate = GCSpause; /* finish collection */ + stepresult = step2pause; + } + break; + } + default: lua_assert(0); return 0; + } + g->gcstopem = 0; + return stepresult; +} + + +/* +** Advances the garbage collector until it reaches the given state. +** (The option 'fast' is only for testing; in normal code, 'fast' +** here is always true.) +*/ +void luaC_runtilstate (lua_State *L, int state, int fast) { + global_State *g = G(L); + lua_assert(g->gckind == KGC_INC); + while (state != g->gcstate) + singlestep(L, fast); +} + + + +/* +** Performs a basic incremental step. The step size is +** converted from bytes to "units of work"; then the function loops +** running single steps until adding that many units of work or +** finishing a cycle (pause state). Finally, it sets the debt that +** controls when next step will be performed. +*/ +static void incstep (lua_State *L, global_State *g) { + l_mem stepsize = applygcparam(g, STEPSIZE, 100); + l_mem work2do = applygcparam(g, STEPMUL, stepsize / cast_int(sizeof(void*))); + l_mem stres; + int fast = (work2do == 0); /* special case: do a full collection */ + do { /* repeat until enough work */ + stres = singlestep(L, fast); /* perform one single step */ + if (stres == step2minor) /* returned to minor collections? */ + return; /* nothing else to be done here */ + else if (stres == step2pause || (stres == atomicstep && !fast)) + break; /* end of cycle or atomic */ + else + work2do -= stres; + } while (fast || work2do > 0); + if (g->gcstate == GCSpause) + setpause(g); /* pause until next cycle */ + else + luaE_setdebt(g, stepsize); +} + + +#if !defined(luai_tracegc) +#define luai_tracegc(L,f) ((void)0) +#endif + +/* +** Performs a basic GC step if collector is running. (If collector was +** stopped by the user, set a reasonable debt to avoid it being called +** at every single check.) +*/ +void luaC_step (lua_State *L) { + global_State *g = G(L); + lua_assert(!g->gcemergency); + if (!gcrunning(g)) { /* not running? */ + if (g->gcstp & GCSTPUSR) /* stopped by the user? */ + luaE_setdebt(g, 20000); + } + else { + luai_tracegc(L, 1); /* for internal debugging */ + switch (g->gckind) { + case KGC_INC: case KGC_GENMAJOR: + incstep(L, g); + break; + case KGC_GENMINOR: + youngcollection(L, g); + setminordebt(g); + break; + } + luai_tracegc(L, 0); /* for internal debugging */ + } +} + + +/* +** Perform a full collection in incremental mode. +** Before running the collection, check 'keepinvariant'; if it is true, +** there may be some objects marked as black, so the collector has +** to sweep all objects to turn them back to white (as white has not +** changed, nothing will be collected). +*/ +static void fullinc (lua_State *L, global_State *g) { + if (keepinvariant(g)) /* black objects? */ + entersweep(L); /* sweep everything to turn them back to white */ + /* finish any pending sweep phase to start a new cycle */ + luaC_runtilstate(L, GCSpause, 1); + luaC_runtilstate(L, GCScallfin, 1); /* run up to finalizers */ + luaC_runtilstate(L, GCSpause, 1); /* finish collection */ + setpause(g); +} + + +/* +** Performs a full GC cycle; if 'isemergency', set a flag to avoid +** some operations which could change the interpreter state in some +** unexpected ways (running finalizers and shrinking some structures). +*/ +void luaC_fullgc (lua_State *L, int isemergency) { + global_State *g = G(L); + lua_assert(!g->gcemergency); + g->gcemergency = cast_byte(isemergency); /* set flag */ + switch (g->gckind) { + case KGC_GENMINOR: fullgen(L, g); break; + case KGC_INC: fullinc(L, g); break; + case KGC_GENMAJOR: + g->gckind = KGC_INC; + fullinc(L, g); + g->gckind = KGC_GENMAJOR; + break; + } + g->gcemergency = 0; +} + +/* }====================================================== */ + + diff --git a/source/external/lua/lib/linux/liblua.a b/source/external/lua/lib/linux/liblua.a deleted file mode 100644 index 6282335a56cc9ff0f5d1447d8519353d90556ad2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 606438 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

h^_1g523R?8s>4llMmXNjS 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

(boZ}_-^DJfRj1v_5@QhQw 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

l#GQh6+V5^5UTzc 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

0}6dYoQUOeqk9R9j@UE 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 z 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 U#AnD>CL+`((S}2)t!eoG1<_zdPXGV_ diff --git a/source/external/lua/linit.c b/source/external/lua/linit.c new file mode 100644 index 0000000..00d06f7 --- /dev/null +++ b/source/external/lua/linit.c @@ -0,0 +1,63 @@ +/* +** $Id: linit.c $ +** Initialization of libraries for lua.c and other clients +** See Copyright Notice in lua.h +*/ + + +#define linit_c +#define LUA_LIB + + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "lualib.h" +#include "lauxlib.h" +#include "llimits.h" + + +/* +** Standard Libraries. (Must be listed in the same ORDER of their +** respective constants LUA_K.) +*/ +static const luaL_Reg stdlibs[] = { + {LUA_GNAME, luaopen_base}, + {LUA_LOADLIBNAME, luaopen_package}, + {LUA_COLIBNAME, luaopen_coroutine}, + {LUA_DBLIBNAME, luaopen_debug}, + {LUA_IOLIBNAME, luaopen_io}, + {LUA_MATHLIBNAME, luaopen_math}, + {LUA_OSLIBNAME, luaopen_os}, + {LUA_STRLIBNAME, luaopen_string}, + {LUA_TABLIBNAME, luaopen_table}, + {LUA_UTF8LIBNAME, luaopen_utf8}, + {NULL, NULL} +}; + + +/* +** require and preload selected standard libraries +*/ +LUALIB_API void luaL_openselectedlibs (lua_State *L, int load, int preload) { + int mask; + const luaL_Reg *lib; + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); + for (lib = stdlibs, mask = 1; lib->name != NULL; lib++, mask <<= 1) { + if (load & mask) { /* selected? */ + luaL_requiref(L, lib->name, lib->func, 1); /* require library */ + lua_pop(L, 1); /* remove result from the stack */ + } + else if (preload & mask) { /* selected? */ + lua_pushcfunction(L, lib->func); + lua_setfield(L, -2, lib->name); /* add library to PRELOAD table */ + } + } + lua_assert((mask >> 1) == LUA_UTF8LIBK); + lua_pop(L, 1); /* remove PRELOAD table */ +} + diff --git a/source/external/lua/liolib.c b/source/external/lua/liolib.c new file mode 100644 index 0000000..57615e6 --- /dev/null +++ b/source/external/lua/liolib.c @@ -0,0 +1,841 @@ +/* +** $Id: liolib.c $ +** Standard I/O (and system) library +** See Copyright Notice in lua.h +*/ + +#define liolib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** Change this macro to accept other modes for 'fopen' besides +** 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]*' */ +static int l_checkmode (const char *mode) { + return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL && + (*mode != '+' || ((void)(++mode), 1)) && /* skip if char is '+' */ + (strspn(mode, L_MODEEXT) == strlen(mode))); /* check extensions */ +} + +#endif + +/* +** {====================================================== +** l_popen spawns a new process connected to the current +** one through the file streams. +** ======================================================= +*/ + +#if !defined(l_popen) /* { */ + +#if defined(LUA_USE_POSIX) /* { */ + +#define l_popen(L,c,m) (fflush(NULL), popen(c,m)) +#define l_pclose(L,file) (pclose(file)) + +#elif defined(LUA_USE_WINDOWS) /* }{ */ + +#define l_popen(L,c,m) (_popen(c,m)) +#define l_pclose(L,file) (_pclose(file)) + +#if !defined(l_checkmodep) +/* Windows accepts "[rw][bt]?" as valid modes */ +#define l_checkmodep(m) ((m[0] == 'r' || m[0] == 'w') && \ + (m[1] == '\0' || ((m[1] == 'b' || m[1] == 't') && m[2] == '\0'))) +#endif + +#else /* }{ */ + +/* ISO C definitions */ +#define l_popen(L,c,m) \ + ((void)c, (void)m, \ + luaL_error(L, "'popen' not supported"), \ + (FILE*)0) +#define l_pclose(L,file) ((void)L, (void)file, -1) + +#endif /* } */ + +#endif /* } */ + + +#if !defined(l_checkmodep) +/* By default, Lua accepts only "r" or "w" as valid modes */ +#define l_checkmodep(m) ((m[0] == 'r' || m[0] == 'w') && m[1] == '\0') +#endif + +/* }====================================================== */ + + +#if !defined(l_getc) /* { */ + +#if defined(LUA_USE_POSIX) +#define l_getc(f) getc_unlocked(f) +#define l_lockfile(f) flockfile(f) +#define l_unlockfile(f) funlockfile(f) +#else +#define l_getc(f) getc(f) +#define l_lockfile(f) ((void)0) +#define l_unlockfile(f) ((void)0) +#endif + +#endif /* } */ + + +/* +** {====================================================== +** l_fseek: configuration for longer offsets +** ======================================================= +*/ + +#if !defined(l_fseek) /* { */ + +#if defined(LUA_USE_POSIX) || defined(LUA_USE_OFF_T) /* { */ + +#include + +#define l_fseek(f,o,w) fseeko(f,o,w) +#define l_ftell(f) ftello(f) +#define l_seeknum off_t + +#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \ + && defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */ + +/* Windows (but not DDK) and Visual C++ 2005 or higher */ +#define l_fseek(f,o,w) _fseeki64(f,o,w) +#define l_ftell(f) _ftelli64(f) +#define l_seeknum __int64 + +#else /* }{ */ + +/* ISO C definitions */ +#define l_fseek(f,o,w) fseek(f,o,w) +#define l_ftell(f) ftell(f) +#define l_seeknum long + +#endif /* } */ + +#endif /* } */ + +/* }====================================================== */ + + + +#define IO_PREFIX "_IO_" +#define IOPREF_LEN (sizeof(IO_PREFIX)/sizeof(char) - 1) +#define IO_INPUT (IO_PREFIX "input") +#define IO_OUTPUT (IO_PREFIX "output") + + +typedef luaL_Stream LStream; + + +#define tolstream(L) ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE)) + +#define isclosed(p) ((p)->closef == NULL) + + +static int io_type (lua_State *L) { + LStream *p; + luaL_checkany(L, 1); + p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE); + if (p == NULL) + luaL_pushfail(L); /* not a file */ + else if (isclosed(p)) + lua_pushliteral(L, "closed file"); + else + lua_pushliteral(L, "file"); + return 1; +} + + +static int f_tostring (lua_State *L) { + LStream *p = tolstream(L); + if (isclosed(p)) + lua_pushliteral(L, "file (closed)"); + else + lua_pushfstring(L, "file (%p)", p->f); + return 1; +} + + +static FILE *tofile (lua_State *L) { + LStream *p = tolstream(L); + if (l_unlikely(isclosed(p))) + luaL_error(L, "attempt to use a closed file"); + lua_assert(p->f); + return p->f; +} + + +/* +** When creating file handles, always creates a 'closed' file handle +** before opening the actual file; so, if there is a memory error, the +** handle is in a consistent state. +*/ +static LStream *newprefile (lua_State *L) { + LStream *p = (LStream *)lua_newuserdatauv(L, sizeof(LStream), 0); + p->closef = NULL; /* mark file handle as 'closed' */ + luaL_setmetatable(L, LUA_FILEHANDLE); + return p; +} + + +/* +** Calls the 'close' function from a file handle. The 'volatile' avoids +** a bug in some versions of the Clang compiler (e.g., clang 3.0 for +** 32 bits). +*/ +static int aux_close (lua_State *L) { + LStream *p = tolstream(L); + volatile lua_CFunction cf = p->closef; + p->closef = NULL; /* mark stream as closed */ + return (*cf)(L); /* close it */ +} + + +static int f_close (lua_State *L) { + tofile(L); /* make sure argument is an open stream */ + return aux_close(L); +} + + +static int io_close (lua_State *L) { + if (lua_isnone(L, 1)) /* no argument? */ + lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT); /* use default output */ + return f_close(L); +} + + +static int f_gc (lua_State *L) { + LStream *p = tolstream(L); + if (!isclosed(p) && p->f != NULL) + aux_close(L); /* ignore closed and incompletely open files */ + return 0; +} + + +/* +** function to close regular files +*/ +static int io_fclose (lua_State *L) { + LStream *p = tolstream(L); + errno = 0; + return luaL_fileresult(L, (fclose(p->f) == 0), NULL); +} + + +static LStream *newfile (lua_State *L) { + LStream *p = newprefile(L); + p->f = NULL; + p->closef = &io_fclose; + return p; +} + + +static void opencheck (lua_State *L, const char *fname, const char *mode) { + LStream *p = newfile(L); + p->f = fopen(fname, mode); + if (l_unlikely(p->f == NULL)) + luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno)); +} + + +static int io_open (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + const char *mode = luaL_optstring(L, 2, "r"); + LStream *p = newfile(L); + const char *md = mode; /* to traverse/check mode */ + luaL_argcheck(L, l_checkmode(md), 2, "invalid mode"); + errno = 0; + p->f = fopen(filename, mode); + return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; +} + + +/* +** function to close 'popen' files +*/ +static int io_pclose (lua_State *L) { + LStream *p = tolstream(L); + errno = 0; + return luaL_execresult(L, l_pclose(L, p->f)); +} + + +static int io_popen (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + const char *mode = luaL_optstring(L, 2, "r"); + LStream *p = newprefile(L); + luaL_argcheck(L, l_checkmodep(mode), 2, "invalid mode"); + errno = 0; + p->f = l_popen(L, filename, mode); + p->closef = &io_pclose; + return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1; +} + + +static int io_tmpfile (lua_State *L) { + LStream *p = newfile(L); + errno = 0; + p->f = tmpfile(); + return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1; +} + + +static FILE *getiofile (lua_State *L, const char *findex) { + LStream *p; + lua_getfield(L, LUA_REGISTRYINDEX, findex); + p = (LStream *)lua_touserdata(L, -1); + if (l_unlikely(isclosed(p))) + luaL_error(L, "default %s file is closed", findex + IOPREF_LEN); + return p->f; +} + + +static int g_iofile (lua_State *L, const char *f, const char *mode) { + if (!lua_isnoneornil(L, 1)) { + const char *filename = lua_tostring(L, 1); + if (filename) + opencheck(L, filename, mode); + else { + tofile(L); /* check that it's a valid file handle */ + lua_pushvalue(L, 1); + } + lua_setfield(L, LUA_REGISTRYINDEX, f); + } + /* return current value */ + lua_getfield(L, LUA_REGISTRYINDEX, f); + return 1; +} + + +static int io_input (lua_State *L) { + return g_iofile(L, IO_INPUT, "r"); +} + + +static int io_output (lua_State *L) { + return g_iofile(L, IO_OUTPUT, "w"); +} + + +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 + +/* +** Auxiliary function to create the iteration function for 'lines'. +** The iteration function is a closure over 'io_readline', with +** the following upvalues: +** 1) The file being read (first value in the stack) +** 2) the number of arguments to read +** 3) a boolean, true iff file has to be closed when finished ('toclose') +** *) a variable number of format arguments (rest of the stack) +*/ +static void aux_lines (lua_State *L, int toclose) { + int n = lua_gettop(L) - 1; /* number of arguments to read */ + luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments"); + lua_pushvalue(L, 1); /* file */ + lua_pushinteger(L, n); /* number of arguments to read */ + lua_pushboolean(L, toclose); /* close/not close file when finished */ + lua_rotate(L, 2, 3); /* move the three values to their positions */ + lua_pushcclosure(L, io_readline, 3 + n); +} + + +static int f_lines (lua_State *L) { + tofile(L); /* check that it's a valid file handle */ + aux_lines(L, 0); + return 1; +} + + +/* +** Return an iteration function for 'io.lines'. If file has to be +** closed, also returns the file itself as a second result (to be +** closed as the state at the exit of a generic for). +*/ +static int io_lines (lua_State *L) { + int toclose; + if (lua_isnone(L, 1)) lua_pushnil(L); /* at least one argument */ + if (lua_isnil(L, 1)) { /* no file name? */ + lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT); /* get default input */ + lua_replace(L, 1); /* put it at index 1 */ + tofile(L); /* check that it's a valid file handle */ + toclose = 0; /* do not close it after iteration */ + } + else { /* open a new file */ + const char *filename = luaL_checkstring(L, 1); + opencheck(L, filename, "r"); + lua_replace(L, 1); /* put file at index 1 */ + toclose = 1; /* close it after iteration */ + } + aux_lines(L, toclose); /* push iteration function */ + if (toclose) { + lua_pushnil(L); /* state */ + lua_pushnil(L); /* control */ + lua_pushvalue(L, 1); /* file is the to-be-closed variable (4th result) */ + return 4; + } + else + return 1; +} + + +/* +** {====================================================== +** READ +** ======================================================= +*/ + + +/* maximum length of a numeral */ +#if !defined (L_MAXLENNUM) +#define L_MAXLENNUM 200 +#endif + + +/* auxiliary structure used by 'read_number' */ +typedef struct { + FILE *f; /* file being read */ + int c; /* current character (look ahead) */ + int n; /* number of elements in buffer 'buff' */ + char buff[L_MAXLENNUM + 1]; /* +1 for ending '\0' */ +} RN; + + +/* +** Add current char to buffer (if not out of space) and read next one +*/ +static int nextc (RN *rn) { + if (l_unlikely(rn->n >= L_MAXLENNUM)) { /* buffer overflow? */ + rn->buff[0] = '\0'; /* invalidate result */ + return 0; /* fail */ + } + else { + rn->buff[rn->n++] = cast_char(rn->c); /* save current char */ + rn->c = l_getc(rn->f); /* read next one */ + return 1; + } +} + + +/* +** Accept current char if it is in 'set' (of size 2) +*/ +static int test2 (RN *rn, const char *set) { + if (rn->c == set[0] || rn->c == set[1]) + return nextc(rn); + else return 0; +} + + +/* +** Read a sequence of (hex)digits +*/ +static int readdigits (RN *rn, int hex) { + int count = 0; + while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn)) + count++; + return count; +} + + +/* +** Read a number: first reads a valid prefix of a numeral into a buffer. +** Then it calls 'lua_stringtonumber' to check whether the format is +** correct and to convert it to a Lua number. +*/ +static int read_number (lua_State *L, FILE *f) { + RN rn; + int count = 0; + int hex = 0; + char decp[2]; + rn.f = f; rn.n = 0; + decp[0] = lua_getlocaledecpoint(); /* get decimal point from locale */ + decp[1] = '.'; /* always accept a dot */ + l_lockfile(rn.f); + do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */ + test2(&rn, "-+"); /* optional sign */ + if (test2(&rn, "00")) { + if (test2(&rn, "xX")) hex = 1; /* numeral is hexadecimal */ + else count = 1; /* count initial '0' as a valid digit */ + } + count += readdigits(&rn, hex); /* integral part */ + if (test2(&rn, decp)) /* decimal point? */ + count += readdigits(&rn, hex); /* fractional part */ + if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) { /* exponent mark? */ + test2(&rn, "-+"); /* exponent sign */ + readdigits(&rn, 0); /* exponent digits */ + } + ungetc(rn.c, rn.f); /* unread look-ahead char */ + l_unlockfile(rn.f); + rn.buff[rn.n] = '\0'; /* finish string */ + if (l_likely(lua_stringtonumber(L, rn.buff))) + return 1; /* ok, it is a valid number */ + else { /* invalid format */ + lua_pushnil(L); /* "result" to be removed */ + return 0; /* read fails */ + } +} + + +static int test_eof (lua_State *L, FILE *f) { + int c = getc(f); + ungetc(c, f); /* no-op when c == EOF */ + lua_pushliteral(L, ""); + return (c != EOF); +} + + +static int read_line (lua_State *L, FILE *f, int chop) { + luaL_Buffer b; + int c; + luaL_buffinit(L, &b); + do { /* may need to read several chunks to get whole line */ + char *buff = luaL_prepbuffer(&b); /* preallocate buffer space */ + unsigned i = 0; + l_lockfile(f); /* no memory errors can happen inside the lock */ + while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n') + buff[i++] = cast_char(c); /* read up to end of line or buffer limit */ + l_unlockfile(f); + luaL_addsize(&b, i); + } while (c != EOF && c != '\n'); /* repeat until end of line */ + if (!chop && c == '\n') /* want a newline and have one? */ + luaL_addchar(&b, '\n'); /* add ending newline to result */ + luaL_pushresult(&b); /* close buffer */ + /* return ok if read something (either a newline or something else) */ + return (c == '\n' || lua_rawlen(L, -1) > 0); +} + + +static void read_all (lua_State *L, FILE *f) { + size_t nr; + luaL_Buffer b; + luaL_buffinit(L, &b); + do { /* read file in chunks of LUAL_BUFFERSIZE bytes */ + char *p = luaL_prepbuffer(&b); + nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f); + luaL_addsize(&b, nr); + } while (nr == LUAL_BUFFERSIZE); + luaL_pushresult(&b); /* close buffer */ +} + + +static int read_chars (lua_State *L, FILE *f, size_t n) { + size_t nr; /* number of chars actually read */ + char *p; + luaL_Buffer b; + luaL_buffinit(L, &b); + p = luaL_prepbuffsize(&b, n); /* prepare buffer to read whole block */ + nr = fread(p, sizeof(char), n, f); /* try to read 'n' chars */ + luaL_addsize(&b, nr); + luaL_pushresult(&b); /* close buffer */ + return (nr > 0); /* true iff read something */ +} + + +static int g_read (lua_State *L, FILE *f, int first) { + int nargs = lua_gettop(L) - 1; + int n, success; + clearerr(f); + errno = 0; + if (nargs == 0) { /* no arguments? */ + success = read_line(L, f, 1); + n = first + 1; /* to return 1 result */ + } + else { + /* ensure stack space for all results and for auxlib's buffer */ + luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments"); + success = 1; + for (n = first; nargs-- && success; n++) { + if (lua_type(L, n) == LUA_TNUMBER) { + size_t l = (size_t)luaL_checkinteger(L, n); + success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l); + } + else { + const char *p = luaL_checkstring(L, n); + if (*p == '*') p++; /* skip optional '*' (for compatibility) */ + switch (*p) { + case 'n': /* number */ + success = read_number(L, f); + break; + case 'l': /* line */ + success = read_line(L, f, 1); + break; + case 'L': /* line with end-of-line */ + success = read_line(L, f, 0); + break; + case 'a': /* file */ + read_all(L, f); /* read entire file */ + success = 1; /* always success */ + break; + default: + return luaL_argerror(L, n, "invalid format"); + } + } + } + } + if (ferror(f)) + return luaL_fileresult(L, 0, NULL); + if (!success) { + lua_pop(L, 1); /* remove last result */ + luaL_pushfail(L); /* push nil instead */ + } + return n - first; +} + + +static int io_read (lua_State *L) { + return g_read(L, getiofile(L, IO_INPUT), 1); +} + + +static int f_read (lua_State *L) { + return g_read(L, tofile(L), 2); +} + + +/* +** Iteration function for 'lines'. +*/ +static int io_readline (lua_State *L) { + LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1)); + int i; + int n = (int)lua_tointeger(L, lua_upvalueindex(2)); + if (isclosed(p)) /* file is already closed? */ + return luaL_error(L, "file is already closed"); + lua_settop(L , 1); + luaL_checkstack(L, n, "too many arguments"); + for (i = 1; i <= n; i++) /* push arguments to 'g_read' */ + lua_pushvalue(L, lua_upvalueindex(3 + i)); + n = g_read(L, p->f, 2); /* 'n' is number of results */ + lua_assert(n > 0); /* should return at least a nil */ + if (lua_toboolean(L, -n)) /* read at least one value? */ + return n; /* return them */ + else { /* first result is false: EOF or error */ + if (n > 1) { /* is there error information? */ + /* 2nd result is error message */ + return luaL_error(L, "%s", lua_tostring(L, -n + 1)); + } + if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */ + lua_settop(L, 0); /* clear stack */ + lua_pushvalue(L, lua_upvalueindex(1)); /* push file at index 1 */ + aux_close(L); /* close it */ + } + return 0; + } +} + +/* }====================================================== */ + + +static int g_write (lua_State *L, FILE *f, int arg) { + int nargs = lua_gettop(L) - arg; + size_t totalbytes = 0; /* total number of bytes written */ + errno = 0; + for (; nargs--; arg++) { /* for each argument */ + char buff[LUA_N2SBUFFSZ]; + const char *s; + size_t numbytes; /* bytes written in one call to 'fwrite' */ + size_t len = lua_numbertocstring(L, arg, buff); /* try as a number */ + if (len > 0) { /* did conversion work (value was a number)? */ + s = buff; + len--; + } + else /* must be a string */ + s = luaL_checklstring(L, arg, &len); + numbytes = fwrite(s, sizeof(char), len, f); + totalbytes += numbytes; + if (numbytes < len) { /* write error? */ + int n = luaL_fileresult(L, 0, NULL); + lua_pushinteger(L, cast_st2S(totalbytes)); + return n + 1; /* return fail, error msg., error code, and counter */ + } + } + return 1; /* no errors; file handle already on stack top */ +} + + +static int io_write (lua_State *L) { + return g_write(L, getiofile(L, IO_OUTPUT), 1); +} + + +static int f_write (lua_State *L) { + FILE *f = tofile(L); + lua_pushvalue(L, 1); /* push file at the stack top (to be returned) */ + return g_write(L, f, 2); +} + + +static int f_seek (lua_State *L) { + static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; + static const char *const modenames[] = {"set", "cur", "end", NULL}; + FILE *f = tofile(L); + int op = luaL_checkoption(L, 2, "cur", modenames); + lua_Integer p3 = luaL_optinteger(L, 3, 0); + l_seeknum offset = (l_seeknum)p3; + luaL_argcheck(L, (lua_Integer)offset == p3, 3, + "not an integer in proper range"); + errno = 0; + op = l_fseek(f, offset, mode[op]); + if (l_unlikely(op)) + return luaL_fileresult(L, 0, NULL); /* error */ + else { + lua_pushinteger(L, (lua_Integer)l_ftell(f)); + return 1; + } +} + + +static int f_setvbuf (lua_State *L) { + static const int mode[] = {_IONBF, _IOFBF, _IOLBF}; + static const char *const modenames[] = {"no", "full", "line", NULL}; + FILE *f = tofile(L); + int op = luaL_checkoption(L, 2, NULL, modenames); + lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE); + int res; + errno = 0; + res = setvbuf(f, NULL, mode[op], (size_t)sz); + return luaL_fileresult(L, res == 0, NULL); +} + + +static int aux_flush (lua_State *L, FILE *f) { + errno = 0; + return luaL_fileresult(L, fflush(f) == 0, NULL); +} + + +static int f_flush (lua_State *L) { + return aux_flush(L, tofile(L)); +} + + +static int io_flush (lua_State *L) { + return aux_flush(L, getiofile(L, IO_OUTPUT)); +} + + +/* +** functions for 'io' library +*/ +static const luaL_Reg iolib[] = { + {"close", io_close}, + {"flush", io_flush}, + {"input", io_input}, + {"lines", io_lines}, + {"open", io_open}, + {"output", io_output}, + {"popen", io_popen}, + {"read", io_read}, + {"tmpfile", io_tmpfile}, + {"type", io_type}, + {"write", io_write}, + {NULL, NULL} +}; + + +/* +** methods for file handles +*/ +static const luaL_Reg meth[] = { + {"read", f_read}, + {"write", f_write}, + {"lines", f_lines}, + {"flush", f_flush}, + {"seek", f_seek}, + {"close", f_close}, + {"setvbuf", f_setvbuf}, + {NULL, NULL} +}; + + +/* +** metamethods for file handles +*/ +static const luaL_Reg metameth[] = { + {"__index", NULL}, /* placeholder */ + {"__gc", f_gc}, + {"__close", f_gc}, + {"__tostring", f_tostring}, + {NULL, NULL} +}; + + +static void createmeta (lua_State *L) { + luaL_newmetatable(L, LUA_FILEHANDLE); /* metatable for file handles */ + luaL_setfuncs(L, metameth, 0); /* add metamethods to new metatable */ + luaL_newlibtable(L, meth); /* create method table */ + luaL_setfuncs(L, meth, 0); /* add file methods to method table */ + lua_setfield(L, -2, "__index"); /* metatable.__index = method table */ + lua_pop(L, 1); /* pop metatable */ +} + + +/* +** function to (not) close the standard files stdin, stdout, and stderr +*/ +static int io_noclose (lua_State *L) { + LStream *p = tolstream(L); + p->closef = &io_noclose; /* keep file opened */ + luaL_pushfail(L); + lua_pushliteral(L, "cannot close standard file"); + return 2; +} + + +static void createstdfile (lua_State *L, FILE *f, const char *k, + const char *fname) { + LStream *p = newprefile(L); + p->f = f; + p->closef = &io_noclose; + if (k != NULL) { + lua_pushvalue(L, -1); + lua_setfield(L, LUA_REGISTRYINDEX, k); /* add file to registry */ + } + lua_setfield(L, -2, fname); /* add file to module */ +} + + +LUAMOD_API int luaopen_io (lua_State *L) { + luaL_newlib(L, iolib); /* new module */ + createmeta(L); + /* create (and set) default files */ + createstdfile(L, stdin, IO_INPUT, "stdin"); + createstdfile(L, stdout, IO_OUTPUT, "stdout"); + createstdfile(L, stderr, NULL, "stderr"); + return 1; +} + diff --git a/source/external/lua/llex.c b/source/external/lua/llex.c new file mode 100644 index 0000000..f8bb3ea --- /dev/null +++ b/source/external/lua/llex.c @@ -0,0 +1,604 @@ +/* +** $Id: llex.c $ +** Lexical Analyzer +** See Copyright Notice in lua.h +*/ + +#define llex_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include + +#include "lua.h" + +#include "lctype.h" +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "llex.h" +#include "lobject.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "lzio.h" + + + +#define next(ls) (ls->current = zgetc(ls->z)) + + +/* minimum size for string buffer */ +#if !defined(LUA_MINBUFFER) +#define LUA_MINBUFFER 32 +#endif + + +#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') + + +/* ORDER RESERVED */ +static const char *const luaX_tokens [] = { + "and", "break", "do", "else", "elseif", + "end", "false", "for", "function", "global", "goto", "if", + "in", "local", "nil", "not", "or", "repeat", + "return", "then", "true", "until", "while", + "//", "..", "...", "==", ">=", "<=", "~=", + "<<", ">>", "::", "", + "", "", "", "" +}; + + +#define save_and_next(ls) (save(ls, ls->current), next(ls)) + + +static l_noret lexerror (LexState *ls, const char *msg, int token); + + +static void save (LexState *ls, int c) { + Mbuffer *b = ls->buff; + if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { + size_t newsize = luaZ_sizebuffer(b); /* get old size */; + if (newsize >= (MAX_SIZE/3 * 2)) /* larger than MAX_SIZE/1.5 ? */ + lexerror(ls, "lexical element too long", 0); + newsize += (newsize >> 1); /* new size is 1.5 times the old one */ + luaZ_resizebuffer(ls->L, b, newsize); + } + b->buffer[luaZ_bufflen(b)++] = cast_char(c); +} + + +void luaX_init (lua_State *L) { + int i; + TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ + luaC_fix(L, obj2gco(e)); /* never collect this name */ + for (i=0; iextra = cast_byte(i+1); /* reserved word */ + } +} + + +const char *luaX_token2str (LexState *ls, int token) { + if (token < FIRST_RESERVED) { /* single-byte symbols? */ + if (lisprint(token)) + return luaO_pushfstring(ls->L, "'%c'", token); + else /* control character */ + return luaO_pushfstring(ls->L, "'<\\%d>'", token); + } + else { + const char *s = luaX_tokens[token - FIRST_RESERVED]; + if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ + return luaO_pushfstring(ls->L, "'%s'", s); + else /* names, strings, and numerals */ + return s; + } +} + + +static const char *txtToken (LexState *ls, int token) { + switch (token) { + case TK_NAME: case TK_STRING: + case TK_FLT: case TK_INT: + save(ls, '\0'); + return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); + default: + return luaX_token2str(ls, token); + } +} + + +static l_noret lexerror (LexState *ls, const char *msg, int token) { + msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); + if (token) + luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); + luaD_throw(ls->L, LUA_ERRSYNTAX); +} + + +l_noret luaX_syntaxerror (LexState *ls, const char *msg) { + lexerror(ls, msg, ls->t.token); +} + + +/* +** Anchors a string in scanner's table so that it will not be collected +** until the end of the compilation; by that time it should be anchored +** somewhere. It also internalizes long strings, ensuring there is only +** one copy of each unique string. +*/ +static TString *anchorstr (LexState *ls, TString *ts) { + lua_State *L = ls->L; + TValue oldts; + int tag = luaH_getstr(ls->h, ts, &oldts); + if (!tagisempty(tag)) /* string already present? */ + return tsvalue(&oldts); /* use stored value */ + else { /* create a new entry */ + TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ + setsvalue(L, stv, ts); /* push (anchor) the string on the stack */ + luaH_set(L, ls->h, stv, stv); /* t[string] = string */ + /* table is not a metatable, so it does not need to invalidate cache */ + luaC_checkGC(L); + L->top.p--; /* remove string from stack */ + return ts; + } +} + + +/* +** Creates a new string and anchors it in scanner's table. +*/ +TString *luaX_newstring (LexState *ls, const char *str, size_t l) { + return anchorstr(ls, luaS_newlstr(ls->L, str, l)); +} + + +/* +** increment line number and skips newline sequence (any of +** \n, \r, \n\r, or \r\n) +*/ +static void inclinenumber (LexState *ls) { + int old = ls->current; + lua_assert(currIsNewline(ls)); + next(ls); /* skip '\n' or '\r' */ + if (currIsNewline(ls) && ls->current != old) + next(ls); /* skip '\n\r' or '\r\n' */ + if (++ls->linenumber >= INT_MAX) + lexerror(ls, "chunk has too many lines", 0); +} + + +void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, + int firstchar) { + ls->t.token = 0; + ls->L = L; + ls->current = firstchar; + ls->lookahead.token = TK_EOS; /* no look-ahead token */ + ls->z = z; + ls->fs = NULL; + ls->linenumber = 1; + ls->lastline = 1; + ls->source = source; + /* all three strings here ("_ENV", "break", "global") were fixed, + so they cannot be collected */ + ls->envn = luaS_newliteral(L, LUA_ENV); /* get env string */ + ls->brkn = luaS_newliteral(L, "break"); /* get "break" string */ +#if defined(LUA_COMPAT_GLOBAL) + /* compatibility mode: "global" is not a reserved word */ + ls->glbn = luaS_newliteral(L, "global"); /* get "global" string */ + ls->glbn->extra = 0; /* mark it as not reserved */ +#endif + luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ +} + + + +/* +** ======================================================= +** LEXICAL ANALYZER +** ======================================================= +*/ + + +static int check_next1 (LexState *ls, int c) { + if (ls->current == c) { + next(ls); + return 1; + } + else return 0; +} + + +/* +** Check whether current char is in set 'set' (with two chars) and +** saves it +*/ +static int check_next2 (LexState *ls, const char *set) { + lua_assert(set[2] == '\0'); + if (ls->current == set[0] || ls->current == set[1]) { + save_and_next(ls); + return 1; + } + else return 0; +} + + +/* LUA_NUMBER */ +/* +** This function is quite liberal in what it accepts, as 'luaO_str2num' +** will reject ill-formed numerals. Roughly, it accepts the following +** pattern: +** +** %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))* +** +** The only tricky part is to accept [+-] only after a valid exponent +** mark, to avoid reading '3-4' or '0xe+1' as a single number. +** +** The caller might have already read an initial dot. +*/ +static int read_numeral (LexState *ls, SemInfo *seminfo) { + TValue obj; + const char *expo = "Ee"; + int first = ls->current; + lua_assert(lisdigit(ls->current)); + save_and_next(ls); + if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ + expo = "Pp"; + for (;;) { + if (check_next2(ls, expo)) /* exponent mark? */ + check_next2(ls, "-+"); /* optional exponent sign */ + else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ + save_and_next(ls); + else break; + } + if (lislalpha(ls->current)) /* is numeral touching a letter? */ + save_and_next(ls); /* force an error */ + save(ls, '\0'); + if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ + lexerror(ls, "malformed number", TK_FLT); + if (ttisinteger(&obj)) { + seminfo->i = ivalue(&obj); + return TK_INT; + } + else { + lua_assert(ttisfloat(&obj)); + seminfo->r = fltvalue(&obj); + return TK_FLT; + } +} + + +/* +** read a sequence '[=*[' or ']=*]', leaving the last bracket. If +** sequence is well formed, return its number of '='s + 2; otherwise, +** return 1 if it is a single bracket (no '='s and no 2nd bracket); +** otherwise (an unfinished '[==...') return 0. +*/ +static size_t skip_sep (LexState *ls) { + size_t count = 0; + int s = ls->current; + lua_assert(s == '[' || s == ']'); + save_and_next(ls); + while (ls->current == '=') { + save_and_next(ls); + count++; + } + return (ls->current == s) ? count + 2 + : (count == 0) ? 1 + : 0; +} + + +static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { + int line = ls->linenumber; /* initial line (for error message) */ + save_and_next(ls); /* skip 2nd '[' */ + if (currIsNewline(ls)) /* string starts with a newline? */ + inclinenumber(ls); /* skip it */ + for (;;) { + switch (ls->current) { + case EOZ: { /* error */ + const char *what = (seminfo ? "string" : "comment"); + const char *msg = luaO_pushfstring(ls->L, + "unfinished long %s (starting at line %d)", what, line); + lexerror(ls, msg, TK_EOS); + break; /* to avoid warnings */ + } + case ']': { + if (skip_sep(ls) == sep) { + save_and_next(ls); /* skip 2nd ']' */ + goto endloop; + } + break; + } + case '\n': case '\r': { + save(ls, '\n'); + inclinenumber(ls); + if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ + break; + } + default: { + if (seminfo) save_and_next(ls); + else next(ls); + } + } + } endloop: + if (seminfo) + seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, + luaZ_bufflen(ls->buff) - 2 * sep); +} + + +static void esccheck (LexState *ls, int c, const char *msg) { + if (!c) { + if (ls->current != EOZ) + save_and_next(ls); /* add current to buffer for error message */ + lexerror(ls, msg, TK_STRING); + } +} + + +static int gethexa (LexState *ls) { + save_and_next(ls); + esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); + return luaO_hexavalue(ls->current); +} + + +static int readhexaesc (LexState *ls) { + int r = gethexa(ls); + r = (r << 4) + gethexa(ls); + luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ + return r; +} + + +/* +** When reading a UTF-8 escape sequence, save everything to the buffer +** for error reporting in case of errors; 'i' counts the number of +** saved characters, so that they can be removed if case of success. +*/ +static l_uint32 readutf8esc (LexState *ls) { + l_uint32 r; + int i = 4; /* number of chars to be removed: start with #"\u{X" */ + save_and_next(ls); /* skip 'u' */ + esccheck(ls, ls->current == '{', "missing '{'"); + r = cast_uint(gethexa(ls)); /* must have at least one digit */ + while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { + i++; + esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); + r = (r << 4) + luaO_hexavalue(ls->current); + } + esccheck(ls, ls->current == '}', "missing '}'"); + next(ls); /* skip '}' */ + luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ + return r; +} + + +static void utf8esc (LexState *ls) { + char buff[UTF8BUFFSZ]; + int n = luaO_utf8esc(buff, readutf8esc(ls)); + for (; n > 0; n--) /* add 'buff' to string */ + save(ls, buff[UTF8BUFFSZ - n]); +} + + +static int readdecesc (LexState *ls) { + int i; + int r = 0; /* result accumulator */ + for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ + r = 10*r + ls->current - '0'; + save_and_next(ls); + } + esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); + luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ + return r; +} + + +static void read_string (LexState *ls, int del, SemInfo *seminfo) { + save_and_next(ls); /* keep delimiter (for error messages) */ + while (ls->current != del) { + switch (ls->current) { + case EOZ: + lexerror(ls, "unfinished string", TK_EOS); + break; /* to avoid warnings */ + case '\n': + case '\r': + lexerror(ls, "unfinished string", TK_STRING); + break; /* to avoid warnings */ + case '\\': { /* escape sequences */ + int c; /* final character to be saved */ + save_and_next(ls); /* keep '\\' for error messages */ + switch (ls->current) { + case 'a': c = '\a'; goto read_save; + case 'b': c = '\b'; goto read_save; + case 'f': c = '\f'; goto read_save; + case 'n': c = '\n'; goto read_save; + case 'r': c = '\r'; goto read_save; + case 't': c = '\t'; goto read_save; + case 'v': c = '\v'; goto read_save; + case 'x': c = readhexaesc(ls); goto read_save; + case 'u': utf8esc(ls); goto no_save; + case '\n': case '\r': + inclinenumber(ls); c = '\n'; goto only_save; + case '\\': case '\"': case '\'': + c = ls->current; goto read_save; + case EOZ: goto no_save; /* will raise an error next loop */ + case 'z': { /* zap following span of spaces */ + luaZ_buffremove(ls->buff, 1); /* remove '\\' */ + next(ls); /* skip the 'z' */ + while (lisspace(ls->current)) { + if (currIsNewline(ls)) inclinenumber(ls); + else next(ls); + } + goto no_save; + } + default: { + esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); + c = readdecesc(ls); /* digital escape '\ddd' */ + goto only_save; + } + } + read_save: + next(ls); + /* go through */ + only_save: + luaZ_buffremove(ls->buff, 1); /* remove '\\' */ + save(ls, c); + /* go through */ + no_save: break; + } + default: + save_and_next(ls); + } + } + save_and_next(ls); /* skip delimiter */ + seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, + luaZ_bufflen(ls->buff) - 2); +} + + +static int llex (LexState *ls, SemInfo *seminfo) { + luaZ_resetbuffer(ls->buff); + for (;;) { + switch (ls->current) { + case '\n': case '\r': { /* line breaks */ + inclinenumber(ls); + break; + } + case ' ': case '\f': case '\t': case '\v': { /* spaces */ + next(ls); + break; + } + case '-': { /* '-' or '--' (comment) */ + next(ls); + if (ls->current != '-') return '-'; + /* else is a comment */ + next(ls); + if (ls->current == '[') { /* long comment? */ + size_t sep = skip_sep(ls); + luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ + if (sep >= 2) { + read_long_string(ls, NULL, sep); /* skip long comment */ + luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ + break; + } + } + /* else short comment */ + while (!currIsNewline(ls) && ls->current != EOZ) + next(ls); /* skip until end of line (or end of file) */ + break; + } + case '[': { /* long string or simply '[' */ + size_t sep = skip_sep(ls); + if (sep >= 2) { + read_long_string(ls, seminfo, sep); + return TK_STRING; + } + else if (sep == 0) /* '[=...' missing second bracket? */ + lexerror(ls, "invalid long string delimiter", TK_STRING); + return '['; + } + case '=': { + next(ls); + if (check_next1(ls, '=')) return TK_EQ; /* '==' */ + else return '='; + } + case '<': { + next(ls); + if (check_next1(ls, '=')) return TK_LE; /* '<=' */ + else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ + else return '<'; + } + case '>': { + next(ls); + if (check_next1(ls, '=')) return TK_GE; /* '>=' */ + else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ + else return '>'; + } + case '/': { + next(ls); + if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ + else return '/'; + } + case '~': { + next(ls); + if (check_next1(ls, '=')) return TK_NE; /* '~=' */ + else return '~'; + } + case ':': { + next(ls); + if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ + else return ':'; + } + case '"': case '\'': { /* short literal strings */ + read_string(ls, ls->current, seminfo); + return TK_STRING; + } + case '.': { /* '.', '..', '...', or number */ + save_and_next(ls); + if (check_next1(ls, '.')) { + if (check_next1(ls, '.')) + return TK_DOTS; /* '...' */ + else return TK_CONCAT; /* '..' */ + } + else if (!lisdigit(ls->current)) return '.'; + else return read_numeral(ls, seminfo); + } + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + return read_numeral(ls, seminfo); + } + case EOZ: { + return TK_EOS; + } + default: { + if (lislalpha(ls->current)) { /* identifier or reserved word? */ + TString *ts; + do { + save_and_next(ls); + } while (lislalnum(ls->current)); + /* find or create string */ + ts = luaS_newlstr(ls->L, luaZ_buffer(ls->buff), + luaZ_bufflen(ls->buff)); + if (isreserved(ts)) /* reserved word? */ + return ts->extra - 1 + FIRST_RESERVED; + else { + seminfo->ts = anchorstr(ls, ts); + return TK_NAME; + } + } + else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ + int c = ls->current; + next(ls); + return c; + } + } + } + } +} + + +void luaX_next (LexState *ls) { + ls->lastline = ls->linenumber; + if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ + ls->t = ls->lookahead; /* use this one */ + ls->lookahead.token = TK_EOS; /* and discharge it */ + } + else + ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ +} + + +int luaX_lookahead (LexState *ls) { + lua_assert(ls->lookahead.token == TK_EOS); + ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); + return ls->lookahead.token; +} + diff --git a/source/external/lua/lmathlib.c b/source/external/lua/lmathlib.c new file mode 100644 index 0000000..a6b13f9 --- /dev/null +++ b/source/external/lua/lmathlib.c @@ -0,0 +1,765 @@ +/* +** $Id: lmathlib.c $ +** Standard mathematical library +** See Copyright Notice in lua.h +*/ + +#define lmathlib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +#undef PI +#define PI (l_mathop(3.141592653589793238462643383279502884)) + + +static int math_abs (lua_State *L) { + if (lua_isinteger(L, 1)) { + lua_Integer n = lua_tointeger(L, 1); + if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n); + lua_pushinteger(L, n); + } + else + lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_sin (lua_State *L) { + lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_cos (lua_State *L) { + lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_tan (lua_State *L) { + lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_asin (lua_State *L) { + lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_acos (lua_State *L) { + lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_atan (lua_State *L) { + lua_Number y = luaL_checknumber(L, 1); + lua_Number x = luaL_optnumber(L, 2, 1); + lua_pushnumber(L, l_mathop(atan2)(y, x)); + return 1; +} + + +static int math_toint (lua_State *L) { + int valid; + lua_Integer n = lua_tointegerx(L, 1, &valid); + if (l_likely(valid)) + lua_pushinteger(L, n); + else { + luaL_checkany(L, 1); + luaL_pushfail(L); /* value is not convertible to integer */ + } + return 1; +} + + +static void pushnumint (lua_State *L, lua_Number d) { + lua_Integer n; + if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */ + lua_pushinteger(L, n); /* result is integer */ + else + lua_pushnumber(L, d); /* result is float */ +} + + +static int math_floor (lua_State *L) { + if (lua_isinteger(L, 1)) + lua_settop(L, 1); /* integer is its own floor */ + else { + lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1)); + pushnumint(L, d); + } + return 1; +} + + +static int math_ceil (lua_State *L) { + if (lua_isinteger(L, 1)) + lua_settop(L, 1); /* integer is its own ceiling */ + else { + lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1)); + pushnumint(L, d); + } + return 1; +} + + +static int math_fmod (lua_State *L) { + if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) { + lua_Integer d = lua_tointeger(L, 2); + if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */ + luaL_argcheck(L, d != 0, 2, "zero"); + lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */ + } + else + lua_pushinteger(L, lua_tointeger(L, 1) % d); + } + else + lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1), + luaL_checknumber(L, 2))); + return 1; +} + + +/* +** next function does not use 'modf', avoiding problems with 'double*' +** (which is not compatible with 'float*') when lua_Number is not +** 'double'. +*/ +static int math_modf (lua_State *L) { + if (lua_isinteger(L ,1)) { + lua_settop(L, 1); /* number is its own integer part */ + lua_pushnumber(L, 0); /* no fractional part */ + } + else { + lua_Number n = luaL_checknumber(L, 1); + /* integer part (rounds toward zero) */ + lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n); + pushnumint(L, ip); + /* fractional part (test needed for inf/-inf) */ + lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip)); + } + return 2; +} + + +static int math_sqrt (lua_State *L) { + lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_ult (lua_State *L) { + lua_Integer a = luaL_checkinteger(L, 1); + lua_Integer b = luaL_checkinteger(L, 2); + lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b); + return 1; +} + + +static int math_log (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + lua_Number res; + if (lua_isnoneornil(L, 2)) + res = l_mathop(log)(x); + else { + lua_Number base = luaL_checknumber(L, 2); +#if !defined(LUA_USE_C89) + if (base == l_mathop(2.0)) + res = l_mathop(log2)(x); + else +#endif + if (base == l_mathop(10.0)) + res = l_mathop(log10)(x); + else + res = l_mathop(log)(x)/l_mathop(log)(base); + } + lua_pushnumber(L, res); + return 1; +} + + +static int math_exp (lua_State *L) { + lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1))); + return 1; +} + + +static int math_deg (lua_State *L) { + lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI)); + return 1; +} + + +static int math_rad (lua_State *L) { + lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0))); + return 1; +} + + +static int math_frexp (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + int ep; + lua_pushnumber(L, l_mathop(frexp)(x, &ep)); + lua_pushinteger(L, ep); + return 2; +} + + +static int math_ldexp (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + int ep = (int)luaL_checkinteger(L, 2); + lua_pushnumber(L, l_mathop(ldexp)(x, ep)); + return 1; +} + + +static int math_min (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int imin = 1; /* index of current minimum value */ + int i; + luaL_argcheck(L, n >= 1, 1, "value expected"); + for (i = 2; i <= n; i++) { + if (lua_compare(L, i, imin, LUA_OPLT)) + imin = i; + } + lua_pushvalue(L, imin); + return 1; +} + + +static int math_max (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int imax = 1; /* index of current maximum value */ + int i; + luaL_argcheck(L, n >= 1, 1, "value expected"); + for (i = 2; i <= n; i++) { + if (lua_compare(L, imax, i, LUA_OPLT)) + imax = i; + } + lua_pushvalue(L, imax); + return 1; +} + + +static int math_type (lua_State *L) { + if (lua_type(L, 1) == LUA_TNUMBER) + lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float"); + else { + luaL_checkany(L, 1); + luaL_pushfail(L); + } + return 1; +} + + + +/* +** {================================================================== +** Pseudo-Random Number Generator based on 'xoshiro256**'. +** =================================================================== +*/ + +/* +** This code uses lots of shifts. ISO C does not allow shifts greater +** than or equal to the width of the type being shifted, so some shifts +** are written in convoluted ways to match that restriction. For +** preprocessor tests, it assumes a width of 32 bits, so the maximum +** shift there is 31 bits. +*/ + + +/* number of binary digits in the mantissa of a float */ +#define FIGS l_floatatt(MANT_DIG) + +#if FIGS > 64 +/* there are only 64 random bits; use them all */ +#undef FIGS +#define FIGS 64 +#endif + + +/* +** LUA_RAND32 forces the use of 32-bit integers in the implementation +** of the PRN generator (mainly for testing). +*/ +#if !defined(LUA_RAND32) && !defined(Rand64) + +/* try to find an integer type with at least 64 bits */ + +#if ((ULONG_MAX >> 31) >> 31) >= 3 + +/* 'long' has at least 64 bits */ +#define Rand64 unsigned long +#define SRand64 long + +#elif !defined(LUA_USE_C89) && defined(LLONG_MAX) + +/* there is a 'long long' type (which must have at least 64 bits) */ +#define Rand64 unsigned long long +#define SRand64 long long + +#elif ((LUA_MAXUNSIGNED >> 31) >> 31) >= 3 + +/* 'lua_Unsigned' has at least 64 bits */ +#define Rand64 lua_Unsigned +#define SRand64 lua_Integer + +#endif + +#endif + + +#if defined(Rand64) /* { */ + +/* +** Standard implementation, using 64-bit integers. +** If 'Rand64' has more than 64 bits, the extra bits do not interfere +** with the 64 initial bits, except in a right shift. Moreover, the +** final result has to discard the extra bits. +*/ + +/* avoid using extra bits when needed */ +#define trim64(x) ((x) & 0xffffffffffffffffu) + + +/* rotate left 'x' by 'n' bits */ +static Rand64 rotl (Rand64 x, int n) { + return (x << n) | (trim64(x) >> (64 - n)); +} + +static Rand64 nextrand (Rand64 *state) { + Rand64 state0 = state[0]; + Rand64 state1 = state[1]; + Rand64 state2 = state[2] ^ state0; + Rand64 state3 = state[3] ^ state1; + Rand64 res = rotl(state1 * 5, 7) * 9; + state[0] = state0 ^ state3; + state[1] = state1 ^ state2; + state[2] = state2 ^ (state1 << 17); + state[3] = rotl(state3, 45); + return res; +} + + +/* +** Convert bits from a random integer into a float in the +** interval [0,1), getting the higher FIG bits from the +** random unsigned integer and converting that to a float. +** Some old Microsoft compilers cannot cast an unsigned long +** to a floating-point number, so we use a signed long as an +** intermediary. When lua_Number is float or double, the shift ensures +** that 'sx' is non negative; in that case, a good compiler will remove +** the correction. +*/ + +/* must throw out the extra (64 - FIGS) bits */ +#define shift64_FIG (64 - FIGS) + +/* 2^(-FIGS) == 2^-1 / 2^(FIGS-1) */ +#define scaleFIG (l_mathop(0.5) / ((Rand64)1 << (FIGS - 1))) + +static lua_Number I2d (Rand64 x) { + SRand64 sx = (SRand64)(trim64(x) >> shift64_FIG); + lua_Number res = (lua_Number)(sx) * scaleFIG; + if (sx < 0) + res += l_mathop(1.0); /* correct the two's complement if negative */ + lua_assert(0 <= res && res < 1); + return res; +} + +/* convert a 'Rand64' to a 'lua_Unsigned' */ +#define I2UInt(x) ((lua_Unsigned)trim64(x)) + +/* convert a 'lua_Unsigned' to a 'Rand64' */ +#define Int2I(x) ((Rand64)(x)) + + +#else /* no 'Rand64' }{ */ + +/* +** Use two 32-bit integers to represent a 64-bit quantity. +*/ +typedef struct Rand64 { + l_uint32 h; /* higher half */ + l_uint32 l; /* lower half */ +} Rand64; + + +/* +** If 'l_uint32' has more than 32 bits, the extra bits do not interfere +** with the 32 initial bits, except in a right shift and comparisons. +** Moreover, the final result has to discard the extra bits. +*/ + +/* avoid using extra bits when needed */ +#define trim32(x) ((x) & 0xffffffffu) + + +/* +** basic operations on 'Rand64' values +*/ + +/* build a new Rand64 value */ +static Rand64 packI (l_uint32 h, l_uint32 l) { + Rand64 result; + result.h = h; + result.l = l; + return result; +} + +/* return i << n */ +static Rand64 Ishl (Rand64 i, int n) { + lua_assert(n > 0 && n < 32); + return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n); +} + +/* i1 ^= i2 */ +static void Ixor (Rand64 *i1, Rand64 i2) { + i1->h ^= i2.h; + i1->l ^= i2.l; +} + +/* return i1 + i2 */ +static Rand64 Iadd (Rand64 i1, Rand64 i2) { + Rand64 result = packI(i1.h + i2.h, i1.l + i2.l); + if (trim32(result.l) < trim32(i1.l)) /* carry? */ + result.h++; + return result; +} + +/* return i * 5 */ +static Rand64 times5 (Rand64 i) { + return Iadd(Ishl(i, 2), i); /* i * 5 == (i << 2) + i */ +} + +/* return i * 9 */ +static Rand64 times9 (Rand64 i) { + return Iadd(Ishl(i, 3), i); /* i * 9 == (i << 3) + i */ +} + +/* return 'i' rotated left 'n' bits */ +static Rand64 rotl (Rand64 i, int n) { + lua_assert(n > 0 && n < 32); + return packI((i.h << n) | (trim32(i.l) >> (32 - n)), + (trim32(i.h) >> (32 - n)) | (i.l << n)); +} + +/* for offsets larger than 32, rotate right by 64 - offset */ +static Rand64 rotl1 (Rand64 i, int n) { + lua_assert(n > 32 && n < 64); + n = 64 - n; + return packI((trim32(i.h) >> n) | (i.l << (32 - n)), + (i.h << (32 - n)) | (trim32(i.l) >> n)); +} + +/* +** implementation of 'xoshiro256**' algorithm on 'Rand64' values +*/ +static Rand64 nextrand (Rand64 *state) { + Rand64 res = times9(rotl(times5(state[1]), 7)); + Rand64 t = Ishl(state[1], 17); + Ixor(&state[2], state[0]); + Ixor(&state[3], state[1]); + Ixor(&state[1], state[2]); + Ixor(&state[0], state[3]); + Ixor(&state[2], t); + state[3] = rotl1(state[3], 45); + return res; +} + + +/* +** Converts a 'Rand64' into a float. +*/ + +/* an unsigned 1 with proper type */ +#define UONE ((l_uint32)1) + + +#if FIGS <= 32 + +/* 2^(-FIGS) */ +#define scaleFIG (l_mathop(0.5) / (UONE << (FIGS - 1))) + +/* +** get up to 32 bits from higher half, shifting right to +** throw out the extra bits. +*/ +static lua_Number I2d (Rand64 x) { + lua_Number h = (lua_Number)(trim32(x.h) >> (32 - FIGS)); + return h * scaleFIG; +} + +#else /* 32 < FIGS <= 64 */ + +/* 2^(-FIGS) = 1.0 / 2^30 / 2^3 / 2^(FIGS-33) */ +#define scaleFIG \ + (l_mathop(1.0) / (UONE << 30) / l_mathop(8.0) / (UONE << (FIGS - 33))) + +/* +** use FIGS - 32 bits from lower half, throwing out the other +** (32 - (FIGS - 32)) = (64 - FIGS) bits +*/ +#define shiftLOW (64 - FIGS) + +/* +** higher 32 bits go after those (FIGS - 32) bits: shiftHI = 2^(FIGS - 32) +*/ +#define shiftHI ((lua_Number)(UONE << (FIGS - 33)) * l_mathop(2.0)) + + +static lua_Number I2d (Rand64 x) { + lua_Number h = (lua_Number)trim32(x.h) * shiftHI; + lua_Number l = (lua_Number)(trim32(x.l) >> shiftLOW); + return (h + l) * scaleFIG; +} + +#endif + + +/* convert a 'Rand64' to a 'lua_Unsigned' */ +static lua_Unsigned I2UInt (Rand64 x) { + return (((lua_Unsigned)trim32(x.h) << 31) << 1) | (lua_Unsigned)trim32(x.l); +} + +/* convert a 'lua_Unsigned' to a 'Rand64' */ +static Rand64 Int2I (lua_Unsigned n) { + return packI((l_uint32)((n >> 31) >> 1), (l_uint32)n); +} + +#endif /* } */ + + +/* +** A state uses four 'Rand64' values. +*/ +typedef struct { + Rand64 s[4]; +} RanState; + + +/* +** Project the random integer 'ran' into the interval [0, n]. +** Because 'ran' has 2^B possible values, the projection can only be +** uniform when the size of the interval is a power of 2 (exact +** division). So, to get a uniform projection into [0, n], we +** first compute 'lim', the smallest Mersenne number not smaller than +** 'n'. We then project 'ran' into the interval [0, lim]. If the result +** is inside [0, n], we are done. Otherwise, we try with another 'ran', +** until we have a result inside the interval. +*/ +static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n, + RanState *state) { + lua_Unsigned lim = n; /* to compute the Mersenne number */ + int sh; /* how much to spread bits to the right in 'lim' */ + /* spread '1' bits in 'lim' until it becomes a Mersenne number */ + for (sh = 1; (lim & (lim + 1)) != 0; sh *= 2) + lim |= (lim >> sh); /* spread '1's to the right */ + while ((ran &= lim) > n) /* project 'ran' into [0..lim] and test */ + ran = I2UInt(nextrand(state->s)); /* not inside [0..n]? try again */ + return ran; +} + + +static int math_random (lua_State *L) { + lua_Integer low, up; + lua_Unsigned p; + RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1)); + Rand64 rv = nextrand(state->s); /* next pseudo-random value */ + switch (lua_gettop(L)) { /* check number of arguments */ + case 0: { /* no arguments */ + lua_pushnumber(L, I2d(rv)); /* float between 0 and 1 */ + return 1; + } + case 1: { /* only upper limit */ + low = 1; + up = luaL_checkinteger(L, 1); + if (up == 0) { /* single 0 as argument? */ + lua_pushinteger(L, l_castU2S(I2UInt(rv))); /* full random integer */ + return 1; + } + break; + } + case 2: { /* lower and upper limits */ + low = luaL_checkinteger(L, 1); + up = luaL_checkinteger(L, 2); + break; + } + default: return luaL_error(L, "wrong number of arguments"); + } + /* random integer in the interval [low, up] */ + luaL_argcheck(L, low <= up, 1, "interval is empty"); + /* project random integer into the interval [0, up - low] */ + p = project(I2UInt(rv), l_castS2U(up) - l_castS2U(low), state); + lua_pushinteger(L, l_castU2S(p + l_castS2U(low))); + return 1; +} + + +static void setseed (lua_State *L, Rand64 *state, + lua_Unsigned n1, lua_Unsigned n2) { + int i; + state[0] = Int2I(n1); + state[1] = Int2I(0xff); /* avoid a zero state */ + state[2] = Int2I(n2); + state[3] = Int2I(0); + for (i = 0; i < 16; i++) + nextrand(state); /* discard initial values to "spread" seed */ + lua_pushinteger(L, l_castU2S(n1)); + lua_pushinteger(L, l_castU2S(n2)); +} + + +static int math_randomseed (lua_State *L) { + RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1)); + lua_Unsigned n1, n2; + if (lua_isnone(L, 1)) { + n1 = luaL_makeseed(L); /* "random" seed */ + n2 = I2UInt(nextrand(state->s)); /* in case seed is not that random... */ + } + else { + n1 = l_castS2U(luaL_checkinteger(L, 1)); + n2 = l_castS2U(luaL_optinteger(L, 2, 0)); + } + setseed(L, state->s, n1, n2); + return 2; /* return seeds */ +} + + +static const luaL_Reg randfuncs[] = { + {"random", math_random}, + {"randomseed", math_randomseed}, + {NULL, NULL} +}; + + +/* +** Register the random functions and initialize their state. +*/ +static void setrandfunc (lua_State *L) { + RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0); + setseed(L, state->s, luaL_makeseed(L), 0); /* initialize with random seed */ + lua_pop(L, 2); /* remove pushed seeds */ + luaL_setfuncs(L, randfuncs, 1); +} + +/* }================================================================== */ + + +/* +** {================================================================== +** Deprecated functions (for compatibility only) +** =================================================================== +*/ +#if defined(LUA_COMPAT_MATHLIB) + +static int math_cosh (lua_State *L) { + lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_sinh (lua_State *L) { + lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_tanh (lua_State *L) { + lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1))); + return 1; +} + +static int math_pow (lua_State *L) { + lua_Number x = luaL_checknumber(L, 1); + lua_Number y = luaL_checknumber(L, 2); + lua_pushnumber(L, l_mathop(pow)(x, y)); + return 1; +} + +static int math_log10 (lua_State *L) { + lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1))); + return 1; +} + +#endif +/* }================================================================== */ + + + +static const luaL_Reg mathlib[] = { + {"abs", math_abs}, + {"acos", math_acos}, + {"asin", math_asin}, + {"atan", math_atan}, + {"ceil", math_ceil}, + {"cos", math_cos}, + {"deg", math_deg}, + {"exp", math_exp}, + {"tointeger", math_toint}, + {"floor", math_floor}, + {"fmod", math_fmod}, + {"frexp", math_frexp}, + {"ult", math_ult}, + {"ldexp", math_ldexp}, + {"log", math_log}, + {"max", math_max}, + {"min", math_min}, + {"modf", math_modf}, + {"rad", math_rad}, + {"sin", math_sin}, + {"sqrt", math_sqrt}, + {"tan", math_tan}, + {"type", math_type}, +#if defined(LUA_COMPAT_MATHLIB) + {"atan2", math_atan}, + {"cosh", math_cosh}, + {"sinh", math_sinh}, + {"tanh", math_tanh}, + {"pow", math_pow}, + {"log10", math_log10}, +#endif + /* placeholders */ + {"random", NULL}, + {"randomseed", NULL}, + {"pi", NULL}, + {"huge", NULL}, + {"maxinteger", NULL}, + {"mininteger", NULL}, + {NULL, NULL} +}; + + +/* +** Open math library +*/ +LUAMOD_API int luaopen_math (lua_State *L) { + luaL_newlib(L, mathlib); + lua_pushnumber(L, PI); + lua_setfield(L, -2, "pi"); + lua_pushnumber(L, (lua_Number)HUGE_VAL); + lua_setfield(L, -2, "huge"); + lua_pushinteger(L, LUA_MAXINTEGER); + lua_setfield(L, -2, "maxinteger"); + lua_pushinteger(L, LUA_MININTEGER); + lua_setfield(L, -2, "mininteger"); + setrandfunc(L); + return 1; +} + diff --git a/source/external/lua/lmem.c b/source/external/lua/lmem.c new file mode 100644 index 0000000..de8503d --- /dev/null +++ b/source/external/lua/lmem.c @@ -0,0 +1,215 @@ +/* +** $Id: lmem.c $ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + +#define lmem_c +#define LUA_CORE + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +/* +** About the realloc function: +** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize); +** ('osize' is the old size, 'nsize' is the new size) +** +** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL. +** Particularly, frealloc(ud, NULL, 0, 0) does nothing, +** which is equivalent to free(NULL) in ISO C. +** +** - frealloc(ud, NULL, x, s) creates a new block of size 's' +** (no matter 'x'). Returns NULL if it cannot create the new block. +** +** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from +** size 'x' to size 'y'. Returns NULL if it cannot reallocate the +** block to the new size. +*/ + + +/* +** Macro to call the allocation function. +*/ +#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) + + +/* +** When an allocation fails, it will try again after an emergency +** collection, except when it cannot run a collection. The GC should +** not be called while the state is not fully built, as the collector +** is not yet fully initialized. Also, it should not be called when +** 'gcstopem' is true, because then the interpreter is in the middle of +** a collection step. +*/ +#define cantryagain(g) (completestate(g) && !g->gcstopem) + + + + +#if defined(EMERGENCYGCTESTS) +/* +** First allocation will fail except when freeing a block (frees never +** fail) and when it cannot try again; this fail will trigger 'tryagain' +** and a full GC cycle at every allocation. +*/ +static void *firsttry (global_State *g, void *block, size_t os, size_t ns) { + if (ns > 0 && cantryagain(g)) + return NULL; /* fail */ + else /* normal allocation */ + return callfrealloc(g, block, os, ns); +} +#else +#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) +#endif + + + + + +/* +** {================================================================== +** Functions to allocate/deallocate arrays for the Parser +** =================================================================== +*/ + +/* +** Minimum size for arrays during parsing, to avoid overhead of +** reallocating to size 1, then 2, and then 4. All these arrays +** will be reallocated to exact sizes or erased when parsing ends. +*/ +#define MINSIZEARRAY 4 + + +void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize, + unsigned size_elems, int limit, const char *what) { + void *newblock; + int size = *psize; + if (nelems + 1 <= size) /* does one extra element still fit? */ + return block; /* nothing to be done */ + if (size >= limit / 2) { /* cannot double it? */ + if (l_unlikely(size >= limit)) /* cannot grow even a little? */ + luaG_runerror(L, "too many %s (limit is %d)", what, limit); + size = limit; /* still have at least one free place */ + } + else { + size *= 2; + if (size < MINSIZEARRAY) + size = MINSIZEARRAY; /* minimum size */ + } + lua_assert(nelems + 1 <= size && size <= limit); + /* 'limit' ensures that multiplication will not overflow */ + newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, + cast_sizet(size) * size_elems); + *psize = size; /* update only when everything else is OK */ + return newblock; +} + + +/* +** In prototypes, the size of the array is also its number of +** elements (to save memory). So, if it cannot shrink an array +** to its number of elements, the only option is to raise an +** error. +*/ +void *luaM_shrinkvector_ (lua_State *L, void *block, int *size, + int final_n, unsigned size_elem) { + void *newblock; + size_t oldsize = cast_sizet(*size) * size_elem; + size_t newsize = cast_sizet(final_n) * size_elem; + lua_assert(newsize <= oldsize); + newblock = luaM_saferealloc_(L, block, oldsize, newsize); + *size = final_n; + return newblock; +} + +/* }================================================================== */ + + +l_noret luaM_toobig (lua_State *L) { + luaG_runerror(L, "memory allocation error: block too big"); +} + + +/* +** Free memory +*/ +void luaM_free_ (lua_State *L, void *block, size_t osize) { + global_State *g = G(L); + lua_assert((osize == 0) == (block == NULL)); + callfrealloc(g, block, osize, 0); + g->GCdebt += cast(l_mem, osize); +} + + +/* +** In case of allocation fail, this function will do an emergency +** collection to free some memory and then try the allocation again. +*/ +static void *tryagain (lua_State *L, void *block, + size_t osize, size_t nsize) { + global_State *g = G(L); + if (cantryagain(g)) { + luaC_fullgc(L, 1); /* try to free some memory... */ + return callfrealloc(g, block, osize, nsize); /* try again */ + } + else return NULL; /* cannot run an emergency collection */ +} + + +/* +** Generic allocation routine. +*/ +void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { + void *newblock; + global_State *g = G(L); + lua_assert((osize == 0) == (block == NULL)); + newblock = firsttry(g, block, osize, nsize); + if (l_unlikely(newblock == NULL && nsize > 0)) { + newblock = tryagain(L, block, osize, nsize); + if (newblock == NULL) /* still no memory? */ + return NULL; /* do not update 'GCdebt' */ + } + lua_assert((nsize == 0) == (newblock == NULL)); + g->GCdebt -= cast(l_mem, nsize) - cast(l_mem, osize); + return newblock; +} + + +void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize, + size_t nsize) { + void *newblock = luaM_realloc_(L, block, osize, nsize); + if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ + luaM_error(L); + return newblock; +} + + +void *luaM_malloc_ (lua_State *L, size_t size, int tag) { + if (size == 0) + return NULL; /* that's all */ + else { + global_State *g = G(L); + void *newblock = firsttry(g, NULL, cast_sizet(tag), size); + if (l_unlikely(newblock == NULL)) { + newblock = tryagain(L, NULL, cast_sizet(tag), size); + if (newblock == NULL) + luaM_error(L); + } + g->GCdebt -= cast(l_mem, size); + return newblock; + } +} diff --git a/source/external/lua/loadlib.c b/source/external/lua/loadlib.c new file mode 100644 index 0000000..3fd26c5 --- /dev/null +++ b/source/external/lua/loadlib.c @@ -0,0 +1,858 @@ +/* +** $Id: loadlib.c $ +** Dynamic library loader for Lua +** See Copyright Notice in lua.h +** +** This module contains an implementation of loadlib for Unix systems +** that have dlfcn, an implementation for Windows, and a stub for other +** systems. +*/ + +#define loadlib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** LUA_CSUBSEP is the character that replaces dots in submodule names +** when searching for a C loader. +** LUA_LSUBSEP is the character that replaces dots in submodule names +** when searching for a Lua loader. +*/ +#if !defined(LUA_CSUBSEP) +#define LUA_CSUBSEP LUA_DIRSEP +#endif + +#if !defined(LUA_LSUBSEP) +#define LUA_LSUBSEP LUA_DIRSEP +#endif + + +/* prefix for open functions in C libraries */ +#define LUA_POF "luaopen_" + +/* separator for open functions in C libraries */ +#define LUA_OFSEP "_" + + +/* +** key for table in the registry that keeps handles +** for all loaded C libraries +*/ +static const char *const CLIBS = "_CLIBS"; + +#define LIB_FAIL "open" + + +#define setprogdir(L) ((void)0) + + +/* cast void* to a Lua function */ +#define cast_Lfunc(p) cast(lua_CFunction, cast_func(p)) + + +/* +** system-dependent functions +*/ + +/* +** unload library 'lib' +*/ +static void lsys_unloadlib (void *lib); + +/* +** load C library in file 'path'. If 'seeglb', load with all names in +** the library global. +** Returns the library; in case of error, returns NULL plus an +** error string in the stack. +*/ +static void *lsys_load (lua_State *L, const char *path, int seeglb); + +/* +** Try to find a function named 'sym' in library 'lib'. +** Returns the function; in case of error, returns NULL plus an +** error string in the stack. +*/ +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym); + + + + +#if defined(LUA_USE_DLOPEN) /* { */ +/* +** {======================================================================== +** This is an implementation of loadlib based on the dlfcn interface, +** which is available in all POSIX systems. +** ========================================================================= +*/ + +#include + + +static void lsys_unloadlib (void *lib) { + dlclose(lib); +} + + +static void *lsys_load (lua_State *L, const char *path, int seeglb) { + void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL)); + if (l_unlikely(lib == NULL)) + lua_pushstring(L, dlerror()); + return lib; +} + + +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { + lua_CFunction f = cast_Lfunc(dlsym(lib, sym)); + if (l_unlikely(f == NULL)) + lua_pushstring(L, dlerror()); + return f; +} + +/* }====================================================== */ + + + +#elif defined(LUA_DL_DLL) /* }{ */ +/* +** {====================================================================== +** This is an implementation of loadlib for Windows using native functions. +** ======================================================================= +*/ + +#include + + +/* +** optional flags for LoadLibraryEx +*/ +#if !defined(LUA_LLE_FLAGS) +#define LUA_LLE_FLAGS 0 +#endif + + +#undef setprogdir + + +/* +** Replace in the path (on the top of the stack) any occurrence +** of LUA_EXEC_DIR with the executable's path. +*/ +static void setprogdir (lua_State *L) { + char buff[MAX_PATH + 1]; + char *lb; + DWORD nsize = sizeof(buff)/sizeof(char); + DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */ + if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL) + luaL_error(L, "unable to get ModuleFileName"); + else { + *lb = '\0'; /* cut name on the last '\\' to get the path */ + luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff); + lua_remove(L, -2); /* remove original string */ + } +} + + + + +static void pusherror (lua_State *L) { + int error = GetLastError(); + char buffer[128]; + if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, + NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL)) + lua_pushstring(L, buffer); + else + lua_pushfstring(L, "system error %d\n", error); +} + +static void lsys_unloadlib (void *lib) { + FreeLibrary((HMODULE)lib); +} + + +static void *lsys_load (lua_State *L, const char *path, int seeglb) { + HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS); + (void)(seeglb); /* not used: symbols are 'global' by default */ + if (lib == NULL) pusherror(L); + return lib; +} + + +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { + lua_CFunction f = cast_Lfunc(GetProcAddress((HMODULE)lib, sym)); + if (f == NULL) pusherror(L); + return f; +} + +/* }====================================================== */ + + +#else /* }{ */ +/* +** {====================================================== +** Fallback for other systems +** ======================================================= +*/ + +#undef LIB_FAIL +#define LIB_FAIL "absent" + + +#define DLMSG "dynamic libraries not enabled; check your Lua installation" + + +static void lsys_unloadlib (void *lib) { + (void)(lib); /* not used */ +} + + +static void *lsys_load (lua_State *L, const char *path, int seeglb) { + (void)(path); (void)(seeglb); /* not used */ + lua_pushliteral(L, DLMSG); + return NULL; +} + + +static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) { + (void)(lib); (void)(sym); /* not used */ + lua_pushliteral(L, DLMSG); + return NULL; +} + +/* }====================================================== */ +#endif /* } */ + + +/* +** {================================================================== +** Set Paths +** =================================================================== +*/ + +/* +** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment +** variables that Lua check to set its paths. +*/ +#if !defined(LUA_PATH_VAR) +#define LUA_PATH_VAR "LUA_PATH" +#endif + +#if !defined(LUA_CPATH_VAR) +#define LUA_CPATH_VAR "LUA_CPATH" +#endif + + + +/* +** return registry.LUA_NOENV as a boolean +*/ +static int noenv (lua_State *L) { + int b; + lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV"); + b = lua_toboolean(L, -1); + lua_pop(L, 1); /* remove value */ + return b; +} + + +/* +** Set a path. (If using the default path, assume it is a string +** literal in C and create it as an external string.) +*/ +static void setpath (lua_State *L, const char *fieldname, + const char *envname, + const char *dft) { + const char *dftmark; + const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX); + const char *path = getenv(nver); /* try versioned name */ + if (path == NULL) /* no versioned environment variable? */ + path = getenv(envname); /* try unversioned name */ + if (path == NULL || noenv(L)) /* no environment variable? */ + lua_pushexternalstring(L, dft, strlen(dft), NULL, NULL); /* use default */ + else if ((dftmark = strstr(path, LUA_PATH_SEP LUA_PATH_SEP)) == NULL) + lua_pushstring(L, path); /* nothing to change */ + else { /* path contains a ";;": insert default path in its place */ + size_t len = strlen(path); + luaL_Buffer b; + luaL_buffinit(L, &b); + if (path < dftmark) { /* is there a prefix before ';;'? */ + luaL_addlstring(&b, path, ct_diff2sz(dftmark - path)); /* add it */ + luaL_addchar(&b, *LUA_PATH_SEP); + } + luaL_addstring(&b, dft); /* add default */ + if (dftmark < path + len - 2) { /* is there a suffix after ';;'? */ + luaL_addchar(&b, *LUA_PATH_SEP); + luaL_addlstring(&b, dftmark + 2, ct_diff2sz((path + len - 2) - dftmark)); + } + luaL_pushresult(&b); + } + setprogdir(L); + lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */ + lua_pop(L, 1); /* pop versioned variable name ('nver') */ +} + +/* }================================================================== */ + + +/* +** External strings created by DLLs may need the DLL code to be +** deallocated. This implies that a DLL can only be unloaded after all +** its strings were deallocated. To ensure that, we create a 'library +** string' to represent each DLL, and when this string is deallocated +** it closes its corresponding DLL. +** (The string itself is irrelevant; its userdata is the DLL pointer.) +*/ + + +/* +** return registry.CLIBS[path] +*/ +static void *checkclib (lua_State *L, const char *path) { + void *plib; + lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); + lua_getfield(L, -1, path); + plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */ + lua_pop(L, 2); /* pop CLIBS table and 'plib' */ + return plib; +} + + +/* +** Deallocate function for library strings. +** Unload the DLL associated with the string being deallocated. +*/ +static void *freelib (void *ud, void *ptr, size_t osize, size_t nsize) { + /* string itself is irrelevant and static */ + (void)ptr; (void)osize; (void)nsize; + lsys_unloadlib(ud); /* unload library represented by the string */ + return NULL; +} + + +/* +** Create a library string that, when deallocated, will unload 'plib' +*/ +static void createlibstr (lua_State *L, void *plib) { + /* common content for all library strings */ + static const char dummy[] = "01234567890"; + lua_pushexternalstring(L, dummy, sizeof(dummy) - 1, freelib, plib); +} + + +/* +** registry.CLIBS[path] = plib -- for queries. +** Also create a reference to strlib, so that the library string will +** only be collected when registry.CLIBS is collected. +*/ +static void addtoclib (lua_State *L, const char *path, void *plib) { + lua_getfield(L, LUA_REGISTRYINDEX, CLIBS); + lua_pushlightuserdata(L, plib); + lua_setfield(L, -2, path); /* CLIBS[path] = plib */ + createlibstr(L, plib); + luaL_ref(L, -2); /* keep library string in CLIBS */ + lua_pop(L, 1); /* pop CLIBS table */ +} + + +/* error codes for 'lookforfunc' */ +#define ERRLIB 1 +#define ERRFUNC 2 + +/* +** Look for a C function named 'sym' in a dynamically loaded library +** 'path'. +** First, check whether the library is already loaded; if not, try +** to load it. +** Then, if 'sym' is '*', return true (as library has been loaded). +** Otherwise, look for symbol 'sym' in the library and push a +** C function with that symbol. +** Return 0 with 'true' or a function in the stack; in case of +** errors, return an error code with an error message in the stack. +*/ +static int lookforfunc (lua_State *L, const char *path, const char *sym) { + void *reg = checkclib(L, path); /* check loaded C libraries */ + if (reg == NULL) { /* must load library? */ + reg = lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */ + if (reg == NULL) return ERRLIB; /* unable to load library */ + addtoclib(L, path, reg); + } + if (*sym == '*') { /* loading only library (no function)? */ + lua_pushboolean(L, 1); /* return 'true' */ + return 0; /* no errors */ + } + else { + lua_CFunction f = lsys_sym(L, reg, sym); + if (f == NULL) + return ERRFUNC; /* unable to find function */ + lua_pushcfunction(L, f); /* else create new function */ + return 0; /* no errors */ + } +} + + +static int ll_loadlib (lua_State *L) { + const char *path = luaL_checkstring(L, 1); + const char *init = luaL_checkstring(L, 2); + int stat = lookforfunc(L, path, init); + if (l_likely(stat == 0)) /* no errors? */ + return 1; /* return the loaded function */ + else { /* error; error message is on stack top */ + luaL_pushfail(L); + lua_insert(L, -2); + lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init"); + return 3; /* return fail, error message, and where */ + } +} + + + +/* +** {====================================================== +** 'require' function +** ======================================================= +*/ + + +static int readable (const char *filename) { + FILE *f = fopen(filename, "r"); /* try to open file */ + if (f == NULL) return 0; /* open failed */ + fclose(f); + return 1; +} + + +/* +** Get the next name in '*path' = 'name1;name2;name3;...', changing +** the ending ';' to '\0' to create a zero-terminated string. Return +** NULL when list ends. +*/ +static const char *getnextfilename (char **path, char *end) { + char *sep; + char *name = *path; + if (name == end) + return NULL; /* no more names */ + else if (*name == '\0') { /* from previous iteration? */ + *name = *LUA_PATH_SEP; /* restore separator */ + name++; /* skip it */ + } + sep = strchr(name, *LUA_PATH_SEP); /* find next separator */ + if (sep == NULL) /* separator not found? */ + sep = end; /* name goes until the end */ + *sep = '\0'; /* finish file name */ + *path = sep; /* will start next search from here */ + return name; +} + + +/* +** Given a path such as ";blabla.so;blublu.so", pushes the string +** +** no file 'blabla.so' +** no file 'blublu.so' +*/ +static void pusherrornotfound (lua_State *L, const char *path) { + luaL_Buffer b; + luaL_buffinit(L, &b); + luaL_addstring(&b, "no file '"); + luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '"); + luaL_addstring(&b, "'"); + luaL_pushresult(&b); +} + + +static const char *searchpath (lua_State *L, const char *name, + const char *path, + const char *sep, + const char *dirsep) { + luaL_Buffer buff; + char *pathname; /* path with name inserted */ + char *endpathname; /* its end */ + const char *filename; + /* separator is non-empty and appears in 'name'? */ + if (*sep != '\0' && strchr(name, *sep) != NULL) + name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */ + luaL_buffinit(L, &buff); + /* add path to the buffer, replacing marks ('?') with the file name */ + luaL_addgsub(&buff, path, LUA_PATH_MARK, name); + luaL_addchar(&buff, '\0'); + pathname = luaL_buffaddr(&buff); /* writable list of file names */ + endpathname = pathname + luaL_bufflen(&buff) - 1; + while ((filename = getnextfilename(&pathname, endpathname)) != NULL) { + if (readable(filename)) /* does file exist and is readable? */ + return lua_pushstring(L, filename); /* save and return name */ + } + luaL_pushresult(&buff); /* push path to create error message */ + pusherrornotfound(L, lua_tostring(L, -1)); /* create error message */ + return NULL; /* not found */ +} + + +static int ll_searchpath (lua_State *L) { + const char *f = searchpath(L, luaL_checkstring(L, 1), + luaL_checkstring(L, 2), + luaL_optstring(L, 3, "."), + luaL_optstring(L, 4, LUA_DIRSEP)); + if (f != NULL) return 1; + else { /* error message is on top of the stack */ + luaL_pushfail(L); + lua_insert(L, -2); + return 2; /* return fail + error message */ + } +} + + +static const char *findfile (lua_State *L, const char *name, + const char *pname, + const char *dirsep) { + const char *path; + lua_getfield(L, lua_upvalueindex(1), pname); + path = lua_tostring(L, -1); + if (l_unlikely(path == NULL)) + luaL_error(L, "'package.%s' must be a string", pname); + return searchpath(L, name, path, ".", dirsep); +} + + +static int checkload (lua_State *L, int stat, const char *filename) { + if (l_likely(stat)) { /* module loaded successfully? */ + lua_pushstring(L, filename); /* will be 2nd argument to module */ + return 2; /* return open function and file name */ + } + else + return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s", + lua_tostring(L, 1), filename, lua_tostring(L, -1)); +} + + +static int searcher_Lua (lua_State *L) { + const char *filename; + const char *name = luaL_checkstring(L, 1); + filename = findfile(L, name, "path", LUA_LSUBSEP); + if (filename == NULL) return 1; /* module not found in this path */ + return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename); +} + + +/* +** Try to find a load function for module 'modname' at file 'filename'. +** First, change '.' to '_' in 'modname'; then, if 'modname' has +** the form X-Y (that is, it has an "ignore mark"), build a function +** name "luaopen_X" and look for it. (For compatibility, if that +** fails, it also tries "luaopen_Y".) If there is no ignore mark, +** look for a function named "luaopen_modname". +*/ +static int loadfunc (lua_State *L, const char *filename, const char *modname) { + const char *openfunc; + const char *mark; + modname = luaL_gsub(L, modname, ".", LUA_OFSEP); + mark = strchr(modname, *LUA_IGMARK); + if (mark) { + int stat; + openfunc = lua_pushlstring(L, modname, ct_diff2sz(mark - modname)); + openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc); + stat = lookforfunc(L, filename, openfunc); + if (stat != ERRFUNC) return stat; + modname = mark + 1; /* else go ahead and try old-style name */ + } + openfunc = lua_pushfstring(L, LUA_POF"%s", modname); + return lookforfunc(L, filename, openfunc); +} + + +static int searcher_C (lua_State *L) { + const char *name = luaL_checkstring(L, 1); + const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP); + if (filename == NULL) return 1; /* module not found in this path */ + return checkload(L, (loadfunc(L, filename, name) == 0), filename); +} + + +static int searcher_Croot (lua_State *L) { + const char *filename; + const char *name = luaL_checkstring(L, 1); + const char *p = strchr(name, '.'); + int stat; + if (p == NULL) return 0; /* is root */ + lua_pushlstring(L, name, ct_diff2sz(p - name)); + filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP); + if (filename == NULL) return 1; /* root not found */ + if ((stat = loadfunc(L, filename, name)) != 0) { + if (stat != ERRFUNC) + return checkload(L, 0, filename); /* real error */ + else { /* open function not found */ + lua_pushfstring(L, "no module '%s' in file '%s'", name, filename); + return 1; + } + } + lua_pushstring(L, filename); /* will be 2nd argument to module */ + return 2; +} + + +static int searcher_preload (lua_State *L) { + const char *name = luaL_checkstring(L, 1); + lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); + if (lua_getfield(L, -1, name) == LUA_TNIL) { /* not found? */ + lua_pushfstring(L, "no field package.preload['%s']", name); + return 1; + } + else { + lua_pushliteral(L, ":preload:"); + return 2; + } +} + + +static void findloader (lua_State *L, const char *name) { + int i; + luaL_Buffer msg; /* to build error message */ + /* push 'package.searchers' to index 3 in the stack */ + if (l_unlikely(lua_getfield(L, lua_upvalueindex(1), "searchers") + != LUA_TTABLE)) + luaL_error(L, "'package.searchers' must be a table"); + luaL_buffinit(L, &msg); + luaL_addstring(&msg, "\n\t"); /* error-message prefix for first message */ + /* iterate over available searchers to find a loader */ + for (i = 1; ; i++) { + if (l_unlikely(lua_rawgeti(L, 3, i) == LUA_TNIL)) { /* no more searchers? */ + lua_pop(L, 1); /* remove nil */ + luaL_buffsub(&msg, 2); /* remove last prefix */ + luaL_pushresult(&msg); /* create error message */ + luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1)); + } + lua_pushstring(L, name); + lua_call(L, 1, 2); /* call it */ + if (lua_isfunction(L, -2)) /* did it find a loader? */ + return; /* module loader found */ + else if (lua_isstring(L, -2)) { /* searcher returned error message? */ + lua_pop(L, 1); /* remove extra return */ + luaL_addvalue(&msg); /* concatenate error message */ + luaL_addstring(&msg, "\n\t"); /* prefix for next message */ + } + else /* no error message */ + lua_pop(L, 2); /* remove both returns */ + } +} + +// [RZC 12/03/2026] ================================== +// Soport per a rutes relatives i absolutes +// +static void resolve_module_name(lua_State *L, char *out, size_t outsz) { + const char *req = luaL_checkstring(L, 1); + + // 1. RUTA ABSOLUTA: empieza por ':' + if (req[0] == ':') { + strncpy(out, req + 1, outsz - 1); + out[outsz - 1] = '\0'; + return; + } + + // 2. Obtener módulo llamador + lua_Debug ar; + if (!lua_getstack(L, 1, &ar)) { + // No hay llamador → usar nombre tal cual + strncpy(out, req, outsz - 1); + out[outsz - 1] = '\0'; + return; + } + + lua_getinfo(L, "S", &ar); + + // ar.source contiene algo como "@ia.test" o "@main" + const char *src = ar.source; + if (!src) { + // No viene de archivo → usar nombre tal cual + strncpy(out, req, outsz - 1); + out[outsz - 1] = '\0'; + return; + } + + // Quitar '@' + //src++; + + // 3. Extraer directorio del módulo llamador + // Ej: "ia.tools.other" → "ia.tools" + char caller[256]; + strncpy(caller, src, sizeof(caller) - 1); + caller[sizeof(caller) - 1] = '\0'; + + char *lastdot = strrchr(caller, '.'); + if (lastdot) + *lastdot = '\0'; // dejar solo el directorio + else + caller[0] = '\0'; // está en la raíz + + // 4. RUTA RELATIVA HACIA ARRIBA: empieza por ".." + if (req[0] == '.' && req[1] == '.') { + // Contar cuántos '.' consecutivos hay + int up = 0; + while (req[up] == '.') + up++; + + // up = número de puntos → niveles a subir + // Ej: "..test" → up=2 → subir 1 nivel + // "...main" → up=3 → subir 2 niveles + + int levels = up - 1; + + // Copiar caller a buffer temporal + char temp[256]; + strncpy(temp, caller, sizeof(temp) - 1); + temp[sizeof(temp) - 1] = '\0'; + + // Subir niveles + for (int i = 0; i < levels; i++) { + char *p = strrchr(temp, '.'); + if (p) + *p = '\0'; + else { + temp[0] = '\0'; + break; + } + } + + // Concatenar lo que queda después de los puntos + const char *rest = req + up; + + if (temp[0] == '\0') { + // Hemos llegado a la raíz + strncpy(out, rest, outsz - 1); + } else { + snprintf(out, outsz, "%s.%s", temp, rest); + } + + out[outsz - 1] = '\0'; + return; + } + + // 5. RUTA RELATIVA NORMAL (no empieza por ':' ni por '..') + if (caller[0] == '\0') { + // Estamos en la raíz + strncpy(out, req, outsz - 1); + } else { + snprintf(out, outsz, "%s.%s", caller, req); + } + + out[outsz - 1] = '\0'; +} +// =================================================== + +static int ll_require (lua_State *L) { + // [RZC 12/03/2026] ================================== + // Soport per a rutes relatives i absolutes + // + //const char *name = luaL_checkstring(L, 1); + char resolved[256]; + resolve_module_name(L, resolved, sizeof(resolved)); + const char *name = resolved; + // =================================================== + + lua_settop(L, 1); /* LOADED table will be at index 2 */ + lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + lua_getfield(L, 2, name); /* LOADED[name] */ + if (lua_toboolean(L, -1)) /* is it there? */ + return 1; /* package is already loaded */ + /* else must load package */ + lua_pop(L, 1); /* remove 'getfield' result */ + findloader(L, name); + lua_rotate(L, -2, 1); /* function <-> loader data */ + lua_pushvalue(L, 1); /* name is 1st argument to module loader */ + lua_pushvalue(L, -3); /* loader data is 2nd argument */ + /* stack: ...; loader data; loader function; mod. name; loader data */ + lua_call(L, 2, 1); /* run loader to load module */ + /* stack: ...; loader data; result from loader */ + if (!lua_isnil(L, -1)) /* non-nil return? */ + lua_setfield(L, 2, name); /* LOADED[name] = returned value */ + else + lua_pop(L, 1); /* pop nil */ + if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */ + lua_pushboolean(L, 1); /* use true as result */ + lua_copy(L, -1, -2); /* replace loader result */ + lua_setfield(L, 2, name); /* LOADED[name] = true */ + } + lua_rotate(L, -2, 1); /* loader data <-> module result */ + return 2; /* return module result and loader data */ +} + +/* }====================================================== */ + + + + +static const luaL_Reg pk_funcs[] = { + {"loadlib", ll_loadlib}, + {"searchpath", ll_searchpath}, + /* placeholders */ + {"preload", NULL}, + {"cpath", NULL}, + {"path", NULL}, + {"searchers", NULL}, + {"loaded", NULL}, + {NULL, NULL} +}; + + +static const luaL_Reg ll_funcs[] = { + {"require", ll_require}, + {NULL, NULL} +}; + + +static void createsearcherstable (lua_State *L) { + static const lua_CFunction searchers[] = { + searcher_preload, + searcher_Lua, + searcher_C, + searcher_Croot, + NULL + }; + int i; + /* create 'searchers' table */ + lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0); + /* fill it with predefined searchers */ + for (i=0; searchers[i] != NULL; i++) { + lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */ + lua_pushcclosure(L, searchers[i], 1); + lua_rawseti(L, -2, i+1); + } + lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */ +} + + +LUAMOD_API int luaopen_package (lua_State *L) { + luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); /* create CLIBS table */ + lua_pop(L, 1); /* will not use it now */ + luaL_newlib(L, pk_funcs); /* create 'package' table */ + createsearcherstable(L); + /* set paths */ + setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT); + setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT); + /* store config information */ + lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n" + LUA_EXEC_DIR "\n" LUA_IGMARK "\n"); + lua_setfield(L, -2, "config"); + /* set field 'loaded' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); + lua_setfield(L, -2, "loaded"); + /* set field 'preload' */ + luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE); + lua_setfield(L, -2, "preload"); + lua_pushglobaltable(L); + lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */ + luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */ + lua_pop(L, 1); /* pop global table */ + return 1; /* return 'package' table */ +} + diff --git a/source/external/lua/lobject.c b/source/external/lua/lobject.c new file mode 100644 index 0000000..763b484 --- /dev/null +++ b/source/external/lua/lobject.c @@ -0,0 +1,718 @@ +/* +** $Id: lobject.c $ +** Some generic functions over Lua objects +** See Copyright Notice in lua.h +*/ + +#define lobject_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lctype.h" +#include "ldebug.h" +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "lvm.h" + + +/* +** Computes ceil(log2(x)), which is the smallest integer n such that +** x <= (1 << n). +*/ +lu_byte luaO_ceillog2 (unsigned int x) { + static const lu_byte log_2[256] = { /* log_2[i - 1] = ceil(log2(i)) */ + 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 + }; + int l = 0; + x--; + while (x >= 256) { l += 8; x >>= 8; } + return cast_byte(l + log_2[x]); +} + +/* +** Encodes 'p'% as a floating-point byte, represented as (eeeexxxx). +** The exponent is represented using excess-7. Mimicking IEEE 754, the +** representation normalizes the number when possible, assuming an extra +** 1 before the mantissa (xxxx) and adding one to the exponent (eeee) +** to signal that. So, the real value is (1xxxx) * 2^(eeee - 7 - 1) if +** eeee != 0, and (xxxx) * 2^-7 otherwise (subnormal numbers). +*/ +lu_byte luaO_codeparam (unsigned int p) { + if (p >= (cast(lu_mem, 0x1F) << (0xF - 7 - 1)) * 100u) /* overflow? */ + return 0xFF; /* return maximum value */ + else { + p = (cast(l_uint32, p) * 128 + 99) / 100; /* round up the division */ + if (p < 0x10) { /* subnormal number? */ + /* exponent bits are already zero; nothing else to do */ + return cast_byte(p); + } + else { /* p >= 0x10 implies ceil(log2(p + 1)) >= 5 */ + /* preserve 5 bits in 'p' */ + unsigned log = luaO_ceillog2(p + 1) - 5u; + return cast_byte(((p >> log) - 0x10) | ((log + 1) << 4)); + } + } +} + + +/* +** Computes 'p' times 'x', where 'p' is a floating-point byte. Roughly, +** we have to multiply 'x' by the mantissa and then shift accordingly to +** the exponent. If the exponent is positive, both the multiplication +** and the shift increase 'x', so we have to care only about overflows. +** For negative exponents, however, multiplying before the shift keeps +** more significant bits, as long as the multiplication does not +** overflow, so we check which order is best. +*/ +l_mem luaO_applyparam (lu_byte p, l_mem x) { + int m = p & 0xF; /* mantissa */ + int e = (p >> 4); /* exponent */ + if (e > 0) { /* normalized? */ + e--; /* correct exponent */ + m += 0x10; /* correct mantissa; maximum value is 0x1F */ + } + e -= 7; /* correct excess-7 */ + if (e >= 0) { + if (x < (MAX_LMEM / 0x1F) >> e) /* no overflow? */ + return (x * m) << e; /* order doesn't matter here */ + else /* real overflow */ + return MAX_LMEM; + } + else { /* negative exponent */ + e = -e; + if (x < MAX_LMEM / 0x1F) /* multiplication cannot overflow? */ + return (x * m) >> e; /* multiplying first gives more precision */ + else if ((x >> e) < MAX_LMEM / 0x1F) /* cannot overflow after shift? */ + return (x >> e) * m; + else /* real overflow */ + return MAX_LMEM; + } +} + + +static lua_Integer intarith (lua_State *L, int op, lua_Integer v1, + lua_Integer v2) { + switch (op) { + case LUA_OPADD: return intop(+, v1, v2); + case LUA_OPSUB:return intop(-, v1, v2); + case LUA_OPMUL:return intop(*, v1, v2); + case LUA_OPMOD: return luaV_mod(L, v1, v2); + case LUA_OPIDIV: return luaV_idiv(L, v1, v2); + case LUA_OPBAND: return intop(&, v1, v2); + case LUA_OPBOR: return intop(|, v1, v2); + case LUA_OPBXOR: return intop(^, v1, v2); + case LUA_OPSHL: return luaV_shiftl(v1, v2); + case LUA_OPSHR: return luaV_shiftr(v1, v2); + case LUA_OPUNM: return intop(-, 0, v1); + case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); + default: lua_assert(0); return 0; + } +} + + +static lua_Number numarith (lua_State *L, int op, lua_Number v1, + lua_Number v2) { + switch (op) { + case LUA_OPADD: return luai_numadd(L, v1, v2); + case LUA_OPSUB: return luai_numsub(L, v1, v2); + case LUA_OPMUL: return luai_nummul(L, v1, v2); + case LUA_OPDIV: return luai_numdiv(L, v1, v2); + case LUA_OPPOW: return luai_numpow(L, v1, v2); + case LUA_OPIDIV: return luai_numidiv(L, v1, v2); + case LUA_OPUNM: return luai_numunm(L, v1); + case LUA_OPMOD: return luaV_modf(L, v1, v2); + default: lua_assert(0); return 0; + } +} + + +int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2, + TValue *res) { + switch (op) { + case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: + case LUA_OPSHL: case LUA_OPSHR: + case LUA_OPBNOT: { /* operate only on integers */ + lua_Integer i1; lua_Integer i2; + if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { + setivalue(res, intarith(L, op, i1, i2)); + return 1; + } + else return 0; /* fail */ + } + case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ + lua_Number n1; lua_Number n2; + if (tonumberns(p1, n1) && tonumberns(p2, n2)) { + setfltvalue(res, numarith(L, op, n1, n2)); + return 1; + } + else return 0; /* fail */ + } + default: { /* other operations */ + lua_Number n1; lua_Number n2; + if (ttisinteger(p1) && ttisinteger(p2)) { + setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); + return 1; + } + else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { + setfltvalue(res, numarith(L, op, n1, n2)); + return 1; + } + else return 0; /* fail */ + } + } +} + + +void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2, + StkId res) { + if (!luaO_rawarith(L, op, p1, p2, s2v(res))) { + /* could not perform raw operation; try metamethod */ + luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD)); + } +} + + +lu_byte luaO_hexavalue (int c) { + lua_assert(lisxdigit(c)); + if (lisdigit(c)) return cast_byte(c - '0'); + else return cast_byte((ltolower(c) - 'a') + 10); +} + + +static int isneg (const char **s) { + if (**s == '-') { (*s)++; return 1; } + else if (**s == '+') (*s)++; + return 0; +} + + + +/* +** {================================================================== +** Lua's implementation for 'lua_strx2number' +** =================================================================== +*/ + +#if !defined(lua_strx2number) + +/* maximum number of significant digits to read (to avoid overflows + even with single floats) */ +#define MAXSIGDIG 30 + +/* +** convert a hexadecimal numeric string to a number, following +** C99 specification for 'strtod' +*/ +static lua_Number lua_strx2number (const char *s, char **endptr) { + int dot = lua_getlocaledecpoint(); + lua_Number r = l_mathop(0.0); /* result (accumulator) */ + int sigdig = 0; /* number of significant digits */ + int nosigdig = 0; /* number of non-significant digits */ + int e = 0; /* exponent correction */ + int neg; /* 1 if number is negative */ + int hasdot = 0; /* true after seen a dot */ + *endptr = cast_charp(s); /* nothing is valid yet */ + while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ + neg = isneg(&s); /* check sign */ + if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */ + return l_mathop(0.0); /* invalid format (no '0x') */ + for (s += 2; ; s++) { /* skip '0x' and read numeral */ + if (*s == dot) { + if (hasdot) break; /* second dot? stop loop */ + else hasdot = 1; + } + else if (lisxdigit(cast_uchar(*s))) { + if (sigdig == 0 && *s == '0') /* non-significant digit (zero)? */ + nosigdig++; + else if (++sigdig <= MAXSIGDIG) /* can read it without overflow? */ + r = (r * l_mathop(16.0)) + luaO_hexavalue(*s); + else e++; /* too many digits; ignore, but still count for exponent */ + if (hasdot) e--; /* decimal digit? correct exponent */ + } + else break; /* neither a dot nor a digit */ + } + if (nosigdig + sigdig == 0) /* no digits? */ + return l_mathop(0.0); /* invalid format */ + *endptr = cast_charp(s); /* valid up to here */ + e *= 4; /* each digit multiplies/divides value by 2^4 */ + if (*s == 'p' || *s == 'P') { /* exponent part? */ + int exp1 = 0; /* exponent value */ + int neg1; /* exponent sign */ + s++; /* skip 'p' */ + neg1 = isneg(&s); /* sign */ + if (!lisdigit(cast_uchar(*s))) + return l_mathop(0.0); /* invalid; must have at least one digit */ + while (lisdigit(cast_uchar(*s))) /* read exponent */ + exp1 = exp1 * 10 + *(s++) - '0'; + if (neg1) exp1 = -exp1; + e += exp1; + *endptr = cast_charp(s); /* valid up to here */ + } + if (neg) r = -r; + return l_mathop(ldexp)(r, e); +} + +#endif +/* }====================================================== */ + + +/* maximum length of a numeral to be converted to a number */ +#if !defined (L_MAXLENNUM) +#define L_MAXLENNUM 200 +#endif + +/* +** Convert string 's' to a Lua number (put in 'result'). Return NULL on +** fail or the address of the ending '\0' on success. ('mode' == 'x') +** means a hexadecimal numeral. +*/ +static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { + char *endptr; + *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ + : lua_str2number(s, &endptr); + if (endptr == s) return NULL; /* nothing recognized? */ + while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ + return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ +} + + +/* +** Convert string 's' to a Lua number (put in 'result') handling the +** current locale. +** This function accepts both the current locale or a dot as the radix +** mark. If the conversion fails, it may mean number has a dot but +** locale accepts something else. In that case, the code copies 's' +** to a buffer (because 's' is read-only), changes the dot to the +** current locale radix mark, and tries to convert again. +** The variable 'mode' checks for special characters in the string: +** - 'n' means 'inf' or 'nan' (which should be rejected) +** - 'x' means a hexadecimal numeral +** - '.' just optimizes the search for the common case (no special chars) +*/ +static const char *l_str2d (const char *s, lua_Number *result) { + const char *endptr; + const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ + int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; + if (mode == 'n') /* reject 'inf' and 'nan' */ + return NULL; + endptr = l_str2dloc(s, result, mode); /* try to convert */ + if (endptr == NULL) { /* failed? may be a different locale */ + char buff[L_MAXLENNUM + 1]; + const char *pdot = strchr(s, '.'); + if (pdot == NULL || strlen(s) > L_MAXLENNUM) + return NULL; /* string too long or no dot; fail */ + strcpy(buff, s); /* copy string to buffer */ + buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ + endptr = l_str2dloc(buff, result, mode); /* try again */ + if (endptr != NULL) + endptr = s + (endptr - buff); /* make relative to 's' */ + } + return endptr; +} + + +#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) +#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) + +static const char *l_str2int (const char *s, lua_Integer *result) { + lua_Unsigned a = 0; + int empty = 1; + int neg; + while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ + neg = isneg(&s); + if (s[0] == '0' && + (s[1] == 'x' || s[1] == 'X')) { /* hex? */ + s += 2; /* skip '0x' */ + for (; lisxdigit(cast_uchar(*s)); s++) { + a = a * 16 + luaO_hexavalue(*s); + empty = 0; + } + } + else { /* decimal */ + for (; lisdigit(cast_uchar(*s)); s++) { + int d = *s - '0'; + if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ + return NULL; /* do not accept it (as integer) */ + a = a * 10 + cast_uint(d); + empty = 0; + } + } + while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ + if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ + else { + *result = l_castU2S((neg) ? 0u - a : a); + return s; + } +} + + +size_t luaO_str2num (const char *s, TValue *o) { + lua_Integer i; lua_Number n; + const char *e; + if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ + setivalue(o, i); + } + else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ + setfltvalue(o, n); + } + else + return 0; /* conversion failed */ + return ct_diff2sz(e - s) + 1; /* success; return string size */ +} + + +int luaO_utf8esc (char *buff, l_uint32 x) { + int n = 1; /* number of bytes put in buffer (backwards) */ + lua_assert(x <= 0x7FFFFFFFu); + if (x < 0x80) /* ASCII? */ + buff[UTF8BUFFSZ - 1] = cast_char(x); + else { /* need continuation bytes */ + unsigned int mfb = 0x3f; /* maximum that fits in first byte */ + do { /* add continuation bytes */ + buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); + x >>= 6; /* remove added bits */ + mfb >>= 1; /* now there is one less bit available in first byte */ + } while (x > mfb); /* still needs continuation byte? */ + buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ + } + return n; +} + + +/* +** The size of the buffer for the conversion of a number to a string +** 'LUA_N2SBUFFSZ' must be enough to accommodate both LUA_INTEGER_FMT +** and LUA_NUMBER_FMT. For a long long int, this is 19 digits plus a +** sign and a final '\0', adding to 21. For a long double, it can go to +** a sign, the dot, an exponent letter, an exponent sign, 4 exponent +** digits, the final '\0', plus the significant digits, which are +** approximately the *_DIG attribute. +*/ +#if LUA_N2SBUFFSZ < (20 + l_floatatt(DIG)) +#error "invalid value for LUA_N2SBUFFSZ" +#endif + + +/* +** Convert a float to a string, adding it to a buffer. First try with +** a not too large number of digits, to avoid noise (for instance, +** 1.1 going to "1.1000000000000001"). If that lose precision, so +** that reading the result back gives a different number, then do the +** conversion again with extra precision. Moreover, if the numeral looks +** like an integer (without a decimal point or an exponent), add ".0" to +** its end. +*/ +static int tostringbuffFloat (lua_Number n, char *buff) { + /* first conversion */ + int len = l_sprintf(buff, LUA_N2SBUFFSZ, LUA_NUMBER_FMT, + (LUAI_UACNUMBER)n); + lua_Number check = lua_str2number(buff, NULL); /* read it back */ + if (check != n) { /* not enough precision? */ + /* convert again with more precision */ + len = l_sprintf(buff, LUA_N2SBUFFSZ, LUA_NUMBER_FMT_N, + (LUAI_UACNUMBER)n); + } + /* looks like an integer? */ + if (buff[strspn(buff, "-0123456789")] == '\0') { + buff[len++] = lua_getlocaledecpoint(); + buff[len++] = '0'; /* adds '.0' to result */ + } + return len; +} + + +/* +** Convert a number object to a string, adding it to a buffer. +*/ +unsigned luaO_tostringbuff (const TValue *obj, char *buff) { + int len; + lua_assert(ttisnumber(obj)); + if (ttisinteger(obj)) + len = lua_integer2str(buff, LUA_N2SBUFFSZ, ivalue(obj)); + else + len = tostringbuffFloat(fltvalue(obj), buff); + lua_assert(len < LUA_N2SBUFFSZ); + return cast_uint(len); +} + + +/* +** Convert a number object to a Lua string, replacing the value at 'obj' +*/ +void luaO_tostring (lua_State *L, TValue *obj) { + char buff[LUA_N2SBUFFSZ]; + unsigned len = luaO_tostringbuff(obj, buff); + setsvalue(L, obj, luaS_newlstr(L, buff, len)); +} + + + + +/* +** {================================================================== +** 'luaO_pushvfstring' +** =================================================================== +*/ + +/* +** Size for buffer space used by 'luaO_pushvfstring'. It should be +** (LUA_IDSIZE + LUA_N2SBUFFSZ) + a minimal space for basic messages, +** so that 'luaG_addinfo' can work directly on the static buffer. +*/ +#define BUFVFS cast_uint(LUA_IDSIZE + LUA_N2SBUFFSZ + 95) + +/* +** Buffer used by 'luaO_pushvfstring'. 'err' signals an error while +** building result (memory error [1] or buffer overflow [2]). +*/ +typedef struct BuffFS { + lua_State *L; + char *b; + size_t buffsize; + size_t blen; /* length of string in 'buff' */ + int err; + char space[BUFVFS]; /* initial buffer */ +} BuffFS; + + +static void initbuff (lua_State *L, BuffFS *buff) { + buff->L = L; + buff->b = buff->space; + buff->buffsize = sizeof(buff->space); + buff->blen = 0; + buff->err = 0; +} + + +/* +** Push final result from 'luaO_pushvfstring'. This function may raise +** errors explicitly or through memory errors, so it must run protected. +*/ +static void pushbuff (lua_State *L, void *ud) { + BuffFS *buff = cast(BuffFS*, ud); + switch (buff->err) { + case 1: /* memory error */ + luaD_throw(L, LUA_ERRMEM); + break; + case 2: /* length overflow: Add "..." at the end of result */ + if (buff->buffsize - buff->blen < 3) + strcpy(buff->b + buff->blen - 3, "..."); /* 'blen' must be > 3 */ + else { /* there is enough space left for the "..." */ + strcpy(buff->b + buff->blen, "..."); + buff->blen += 3; + } + /* FALLTHROUGH */ + default: { /* no errors, but it can raise one creating the new string */ + TString *ts = luaS_newlstr(L, buff->b, buff->blen); + setsvalue2s(L, L->top.p, ts); + L->top.p++; + } + } +} + + +static const char *clearbuff (BuffFS *buff) { + lua_State *L = buff->L; + const char *res; + if (luaD_rawrunprotected(L, pushbuff, buff) != LUA_OK) /* errors? */ + res = NULL; /* error message is on the top of the stack */ + else + res = getstr(tsvalue(s2v(L->top.p - 1))); + if (buff->b != buff->space) /* using dynamic buffer? */ + luaM_freearray(L, buff->b, buff->buffsize); /* free it */ + return res; +} + + +static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { + size_t left = buff->buffsize - buff->blen; /* space left in the buffer */ + if (buff->err) /* do nothing else after an error */ + return; + if (slen > left) { /* new string doesn't fit into current buffer? */ + if (slen > ((MAX_SIZE/2) - buff->blen)) { /* overflow? */ + memcpy(buff->b + buff->blen, str, left); /* copy what it can */ + buff->blen = buff->buffsize; + buff->err = 2; /* doesn't add anything else */ + return; + } + else { + size_t newsize = buff->buffsize + slen; /* limited to MAX_SIZE/2 */ + char *newb = + (buff->b == buff->space) /* still using static space? */ + ? luaM_reallocvector(buff->L, NULL, 0, newsize, char) + : luaM_reallocvector(buff->L, buff->b, buff->buffsize, newsize, + char); + if (newb == NULL) { /* allocation error? */ + buff->err = 1; /* signal a memory error */ + return; + } + if (buff->b == buff->space) /* new buffer (not reallocated)? */ + memcpy(newb, buff->b, buff->blen); /* copy previous content */ + buff->b = newb; /* set new (larger) buffer... */ + buff->buffsize = newsize; /* ...and its new size */ + } + } + memcpy(buff->b + buff->blen, str, slen); /* copy new content */ + buff->blen += slen; +} + + +/* +** Add a numeral to the buffer. +*/ +static void addnum2buff (BuffFS *buff, TValue *num) { + char numbuff[LUA_N2SBUFFSZ]; + unsigned len = luaO_tostringbuff(num, numbuff); + addstr2buff(buff, numbuff, len); +} + + +/* +** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%' + conventional formats, plus Lua-specific '%I' and '%U' +*/ +const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { + BuffFS buff; /* holds last part of the result */ + const char *e; /* points to next '%' */ + initbuff(L, &buff); + while ((e = strchr(fmt, '%')) != NULL) { + addstr2buff(&buff, fmt, ct_diff2sz(e - fmt)); /* add 'fmt' up to '%' */ + switch (*(e + 1)) { /* conversion specifier */ + case 's': { /* zero-terminated string */ + const char *s = va_arg(argp, char *); + if (s == NULL) s = "(null)"; + addstr2buff(&buff, s, strlen(s)); + break; + } + case 'c': { /* an 'int' as a character */ + char c = cast_char(va_arg(argp, int)); + addstr2buff(&buff, &c, sizeof(char)); + break; + } + case 'd': { /* an 'int' */ + TValue num; + setivalue(&num, va_arg(argp, int)); + addnum2buff(&buff, &num); + break; + } + case 'I': { /* a 'lua_Integer' */ + TValue num; + setivalue(&num, cast_Integer(va_arg(argp, l_uacInt))); + addnum2buff(&buff, &num); + break; + } + case 'f': { /* a 'lua_Number' */ + TValue num; + setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber))); + addnum2buff(&buff, &num); + break; + } + case 'p': { /* a pointer */ + char bf[LUA_N2SBUFFSZ]; /* enough space for '%p' */ + void *p = va_arg(argp, void *); + int len = lua_pointer2str(bf, LUA_N2SBUFFSZ, p); + addstr2buff(&buff, bf, cast_uint(len)); + break; + } + case 'U': { /* an 'unsigned long' as a UTF-8 sequence */ + char bf[UTF8BUFFSZ]; + unsigned long arg = va_arg(argp, unsigned long); + int len = luaO_utf8esc(bf, cast(l_uint32, arg)); + addstr2buff(&buff, bf + UTF8BUFFSZ - len, cast_uint(len)); + break; + } + case '%': { + addstr2buff(&buff, "%", 1); + break; + } + default: { + addstr2buff(&buff, e, 2); /* keep unknown format in the result */ + break; + } + } + fmt = e + 2; /* skip '%' and the specifier */ + } + addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ + return clearbuff(&buff); /* empty buffer into a new string */ +} + + +const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { + const char *msg; + va_list argp; + va_start(argp, fmt); + msg = luaO_pushvfstring(L, fmt, argp); + va_end(argp); + if (msg == NULL) /* error? */ + luaD_throw(L, LUA_ERRMEM); + return msg; +} + +/* }================================================================== */ + + +#define RETS "..." +#define PRE "[string \"" +#define POS "\"]" + +#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) + +void luaO_chunkid (char *out, const char *source, size_t srclen) { + size_t bufflen = LUA_IDSIZE; /* free space in buffer */ + if (*source == '=') { /* 'literal' source */ + if (srclen <= bufflen) /* small enough? */ + memcpy(out, source + 1, srclen * sizeof(char)); + else { /* truncate it */ + addstr(out, source + 1, bufflen - 1); + *out = '\0'; + } + } + else if (*source == '@') { /* file name */ + if (srclen <= bufflen) /* small enough? */ + memcpy(out, source + 1, srclen * sizeof(char)); + else { /* add '...' before rest of name */ + addstr(out, RETS, LL(RETS)); + bufflen -= LL(RETS); + memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char)); + } + } + else { /* string; format as [string "source"] */ + const char *nl = strchr(source, '\n'); /* find first new line (if any) */ + addstr(out, PRE, LL(PRE)); /* add prefix */ + bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ + if (srclen < bufflen && nl == NULL) { /* small one-line source? */ + addstr(out, source, srclen); /* keep it */ + } + else { + if (nl != NULL) + srclen = ct_diff2sz(nl - source); /* stop at first newline */ + if (srclen > bufflen) srclen = bufflen; + addstr(out, source, srclen); + addstr(out, RETS, LL(RETS)); + } + memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); + } +} + diff --git a/source/external/lua/lopcodes.c b/source/external/lua/lopcodes.c new file mode 100644 index 0000000..7e18231 --- /dev/null +++ b/source/external/lua/lopcodes.c @@ -0,0 +1,140 @@ +/* +** $Id: lopcodes.c $ +** Opcodes for Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#define lopcodes_c +#define LUA_CORE + +#include "lprefix.h" + + +#include "lopcodes.h" + + +#define opmode(mm,ot,it,t,a,m) \ + (((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m)) + + +/* ORDER OP */ + +LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = { +/* MM OT IT T A mode opcode */ + opmode(0, 0, 0, 0, 1, iABC) /* OP_MOVE */ + ,opmode(0, 0, 0, 0, 1, iAsBx) /* OP_LOADI */ + ,opmode(0, 0, 0, 0, 1, iAsBx) /* OP_LOADF */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_LOADK */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_LOADKX */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADFALSE */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_LFALSESKIP */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADTRUE */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADNIL */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETUPVAL */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETUPVAL */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETTABUP */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETTABLE */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETI */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETFIELD */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETTABUP */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETTABLE */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETI */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETFIELD */ + ,opmode(0, 0, 0, 0, 1, ivABC) /* OP_NEWTABLE */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SELF */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADDI */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADDK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SUBK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_MULK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_MODK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_POWK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_DIVK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_IDIVK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BANDK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BORK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BXORK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHLI */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHRI */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADD */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SUB */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_MUL */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_MOD */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_POW */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_DIV */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_IDIV */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BAND */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BOR */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BXOR */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHL */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHR */ + ,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBIN */ + ,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBINI */ + ,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBINK */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_UNM */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_BNOT */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_NOT */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_LEN */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_CONCAT */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_CLOSE */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_TBC */ + ,opmode(0, 0, 0, 0, 0, isJ) /* OP_JMP */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQ */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_LT */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_LE */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQK */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQI */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_LTI */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_LEI */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_GTI */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_GEI */ + ,opmode(0, 0, 0, 1, 0, iABC) /* OP_TEST */ + ,opmode(0, 0, 0, 1, 1, iABC) /* OP_TESTSET */ + ,opmode(0, 1, 1, 0, 1, iABC) /* OP_CALL */ + ,opmode(0, 1, 1, 0, 1, iABC) /* OP_TAILCALL */ + ,opmode(0, 0, 1, 0, 0, iABC) /* OP_RETURN */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_RETURN0 */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_RETURN1 */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_FORLOOP */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_FORPREP */ + ,opmode(0, 0, 0, 0, 0, iABx) /* OP_TFORPREP */ + ,opmode(0, 0, 0, 0, 0, iABC) /* OP_TFORCALL */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_TFORLOOP */ + ,opmode(0, 0, 1, 0, 0, ivABC) /* OP_SETLIST */ + ,opmode(0, 0, 0, 0, 1, iABx) /* OP_CLOSURE */ + ,opmode(0, 1, 0, 0, 1, iABC) /* OP_VARARG */ + ,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETVARG */ + ,opmode(0, 0, 0, 0, 0, iABx) /* OP_ERRNNIL */ + ,opmode(0, 0, 1, 0, 1, iABC) /* OP_VARARGPREP */ + ,opmode(0, 0, 0, 0, 0, iAx) /* OP_EXTRAARG */ +}; + + + +/* +** Check whether instruction sets top for next instruction, that is, +** it results in multiple values. +*/ +int luaP_isOT (Instruction i) { + OpCode op = GET_OPCODE(i); + switch (op) { + case OP_TAILCALL: return 1; + default: + return testOTMode(op) && GETARG_C(i) == 0; + } +} + + +/* +** Check whether instruction uses top from previous instruction, that is, +** it accepts multiple results. +*/ +int luaP_isIT (Instruction i) { + OpCode op = GET_OPCODE(i); + switch (op) { + case OP_SETLIST: + return testITMode(GET_OPCODE(i)) && GETARG_vB(i) == 0; + default: + return testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0; + } +} + diff --git a/source/external/lua/loslib.c b/source/external/lua/loslib.c new file mode 100644 index 0000000..b7a2b0d --- /dev/null +++ b/source/external/lua/loslib.c @@ -0,0 +1,432 @@ +/* +** $Id: loslib.c $ +** Standard Operating System library +** See Copyright Notice in lua.h +*/ + +#define loslib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** {================================================================== +** List of valid conversion specifiers for the 'strftime' function; +** options are grouped by length; group of length 2 start with '||'. +** =================================================================== +*/ +#if !defined(LUA_STRFTIMEOPTIONS) /* { */ + +#if defined(LUA_USE_WINDOWS) +#define LUA_STRFTIMEOPTIONS "aAbBcdHIjmMpSUwWxXyYzZ%" \ + "||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y" /* two-char options */ +#elif defined(LUA_USE_C89) /* C89 (only 1-char options) */ +#define LUA_STRFTIMEOPTIONS "aAbBcdHIjmMpSUwWxXyYZ%" +#else /* C99 specification */ +#define LUA_STRFTIMEOPTIONS "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \ + "||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy" /* two-char options */ +#endif + +#endif /* } */ +/* }================================================================== */ + + +/* +** {================================================================== +** Configuration for time-related stuff +** =================================================================== +*/ + +/* +** type to represent time_t in Lua +*/ +#if !defined(LUA_NUMTIME) /* { */ + +#define l_timet lua_Integer +#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t)) +#define l_gettime(L,arg) luaL_checkinteger(L, arg) + +#else /* }{ */ + +#define l_timet lua_Number +#define l_pushtime(L,t) lua_pushnumber(L,(lua_Number)(t)) +#define l_gettime(L,arg) luaL_checknumber(L, arg) + +#endif /* } */ + + +#if !defined(l_gmtime) /* { */ +/* +** By default, Lua uses gmtime/localtime, except when POSIX is available, +** where it uses gmtime_r/localtime_r +*/ + +#if defined(LUA_USE_POSIX) /* { */ + +#define l_gmtime(t,r) gmtime_r(t,r) +#define l_localtime(t,r) localtime_r(t,r) + +#else /* }{ */ + +/* ISO C definitions */ +#define l_gmtime(t,r) ((void)(r)->tm_sec, gmtime(t)) +#define l_localtime(t,r) ((void)(r)->tm_sec, localtime(t)) + +#endif /* } */ + +#endif /* } */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Configuration for 'tmpnam': +** By default, Lua uses tmpnam except when POSIX is available, where +** it uses mkstemp. +** =================================================================== +*/ +#if !defined(lua_tmpnam) /* { */ + +#if defined(LUA_USE_POSIX) /* { */ + +#include + +#define LUA_TMPNAMBUFSIZE 32 + +#if !defined(LUA_TMPNAMTEMPLATE) +#define LUA_TMPNAMTEMPLATE "/tmp/lua_XXXXXX" +#endif + +#define lua_tmpnam(b,e) { \ + strcpy(b, LUA_TMPNAMTEMPLATE); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } + +#else /* }{ */ + +/* ISO C definitions */ +#define LUA_TMPNAMBUFSIZE L_tmpnam +#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } + +#endif /* } */ + +#endif /* } */ +/* }================================================================== */ + + +#if !defined(l_system) +#if defined(LUA_USE_IOS) +/* Despite claiming to be ISO C, iOS does not implement 'system'. */ +#define l_system(cmd) ((cmd) == NULL ? 0 : -1) +#else +#define l_system(cmd) system(cmd) /* default definition */ +#endif +#endif + + +static int os_execute (lua_State *L) { + const char *cmd = luaL_optstring(L, 1, NULL); + int stat; + errno = 0; + stat = l_system(cmd); + if (cmd != NULL) + return luaL_execresult(L, stat); + else { + lua_pushboolean(L, stat); /* true if there is a shell */ + return 1; + } +} + + +static int os_remove (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + errno = 0; + return luaL_fileresult(L, remove(filename) == 0, filename); +} + + +static int os_rename (lua_State *L) { + const char *fromname = luaL_checkstring(L, 1); + const char *toname = luaL_checkstring(L, 2); + errno = 0; + return luaL_fileresult(L, rename(fromname, toname) == 0, NULL); +} + + +static int os_tmpname (lua_State *L) { + char buff[LUA_TMPNAMBUFSIZE]; + int err; + lua_tmpnam(buff, err); + if (l_unlikely(err)) + return luaL_error(L, "unable to generate a unique filename"); + lua_pushstring(L, buff); + return 1; +} + + +static int os_getenv (lua_State *L) { + lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */ + return 1; +} + + +static int os_clock (lua_State *L) { + lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC); + return 1; +} + + +/* +** {====================================================== +** Time/Date operations +** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S, +** wday=%w+1, yday=%j, isdst=? } +** ======================================================= +*/ + +/* +** About the overflow check: an overflow cannot occur when time +** is represented by a lua_Integer, because either lua_Integer is +** large enough to represent all int fields or it is not large enough +** to represent a time that cause a field to overflow. However, if +** times are represented as doubles and lua_Integer is int, then the +** time 0x1.e1853b0d184f6p+55 would cause an overflow when adding 1900 +** to compute the year. +*/ +static void setfield (lua_State *L, const char *key, int value, int delta) { + #if (defined(LUA_NUMTIME) && LUA_MAXINTEGER <= INT_MAX) + if (l_unlikely(value > LUA_MAXINTEGER - delta)) + luaL_error(L, "field '%s' is out-of-bound", key); + #endif + lua_pushinteger(L, (lua_Integer)value + delta); + lua_setfield(L, -2, key); +} + + +static void setboolfield (lua_State *L, const char *key, int value) { + if (value < 0) /* undefined? */ + return; /* does not set field */ + lua_pushboolean(L, value); + lua_setfield(L, -2, key); +} + + +/* +** Set all fields from structure 'tm' in the table on top of the stack +*/ +static void setallfields (lua_State *L, struct tm *stm) { + setfield(L, "year", stm->tm_year, 1900); + setfield(L, "month", stm->tm_mon, 1); + setfield(L, "day", stm->tm_mday, 0); + setfield(L, "hour", stm->tm_hour, 0); + setfield(L, "min", stm->tm_min, 0); + setfield(L, "sec", stm->tm_sec, 0); + setfield(L, "yday", stm->tm_yday, 1); + setfield(L, "wday", stm->tm_wday, 1); + setboolfield(L, "isdst", stm->tm_isdst); +} + + +static int getboolfield (lua_State *L, const char *key) { + int res; + res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1); + lua_pop(L, 1); + return res; +} + + +static int getfield (lua_State *L, const char *key, int d, int delta) { + int isnum; + int t = lua_getfield(L, -1, key); /* get field and its type */ + lua_Integer res = lua_tointegerx(L, -1, &isnum); + if (!isnum) { /* field is not an integer? */ + if (l_unlikely(t != LUA_TNIL)) /* some other value? */ + return luaL_error(L, "field '%s' is not an integer", key); + else if (l_unlikely(d < 0)) /* absent field; no default? */ + return luaL_error(L, "field '%s' missing in date table", key); + res = d; + } + else { + if (!(res >= 0 ? res - delta <= INT_MAX : INT_MIN + delta <= res)) + return luaL_error(L, "field '%s' is out-of-bound", key); + res -= delta; + } + lua_pop(L, 1); + return (int)res; +} + + +static const char *checkoption (lua_State *L, const char *conv, + size_t convlen, char *buff) { + const char *option = LUA_STRFTIMEOPTIONS; + unsigned oplen = 1; /* length of options being checked */ + for (; *option != '\0' && oplen <= convlen; option += oplen) { + if (*option == '|') /* next block? */ + oplen++; /* will check options with next length (+1) */ + else if (memcmp(conv, option, oplen) == 0) { /* match? */ + memcpy(buff, conv, oplen); /* copy valid option to buffer */ + buff[oplen] = '\0'; + return conv + oplen; /* return next item */ + } + } + luaL_argerror(L, 1, + lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv)); + return conv; /* to avoid warnings */ +} + + +static time_t l_checktime (lua_State *L, int arg) { + l_timet t = l_gettime(L, arg); + luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds"); + return (time_t)t; +} + + +/* maximum size for an individual 'strftime' item */ +#define SIZETIMEFMT 250 + + +static int os_date (lua_State *L) { + size_t slen; + const char *s = luaL_optlstring(L, 1, "%c", &slen); + time_t t = luaL_opt(L, l_checktime, 2, time(NULL)); + const char *se = s + slen; /* 's' end */ + struct tm tmr, *stm; + if (*s == '!') { /* UTC? */ + stm = l_gmtime(&t, &tmr); + s++; /* skip '!' */ + } + else + stm = l_localtime(&t, &tmr); + if (stm == NULL) /* invalid date? */ + return luaL_error(L, + "date result cannot be represented in this installation"); + if (strcmp(s, "*t") == 0) { + lua_createtable(L, 0, 9); /* 9 = number of fields */ + setallfields(L, stm); + } + else { + char cc[4]; /* buffer for individual conversion specifiers */ + luaL_Buffer b; + cc[0] = '%'; + luaL_buffinit(L, &b); + while (s < se) { + if (*s != '%') /* not a conversion specifier? */ + luaL_addchar(&b, *s++); + else { + size_t reslen; + char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT); + s++; /* skip '%' */ + /* copy specifier to 'cc' */ + s = checkoption(L, s, ct_diff2sz(se - s), cc + 1); + reslen = strftime(buff, SIZETIMEFMT, cc, stm); + luaL_addsize(&b, reslen); + } + } + luaL_pushresult(&b); + } + return 1; +} + + +static int os_time (lua_State *L) { + time_t t; + if (lua_isnoneornil(L, 1)) /* called without args? */ + t = time(NULL); /* get current time */ + else { + struct tm ts; + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 1); /* make sure table is at the top */ + ts.tm_year = getfield(L, "year", -1, 1900); + ts.tm_mon = getfield(L, "month", -1, 1); + ts.tm_mday = getfield(L, "day", -1, 0); + ts.tm_hour = getfield(L, "hour", 12, 0); + ts.tm_min = getfield(L, "min", 0, 0); + ts.tm_sec = getfield(L, "sec", 0, 0); + ts.tm_isdst = getboolfield(L, "isdst"); + t = mktime(&ts); + setallfields(L, &ts); /* update fields with normalized values */ + } + if (t != (time_t)(l_timet)t || t == (time_t)(-1)) + return luaL_error(L, + "time result cannot be represented in this installation"); + l_pushtime(L, t); + return 1; +} + + +static int os_difftime (lua_State *L) { + time_t t1 = l_checktime(L, 1); + time_t t2 = l_checktime(L, 2); + lua_pushnumber(L, (lua_Number)difftime(t1, t2)); + return 1; +} + +/* }====================================================== */ + + +static int os_setlocale (lua_State *L) { + static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, + LC_NUMERIC, LC_TIME}; + static const char *const catnames[] = {"all", "collate", "ctype", "monetary", + "numeric", "time", NULL}; + const char *l = luaL_optstring(L, 1, NULL); + int op = luaL_checkoption(L, 2, "all", catnames); + lua_pushstring(L, setlocale(cat[op], l)); + return 1; +} + + +static int os_exit (lua_State *L) { + int status; + if (lua_isboolean(L, 1)) + status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE); + else + status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS); + if (lua_toboolean(L, 2)) + lua_close(L); + if (L) exit(status); /* 'if' to avoid warnings for unreachable 'return' */ + return 0; +} + + +static const luaL_Reg syslib[] = { + {"clock", os_clock}, + {"date", os_date}, + {"difftime", os_difftime}, + {"execute", os_execute}, + {"exit", os_exit}, + {"getenv", os_getenv}, + {"remove", os_remove}, + {"rename", os_rename}, + {"setlocale", os_setlocale}, + {"time", os_time}, + {"tmpname", os_tmpname}, + {NULL, NULL} +}; + +/* }====================================================== */ + + + +LUAMOD_API int luaopen_os (lua_State *L) { + luaL_newlib(L, syslib); + return 1; +} + diff --git a/source/external/lua/lparser.c b/source/external/lua/lparser.c new file mode 100644 index 0000000..b3855d4 --- /dev/null +++ b/source/external/lua/lparser.c @@ -0,0 +1,2193 @@ +/* +** $Id: lparser.c $ +** Lua Parser +** See Copyright Notice in lua.h +*/ + +#define lparser_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" + + + +/* maximum number of variable declarations per function (must be + smaller than 250, due to the bytecode format) */ +#define MAXVARS 200 + + +#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) + + +/* because all strings are unified by the scanner, the parser + can use pointer equality for string equality */ +#define eqstr(a,b) ((a) == (b)) + + +/* +** nodes for block list (list of active blocks) +*/ +typedef struct BlockCnt { + struct BlockCnt *previous; /* chain */ + int firstlabel; /* index of first label in this block */ + int firstgoto; /* index of first pending goto in this block */ + short nactvar; /* number of active declarations at block entry */ + lu_byte upval; /* true if some variable in the block is an upvalue */ + lu_byte isloop; /* 1 if 'block' is a loop; 2 if it has pending breaks */ + lu_byte insidetbc; /* true if inside the scope of a to-be-closed var. */ +} BlockCnt; + + + +/* +** prototypes for recursive non-terminal functions +*/ +static void statement (LexState *ls); +static void expr (LexState *ls, expdesc *v); + + +static l_noret error_expected (LexState *ls, int token) { + luaX_syntaxerror(ls, + luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); +} + + +static l_noret errorlimit (FuncState *fs, int limit, const char *what) { + lua_State *L = fs->ls->L; + const char *msg; + int line = fs->f->linedefined; + const char *where = (line == 0) + ? "main function" + : luaO_pushfstring(L, "function at line %d", line); + msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", + what, limit, where); + luaX_syntaxerror(fs->ls, msg); +} + + +void luaY_checklimit (FuncState *fs, int v, int l, const char *what) { + if (l_unlikely(v > l)) errorlimit(fs, l, what); +} + + +/* +** Test whether next token is 'c'; if so, skip it. +*/ +static int testnext (LexState *ls, int c) { + if (ls->t.token == c) { + luaX_next(ls); + return 1; + } + else return 0; +} + + +/* +** Check that next token is 'c'. +*/ +static void check (LexState *ls, int c) { + if (ls->t.token != c) + error_expected(ls, c); +} + + +/* +** Check that next token is 'c' and skip it. +*/ +static void checknext (LexState *ls, int c) { + check(ls, c); + luaX_next(ls); +} + + +#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } + + +/* +** Check that next token is 'what' and skip it. In case of error, +** raise an error that the expected 'what' should match a 'who' +** in line 'where' (if that is not the current line). +*/ +static void check_match (LexState *ls, int what, int who, int where) { + if (l_unlikely(!testnext(ls, what))) { + if (where == ls->linenumber) /* all in the same line? */ + error_expected(ls, what); /* do not need a complex message */ + else { + luaX_syntaxerror(ls, luaO_pushfstring(ls->L, + "%s expected (to close %s at line %d)", + luaX_token2str(ls, what), luaX_token2str(ls, who), where)); + } + } +} + + +static TString *str_checkname (LexState *ls) { + TString *ts; + check(ls, TK_NAME); + ts = ls->t.seminfo.ts; + luaX_next(ls); + return ts; +} + + +static void init_exp (expdesc *e, expkind k, int i) { + e->f = e->t = NO_JUMP; + e->k = k; + e->u.info = i; +} + + +static void codestring (expdesc *e, TString *s) { + e->f = e->t = NO_JUMP; + e->k = VKSTR; + e->u.strval = s; +} + + +static void codename (LexState *ls, expdesc *e) { + codestring(e, str_checkname(ls)); +} + + +/* +** Register a new local variable in the active 'Proto' (for debug +** information). +*/ +static short registerlocalvar (LexState *ls, FuncState *fs, + TString *varname) { + Proto *f = fs->f; + int oldsize = f->sizelocvars; + luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars, + LocVar, SHRT_MAX, "local variables"); + while (oldsize < f->sizelocvars) + f->locvars[oldsize++].varname = NULL; + f->locvars[fs->ndebugvars].varname = varname; + f->locvars[fs->ndebugvars].startpc = fs->pc; + luaC_objbarrier(ls->L, f, varname); + return fs->ndebugvars++; +} + + +/* +** Create a new variable with the given 'name' and given 'kind'. +** Return its index in the function. +*/ +static int new_varkind (LexState *ls, TString *name, lu_byte kind) { + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Dyndata *dyd = ls->dyd; + Vardesc *var; + luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1, + dyd->actvar.size, Vardesc, SHRT_MAX, "variable declarations"); + var = &dyd->actvar.arr[dyd->actvar.n++]; + var->vd.kind = kind; /* default */ + var->vd.name = name; + return dyd->actvar.n - 1 - fs->firstlocal; +} + + +/* +** Create a new local variable with the given 'name' and regular kind. +*/ +static int new_localvar (LexState *ls, TString *name) { + return new_varkind(ls, name, VDKREG); +} + +#define new_localvarliteral(ls,v) \ + new_localvar(ls, \ + luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); + + + +/* +** Return the "variable description" (Vardesc) of a given variable. +** (Unless noted otherwise, all variables are referred to by their +** compiler indices.) +*/ +static Vardesc *getlocalvardesc (FuncState *fs, int vidx) { + return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx]; +} + + +/* +** Convert 'nvar', a compiler index level, to its corresponding +** register. For that, search for the highest variable below that level +** that is in a register and uses its register index ('ridx') plus one. +*/ +static lu_byte reglevel (FuncState *fs, int nvar) { + while (nvar-- > 0) { + Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */ + if (varinreg(vd)) /* is in a register? */ + return cast_byte(vd->vd.ridx + 1); + } + return 0; /* no variables in registers */ +} + + +/* +** Return the number of variables in the register stack for the given +** function. +*/ +lu_byte luaY_nvarstack (FuncState *fs) { + return reglevel(fs, fs->nactvar); +} + + +/* +** Get the debug-information entry for current variable 'vidx'. +*/ +static LocVar *localdebuginfo (FuncState *fs, int vidx) { + Vardesc *vd = getlocalvardesc(fs, vidx); + if (!varinreg(vd)) + return NULL; /* no debug info. for constants */ + else { + int idx = vd->vd.pidx; + lua_assert(idx < fs->ndebugvars); + return &fs->f->locvars[idx]; + } +} + + +/* +** Create an expression representing variable 'vidx' +*/ +static void init_var (FuncState *fs, expdesc *e, int vidx) { + e->f = e->t = NO_JUMP; + e->k = VLOCAL; + e->u.var.vidx = cast_short(vidx); + e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx; +} + + +/* +** Raises an error if variable described by 'e' is read only; moreover, +** if 'e' is t[exp] where t is the vararg parameter, change it to index +** a real table. (Virtual vararg tables cannot be changed.) +*/ +static void check_readonly (LexState *ls, expdesc *e) { + FuncState *fs = ls->fs; + TString *varname = NULL; /* to be set if variable is const */ + switch (e->k) { + case VCONST: { + varname = ls->dyd->actvar.arr[e->u.info].vd.name; + break; + } + case VLOCAL: case VVARGVAR: { + Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx); + if (vardesc->vd.kind != VDKREG) /* not a regular variable? */ + varname = vardesc->vd.name; + break; + } + case VUPVAL: { + Upvaldesc *up = &fs->f->upvalues[e->u.info]; + if (up->kind != VDKREG) + varname = up->name; + break; + } + case VVARGIND: { + needvatab(fs->f); /* function will need a vararg table */ + e->k = VINDEXED; + } /* FALLTHROUGH */ + case VINDEXUP: case VINDEXSTR: case VINDEXED: { /* global variable */ + if (e->u.ind.ro) /* read-only? */ + varname = tsvalue(&fs->f->k[e->u.ind.keystr]); + break; + } + default: + lua_assert(e->k == VINDEXI); /* this one doesn't need any check */ + return; /* integer index cannot be read-only */ + } + if (varname) + luaK_semerror(ls, "attempt to assign to const variable '%s'", + getstr(varname)); +} + + +/* +** Start the scope for the last 'nvars' created variables. +*/ +static void adjustlocalvars (LexState *ls, int nvars) { + FuncState *fs = ls->fs; + int reglevel = luaY_nvarstack(fs); + int i; + for (i = 0; i < nvars; i++) { + int vidx = fs->nactvar++; + Vardesc *var = getlocalvardesc(fs, vidx); + var->vd.ridx = cast_byte(reglevel++); + var->vd.pidx = registerlocalvar(ls, fs, var->vd.name); + luaY_checklimit(fs, reglevel, MAXVARS, "local variables"); + } +} + + +/* +** Close the scope for all variables up to level 'tolevel'. +** (debug info.) +*/ +static void removevars (FuncState *fs, int tolevel) { + fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); + while (fs->nactvar > tolevel) { + LocVar *var = localdebuginfo(fs, --fs->nactvar); + if (var) /* does it have debug information? */ + var->endpc = fs->pc; + } +} + + +/* +** Search the upvalues of the function 'fs' for one +** with the given 'name'. +*/ +static int searchupvalue (FuncState *fs, TString *name) { + int i; + Upvaldesc *up = fs->f->upvalues; + for (i = 0; i < fs->nups; i++) { + if (eqstr(up[i].name, name)) return i; + } + return -1; /* not found */ +} + + +static Upvaldesc *allocupvalue (FuncState *fs) { + Proto *f = fs->f; + int oldsize = f->sizeupvalues; + luaY_checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); + luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, + Upvaldesc, MAXUPVAL, "upvalues"); + while (oldsize < f->sizeupvalues) + f->upvalues[oldsize++].name = NULL; + return &f->upvalues[fs->nups++]; +} + + +static int newupvalue (FuncState *fs, TString *name, expdesc *v) { + Upvaldesc *up = allocupvalue(fs); + FuncState *prev = fs->prev; + if (v->k == VLOCAL) { + up->instack = 1; + up->idx = v->u.var.ridx; + up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind; + lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name)); + } + else { + up->instack = 0; + up->idx = cast_byte(v->u.info); + up->kind = prev->f->upvalues[v->u.info].kind; + lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name)); + } + up->name = name; + luaC_objbarrier(fs->ls->L, fs->f, name); + return fs->nups - 1; +} + + +/* +** Look for an active variable with the name 'n' in the +** function 'fs'. If found, initialize 'var' with it and return +** its expression kind; otherwise return -1. While searching, +** var->u.info==-1 means that the preambular global declaration is +** active (the default while there is no other global declaration); +** var->u.info==-2 means there is no active collective declaration +** (some previous global declaration but no collective declaration); +** and var->u.info>=0 points to the inner-most (the first one found) +** collective declaration, if there is one. +*/ +static int searchvar (FuncState *fs, TString *n, expdesc *var) { + int i; + for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { + Vardesc *vd = getlocalvardesc(fs, i); + if (varglobal(vd)) { /* global declaration? */ + if (vd->vd.name == NULL) { /* collective declaration? */ + if (var->u.info < 0) /* no previous collective declaration? */ + var->u.info = fs->firstlocal + i; /* this is the first one */ + } + else { /* global name */ + if (eqstr(n, vd->vd.name)) { /* found? */ + init_exp(var, VGLOBAL, fs->firstlocal + i); + return VGLOBAL; + } + else if (var->u.info == -1) /* active preambular declaration? */ + var->u.info = -2; /* invalidate preambular declaration */ + } + } + else if (eqstr(n, vd->vd.name)) { /* found? */ + if (vd->vd.kind == RDKCTC) /* compile-time constant? */ + init_exp(var, VCONST, fs->firstlocal + i); + else { /* local variable */ + init_var(fs, var, i); + if (vd->vd.kind == RDKVAVAR) /* vararg parameter? */ + var->k = VVARGVAR; + } + return cast_int(var->k); + } + } + return -1; /* not found */ +} + + +/* +** Mark block where variable at given level was defined +** (to emit close instructions later). +*/ +static void markupval (FuncState *fs, int level) { + BlockCnt *bl = fs->bl; + while (bl->nactvar > level) + bl = bl->previous; + bl->upval = 1; + fs->needclose = 1; +} + + +/* +** Mark that current block has a to-be-closed variable. +*/ +static void marktobeclosed (FuncState *fs) { + BlockCnt *bl = fs->bl; + bl->upval = 1; + bl->insidetbc = 1; + fs->needclose = 1; +} + + +/* +** Find a variable with the given name 'n'. If it is an upvalue, add +** this upvalue into all intermediate functions. If it is a global, set +** 'var' as 'void' as a flag. +*/ +static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { + int v = searchvar(fs, n, var); /* look up variables at current level */ + if (v >= 0) { /* found? */ + if (!base) { + if (var->k == VVARGVAR) /* vararg parameter? */ + luaK_vapar2local(fs, var); /* change it to a regular local */ + if (var->k == VLOCAL) + markupval(fs, var->u.var.vidx); /* will be used as an upvalue */ + } + /* else nothing else to be done */ + } + else { /* not found at current level; try upvalues */ + int idx = searchupvalue(fs, n); /* try existing upvalues */ + if (idx < 0) { /* not found? */ + if (fs->prev != NULL) /* more levels? */ + singlevaraux(fs->prev, n, var, 0); /* try upper levels */ + if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ + idx = newupvalue(fs, n, var); /* will be a new upvalue */ + else /* it is a global or a constant */ + return; /* don't need to do anything at this level */ + } + init_exp(var, VUPVAL, idx); /* new or old upvalue */ + } +} + + +static void buildglobal (LexState *ls, TString *varname, expdesc *var) { + FuncState *fs = ls->fs; + expdesc key; + init_exp(var, VGLOBAL, -1); /* global by default */ + singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ + if (var->k == VGLOBAL) + luaK_semerror(ls, "%s is global when accessing variable '%s'", + LUA_ENV, getstr(varname)); + luaK_exp2anyregup(fs, var); /* _ENV could be a constant */ + codestring(&key, varname); /* key is variable name */ + luaK_indexed(fs, var, &key); /* 'var' represents _ENV[varname] */ +} + + +/* +** Find a variable with the given name 'n', handling global variables +** too. +*/ +static void buildvar (LexState *ls, TString *varname, expdesc *var) { + FuncState *fs = ls->fs; + init_exp(var, VGLOBAL, -1); /* global by default */ + singlevaraux(fs, varname, var, 1); + if (var->k == VGLOBAL) { /* global name? */ + int info = var->u.info; + /* global by default in the scope of a global declaration? */ + if (info == -2) + luaK_semerror(ls, "variable '%s' not declared", getstr(varname)); + buildglobal(ls, varname, var); + if (info != -1 && ls->dyd->actvar.arr[info].vd.kind == GDKCONST) + var->u.ind.ro = 1; /* mark variable as read-only */ + else /* anyway must be a global */ + lua_assert(info == -1 || ls->dyd->actvar.arr[info].vd.kind == GDKREG); + } +} + + +static void singlevar (LexState *ls, expdesc *var) { + buildvar(ls, str_checkname(ls), var); +} + + +/* +** Adjust the number of results from an expression list 'e' with 'nexps' +** expressions to 'nvars' values. +*/ +static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { + FuncState *fs = ls->fs; + int needed = nvars - nexps; /* extra values needed */ + luaK_checkstack(fs, needed); + if (hasmultret(e->k)) { /* last expression has multiple returns? */ + int extra = needed + 1; /* discount last expression itself */ + if (extra < 0) + extra = 0; + luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ + } + else { + if (e->k != VVOID) /* at least one expression? */ + luaK_exp2nextreg(fs, e); /* close last expression */ + if (needed > 0) /* missing values? */ + luaK_nil(fs, fs->freereg, needed); /* complete with nils */ + } + if (needed > 0) + luaK_reserveregs(fs, needed); /* registers for extra values */ + else /* adding 'needed' is actually a subtraction */ + fs->freereg = cast_byte(fs->freereg + needed); /* remove extra values */ +} + + +#define enterlevel(ls) luaE_incCstack(ls->L) + + +#define leavelevel(ls) ((ls)->L->nCcalls--) + + +/* +** Generates an error that a goto jumps into the scope of some +** variable declaration. +*/ +static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) { + TString *tsname = getlocalvardesc(ls->fs, gt->nactvar)->vd.name; + const char *varname = (tsname != NULL) ? getstr(tsname) : "*"; + luaK_semerror(ls, + " at line %d jumps into the scope of '%s'", + getstr(gt->name), gt->line, varname); /* raise the error */ +} + + +/* +** Closes the goto at index 'g' to given 'label' and removes it +** from the list of pending gotos. +** If it jumps into the scope of some variable, raises an error. +** The goto needs a CLOSE if it jumps out of a block with upvalues, +** or out of the scope of some variable and the block has upvalues +** (signaled by parameter 'bup'). +*/ +static void closegoto (LexState *ls, int g, Labeldesc *label, int bup) { + int i; + FuncState *fs = ls->fs; + Labellist *gl = &ls->dyd->gt; /* list of gotos */ + Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */ + lua_assert(eqstr(gt->name, label->name)); + if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */ + jumpscopeerror(ls, gt); + if (gt->close || + (label->nactvar < gt->nactvar && bup)) { /* needs close? */ + lu_byte stklevel = reglevel(fs, label->nactvar); + /* move jump to CLOSE position */ + fs->f->code[gt->pc + 1] = fs->f->code[gt->pc]; + /* put CLOSE instruction at original position */ + fs->f->code[gt->pc] = CREATE_ABCk(OP_CLOSE, stklevel, 0, 0, 0); + gt->pc++; /* must point to jump instruction */ + } + luaK_patchlist(ls->fs, gt->pc, label->pc); /* goto jumps to label */ + for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */ + gl->arr[i] = gl->arr[i + 1]; + gl->n--; +} + + +/* +** Search for an active label with the given name, starting at +** index 'ilb' (so that it can search for all labels in current block +** or all labels in current function). +*/ +static Labeldesc *findlabel (LexState *ls, TString *name, int ilb) { + Dyndata *dyd = ls->dyd; + for (; ilb < dyd->label.n; ilb++) { + Labeldesc *lb = &dyd->label.arr[ilb]; + if (eqstr(lb->name, name)) /* correct label? */ + return lb; + } + return NULL; /* label not found */ +} + + +/* +** Adds a new label/goto in the corresponding list. +*/ +static int newlabelentry (LexState *ls, Labellist *l, TString *name, + int line, int pc) { + int n = l->n; + luaM_growvector(ls->L, l->arr, n, l->size, + Labeldesc, SHRT_MAX, "labels/gotos"); + l->arr[n].name = name; + l->arr[n].line = line; + l->arr[n].nactvar = ls->fs->nactvar; + l->arr[n].close = 0; + l->arr[n].pc = pc; + l->n = n + 1; + return n; +} + + +/* +** Create an entry for the goto and the code for it. As it is not known +** at this point whether the goto may need a CLOSE, the code has a jump +** followed by an CLOSE. (As the CLOSE comes after the jump, it is a +** dead instruction; it works as a placeholder.) When the goto is closed +** against a label, if it needs a CLOSE, the two instructions swap +** positions, so that the CLOSE comes before the jump. +*/ +static int newgotoentry (LexState *ls, TString *name, int line) { + FuncState *fs = ls->fs; + int pc = luaK_jump(fs); /* create jump */ + luaK_codeABC(fs, OP_CLOSE, 0, 1, 0); /* spaceholder, marked as dead */ + return newlabelentry(ls, &ls->dyd->gt, name, line, pc); +} + + +/* +** Create a new label with the given 'name' at the given 'line'. +** 'last' tells whether label is the last non-op statement in its +** block. Solves all pending gotos to this new label and adds +** a close instruction if necessary. +** Returns true iff it added a close instruction. +*/ +static void createlabel (LexState *ls, TString *name, int line, int last) { + FuncState *fs = ls->fs; + Labellist *ll = &ls->dyd->label; + int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs)); + if (last) { /* label is last no-op statement in the block? */ + /* assume that locals are already out of scope */ + ll->arr[l].nactvar = fs->bl->nactvar; + } +} + + +/* +** Traverse the pending gotos of the finishing block checking whether +** each match some label of that block. Those that do not match are +** "exported" to the outer block, to be solved there. In particular, +** its 'nactvar' is updated with the level of the inner block, +** as the variables of the inner block are now out of scope. +*/ +static void solvegotos (FuncState *fs, BlockCnt *bl) { + LexState *ls = fs->ls; + Labellist *gl = &ls->dyd->gt; + int outlevel = reglevel(fs, bl->nactvar); /* level outside the block */ + int igt = bl->firstgoto; /* first goto in the finishing block */ + while (igt < gl->n) { /* for each pending goto */ + Labeldesc *gt = &gl->arr[igt]; + /* search for a matching label in the current block */ + Labeldesc *lb = findlabel(ls, gt->name, bl->firstlabel); + if (lb != NULL) /* found a match? */ + closegoto(ls, igt, lb, bl->upval); /* close and remove goto */ + else { /* adjust 'goto' for outer block */ + /* block has variables to be closed and goto escapes the scope of + some variable? */ + if (bl->upval && reglevel(fs, gt->nactvar) > outlevel) + gt->close = 1; /* jump may need a close */ + gt->nactvar = bl->nactvar; /* correct level for outer block */ + igt++; /* go to next goto */ + } + } + ls->dyd->label.n = bl->firstlabel; /* remove local labels */ +} + + +static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { + bl->isloop = isloop; + bl->nactvar = fs->nactvar; + bl->firstlabel = fs->ls->dyd->label.n; + bl->firstgoto = fs->ls->dyd->gt.n; + bl->upval = 0; + /* inherit 'insidetbc' from enclosing block */ + bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); + bl->previous = fs->bl; /* link block in function's block list */ + fs->bl = bl; + lua_assert(fs->freereg == luaY_nvarstack(fs)); +} + + +/* +** generates an error for an undefined 'goto'. +*/ +static l_noret undefgoto (LexState *ls, Labeldesc *gt) { + /* breaks are checked when created, cannot be undefined */ + lua_assert(!eqstr(gt->name, ls->brkn)); + luaK_semerror(ls, "no visible label '%s' for at line %d", + getstr(gt->name), gt->line); +} + + +static void leaveblock (FuncState *fs) { + BlockCnt *bl = fs->bl; + LexState *ls = fs->ls; + lu_byte stklevel = reglevel(fs, bl->nactvar); /* level outside block */ + if (bl->previous && bl->upval) /* need a 'close'? */ + luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0); + fs->freereg = stklevel; /* free registers */ + removevars(fs, bl->nactvar); /* remove block locals */ + lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */ + if (bl->isloop == 2) /* has to fix pending breaks? */ + createlabel(ls, ls->brkn, 0, 0); + solvegotos(fs, bl); + if (bl->previous == NULL) { /* was it the last block? */ + if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */ + undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ + } + fs->bl = bl->previous; /* current block now is previous one */ +} + + +/* +** adds a new prototype into list of prototypes +*/ +static Proto *addprototype (LexState *ls) { + Proto *clp; + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; /* prototype of current function */ + if (fs->np >= f->sizep) { + int oldsize = f->sizep; + luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); + while (oldsize < f->sizep) + f->p[oldsize++] = NULL; + } + f->p[fs->np++] = clp = luaF_newproto(L); + luaC_objbarrier(L, f, clp); + return clp; +} + + +/* +** codes instruction to create new closure in parent function. +** The OP_CLOSURE instruction uses the last available register, +** so that, if it invokes the GC, the GC knows which registers +** are in use at that time. + +*/ +static void codeclosure (LexState *ls, expdesc *v) { + FuncState *fs = ls->fs->prev; + init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); + luaK_exp2nextreg(fs, v); /* fix it at the last register */ +} + + +static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { + lua_State *L = ls->L; + Proto *f = fs->f; + fs->prev = ls->fs; /* linked list of funcstates */ + fs->ls = ls; + ls->fs = fs; + fs->pc = 0; + fs->previousline = f->linedefined; + fs->iwthabs = 0; + fs->lasttarget = 0; + fs->freereg = 0; + fs->nk = 0; + fs->nabslineinfo = 0; + fs->np = 0; + fs->nups = 0; + fs->ndebugvars = 0; + fs->nactvar = 0; + fs->needclose = 0; + fs->firstlocal = ls->dyd->actvar.n; + fs->firstlabel = ls->dyd->label.n; + fs->bl = NULL; + f->source = ls->source; + luaC_objbarrier(L, f, f->source); + f->maxstacksize = 2; /* registers 0/1 are always valid */ + fs->kcache = luaH_new(L); /* create table for function */ + sethvalue2s(L, L->top.p, fs->kcache); /* anchor it */ + luaD_inctop(L); + enterblock(fs, bl, 0); +} + + +static void close_func (LexState *ls) { + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; + luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */ + leaveblock(fs); + lua_assert(fs->bl == NULL); + luaK_finish(fs); + luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); + luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte); + luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo, + fs->nabslineinfo, AbsLineInfo); + luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue); + luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); + luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar); + luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); + ls->fs = fs->prev; + L->top.p--; /* pop kcache table */ + luaC_checkGC(L); +} + + +/* +** {====================================================================== +** GRAMMAR RULES +** ======================================================================= +*/ + + +/* +** check whether current token is in the follow set of a block. +** 'until' closes syntactical blocks, but do not close scope, +** so it is handled in separate. +*/ +static int block_follow (LexState *ls, int withuntil) { + switch (ls->t.token) { + case TK_ELSE: case TK_ELSEIF: + case TK_END: case TK_EOS: + return 1; + case TK_UNTIL: return withuntil; + default: return 0; + } +} + + +static void statlist (LexState *ls) { + /* statlist -> { stat [';'] } */ + while (!block_follow(ls, 1)) { + if (ls->t.token == TK_RETURN) { + statement(ls); + return; /* 'return' must be last statement */ + } + statement(ls); + } +} + + +static void fieldsel (LexState *ls, expdesc *v) { + /* fieldsel -> ['.' | ':'] NAME */ + FuncState *fs = ls->fs; + expdesc key; + luaK_exp2anyregup(fs, v); + luaX_next(ls); /* skip the dot or colon */ + codename(ls, &key); + luaK_indexed(fs, v, &key); +} + + +static void yindex (LexState *ls, expdesc *v) { + /* index -> '[' expr ']' */ + luaX_next(ls); /* skip the '[' */ + expr(ls, v); + luaK_exp2val(ls->fs, v); + checknext(ls, ']'); +} + + +/* +** {====================================================================== +** Rules for Constructors +** ======================================================================= +*/ + +typedef struct ConsControl { + expdesc v; /* last list item read */ + expdesc *t; /* table descriptor */ + int nh; /* total number of 'record' elements */ + int na; /* number of array elements already stored */ + int tostore; /* number of array elements pending to be stored */ + int maxtostore; /* maximum number of pending elements */ +} ConsControl; + + +/* +** Maximum number of elements in a constructor, to control the following: +** * counter overflows; +** * overflows in 'extra' for OP_NEWTABLE and OP_SETLIST; +** * overflows when adding multiple returns in OP_SETLIST. +*/ +#define MAX_CNST (INT_MAX/2) +#if MAX_CNST/(MAXARG_vC + 1) > MAXARG_Ax +#undef MAX_CNST +#define MAX_CNST (MAXARG_Ax * (MAXARG_vC + 1)) +#endif + + +static void recfield (LexState *ls, ConsControl *cc) { + /* recfield -> (NAME | '['exp']') = exp */ + FuncState *fs = ls->fs; + lu_byte reg = ls->fs->freereg; + expdesc tab, key, val; + if (ls->t.token == TK_NAME) + codename(ls, &key); + else /* ls->t.token == '[' */ + yindex(ls, &key); + cc->nh++; + checknext(ls, '='); + tab = *cc->t; + luaK_indexed(fs, &tab, &key); + expr(ls, &val); + luaK_storevar(fs, &tab, &val); + fs->freereg = reg; /* free registers */ +} + + +static void closelistfield (FuncState *fs, ConsControl *cc) { + lua_assert(cc->tostore > 0); + luaK_exp2nextreg(fs, &cc->v); + cc->v.k = VVOID; + if (cc->tostore >= cc->maxtostore) { + luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */ + cc->na += cc->tostore; + cc->tostore = 0; /* no more items pending */ + } +} + + +static void lastlistfield (FuncState *fs, ConsControl *cc) { + if (cc->tostore == 0) return; + if (hasmultret(cc->v.k)) { + luaK_setmultret(fs, &cc->v); + luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); + cc->na--; /* do not count last expression (unknown number of elements) */ + } + else { + if (cc->v.k != VVOID) + luaK_exp2nextreg(fs, &cc->v); + luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); + } + cc->na += cc->tostore; +} + + +static void listfield (LexState *ls, ConsControl *cc) { + /* listfield -> exp */ + expr(ls, &cc->v); + cc->tostore++; +} + + +static void field (LexState *ls, ConsControl *cc) { + /* field -> listfield | recfield */ + switch(ls->t.token) { + case TK_NAME: { /* may be 'listfield' or 'recfield' */ + if (luaX_lookahead(ls) != '=') /* expression? */ + listfield(ls, cc); + else + recfield(ls, cc); + break; + } + case '[': { + recfield(ls, cc); + break; + } + default: { + listfield(ls, cc); + break; + } + } +} + + +/* +** Compute a limit for how many registers a constructor can use before +** emitting a 'SETLIST' instruction, based on how many registers are +** available. +*/ +static int maxtostore (FuncState *fs) { + int numfreeregs = MAX_FSTACK - fs->freereg; + if (numfreeregs >= 160) /* "lots" of registers? */ + return numfreeregs / 5; /* use up to 1/5 of them */ + else if (numfreeregs >= 80) /* still "enough" registers? */ + return 10; /* one 'SETLIST' instruction for each 10 values */ + else /* save registers for potential more nesting */ + return 1; +} + + +static void constructor (LexState *ls, expdesc *t) { + /* constructor -> '{' [ field { sep field } [sep] ] '}' + sep -> ',' | ';' */ + FuncState *fs = ls->fs; + int line = ls->linenumber; + int pc = luaK_codevABCk(fs, OP_NEWTABLE, 0, 0, 0, 0); + ConsControl cc; + luaK_code(fs, 0); /* space for extra arg. */ + cc.na = cc.nh = cc.tostore = 0; + cc.t = t; + init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */ + luaK_reserveregs(fs, 1); + init_exp(&cc.v, VVOID, 0); /* no value (yet) */ + checknext(ls, '{' /*}*/); + cc.maxtostore = maxtostore(fs); + do { + if (ls->t.token == /*{*/ '}') break; + if (cc.v.k != VVOID) /* is there a previous list item? */ + closelistfield(fs, &cc); /* close it */ + field(ls, &cc); + luaY_checklimit(fs, cc.tostore + cc.na + cc.nh, MAX_CNST, + "items in a constructor"); + } while (testnext(ls, ',') || testnext(ls, ';')); + check_match(ls, /*{*/ '}', '{' /*}*/, line); + lastlistfield(fs, &cc); + luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh); +} + +/* }====================================================================== */ + + +static void setvararg (FuncState *fs) { + fs->f->flag |= PF_VAHID; /* by default, use hidden vararg arguments */ + luaK_codeABC(fs, OP_VARARGPREP, 0, 0, 0); +} + + +static void parlist (LexState *ls) { + /* parlist -> [ {NAME ','} (NAME | '...') ] */ + FuncState *fs = ls->fs; + Proto *f = fs->f; + int nparams = 0; + int varargk = 0; + if (ls->t.token != ')') { /* is 'parlist' not empty? */ + do { + switch (ls->t.token) { + case TK_NAME: { + new_localvar(ls, str_checkname(ls)); + nparams++; + break; + } + case TK_DOTS: { + varargk = 1; + luaX_next(ls); /* skip '...' */ + if (ls->t.token == TK_NAME) + new_varkind(ls, str_checkname(ls), RDKVAVAR); + else + new_localvarliteral(ls, "(vararg table)"); + break; + } + default: luaX_syntaxerror(ls, " or '...' expected"); + } + } while (!varargk && testnext(ls, ',')); + } + adjustlocalvars(ls, nparams); + f->numparams = cast_byte(fs->nactvar); + if (varargk) { + setvararg(fs); /* declared vararg */ + adjustlocalvars(ls, 1); /* vararg parameter */ + } + /* reserve registers for parameters (plus vararg parameter, if present) */ + luaK_reserveregs(fs, fs->nactvar); +} + + +static void body (LexState *ls, expdesc *e, int ismethod, int line) { + /* body -> '(' parlist ')' block END */ + FuncState new_fs; + BlockCnt bl; + new_fs.f = addprototype(ls); + new_fs.f->linedefined = line; + open_func(ls, &new_fs, &bl); + checknext(ls, '('); + if (ismethod) { + new_localvarliteral(ls, "self"); /* create 'self' parameter */ + adjustlocalvars(ls, 1); + } + parlist(ls); + checknext(ls, ')'); + statlist(ls); + new_fs.f->lastlinedefined = ls->linenumber; + check_match(ls, TK_END, TK_FUNCTION, line); + codeclosure(ls, e); + close_func(ls); +} + + +static int explist (LexState *ls, expdesc *v) { + /* explist -> expr { ',' expr } */ + int n = 1; /* at least one expression */ + expr(ls, v); + while (testnext(ls, ',')) { + luaK_exp2nextreg(ls->fs, v); + expr(ls, v); + n++; + } + return n; +} + + +static void funcargs (LexState *ls, expdesc *f) { + FuncState *fs = ls->fs; + expdesc args; + int base, nparams; + int line = ls->linenumber; + switch (ls->t.token) { + case '(': { /* funcargs -> '(' [ explist ] ')' */ + luaX_next(ls); + if (ls->t.token == ')') /* arg list is empty? */ + args.k = VVOID; + else { + explist(ls, &args); + if (hasmultret(args.k)) + luaK_setmultret(fs, &args); + } + check_match(ls, ')', '(', line); + break; + } + case '{' /*}*/: { /* funcargs -> constructor */ + constructor(ls, &args); + break; + } + case TK_STRING: { /* funcargs -> STRING */ + codestring(&args, ls->t.seminfo.ts); + luaX_next(ls); /* must use 'seminfo' before 'next' */ + break; + } + default: { + luaX_syntaxerror(ls, "function arguments expected"); + } + } + lua_assert(f->k == VNONRELOC); + base = f->u.info; /* base register for call */ + if (hasmultret(args.k)) + nparams = LUA_MULTRET; /* open call */ + else { + if (args.k != VVOID) + luaK_exp2nextreg(fs, &args); /* close last argument */ + nparams = fs->freereg - (base+1); + } + init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); + luaK_fixline(fs, line); + /* call removes function and arguments and leaves one result (unless + changed later) */ + fs->freereg = cast_byte(base + 1); +} + + + + +/* +** {====================================================================== +** Expression parsing +** ======================================================================= +*/ + + +static void primaryexp (LexState *ls, expdesc *v) { + /* primaryexp -> NAME | '(' expr ')' */ + switch (ls->t.token) { + case '(': { + int line = ls->linenumber; + luaX_next(ls); + expr(ls, v); + check_match(ls, ')', '(', line); + luaK_dischargevars(ls->fs, v); + return; + } + case TK_NAME: { + singlevar(ls, v); + return; + } + default: { + luaX_syntaxerror(ls, "unexpected symbol"); + } + } +} + + +static void suffixedexp (LexState *ls, expdesc *v) { + /* suffixedexp -> + primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ + FuncState *fs = ls->fs; + primaryexp(ls, v); + for (;;) { + switch (ls->t.token) { + case '.': { /* fieldsel */ + fieldsel(ls, v); + break; + } + case '[': { /* '[' exp ']' */ + expdesc key; + luaK_exp2anyregup(fs, v); + yindex(ls, &key); + luaK_indexed(fs, v, &key); + break; + } + case ':': { /* ':' NAME funcargs */ + expdesc key; + luaX_next(ls); + codename(ls, &key); + luaK_self(fs, v, &key); + funcargs(ls, v); + break; + } + case '(': case TK_STRING: case '{' /*}*/: { /* funcargs */ + luaK_exp2nextreg(fs, v); + funcargs(ls, v); + break; + } + default: return; + } + } +} + + +static void simpleexp (LexState *ls, expdesc *v) { + /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | + constructor | FUNCTION body | suffixedexp */ + switch (ls->t.token) { + case TK_FLT: { + init_exp(v, VKFLT, 0); + v->u.nval = ls->t.seminfo.r; + break; + } + case TK_INT: { + init_exp(v, VKINT, 0); + v->u.ival = ls->t.seminfo.i; + break; + } + case TK_STRING: { + codestring(v, ls->t.seminfo.ts); + break; + } + case TK_NIL: { + init_exp(v, VNIL, 0); + break; + } + case TK_TRUE: { + init_exp(v, VTRUE, 0); + break; + } + case TK_FALSE: { + init_exp(v, VFALSE, 0); + break; + } + case TK_DOTS: { /* vararg */ + FuncState *fs = ls->fs; + check_condition(ls, isvararg(fs->f), + "cannot use '...' outside a vararg function"); + init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, fs->f->numparams, 1)); + break; + } + case '{' /*}*/: { /* constructor */ + constructor(ls, v); + return; + } + case TK_FUNCTION: { + luaX_next(ls); + body(ls, v, 0, ls->linenumber); + return; + } + default: { + suffixedexp(ls, v); + return; + } + } + luaX_next(ls); +} + + +static UnOpr getunopr (int op) { + switch (op) { + case TK_NOT: return OPR_NOT; + case '-': return OPR_MINUS; + case '~': return OPR_BNOT; + case '#': return OPR_LEN; + default: return OPR_NOUNOPR; + } +} + + +static BinOpr getbinopr (int op) { + switch (op) { + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MUL; + case '%': return OPR_MOD; + case '^': return OPR_POW; + case '/': return OPR_DIV; + case TK_IDIV: return OPR_IDIV; + case '&': return OPR_BAND; + case '|': return OPR_BOR; + case '~': return OPR_BXOR; + case TK_SHL: return OPR_SHL; + case TK_SHR: return OPR_SHR; + case TK_CONCAT: return OPR_CONCAT; + case TK_NE: return OPR_NE; + case TK_EQ: return OPR_EQ; + case '<': return OPR_LT; + case TK_LE: return OPR_LE; + case '>': return OPR_GT; + case TK_GE: return OPR_GE; + case TK_AND: return OPR_AND; + case TK_OR: return OPR_OR; + default: return OPR_NOBINOPR; + } +} + + +/* +** Priority table for binary operators. +*/ +static const struct { + lu_byte left; /* left priority for each binary operator */ + lu_byte right; /* right priority */ +} priority[] = { /* ORDER OPR */ + {10, 10}, {10, 10}, /* '+' '-' */ + {11, 11}, {11, 11}, /* '*' '%' */ + {14, 13}, /* '^' (right associative) */ + {11, 11}, {11, 11}, /* '/' '//' */ + {6, 6}, {4, 4}, {5, 5}, /* '&' '|' '~' */ + {7, 7}, {7, 7}, /* '<<' '>>' */ + {9, 8}, /* '..' (right associative) */ + {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ + {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ + {2, 2}, {1, 1} /* and, or */ +}; + +#define UNARY_PRIORITY 12 /* priority for unary operators */ + + +/* +** subexpr -> (simpleexp | unop subexpr) { binop subexpr } +** where 'binop' is any binary operator with a priority higher than 'limit' +*/ +static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { + BinOpr op; + UnOpr uop; + enterlevel(ls); + uop = getunopr(ls->t.token); + if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */ + int line = ls->linenumber; + luaX_next(ls); /* skip operator */ + subexpr(ls, v, UNARY_PRIORITY); + luaK_prefix(ls->fs, uop, v, line); + } + else simpleexp(ls, v); + /* expand while operators have priorities higher than 'limit' */ + op = getbinopr(ls->t.token); + while (op != OPR_NOBINOPR && priority[op].left > limit) { + expdesc v2; + BinOpr nextop; + int line = ls->linenumber; + luaX_next(ls); /* skip operator */ + luaK_infix(ls->fs, op, v); + /* read sub-expression with higher priority */ + nextop = subexpr(ls, &v2, priority[op].right); + luaK_posfix(ls->fs, op, v, &v2, line); + op = nextop; + } + leavelevel(ls); + return op; /* return first untreated operator */ +} + + +static void expr (LexState *ls, expdesc *v) { + subexpr(ls, v, 0); +} + +/* }==================================================================== */ + + + +/* +** {====================================================================== +** Rules for Statements +** ======================================================================= +*/ + + +static void block (LexState *ls) { + /* block -> statlist */ + FuncState *fs = ls->fs; + BlockCnt bl; + enterblock(fs, &bl, 0); + statlist(ls); + leaveblock(fs); +} + + +/* +** structure to chain all variables in the left-hand side of an +** assignment +*/ +struct LHS_assign { + struct LHS_assign *prev; + expdesc v; /* variable (global, local, upvalue, or indexed) */ +}; + + +/* +** check whether, in an assignment to an upvalue/local variable, the +** upvalue/local variable is begin used in a previous assignment to a +** table. If so, save original upvalue/local value in a safe place and +** use this safe copy in the previous assignment. +*/ +static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { + FuncState *fs = ls->fs; + lu_byte extra = fs->freereg; /* eventual position to save local variable */ + int conflict = 0; + for (; lh; lh = lh->prev) { /* check all previous assignments */ + if (vkisindexed(lh->v.k)) { /* assignment to table field? */ + if (lh->v.k == VINDEXUP) { /* is table an upvalue? */ + if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) { + conflict = 1; /* table is the upvalue being assigned now */ + lh->v.k = VINDEXSTR; + lh->v.u.ind.t = extra; /* assignment will use safe copy */ + } + } + else { /* table is a register */ + if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) { + conflict = 1; /* table is the local being assigned now */ + lh->v.u.ind.t = extra; /* assignment will use safe copy */ + } + /* is index the local being assigned? */ + if (lh->v.k == VINDEXED && v->k == VLOCAL && + lh->v.u.ind.idx == v->u.var.ridx) { + conflict = 1; + lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ + } + } + } + } + if (conflict) { + /* copy upvalue/local value to a temporary (in position 'extra') */ + if (v->k == VLOCAL) + luaK_codeABC(fs, OP_MOVE, extra, v->u.var.ridx, 0); + else + luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0); + luaK_reserveregs(fs, 1); + } +} + + +/* Create code to store the "top" register in 'var' */ +static void storevartop (FuncState *fs, expdesc *var) { + expdesc e; + init_exp(&e, VNONRELOC, fs->freereg - 1); + luaK_storevar(fs, var, &e); /* will also free the top register */ +} + + +/* +** Parse and compile a multiple assignment. The first "variable" +** (a 'suffixedexp') was already read by the caller. +** +** assignment -> suffixedexp restassign +** restassign -> ',' suffixedexp restassign | '=' explist +*/ +static void restassign (LexState *ls, struct LHS_assign *lh, int nvars) { + expdesc e; + check_condition(ls, vkisvar(lh->v.k), "syntax error"); + check_readonly(ls, &lh->v); + if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */ + struct LHS_assign nv; + nv.prev = lh; + suffixedexp(ls, &nv.v); + if (!vkisindexed(nv.v.k)) + check_conflict(ls, lh, &nv.v); + enterlevel(ls); /* control recursion depth */ + restassign(ls, &nv, nvars+1); + leavelevel(ls); + } + else { /* restassign -> '=' explist */ + int nexps; + checknext(ls, '='); + nexps = explist(ls, &e); + if (nexps != nvars) + adjust_assign(ls, nvars, nexps, &e); + else { + luaK_setoneret(ls->fs, &e); /* close last expression */ + luaK_storevar(ls->fs, &lh->v, &e); + return; /* avoid default */ + } + } + storevartop(ls->fs, &lh->v); /* default assignment */ +} + + +static int cond (LexState *ls) { + /* cond -> exp */ + expdesc v; + expr(ls, &v); /* read condition */ + if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ + luaK_goiftrue(ls->fs, &v); + return v.f; +} + + +static void gotostat (LexState *ls, int line) { + TString *name = str_checkname(ls); /* label's name */ + newgotoentry(ls, name, line); +} + + +/* +** Break statement. Semantically equivalent to "goto break". +*/ +static void breakstat (LexState *ls, int line) { + BlockCnt *bl; /* to look for an enclosing loop */ + for (bl = ls->fs->bl; bl != NULL; bl = bl->previous) { + if (bl->isloop) /* found one? */ + goto ok; + } + luaX_syntaxerror(ls, "break outside loop"); + ok: + bl->isloop = 2; /* signal that block has pending breaks */ + luaX_next(ls); /* skip break */ + newgotoentry(ls, ls->brkn, line); +} + + +/* +** Check whether there is already a label with the given 'name' at +** current function. +*/ +static void checkrepeated (LexState *ls, TString *name) { + Labeldesc *lb = findlabel(ls, name, ls->fs->firstlabel); + if (l_unlikely(lb != NULL)) /* already defined? */ + luaK_semerror(ls, "label '%s' already defined on line %d", + getstr(name), lb->line); /* error */ +} + + +static void labelstat (LexState *ls, TString *name, int line) { + /* label -> '::' NAME '::' */ + checknext(ls, TK_DBCOLON); /* skip double colon */ + while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) + statement(ls); /* skip other no-op statements */ + checkrepeated(ls, name); /* check for repeated labels */ + createlabel(ls, name, line, block_follow(ls, 0)); +} + + +static void whilestat (LexState *ls, int line) { + /* whilestat -> WHILE cond DO block END */ + FuncState *fs = ls->fs; + int whileinit; + int condexit; + BlockCnt bl; + luaX_next(ls); /* skip WHILE */ + whileinit = luaK_getlabel(fs); + condexit = cond(ls); + enterblock(fs, &bl, 1); + checknext(ls, TK_DO); + block(ls); + luaK_jumpto(fs, whileinit); + check_match(ls, TK_END, TK_WHILE, line); + leaveblock(fs); + luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ +} + + +static void repeatstat (LexState *ls, int line) { + /* repeatstat -> REPEAT block UNTIL cond */ + int condexit; + FuncState *fs = ls->fs; + int repeat_init = luaK_getlabel(fs); + BlockCnt bl1, bl2; + enterblock(fs, &bl1, 1); /* loop block */ + enterblock(fs, &bl2, 0); /* scope block */ + luaX_next(ls); /* skip REPEAT */ + statlist(ls); + check_match(ls, TK_UNTIL, TK_REPEAT, line); + condexit = cond(ls); /* read condition (inside scope block) */ + leaveblock(fs); /* finish scope */ + if (bl2.upval) { /* upvalues? */ + int exit = luaK_jump(fs); /* normal exit must jump over fix */ + luaK_patchtohere(fs, condexit); /* repetition must close upvalues */ + luaK_codeABC(fs, OP_CLOSE, reglevel(fs, bl2.nactvar), 0, 0); + condexit = luaK_jump(fs); /* repeat after closing upvalues */ + luaK_patchtohere(fs, exit); /* normal exit comes to here */ + } + luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ + leaveblock(fs); /* finish loop */ +} + + +/* +** Read an expression and generate code to put its results in next +** stack slot. +** +*/ +static void exp1 (LexState *ls) { + expdesc e; + expr(ls, &e); + luaK_exp2nextreg(ls->fs, &e); + lua_assert(e.k == VNONRELOC); +} + + +/* +** Fix for instruction at position 'pc' to jump to 'dest'. +** (Jump addresses are relative in Lua). 'back' true means +** a back jump. +*/ +static void fixforjump (FuncState *fs, int pc, int dest, int back) { + Instruction *jmp = &fs->f->code[pc]; + int offset = dest - (pc + 1); + if (back) + offset = -offset; + if (l_unlikely(offset > MAXARG_Bx)) + luaX_syntaxerror(fs->ls, "control structure too long"); + SETARG_Bx(*jmp, offset); +} + + +/* +** Generate code for a 'for' loop. +*/ +static void forbody (LexState *ls, int base, int line, int nvars, int isgen) { + /* forbody -> DO block */ + static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP}; + static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP}; + BlockCnt bl; + FuncState *fs = ls->fs; + int prep, endfor; + checknext(ls, TK_DO); + prep = luaK_codeABx(fs, forprep[isgen], base, 0); + fs->freereg--; /* both 'forprep' remove one register from the stack */ + enterblock(fs, &bl, 0); /* scope for declared variables */ + adjustlocalvars(ls, nvars); + luaK_reserveregs(fs, nvars); + block(ls); + leaveblock(fs); /* end of scope for declared variables */ + fixforjump(fs, prep, luaK_getlabel(fs), 0); + if (isgen) { /* generic for? */ + luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); + luaK_fixline(fs, line); + } + endfor = luaK_codeABx(fs, forloop[isgen], base, 0); + fixforjump(fs, endfor, prep + 1, 1); + luaK_fixline(fs, line); +} + + +static void fornum (LexState *ls, TString *varname, int line) { + /* fornum -> NAME = exp,exp[,exp] forbody */ + FuncState *fs = ls->fs; + int base = fs->freereg; + new_localvarliteral(ls, "(for state)"); + new_localvarliteral(ls, "(for state)"); + new_varkind(ls, varname, RDKCONST); /* control variable */ + checknext(ls, '='); + exp1(ls); /* initial value */ + checknext(ls, ','); + exp1(ls); /* limit */ + if (testnext(ls, ',')) + exp1(ls); /* optional step */ + else { /* default step = 1 */ + luaK_int(fs, fs->freereg, 1); + luaK_reserveregs(fs, 1); + } + adjustlocalvars(ls, 2); /* start scope for internal variables */ + forbody(ls, base, line, 1, 0); +} + + +static void forlist (LexState *ls, TString *indexname) { + /* forlist -> NAME {,NAME} IN explist forbody */ + FuncState *fs = ls->fs; + expdesc e; + int nvars = 4; /* function, state, closing, control */ + int line; + int base = fs->freereg; + /* create internal variables */ + new_localvarliteral(ls, "(for state)"); /* iterator function */ + new_localvarliteral(ls, "(for state)"); /* state */ + new_localvarliteral(ls, "(for state)"); /* closing var. (after swap) */ + new_varkind(ls, indexname, RDKCONST); /* control variable */ + /* other declared variables */ + while (testnext(ls, ',')) { + new_localvar(ls, str_checkname(ls)); + nvars++; + } + checknext(ls, TK_IN); + line = ls->linenumber; + adjust_assign(ls, 4, explist(ls, &e), &e); + adjustlocalvars(ls, 3); /* start scope for internal variables */ + marktobeclosed(fs); /* last internal var. must be closed */ + luaK_checkstack(fs, 2); /* extra space to call iterator */ + forbody(ls, base, line, nvars - 3, 1); +} + + +static void forstat (LexState *ls, int line) { + /* forstat -> FOR (fornum | forlist) END */ + FuncState *fs = ls->fs; + TString *varname; + BlockCnt bl; + enterblock(fs, &bl, 1); /* scope for loop and control variables */ + luaX_next(ls); /* skip 'for' */ + varname = str_checkname(ls); /* first variable name */ + switch (ls->t.token) { + case '=': fornum(ls, varname, line); break; + case ',': case TK_IN: forlist(ls, varname); break; + default: luaX_syntaxerror(ls, "'=' or 'in' expected"); + } + check_match(ls, TK_END, TK_FOR, line); + leaveblock(fs); /* loop scope ('break' jumps to this point) */ +} + + +static void test_then_block (LexState *ls, int *escapelist) { + /* test_then_block -> [IF | ELSEIF] cond THEN block */ + FuncState *fs = ls->fs; + int condtrue; + luaX_next(ls); /* skip IF or ELSEIF */ + condtrue = cond(ls); /* read condition */ + checknext(ls, TK_THEN); + block(ls); /* 'then' part */ + if (ls->t.token == TK_ELSE || + ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ + luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ + luaK_patchtohere(fs, condtrue); +} + + +static void ifstat (LexState *ls, int line) { + /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ + FuncState *fs = ls->fs; + int escapelist = NO_JUMP; /* exit list for finished parts */ + test_then_block(ls, &escapelist); /* IF cond THEN block */ + while (ls->t.token == TK_ELSEIF) + test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ + if (testnext(ls, TK_ELSE)) + block(ls); /* 'else' part */ + check_match(ls, TK_END, TK_IF, line); + luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ +} + + +static void localfunc (LexState *ls) { + expdesc b; + FuncState *fs = ls->fs; + int fvar = fs->nactvar; /* function's variable index */ + new_localvar(ls, str_checkname(ls)); /* new local variable */ + adjustlocalvars(ls, 1); /* enter its scope */ + body(ls, &b, 0, ls->linenumber); /* function created in next register */ + /* debug information will only see the variable after this point! */ + localdebuginfo(fs, fvar)->startpc = fs->pc; +} + + +static lu_byte getvarattribute (LexState *ls, lu_byte df) { + /* attrib -> ['<' NAME '>'] */ + if (testnext(ls, '<')) { + TString *ts = str_checkname(ls); + const char *attr = getstr(ts); + checknext(ls, '>'); + if (strcmp(attr, "const") == 0) + return RDKCONST; /* read-only variable */ + else if (strcmp(attr, "close") == 0) + return RDKTOCLOSE; /* to-be-closed variable */ + else + luaK_semerror(ls, "unknown attribute '%s'", attr); + } + return df; /* return default value */ +} + + +static void checktoclose (FuncState *fs, int level) { + if (level != -1) { /* is there a to-be-closed variable? */ + marktobeclosed(fs); + luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0); + } +} + + +static void localstat (LexState *ls) { + /* stat -> LOCAL NAME attrib { ',' NAME attrib } ['=' explist] */ + FuncState *fs = ls->fs; + int toclose = -1; /* index of to-be-closed variable (if any) */ + Vardesc *var; /* last variable */ + int vidx; /* index of last variable */ + int nvars = 0; + int nexps; + expdesc e; + /* get prefixed attribute (if any); default is regular local variable */ + lu_byte defkind = getvarattribute(ls, VDKREG); + do { /* for each variable */ + TString *vname = str_checkname(ls); /* get its name */ + lu_byte kind = getvarattribute(ls, defkind); /* postfixed attribute */ + vidx = new_varkind(ls, vname, kind); /* predeclare it */ + if (kind == RDKTOCLOSE) { /* to-be-closed? */ + if (toclose != -1) /* one already present? */ + luaK_semerror(ls, "multiple to-be-closed variables in local list"); + toclose = fs->nactvar + nvars; + } + nvars++; + } while (testnext(ls, ',')); + if (testnext(ls, '=')) /* initialization? */ + nexps = explist(ls, &e); + else { + e.k = VVOID; + nexps = 0; + } + var = getlocalvardesc(fs, vidx); /* retrieve last variable */ + if (nvars == nexps && /* no adjustments? */ + var->vd.kind == RDKCONST && /* last variable is const? */ + luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */ + var->vd.kind = RDKCTC; /* variable is a compile-time constant */ + adjustlocalvars(ls, nvars - 1); /* exclude last variable */ + fs->nactvar++; /* but count it */ + } + else { + adjust_assign(ls, nvars, nexps, &e); + adjustlocalvars(ls, nvars); + } + checktoclose(fs, toclose); +} + + +static lu_byte getglobalattribute (LexState *ls, lu_byte df) { + lu_byte kind = getvarattribute(ls, df); + switch (kind) { + case RDKTOCLOSE: + luaK_semerror(ls, "global variables cannot be to-be-closed"); + return kind; /* to avoid warnings */ + case RDKCONST: + return GDKCONST; /* adjust kind for global variable */ + default: + return kind; + } +} + + +static void checkglobal (LexState *ls, TString *varname, int line) { + FuncState *fs = ls->fs; + expdesc var; + int k; + buildglobal(ls, varname, &var); /* create global variable in 'var' */ + k = var.u.ind.keystr; /* index of global name in 'k' */ + luaK_codecheckglobal(fs, &var, k, line); +} + + +/* +** Recursively traverse list of globals to be initalized. When +** going, generate table description for the global. In the end, +** after all indices have been generated, read list of initializing +** expressions. When returning, generate the assignment of the value on +** the stack to the corresponding table description. 'n' is the variable +** being handled, range [0, nvars - 1]. +*/ +static void initglobal (LexState *ls, int nvars, int firstidx, int n, + int line) { + if (n == nvars) { /* traversed all variables? */ + expdesc e; + int nexps = explist(ls, &e); /* read list of expressions */ + adjust_assign(ls, nvars, nexps, &e); + } + else { /* handle variable 'n' */ + FuncState *fs = ls->fs; + expdesc var; + TString *varname = getlocalvardesc(fs, firstidx + n)->vd.name; + buildglobal(ls, varname, &var); /* create global variable in 'var' */ + enterlevel(ls); /* control recursion depth */ + initglobal(ls, nvars, firstidx, n + 1, line); + leavelevel(ls); + checkglobal(ls, varname, line); + storevartop(fs, &var); + } +} + + +static void globalnames (LexState *ls, lu_byte defkind) { + FuncState *fs = ls->fs; + int nvars = 0; + int lastidx; /* index of last registered variable */ + do { /* for each name */ + TString *vname = str_checkname(ls); + lu_byte kind = getglobalattribute(ls, defkind); + lastidx = new_varkind(ls, vname, kind); + nvars++; + } while (testnext(ls, ',')); + if (testnext(ls, '=')) /* initialization? */ + initglobal(ls, nvars, lastidx - nvars + 1, 0, ls->linenumber); + fs->nactvar = cast_short(fs->nactvar + nvars); /* activate declaration */ +} + + +static void globalstat (LexState *ls) { + /* globalstat -> (GLOBAL) attrib '*' + globalstat -> (GLOBAL) attrib NAME attrib {',' NAME attrib} */ + FuncState *fs = ls->fs; + /* get prefixed attribute (if any); default is regular global variable */ + lu_byte defkind = getglobalattribute(ls, GDKREG); + if (!testnext(ls, '*')) + globalnames(ls, defkind); + else { + /* use NULL as name to represent '*' entries */ + new_varkind(ls, NULL, defkind); + fs->nactvar++; /* activate declaration */ + } +} + + +static void globalfunc (LexState *ls, int line) { + /* globalfunc -> (GLOBAL FUNCTION) NAME body */ + expdesc var, b; + FuncState *fs = ls->fs; + TString *fname = str_checkname(ls); + new_varkind(ls, fname, GDKREG); /* declare global variable */ + fs->nactvar++; /* enter its scope */ + buildglobal(ls, fname, &var); + body(ls, &b, 0, ls->linenumber); /* compile and return closure in 'b' */ + checkglobal(ls, fname, line); + luaK_storevar(fs, &var, &b); + luaK_fixline(fs, line); /* definition "happens" in the first line */ +} + + +static void globalstatfunc (LexState *ls, int line) { + /* stat -> GLOBAL globalfunc | GLOBAL globalstat */ + luaX_next(ls); /* skip 'global' */ + if (testnext(ls, TK_FUNCTION)) + globalfunc(ls, line); + else + globalstat(ls); +} + + +static int funcname (LexState *ls, expdesc *v) { + /* funcname -> NAME {fieldsel} [':' NAME] */ + int ismethod = 0; + singlevar(ls, v); + while (ls->t.token == '.') + fieldsel(ls, v); + if (ls->t.token == ':') { + ismethod = 1; + fieldsel(ls, v); + } + return ismethod; +} + + +static void funcstat (LexState *ls, int line) { + /* funcstat -> FUNCTION funcname body */ + int ismethod; + expdesc v, b; + luaX_next(ls); /* skip FUNCTION */ + ismethod = funcname(ls, &v); + check_readonly(ls, &v); + body(ls, &b, ismethod, line); + luaK_storevar(ls->fs, &v, &b); + luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ +} + + +static void exprstat (LexState *ls) { + /* stat -> func | assignment */ + FuncState *fs = ls->fs; + struct LHS_assign v; + suffixedexp(ls, &v.v); + if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ + v.prev = NULL; + restassign(ls, &v, 1); + } + else { /* stat -> func */ + Instruction *inst; + check_condition(ls, v.v.k == VCALL, "syntax error"); + inst = &getinstruction(fs, &v.v); + SETARG_C(*inst, 1); /* call statement uses no results */ + } +} + + +static void retstat (LexState *ls) { + /* stat -> RETURN [explist] [';'] */ + FuncState *fs = ls->fs; + expdesc e; + int nret; /* number of values being returned */ + int first = luaY_nvarstack(fs); /* first slot to be returned */ + if (block_follow(ls, 1) || ls->t.token == ';') + nret = 0; /* return no values */ + else { + nret = explist(ls, &e); /* optional return values */ + if (hasmultret(e.k)) { + luaK_setmultret(fs, &e); + if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */ + SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); + lua_assert(GETARG_A(getinstruction(fs,&e)) == luaY_nvarstack(fs)); + } + nret = LUA_MULTRET; /* return all values */ + } + else { + if (nret == 1) /* only one single value? */ + first = luaK_exp2anyreg(fs, &e); /* can use original slot */ + else { /* values must go to the top of the stack */ + luaK_exp2nextreg(fs, &e); + lua_assert(nret == fs->freereg - first); + } + } + } + luaK_ret(fs, first, nret); + testnext(ls, ';'); /* skip optional semicolon */ +} + + +static void statement (LexState *ls) { + int line = ls->linenumber; /* may be needed for error messages */ + enterlevel(ls); + switch (ls->t.token) { + case ';': { /* stat -> ';' (empty statement) */ + luaX_next(ls); /* skip ';' */ + break; + } + case TK_IF: { /* stat -> ifstat */ + ifstat(ls, line); + break; + } + case TK_WHILE: { /* stat -> whilestat */ + whilestat(ls, line); + break; + } + case TK_DO: { /* stat -> DO block END */ + luaX_next(ls); /* skip DO */ + block(ls); + check_match(ls, TK_END, TK_DO, line); + break; + } + case TK_FOR: { /* stat -> forstat */ + forstat(ls, line); + break; + } + case TK_REPEAT: { /* stat -> repeatstat */ + repeatstat(ls, line); + break; + } + case TK_FUNCTION: { /* stat -> funcstat */ + funcstat(ls, line); + break; + } + case TK_LOCAL: { /* stat -> localstat */ + luaX_next(ls); /* skip LOCAL */ + if (testnext(ls, TK_FUNCTION)) /* local function? */ + localfunc(ls); + else + localstat(ls); + break; + } + case TK_GLOBAL: { /* stat -> globalstatfunc */ + globalstatfunc(ls, line); + break; + } + case TK_DBCOLON: { /* stat -> label */ + luaX_next(ls); /* skip double colon */ + labelstat(ls, str_checkname(ls), line); + break; + } + case TK_RETURN: { /* stat -> retstat */ + luaX_next(ls); /* skip RETURN */ + retstat(ls); + break; + } + case TK_BREAK: { /* stat -> breakstat */ + breakstat(ls, line); + break; + } + case TK_GOTO: { /* stat -> 'goto' NAME */ + luaX_next(ls); /* skip 'goto' */ + gotostat(ls, line); + break; + } +#if defined(LUA_COMPAT_GLOBAL) + case TK_NAME: { + /* compatibility code to parse global keyword when "global" + is not reserved */ + if (ls->t.seminfo.ts == ls->glbn) { /* current = "global"? */ + int lk = luaX_lookahead(ls); + if (lk == '<' || lk == TK_NAME || lk == '*' || lk == TK_FUNCTION) { + /* 'global ' or 'global name' or 'global *' or + 'global function' */ + globalstatfunc(ls, line); + break; + } + } /* else... */ + } +#endif + /* FALLTHROUGH */ + default: { /* stat -> func | assignment */ + exprstat(ls); + break; + } + } + lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && + ls->fs->freereg >= luaY_nvarstack(ls->fs)); + ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ + leavelevel(ls); +} + +/* }====================================================================== */ + +/* }====================================================================== */ + + +/* +** compiles the main function, which is a regular vararg function with an +** upvalue named LUA_ENV +*/ +static void mainfunc (LexState *ls, FuncState *fs) { + BlockCnt bl; + Upvaldesc *env; + open_func(ls, fs, &bl); + setvararg(fs); /* main function is always vararg */ + env = allocupvalue(fs); /* ...set environment upvalue */ + env->instack = 1; + env->idx = 0; + env->kind = VDKREG; + env->name = ls->envn; + luaC_objbarrier(ls->L, fs->f, env->name); + luaX_next(ls); /* read first token */ + statlist(ls); /* parse main body */ + check(ls, TK_EOS); + close_func(ls); +} + + +LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, + Dyndata *dyd, const char *name, int firstchar) { + LexState lexstate; + FuncState funcstate; + LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ + setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ + luaD_inctop(L); + lexstate.h = luaH_new(L); /* create table for scanner */ + sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ + luaD_inctop(L); + funcstate.f = cl->p = luaF_newproto(L); + luaC_objbarrier(L, cl, cl->p); + funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ + luaC_objbarrier(L, funcstate.f, funcstate.f->source); + lexstate.buff = buff; + lexstate.dyd = dyd; + dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; + luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); + mainfunc(&lexstate, &funcstate); + lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); + /* all scopes should be correctly finished */ + lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); + L->top.p--; /* remove scanner's table */ + return cl; /* closure is on the stack, too */ +} + diff --git a/source/external/lua/lstate.c b/source/external/lua/lstate.c new file mode 100644 index 0000000..70a11aa --- /dev/null +++ b/source/external/lua/lstate.c @@ -0,0 +1,420 @@ +/* +** $Id: lstate.c $ +** Global State +** See Copyright Notice in lua.h +*/ + +#define lstate_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + + +#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) + + +/* +** these macros allow user-specific actions when a thread is +** created/deleted +*/ +#if !defined(luai_userstateopen) +#define luai_userstateopen(L) ((void)L) +#endif + +#if !defined(luai_userstateclose) +#define luai_userstateclose(L) ((void)L) +#endif + +#if !defined(luai_userstatethread) +#define luai_userstatethread(L,L1) ((void)L) +#endif + +#if !defined(luai_userstatefree) +#define luai_userstatefree(L,L1) ((void)L) +#endif + + +/* +** set GCdebt to a new value keeping the real number of allocated +** objects (GCtotalobjs - GCdebt) invariant and avoiding overflows in +** 'GCtotalobjs'. +*/ +void luaE_setdebt (global_State *g, l_mem debt) { + l_mem tb = gettotalbytes(g); + lua_assert(tb > 0); + if (debt > MAX_LMEM - tb) + debt = MAX_LMEM - tb; /* will make GCtotalbytes == MAX_LMEM */ + g->GCtotalbytes = tb + debt; + g->GCdebt = debt; +} + + +CallInfo *luaE_extendCI (lua_State *L) { + CallInfo *ci; + lua_assert(L->ci->next == NULL); + ci = luaM_new(L, CallInfo); + lua_assert(L->ci->next == NULL); + L->ci->next = ci; + ci->previous = L->ci; + ci->next = NULL; + ci->u.l.trap = 0; + L->nci++; + return ci; +} + + +/* +** free all CallInfo structures not in use by a thread +*/ +static void freeCI (lua_State *L) { + CallInfo *ci = L->ci; + CallInfo *next = ci->next; + ci->next = NULL; + while ((ci = next) != NULL) { + next = ci->next; + luaM_free(L, ci); + L->nci--; + } +} + + +/* +** free half of the CallInfo structures not in use by a thread, +** keeping the first one. +*/ +void luaE_shrinkCI (lua_State *L) { + CallInfo *ci = L->ci->next; /* first free CallInfo */ + CallInfo *next; + if (ci == NULL) + return; /* no extra elements */ + while ((next = ci->next) != NULL) { /* two extra elements? */ + CallInfo *next2 = next->next; /* next's next */ + ci->next = next2; /* remove next from the list */ + L->nci--; + luaM_free(L, next); /* free next */ + if (next2 == NULL) + break; /* no more elements */ + else { + next2->previous = ci; + ci = next2; /* continue */ + } + } +} + + +/* +** Called when 'getCcalls(L)' larger or equal to LUAI_MAXCCALLS. +** If equal, raises an overflow error. If value is larger than +** LUAI_MAXCCALLS (which means it is handling an overflow) but +** not much larger, does not report an error (to allow overflow +** handling to work). +*/ +void luaE_checkcstack (lua_State *L) { + if (getCcalls(L) == LUAI_MAXCCALLS) + luaG_runerror(L, "C stack overflow"); + else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11)) + luaD_errerr(L); /* error while handling stack error */ +} + + +LUAI_FUNC void luaE_incCstack (lua_State *L) { + L->nCcalls++; + if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) + luaE_checkcstack(L); +} + + +static void resetCI (lua_State *L) { + CallInfo *ci = L->ci = &L->base_ci; + ci->func.p = L->stack.p; + setnilvalue(s2v(ci->func.p)); /* 'function' entry for basic 'ci' */ + ci->top.p = ci->func.p + 1 + LUA_MINSTACK; /* +1 for 'function' entry */ + ci->u.c.k = NULL; + ci->callstatus = CIST_C; + L->status = LUA_OK; + L->errfunc = 0; /* stack unwind can "throw away" the error function */ +} + + +static void stack_init (lua_State *L1, lua_State *L) { + int i; + /* initialize stack array */ + L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); + L1->tbclist.p = L1->stack.p; + for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) + setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ + L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; + /* initialize first ci */ + resetCI(L1); + L1->top.p = L1->stack.p + 1; /* +1 for 'function' entry */ +} + + +static void freestack (lua_State *L) { + if (L->stack.p == NULL) + return; /* stack not completely built yet */ + L->ci = &L->base_ci; /* free the entire 'ci' list */ + freeCI(L); + lua_assert(L->nci == 0); + /* free stack */ + luaM_freearray(L, L->stack.p, cast_sizet(stacksize(L) + EXTRA_STACK)); +} + + +/* +** Create registry table and its predefined values +*/ +static void init_registry (lua_State *L, global_State *g) { + /* create registry */ + TValue aux; + Table *registry = luaH_new(L); + sethvalue(L, &g->l_registry, registry); + luaH_resize(L, registry, LUA_RIDX_LAST, 0); + /* registry[1] = false */ + setbfvalue(&aux); + luaH_setint(L, registry, 1, &aux); + /* registry[LUA_RIDX_MAINTHREAD] = L */ + setthvalue(L, &aux, L); + luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &aux); + /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ + sethvalue(L, &aux, luaH_new(L)); + luaH_setint(L, registry, LUA_RIDX_GLOBALS, &aux); +} + + +/* +** open parts of the state that may cause memory-allocation errors. +*/ +static void f_luaopen (lua_State *L, void *ud) { + global_State *g = G(L); + UNUSED(ud); + stack_init(L, L); /* init stack */ + init_registry(L, g); + luaS_init(L); + luaT_init(L); + luaX_init(L); + g->gcstp = 0; /* allow gc */ + setnilvalue(&g->nilvalue); /* now state is complete */ + luai_userstateopen(L); +} + + +/* +** preinitialize a thread with consistent values without allocating +** any memory (to avoid errors) +*/ +static void preinit_thread (lua_State *L, global_State *g) { + G(L) = g; + L->stack.p = NULL; + L->ci = NULL; + L->nci = 0; + L->twups = L; /* thread has no upvalues */ + L->nCcalls = 0; + L->errorJmp = NULL; + L->hook = NULL; + L->hookmask = 0; + L->basehookcount = 0; + L->allowhook = 1; + resethookcount(L); + L->openupval = NULL; + L->status = LUA_OK; + L->errfunc = 0; + L->oldpc = 0; + L->base_ci.previous = L->base_ci.next = NULL; +} + + +lu_mem luaE_threadsize (lua_State *L) { + lu_mem sz = cast(lu_mem, sizeof(LX)) + + cast_uint(L->nci) * sizeof(CallInfo); + if (L->stack.p != NULL) + sz += cast_uint(stacksize(L) + EXTRA_STACK) * sizeof(StackValue); + return sz; +} + + +static void close_state (lua_State *L) { + global_State *g = G(L); + if (!completestate(g)) /* closing a partially built state? */ + luaC_freeallobjects(L); /* just collect its objects */ + else { /* closing a fully built state */ + resetCI(L); + luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ + L->top.p = L->stack.p + 1; /* empty the stack to run finalizers */ + luaC_freeallobjects(L); /* collect all objects */ + luai_userstateclose(L); + } + luaM_freearray(L, G(L)->strt.hash, cast_sizet(G(L)->strt.size)); + freestack(L); + lua_assert(gettotalbytes(g) == sizeof(global_State)); + (*g->frealloc)(g->ud, g, sizeof(global_State), 0); /* free main block */ +} + + +LUA_API lua_State *lua_newthread (lua_State *L) { + global_State *g = G(L); + GCObject *o; + lua_State *L1; + lua_lock(L); + luaC_checkGC(L); + /* create new thread */ + o = luaC_newobjdt(L, LUA_TTHREAD, sizeof(LX), offsetof(LX, l)); + L1 = gco2th(o); + /* anchor it on L stack */ + setthvalue2s(L, L->top.p, L1); + api_incr_top(L); + preinit_thread(L1, g); + L1->hookmask = L->hookmask; + L1->basehookcount = L->basehookcount; + L1->hook = L->hook; + resethookcount(L1); + /* initialize L1 extra space */ + memcpy(lua_getextraspace(L1), lua_getextraspace(mainthread(g)), + LUA_EXTRASPACE); + luai_userstatethread(L, L1); + stack_init(L1, L); /* init stack */ + lua_unlock(L); + return L1; +} + + +void luaE_freethread (lua_State *L, lua_State *L1) { + LX *l = fromstate(L1); + luaF_closeupval(L1, L1->stack.p); /* close all upvalues */ + lua_assert(L1->openupval == NULL); + luai_userstatefree(L, L1); + freestack(L1); + luaM_free(L, l); +} + + +TStatus luaE_resetthread (lua_State *L, TStatus status) { + resetCI(L); + if (status == LUA_YIELD) + status = LUA_OK; + status = luaD_closeprotected(L, 1, status); + if (status != LUA_OK) /* errors? */ + luaD_seterrorobj(L, status, L->stack.p + 1); + else + L->top.p = L->stack.p + 1; + luaD_reallocstack(L, cast_int(L->ci->top.p - L->stack.p), 0); + return status; +} + + +LUA_API int lua_closethread (lua_State *L, lua_State *from) { + TStatus status; + lua_lock(L); + L->nCcalls = (from) ? getCcalls(from) : 0; + status = luaE_resetthread(L, L->status); + if (L == from) /* closing itself? */ + luaD_throwbaselevel(L, status); + lua_unlock(L); + return APIstatus(status); +} + + +LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud, unsigned seed) { + int i; + lua_State *L; + global_State *g = cast(global_State*, + (*f)(ud, NULL, LUA_TTHREAD, sizeof(global_State))); + if (g == NULL) return NULL; + L = &g->mainth.l; + L->tt = LUA_VTHREAD; + g->currentwhite = bitmask(WHITE0BIT); + L->marked = luaC_white(g); + preinit_thread(L, g); + g->allgc = obj2gco(L); /* by now, only object is the main thread */ + L->next = NULL; + incnny(L); /* main thread is always non yieldable */ + g->frealloc = f; + g->ud = ud; + g->warnf = NULL; + g->ud_warn = NULL; + g->seed = seed; + g->gcstp = GCSTPGC; /* no GC while building state */ + g->strt.size = g->strt.nuse = 0; + g->strt.hash = NULL; + setnilvalue(&g->l_registry); + g->panic = NULL; + g->gcstate = GCSpause; + g->gckind = KGC_INC; + g->gcstopem = 0; + g->gcemergency = 0; + g->finobj = g->tobefnz = g->fixedgc = NULL; + g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; + g->finobjsur = g->finobjold1 = g->finobjrold = NULL; + g->sweepgc = NULL; + g->gray = g->grayagain = NULL; + g->weak = g->ephemeron = g->allweak = NULL; + g->twups = NULL; + g->GCtotalbytes = sizeof(global_State); + g->GCmarked = 0; + g->GCdebt = 0; + setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ + setgcparam(g, PAUSE, LUAI_GCPAUSE); + setgcparam(g, STEPMUL, LUAI_GCMUL); + setgcparam(g, STEPSIZE, LUAI_GCSTEPSIZE); + setgcparam(g, MINORMUL, LUAI_GENMINORMUL); + setgcparam(g, MINORMAJOR, LUAI_MINORMAJOR); + setgcparam(g, MAJORMINOR, LUAI_MAJORMINOR); + for (i=0; i < LUA_NUMTYPES; i++) g->mt[i] = NULL; + if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { + /* memory allocation error: free partial state */ + close_state(L); + L = NULL; + } + return L; +} + + +LUA_API void lua_close (lua_State *L) { + lua_lock(L); + L = mainthread(G(L)); /* only the main thread can be closed */ + close_state(L); +} + + +void luaE_warning (lua_State *L, const char *msg, int tocont) { + lua_WarnFunction wf = G(L)->warnf; + if (wf != NULL) + wf(G(L)->ud_warn, msg, tocont); +} + + +/* +** Generate a warning from an error message +*/ +void luaE_warnerror (lua_State *L, const char *where) { + TValue *errobj = s2v(L->top.p - 1); /* error object */ + const char *msg = (ttisstring(errobj)) + ? getstr(tsvalue(errobj)) + : "error object is not a string"; + /* produce warning "error in %s (%s)" (where, msg) */ + luaE_warning(L, "error in ", 1); + luaE_warning(L, where, 1); + luaE_warning(L, " (", 1); + luaE_warning(L, msg, 1); + luaE_warning(L, ")", 0); +} + diff --git a/source/external/lua/lstring.c b/source/external/lua/lstring.c new file mode 100644 index 0000000..7563514 --- /dev/null +++ b/source/external/lua/lstring.c @@ -0,0 +1,353 @@ +/* +** $Id: lstring.c $ +** String table (keeps all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + +#define lstring_c +#define LUA_CORE + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" + + +/* +** Maximum size for string table. +*/ +#define MAXSTRTB cast_int(luaM_limitN(INT_MAX, TString*)) + +/* +** Initial size for the string table (must be power of 2). +** The Lua core alone registers ~50 strings (reserved words + +** metaevent keys + a few others). Libraries would typically add +** a few dozens more. +*/ +#if !defined(MINSTRTABSIZE) +#define MINSTRTABSIZE 128 +#endif + + +/* +** generic equality for strings +*/ +int luaS_eqstr (TString *a, TString *b) { + size_t len1, len2; + const char *s1 = getlstr(a, len1); + const char *s2 = getlstr(b, len2); + return ((len1 == len2) && /* equal length and ... */ + (memcmp(s1, s2, len1) == 0)); /* equal contents */ +} + + +static unsigned luaS_hash (const char *str, size_t l, unsigned seed) { + unsigned int h = seed ^ cast_uint(l); + for (; l > 0; l--) + h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); + return h; +} + + +unsigned luaS_hashlongstr (TString *ts) { + lua_assert(ts->tt == LUA_VLNGSTR); + if (ts->extra == 0) { /* no hash? */ + size_t len = ts->u.lnglen; + ts->hash = luaS_hash(getlngstr(ts), len, ts->hash); + ts->extra = 1; /* now it has its hash */ + } + return ts->hash; +} + + +static void tablerehash (TString **vect, int osize, int nsize) { + int i; + for (i = osize; i < nsize; i++) /* clear new elements */ + vect[i] = NULL; + for (i = 0; i < osize; i++) { /* rehash old part of the array */ + TString *p = vect[i]; + vect[i] = NULL; + while (p) { /* for each string in the list */ + TString *hnext = p->u.hnext; /* save next */ + unsigned int h = lmod(p->hash, nsize); /* new position */ + p->u.hnext = vect[h]; /* chain it into array */ + vect[h] = p; + p = hnext; + } + } +} + + +/* +** Resize the string table. If allocation fails, keep the current size. +** (This can degrade performance, but any non-zero size should work +** correctly.) +*/ +void luaS_resize (lua_State *L, int nsize) { + stringtable *tb = &G(L)->strt; + int osize = tb->size; + TString **newvect; + if (nsize < osize) /* shrinking table? */ + tablerehash(tb->hash, osize, nsize); /* depopulate shrinking part */ + newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*); + if (l_unlikely(newvect == NULL)) { /* reallocation failed? */ + if (nsize < osize) /* was it shrinking table? */ + tablerehash(tb->hash, nsize, osize); /* restore to original size */ + /* leave table as it was */ + } + else { /* allocation succeeded */ + tb->hash = newvect; + tb->size = nsize; + if (nsize > osize) + tablerehash(newvect, osize, nsize); /* rehash for new size */ + } +} + + +/* +** Clear API string cache. (Entries cannot be empty, so fill them with +** a non-collectable string.) +*/ +void luaS_clearcache (global_State *g) { + int i, j; + for (i = 0; i < STRCACHE_N; i++) + for (j = 0; j < STRCACHE_M; j++) { + if (iswhite(g->strcache[i][j])) /* will entry be collected? */ + g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ + } +} + + +/* +** Initialize the string table and the string cache +*/ +void luaS_init (lua_State *L) { + global_State *g = G(L); + int i, j; + stringtable *tb = &G(L)->strt; + tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); + tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ + tb->size = MINSTRTABSIZE; + /* pre-create memory-error message */ + g->memerrmsg = luaS_newliteral(L, MEMERRMSG); + luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ + for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ + for (j = 0; j < STRCACHE_M; j++) + g->strcache[i][j] = g->memerrmsg; +} + + +size_t luaS_sizelngstr (size_t len, int kind) { + switch (kind) { + case LSTRREG: /* regular long string */ + /* don't need 'falloc'/'ud', but need space for content */ + return offsetof(TString, falloc) + (len + 1) * sizeof(char); + case LSTRFIX: /* fixed external long string */ + /* don't need 'falloc'/'ud' */ + return offsetof(TString, falloc); + default: /* external long string with deallocation */ + lua_assert(kind == LSTRMEM); + return sizeof(TString); + } +} + + +/* +** creates a new string object +*/ +static TString *createstrobj (lua_State *L, size_t totalsize, lu_byte tag, + unsigned h) { + TString *ts; + GCObject *o; + o = luaC_newobj(L, tag, totalsize); + ts = gco2ts(o); + ts->hash = h; + ts->extra = 0; + return ts; +} + + +TString *luaS_createlngstrobj (lua_State *L, size_t l) { + size_t totalsize = luaS_sizelngstr(l, LSTRREG); + TString *ts = createstrobj(L, totalsize, LUA_VLNGSTR, G(L)->seed); + ts->u.lnglen = l; + ts->shrlen = LSTRREG; /* signals that it is a regular long string */ + ts->contents = cast_charp(ts) + offsetof(TString, falloc); + ts->contents[l] = '\0'; /* ending 0 */ + return ts; +} + + +void luaS_remove (lua_State *L, TString *ts) { + stringtable *tb = &G(L)->strt; + TString **p = &tb->hash[lmod(ts->hash, tb->size)]; + while (*p != ts) /* find previous element */ + p = &(*p)->u.hnext; + *p = (*p)->u.hnext; /* remove element from its list */ + tb->nuse--; +} + + +static void growstrtab (lua_State *L, stringtable *tb) { + if (l_unlikely(tb->nuse == INT_MAX)) { /* too many strings? */ + luaC_fullgc(L, 1); /* try to free some... */ + if (tb->nuse == INT_MAX) /* still too many? */ + luaM_error(L); /* cannot even create a message... */ + } + if (tb->size <= MAXSTRTB / 2) /* can grow string table? */ + luaS_resize(L, tb->size * 2); +} + + +/* +** Checks whether short string exists and reuses it or creates a new one. +*/ +static TString *internshrstr (lua_State *L, const char *str, size_t l) { + TString *ts; + global_State *g = G(L); + stringtable *tb = &g->strt; + unsigned int h = luaS_hash(str, l, g->seed); + TString **list = &tb->hash[lmod(h, tb->size)]; + lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ + for (ts = *list; ts != NULL; ts = ts->u.hnext) { + if (l == cast_uint(ts->shrlen) && + (memcmp(str, getshrstr(ts), l * sizeof(char)) == 0)) { + /* found! */ + if (isdead(g, ts)) /* dead (but not collected yet)? */ + changewhite(ts); /* resurrect it */ + return ts; + } + } + /* else must create a new string */ + if (tb->nuse >= tb->size) { /* need to grow string table? */ + growstrtab(L, tb); + list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ + } + ts = createstrobj(L, sizestrshr(l), LUA_VSHRSTR, h); + ts->shrlen = cast(ls_byte, l); + getshrstr(ts)[l] = '\0'; /* ending 0 */ + memcpy(getshrstr(ts), str, l * sizeof(char)); + ts->u.hnext = *list; + *list = ts; + tb->nuse++; + return ts; +} + + +/* +** new string (with explicit length) +*/ +TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { + if (l <= LUAI_MAXSHORTLEN) /* short string? */ + return internshrstr(L, str, l); + else { + TString *ts; + if (l_unlikely(l * sizeof(char) >= (MAX_SIZE - sizeof(TString)))) + luaM_toobig(L); + ts = luaS_createlngstrobj(L, l); + memcpy(getlngstr(ts), str, l * sizeof(char)); + return ts; + } +} + + +/* +** Create or reuse a zero-terminated string, first checking in the +** cache (using the string address as a key). The cache can contain +** only zero-terminated strings, so it is safe to use 'strcmp' to +** check hits. +*/ +TString *luaS_new (lua_State *L, const char *str) { + unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ + int j; + TString **p = G(L)->strcache[i]; + for (j = 0; j < STRCACHE_M; j++) { + if (strcmp(str, getstr(p[j])) == 0) /* hit? */ + return p[j]; /* that is it */ + } + /* 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]; +} + + +Udata *luaS_newudata (lua_State *L, size_t s, unsigned short nuvalue) { + Udata *u; + int i; + GCObject *o; + if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue))) + luaM_toobig(L); + o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); + u = gco2u(o); + u->len = s; + u->nuvalue = nuvalue; + u->metatable = NULL; + for (i = 0; i < nuvalue; i++) + setnilvalue(&u->uv[i].uv); + return u; +} + + +struct NewExt { + ls_byte kind; + const char *s; + size_t len; + TString *ts; /* output */ +}; + + +static void f_newext (lua_State *L, void *ud) { + struct NewExt *ne = cast(struct NewExt *, ud); + size_t size = luaS_sizelngstr(0, ne->kind); + ne->ts = createstrobj(L, size, LUA_VLNGSTR, G(L)->seed); +} + + +TString *luaS_newextlstr (lua_State *L, + const char *s, size_t len, lua_Alloc falloc, void *ud) { + struct NewExt ne; + if (!falloc) { + ne.kind = LSTRFIX; + f_newext(L, &ne); /* just create header */ + } + else { + ne.kind = LSTRMEM; + if (luaD_rawrunprotected(L, f_newext, &ne) != LUA_OK) { /* mem. error? */ + (*falloc)(ud, cast_voidp(s), len + 1, 0); /* free external string */ + luaM_error(L); /* re-raise memory error */ + } + ne.ts->falloc = falloc; + ne.ts->ud = ud; + } + ne.ts->shrlen = ne.kind; + ne.ts->u.lnglen = len; + ne.ts->contents = cast_charp(s); + return ne.ts; +} + + +/* +** Normalize an external string: If it is short, internalize it. +*/ +TString *luaS_normstr (lua_State *L, TString *ts) { + size_t len = ts->u.lnglen; + if (len > LUAI_MAXSHORTLEN) + return ts; /* long string; keep the original */ + else { + const char *str = getlngstr(ts); + return internshrstr(L, str, len); + } +} + diff --git a/source/external/lua/lstrlib.c b/source/external/lua/lstrlib.c new file mode 100644 index 0000000..23df839 --- /dev/null +++ b/source/external/lua/lstrlib.c @@ -0,0 +1,1894 @@ +/* +** $Id: lstrlib.c $ +** Standard library for string operations and pattern-matching +** See Copyright Notice in lua.h +*/ + +#define lstrlib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** maximum number of captures that a pattern can do during +** pattern-matching. This limit is arbitrary, but must fit in +** an unsigned char. +*/ +#if !defined(LUA_MAXCAPTURES) +#define LUA_MAXCAPTURES 32 +#endif + + +static int str_len (lua_State *L) { + size_t l; + luaL_checklstring(L, 1, &l); + lua_pushinteger(L, (lua_Integer)l); + return 1; +} + + +/* +** translate a relative initial string position +** (negative means back from end): clip result to [1, inf). +** The length of any string in Lua must fit in a lua_Integer, +** so there are no overflows in the casts. +** The inverted comparison avoids a possible overflow +** computing '-pos'. +*/ +static size_t posrelatI (lua_Integer pos, size_t len) { + if (pos > 0) + return (size_t)pos; + else if (pos == 0) + return 1; + else if (pos < -(lua_Integer)len) /* inverted comparison */ + return 1; /* clip to 1 */ + else return len + (size_t)pos + 1; +} + + +/* +** Gets an optional ending string position from argument 'arg', +** with default value 'def'. +** Negative means back from end: clip result to [0, len] +*/ +static size_t getendpos (lua_State *L, int arg, lua_Integer def, + size_t len) { + lua_Integer pos = luaL_optinteger(L, arg, def); + if (pos > (lua_Integer)len) + return len; + else if (pos >= 0) + return (size_t)pos; + else if (pos < -(lua_Integer)len) + return 0; + else return len + (size_t)pos + 1; +} + + +static int str_sub (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + size_t start = posrelatI(luaL_checkinteger(L, 2), l); + size_t end = getendpos(L, 3, -1, l); + if (start <= end) + lua_pushlstring(L, s + start - 1, (end - start) + 1); + else lua_pushliteral(L, ""); + return 1; +} + + +static int str_reverse (lua_State *L) { + size_t l, i; + luaL_Buffer b; + const char *s = luaL_checklstring(L, 1, &l); + char *p = luaL_buffinitsize(L, &b, l); + for (i = 0; i < l; i++) + p[i] = s[l - i - 1]; + luaL_pushresultsize(&b, l); + return 1; +} + + +static int str_lower (lua_State *L) { + size_t l; + size_t i; + luaL_Buffer b; + const char *s = luaL_checklstring(L, 1, &l); + char *p = luaL_buffinitsize(L, &b, l); + for (i=0; i MAX_SIZE - lsep || + cast_st2S(len + lsep) > cast_st2S(MAX_SIZE) / n)) + return luaL_error(L, "resulting string too large"); + else { + size_t totallen = (cast_sizet(n) * (len + lsep)) - lsep; + luaL_Buffer b; + char *p = luaL_buffinitsize(L, &b, totallen); + while (n-- > 1) { /* first n-1 copies (followed by separator) */ + memcpy(p, s, len * sizeof(char)); p += len; + if (lsep > 0) { /* empty 'memcpy' is not that cheap */ + memcpy(p, sep, lsep * sizeof(char)); p += lsep; + } + } + memcpy(p, s, len * sizeof(char)); /* last copy without separator */ + luaL_pushresultsize(&b, totallen); + } + return 1; +} + + +static int str_byte (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + lua_Integer pi = luaL_optinteger(L, 2, 1); + size_t posi = posrelatI(pi, l); + size_t pose = getendpos(L, 3, pi, l); + int n, i; + if (posi > pose) return 0; /* empty interval; return no values */ + if (l_unlikely(pose - posi >= (size_t)INT_MAX)) /* arithmetic overflow? */ + return luaL_error(L, "string slice too long"); + n = (int)(pose - posi) + 1; + luaL_checkstack(L, n, "string slice too long"); + for (i=0; iinit) { + state->init = 1; + luaL_buffinit(L, &state->B); + } + if (b == NULL) { /* finishing dump? */ + luaL_pushresult(&state->B); /* push result */ + lua_replace(L, 1); /* move it to reserved slot */ + } + else + luaL_addlstring(&state->B, (const char *)b, size); + return 0; +} + + +static int str_dump (lua_State *L) { + struct str_Writer state; + int strip = lua_toboolean(L, 2); + luaL_argcheck(L, lua_type(L, 1) == LUA_TFUNCTION && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + /* ensure function is on the top of the stack and vacate slot 1 */ + lua_pushvalue(L, 1); + state.init = 0; + lua_dump(L, writer, &state, strip); + lua_settop(L, 1); /* leave final result on top */ + return 1; +} + + + +/* +** {====================================================== +** METAMETHODS +** ======================================================= +*/ + +#if defined(LUA_NOCVTS2N) /* { */ + +/* no coercion from strings to numbers */ + +static const luaL_Reg stringmetamethods[] = { + {"__index", NULL}, /* placeholder */ + {NULL, NULL} +}; + +#else /* }{ */ + +static int tonum (lua_State *L, int arg) { + if (lua_type(L, arg) == LUA_TNUMBER) { /* already a number? */ + lua_pushvalue(L, arg); + return 1; + } + else { /* check whether it is a numerical string */ + size_t len; + const char *s = lua_tolstring(L, arg, &len); + return (s != NULL && lua_stringtonumber(L, s) == len + 1); + } +} + + +/* +** To be here, either the first operand was a string or the first +** operand didn't have a corresponding metamethod. (Otherwise, that +** other metamethod would have been called.) So, if this metamethod +** doesn't work, the only other option would be for the second +** operand to have a different metamethod. +*/ +static void trymt (lua_State *L, const char *mtkey, const char *opname) { + lua_settop(L, 2); /* back to the original arguments */ + if (l_unlikely(lua_type(L, 2) == LUA_TSTRING || + !luaL_getmetafield(L, 2, mtkey))) + luaL_error(L, "attempt to %s a '%s' with a '%s'", opname, + luaL_typename(L, -2), luaL_typename(L, -1)); + lua_insert(L, -3); /* put metamethod before arguments */ + lua_call(L, 2, 1); /* call metamethod */ +} + + +static int arith (lua_State *L, int op, const char *mtname) { + if (tonum(L, 1) && tonum(L, 2)) + lua_arith(L, op); /* result will be on the top */ + else + trymt(L, mtname, mtname + 2); + return 1; +} + + +static int arith_add (lua_State *L) { + return arith(L, LUA_OPADD, "__add"); +} + +static int arith_sub (lua_State *L) { + return arith(L, LUA_OPSUB, "__sub"); +} + +static int arith_mul (lua_State *L) { + return arith(L, LUA_OPMUL, "__mul"); +} + +static int arith_mod (lua_State *L) { + return arith(L, LUA_OPMOD, "__mod"); +} + +static int arith_pow (lua_State *L) { + return arith(L, LUA_OPPOW, "__pow"); +} + +static int arith_div (lua_State *L) { + return arith(L, LUA_OPDIV, "__div"); +} + +static int arith_idiv (lua_State *L) { + return arith(L, LUA_OPIDIV, "__idiv"); +} + +static int arith_unm (lua_State *L) { + return arith(L, LUA_OPUNM, "__unm"); +} + + +static const luaL_Reg stringmetamethods[] = { + {"__add", arith_add}, + {"__sub", arith_sub}, + {"__mul", arith_mul}, + {"__mod", arith_mod}, + {"__pow", arith_pow}, + {"__div", arith_div}, + {"__idiv", arith_idiv}, + {"__unm", arith_unm}, + {"__index", NULL}, /* placeholder */ + {NULL, NULL} +}; + +#endif /* } */ + +/* }====================================================== */ + +/* +** {====================================================== +** PATTERN MATCHING +** ======================================================= +*/ + + +#define CAP_UNFINISHED (-1) +#define CAP_POSITION (-2) + + +typedef struct MatchState { + const char *src_init; /* init of source string */ + const char *src_end; /* end ('\0') of source string */ + const char *p_end; /* end ('\0') of pattern */ + lua_State *L; + int matchdepth; /* control for recursive depth (to avoid C stack overflow) */ + int level; /* total number of captures (finished or unfinished) */ + struct { + const char *init; + ptrdiff_t len; /* length or special value (CAP_*) */ + } capture[LUA_MAXCAPTURES]; +} MatchState; + + +/* recursive function */ +static const char *match (MatchState *ms, const char *s, const char *p); + + +/* maximum recursion depth for 'match' */ +#if !defined(MAXCCALLS) +#define MAXCCALLS 200 +#endif + + +#define L_ESC '%' +#define SPECIALS "^$*+?.([%-" + + +static int check_capture (MatchState *ms, int l) { + l -= '1'; + if (l_unlikely(l < 0 || l >= ms->level || + ms->capture[l].len == CAP_UNFINISHED)) + return luaL_error(ms->L, "invalid capture index %%%d", l + 1); + return l; +} + + +static int capture_to_close (MatchState *ms) { + int level = ms->level; + for (level--; level>=0; level--) + if (ms->capture[level].len == CAP_UNFINISHED) return level; + return luaL_error(ms->L, "invalid pattern capture"); +} + + +static const char *classend (MatchState *ms, const char *p) { + switch (*p++) { + case L_ESC: { + if (l_unlikely(p == ms->p_end)) + luaL_error(ms->L, "malformed pattern (ends with '%%')"); + return p+1; + } + case '[': { + if (*p == '^') p++; + do { /* look for a ']' */ + if (l_unlikely(p == ms->p_end)) + luaL_error(ms->L, "malformed pattern (missing ']')"); + if (*(p++) == L_ESC && p < ms->p_end) + p++; /* skip escapes (e.g. '%]') */ + } while (*p != ']'); + return p+1; + } + default: { + return p; + } + } +} + + +static int match_class (int c, int cl) { + int res; + switch (tolower(cl)) { + case 'a' : res = isalpha(c); break; + case 'c' : res = iscntrl(c); break; + case 'd' : res = isdigit(c); break; + case 'g' : res = isgraph(c); break; + case 'l' : res = islower(c); break; + case 'p' : res = ispunct(c); break; + case 's' : res = isspace(c); break; + case 'u' : res = isupper(c); break; + case 'w' : res = isalnum(c); break; + case 'x' : res = isxdigit(c); break; + case 'z' : res = (c == 0); break; /* deprecated option */ + default: return (cl == c); + } + return (islower(cl) ? res : !res); +} + + +static int matchbracketclass (int c, const char *p, const char *ec) { + int sig = 1; + if (*(p+1) == '^') { + sig = 0; + p++; /* skip the '^' */ + } + while (++p < ec) { + if (*p == L_ESC) { + p++; + if (match_class(c, cast_uchar(*p))) + return sig; + } + else if ((*(p+1) == '-') && (p+2 < ec)) { + p+=2; + if (cast_uchar(*(p-2)) <= c && c <= cast_uchar(*p)) + return sig; + } + else if (cast_uchar(*p) == c) return sig; + } + return !sig; +} + + +static int singlematch (MatchState *ms, const char *s, const char *p, + const char *ep) { + if (s >= ms->src_end) + return 0; + else { + int c = cast_uchar(*s); + switch (*p) { + case '.': return 1; /* matches any char */ + case L_ESC: return match_class(c, cast_uchar(*(p+1))); + case '[': return matchbracketclass(c, p, ep-1); + default: return (cast_uchar(*p) == c); + } + } +} + + +static const char *matchbalance (MatchState *ms, const char *s, + const char *p) { + if (l_unlikely(p >= ms->p_end - 1)) + luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')"); + if (*s != *p) return NULL; + else { + int b = *p; + int e = *(p+1); + int cont = 1; + while (++s < ms->src_end) { + if (*s == e) { + if (--cont == 0) return s+1; + } + else if (*s == b) cont++; + } + } + return NULL; /* string ends out of balance */ +} + + +static const char *max_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + ptrdiff_t i = 0; /* counts maximum expand for item */ + while (singlematch(ms, s + i, p, ep)) + i++; + /* keeps trying to match with the maximum repetitions */ + while (i>=0) { + const char *res = match(ms, (s+i), ep+1); + if (res) return res; + i--; /* else didn't match; reduce 1 repetition to try again */ + } + return NULL; +} + + +static const char *min_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + for (;;) { + const char *res = match(ms, s, ep+1); + if (res != NULL) + return res; + else if (singlematch(ms, s, p, ep)) + s++; /* try with one more repetition */ + else return NULL; + } +} + + +static const char *start_capture (MatchState *ms, const char *s, + const char *p, int what) { + const char *res; + int level = ms->level; + if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures"); + ms->capture[level].init = s; + ms->capture[level].len = what; + ms->level = level+1; + if ((res=match(ms, s, p)) == NULL) /* match failed? */ + ms->level--; /* undo capture */ + return res; +} + + +static const char *end_capture (MatchState *ms, const char *s, + const char *p) { + int l = capture_to_close(ms); + const char *res; + ms->capture[l].len = s - ms->capture[l].init; /* close capture */ + if ((res = match(ms, s, p)) == NULL) /* match failed? */ + ms->capture[l].len = CAP_UNFINISHED; /* undo capture */ + return res; +} + + +static const char *match_capture (MatchState *ms, const char *s, int l) { + size_t len; + l = check_capture(ms, l); + len = cast_sizet(ms->capture[l].len); + if ((size_t)(ms->src_end-s) >= len && + memcmp(ms->capture[l].init, s, len) == 0) + return s+len; + else return NULL; +} + + +static const char *match (MatchState *ms, const char *s, const char *p) { + if (l_unlikely(ms->matchdepth-- == 0)) + luaL_error(ms->L, "pattern too complex"); + init: /* using goto to optimize tail recursion */ + if (p != ms->p_end) { /* end of pattern? */ + switch (*p) { + case '(': { /* start capture */ + if (*(p + 1) == ')') /* position capture? */ + s = start_capture(ms, s, p + 2, CAP_POSITION); + else + s = start_capture(ms, s, p + 1, CAP_UNFINISHED); + break; + } + case ')': { /* end capture */ + s = end_capture(ms, s, p + 1); + break; + } + case '$': { + if ((p + 1) != ms->p_end) /* is the '$' the last char in pattern? */ + goto dflt; /* no; go to default */ + s = (s == ms->src_end) ? s : NULL; /* check end of string */ + break; + } + case L_ESC: { /* escaped sequences not in the format class[*+?-]? */ + switch (*(p + 1)) { + case 'b': { /* balanced string? */ + s = matchbalance(ms, s, p + 2); + if (s != NULL) { + p += 4; goto init; /* return match(ms, s, p + 4); */ + } /* else fail (s == NULL) */ + break; + } + case 'f': { /* frontier? */ + const char *ep; char previous; + p += 2; + if (l_unlikely(*p != '[')) + luaL_error(ms->L, "missing '[' after '%%f' in pattern"); + ep = classend(ms, p); /* points to what is next */ + previous = (s == ms->src_init) ? '\0' : *(s - 1); + if (!matchbracketclass(cast_uchar(previous), p, ep - 1) && + matchbracketclass(cast_uchar(*s), p, ep - 1)) { + p = ep; goto init; /* return match(ms, s, ep); */ + } + s = NULL; /* match failed */ + break; + } + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + case '8': case '9': { /* capture results (%0-%9)? */ + s = match_capture(ms, s, cast_uchar(*(p + 1))); + if (s != NULL) { + p += 2; goto init; /* return match(ms, s, p + 2) */ + } + break; + } + default: goto dflt; + } + break; + } + default: dflt: { /* pattern class plus optional suffix */ + const char *ep = classend(ms, p); /* points to optional suffix */ + /* does not match at least once? */ + if (!singlematch(ms, s, p, ep)) { + if (*ep == '*' || *ep == '?' || *ep == '-') { /* accept empty? */ + p = ep + 1; goto init; /* return match(ms, s, ep + 1); */ + } + else /* '+' or no suffix */ + s = NULL; /* fail */ + } + else { /* matched once */ + switch (*ep) { /* handle optional suffix */ + case '?': { /* optional */ + const char *res; + if ((res = match(ms, s + 1, ep + 1)) != NULL) + s = res; + else { + p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */ + } + break; + } + case '+': /* 1 or more repetitions */ + s++; /* 1 match already done */ + /* FALLTHROUGH */ + case '*': /* 0 or more repetitions */ + s = max_expand(ms, s, p, ep); + break; + case '-': /* 0 or more repetitions (minimum) */ + s = min_expand(ms, s, p, ep); + break; + default: /* no suffix */ + s++; p = ep; goto init; /* return match(ms, s + 1, ep); */ + } + } + break; + } + } + } + ms->matchdepth++; + return s; +} + + + +static const char *lmemfind (const char *s1, size_t l1, + const char *s2, size_t l2) { + if (l2 == 0) return s1; /* empty strings are everywhere */ + else if (l2 > l1) return NULL; /* avoids a negative 'l1' */ + else { + const char *init; /* to search for a '*s2' inside 's1' */ + l2--; /* 1st char will be checked by 'memchr' */ + l1 = l1-l2; /* 's2' cannot be found after that */ + while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { + init++; /* 1st char is already checked */ + if (memcmp(init, s2+1, l2) == 0) + return init-1; + else { /* correct 'l1' and 's1' to try again */ + l1 -= ct_diff2sz(init - s1); + s1 = init; + } + } + return NULL; /* not found */ + } +} + + +/* +** get information about the i-th capture. If there are no captures +** and 'i==0', return information about the whole match, which +** is the range 's'..'e'. If the capture is a string, return +** its length and put its address in '*cap'. If it is an integer +** (a position), push it on the stack and return CAP_POSITION. +*/ +static ptrdiff_t get_onecapture (MatchState *ms, int i, const char *s, + const char *e, const char **cap) { + if (i >= ms->level) { + if (l_unlikely(i != 0)) + luaL_error(ms->L, "invalid capture index %%%d", i + 1); + *cap = s; + return (e - s); + } + else { + ptrdiff_t capl = ms->capture[i].len; + *cap = ms->capture[i].init; + if (l_unlikely(capl == CAP_UNFINISHED)) + luaL_error(ms->L, "unfinished capture"); + else if (capl == CAP_POSITION) + lua_pushinteger(ms->L, + ct_diff2S(ms->capture[i].init - ms->src_init) + 1); + return capl; + } +} + + +/* +** Push the i-th capture on the stack. +*/ +static void push_onecapture (MatchState *ms, int i, const char *s, + const char *e) { + const char *cap; + ptrdiff_t l = get_onecapture(ms, i, s, e, &cap); + if (l != CAP_POSITION) + lua_pushlstring(ms->L, cap, cast_sizet(l)); + /* else position was already pushed */ +} + + +static int push_captures (MatchState *ms, const char *s, const char *e) { + int i; + int nlevels = (ms->level == 0 && s) ? 1 : ms->level; + luaL_checkstack(ms->L, nlevels, "too many captures"); + for (i = 0; i < nlevels; i++) + push_onecapture(ms, i, s, e); + return nlevels; /* number of strings pushed */ +} + + +/* check whether pattern has no special characters */ +static int nospecials (const char *p, size_t l) { + size_t upto = 0; + do { + if (strpbrk(p + upto, SPECIALS)) + return 0; /* pattern has a special character */ + upto += strlen(p + upto) + 1; /* may have more after \0 */ + } while (upto <= l); + return 1; /* no special chars found */ +} + + +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; +} + + +static void reprepstate (MatchState *ms) { + ms->level = 0; + lua_assert(ms->matchdepth == MAXCCALLS); +} + + +static int str_find_aux (lua_State *L, int find) { + size_t ls, lp; + const char *s = luaL_checklstring(L, 1, &ls); + const char *p = luaL_checklstring(L, 2, &lp); + size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1; + if (init > ls) { /* start after string's end? */ + luaL_pushfail(L); /* cannot find anything */ + return 1; + } + /* explicit request or no special characters? */ + if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) { + /* do a plain search */ + const char *s2 = lmemfind(s + init, ls - init, p, lp); + if (s2) { + lua_pushinteger(L, ct_diff2S(s2 - s) + 1); + lua_pushinteger(L, cast_st2S(ct_diff2sz(s2 - s) + lp)); + return 2; + } + } + else { + MatchState ms; + const char *s1 = s + init; + int anchor = (*p == '^'); + if (anchor) { + p++; lp--; /* skip anchor character */ + } + prepstate(&ms, L, s, ls, p, lp); + do { + const char *res; + reprepstate(&ms); + if ((res=match(&ms, s1, p)) != NULL) { + if (find) { + lua_pushinteger(L, ct_diff2S(s1 - s) + 1); /* start */ + lua_pushinteger(L, ct_diff2S(res - s)); /* end */ + return push_captures(&ms, NULL, 0) + 2; + } + else + return push_captures(&ms, s1, res); + } + } while (s1++ < ms.src_end && !anchor); + } + luaL_pushfail(L); /* not found */ + return 1; +} + + +static int str_find (lua_State *L) { + return str_find_aux(L, 1); +} + + +static int str_match (lua_State *L) { + return str_find_aux(L, 0); +} + + +/* state for 'gmatch' */ +typedef struct GMatchState { + const char *src; /* current position */ + const char *p; /* pattern */ + const char *lastmatch; /* end of last match */ + MatchState ms; /* match state */ +} GMatchState; + + +static int gmatch_aux (lua_State *L) { + GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3)); + const char *src; + gm->ms.L = L; + for (src = gm->src; src <= gm->ms.src_end; src++) { + const char *e; + reprepstate(&gm->ms); + if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) { + gm->src = gm->lastmatch = e; + return push_captures(&gm->ms, src, e); + } + } + return 0; /* not found */ +} + + +static int gmatch (lua_State *L) { + size_t ls, lp; + const char *s = luaL_checklstring(L, 1, &ls); + const char *p = luaL_checklstring(L, 2, &lp); + size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1; + GMatchState *gm; + lua_settop(L, 2); /* keep strings on closure to avoid being collected */ + gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0); + if (init > ls) /* start after string's end? */ + init = ls + 1; /* avoid overflows in 's + init' */ + prepstate(&gm->ms, L, s, ls, p, lp); + gm->src = s + init; gm->p = p; gm->lastmatch = NULL; + lua_pushcclosure(L, gmatch_aux, 3); + return 1; +} + + +static void add_s (MatchState *ms, luaL_Buffer *b, const char *s, + const char *e) { + size_t l; + lua_State *L = ms->L; + const char *news = lua_tolstring(L, 3, &l); + const char *p; + while ((p = (char *)memchr(news, L_ESC, l)) != NULL) { + luaL_addlstring(b, news, ct_diff2sz(p - news)); + p++; /* skip ESC */ + if (*p == L_ESC) /* '%%' */ + luaL_addchar(b, *p); + else if (*p == '0') /* '%0' */ + luaL_addlstring(b, s, ct_diff2sz(e - s)); + else if (isdigit(cast_uchar(*p))) { /* '%n' */ + const char *cap; + ptrdiff_t resl = get_onecapture(ms, *p - '1', s, e, &cap); + if (resl == CAP_POSITION) + luaL_addvalue(b); /* add position to accumulated result */ + else + luaL_addlstring(b, cap, cast_sizet(resl)); + } + else + luaL_error(L, "invalid use of '%c' in replacement string", L_ESC); + l -= ct_diff2sz(p + 1 - news); + news = p + 1; + } + luaL_addlstring(b, news, l); +} + + +/* +** Add the replacement value to the string buffer 'b'. +** Return true if the original string was changed. (Function calls and +** table indexing resulting in nil or false do not change the subject.) +*/ +static int add_value (MatchState *ms, luaL_Buffer *b, const char *s, + const char *e, int tr) { + lua_State *L = ms->L; + switch (tr) { + case LUA_TFUNCTION: { /* call the function */ + int n; + lua_pushvalue(L, 3); /* push the function */ + n = push_captures(ms, s, e); /* all captures as arguments */ + lua_call(L, n, 1); /* call it */ + break; + } + case LUA_TTABLE: { /* index the table */ + push_onecapture(ms, 0, s, e); /* first capture is the index */ + lua_gettable(L, 3); + break; + } + default: { /* LUA_TNUMBER or LUA_TSTRING */ + add_s(ms, b, s, e); /* add value to the buffer */ + return 1; /* something changed */ + } + } + if (!lua_toboolean(L, -1)) { /* nil or false? */ + lua_pop(L, 1); /* remove value */ + luaL_addlstring(b, s, ct_diff2sz(e - s)); /* keep original text */ + return 0; /* no changes */ + } + else if (l_unlikely(!lua_isstring(L, -1))) + return luaL_error(L, "invalid replacement value (a %s)", + luaL_typename(L, -1)); + else { + luaL_addvalue(b); /* add result to accumulator */ + return 1; /* something changed */ + } +} + + +static int str_gsub (lua_State *L) { + size_t srcl, lp; + const char *src = luaL_checklstring(L, 1, &srcl); /* subject */ + const char *p = luaL_checklstring(L, 2, &lp); /* pattern */ + const char *lastmatch = NULL; /* end of last match */ + int tr = lua_type(L, 3); /* replacement type */ + /* max replacements */ + lua_Integer max_s = luaL_optinteger(L, 4, cast_st2S(srcl) + 1); + int anchor = (*p == '^'); + lua_Integer n = 0; /* replacement count */ + int changed = 0; /* change flag */ + MatchState ms; + luaL_Buffer b; + luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING || + tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3, + "string/function/table"); + luaL_buffinit(L, &b); + if (anchor) { + p++; lp--; /* skip anchor character */ + } + prepstate(&ms, L, src, srcl, p, lp); + while (n < max_s) { + const char *e; + reprepstate(&ms); /* (re)prepare state for new match */ + if ((e = match(&ms, src, p)) != NULL && e != lastmatch) { /* match? */ + n++; + changed = add_value(&ms, &b, src, e, tr) | changed; + src = lastmatch = e; + } + else if (src < ms.src_end) /* otherwise, skip one character */ + luaL_addchar(&b, *src++); + else break; /* end of subject */ + if (anchor) break; + } + if (!changed) /* no changes? */ + lua_pushvalue(L, 1); /* return original string */ + else { /* something changed */ + luaL_addlstring(&b, src, ct_diff2sz(ms.src_end - src)); + luaL_pushresult(&b); /* create and return new string */ + } + lua_pushinteger(L, n); /* number of substitutions */ + return 2; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** STRING FORMAT +** ======================================================= +*/ + +#if !defined(lua_number2strx) /* { */ + +/* +** Hexadecimal floating-point formatter +*/ + +#define SIZELENMOD (sizeof(LUA_NUMBER_FRMLEN)/sizeof(char)) + + +/* +** Number of bits that goes into the first digit. It can be any value +** between 1 and 4; the following definition tries to align the number +** to nibble boundaries by making what is left after that first digit a +** multiple of 4. +*/ +#define L_NBFD ((l_floatatt(MANT_DIG) - 1)%4 + 1) + + +/* +** Add integer part of 'x' to buffer and return new 'x' +*/ +static lua_Number adddigit (char *buff, unsigned n, lua_Number x) { + lua_Number dd = l_mathop(floor)(x); /* get integer part from 'x' */ + int d = (int)dd; + buff[n] = cast_char(d < 10 ? d + '0' : d - 10 + 'a'); /* add to buffer */ + return x - dd; /* return what is left */ +} + + +static int num2straux (char *buff, unsigned sz, lua_Number x) { + /* if 'inf' or 'NaN', format it like '%g' */ + if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL) + return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x); + else if (x == 0) { /* can be -0... */ + /* create "0" or "-0" followed by exponent */ + return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", (LUAI_UACNUMBER)x); + } + else { + int e; + lua_Number m = l_mathop(frexp)(x, &e); /* 'x' fraction and exponent */ + unsigned n = 0; /* character count */ + if (m < 0) { /* is number negative? */ + buff[n++] = '-'; /* add sign */ + m = -m; /* make it positive */ + } + buff[n++] = '0'; buff[n++] = 'x'; /* add "0x" */ + m = adddigit(buff, n++, m * (1 << L_NBFD)); /* add first digit */ + e -= L_NBFD; /* this digit goes before the radix point */ + if (m > 0) { /* more digits? */ + buff[n++] = lua_getlocaledecpoint(); /* add radix point */ + do { /* add as many digits as needed */ + m = adddigit(buff, n++, m * 16); + } while (m > 0); + } + n += cast_uint(l_sprintf(buff + n, sz - n, "p%+d", e)); /* add exponent */ + lua_assert(n < sz); + return cast_int(n); + } +} + + +static int lua_number2strx (lua_State *L, char *buff, unsigned sz, + const char *fmt, lua_Number x) { + int n = num2straux(buff, sz, x); + if (fmt[SIZELENMOD] == 'A') { + int i; + for (i = 0; i < n; i++) + buff[i] = cast_char(toupper(cast_uchar(buff[i]))); + } + else if (l_unlikely(fmt[SIZELENMOD] != 'a')) + return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented"); + return n; +} + +#endif /* } */ + + +/* +** Maximum size for items formatted with '%f'. This size is produced +** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.', +** and '\0') + number of decimal digits to represent maxfloat (which +** is maximum exponent + 1). (99+3+1, adding some extra, 110) +*/ +#define MAX_ITEMF (110 + l_floatatt(MAX_10_EXP)) + + +/* +** All formats except '%f' do not need that large limit. The other +** float formats use exponents, so that they fit in the 99 limit for +** significant digits; 's' for large strings and 'q' add items directly +** to the buffer; all integer formats also fit in the 99 limit. The +** worst case are floats: they may need 99 significant digits, plus +** '0x', '-', '.', 'e+XXXX', and '\0'. Adding some extra, 120. +*/ +#define MAX_ITEM 120 + + +/* valid flags in a format specification */ +#if !defined(L_FMTFLAGSF) + +/* valid flags for a, A, e, E, f, F, g, and G conversions */ +#define L_FMTFLAGSF "-+#0 " + +/* valid flags for o, x, and X conversions */ +#define L_FMTFLAGSX "-#0" + +/* valid flags for d and i conversions */ +#define L_FMTFLAGSI "-+0 " + +/* valid flags for u conversions */ +#define L_FMTFLAGSU "-0" + +/* valid flags for c, p, and s conversions */ +#define L_FMTFLAGSC "-" + +#endif + + +/* +** Maximum size of each format specification (such as "%-099.99d"): +** Initial '%', flags (up to 5), width (2), period, precision (2), +** length modifier (8), conversion specifier, and final '\0', plus some +** extra. +*/ +#define MAX_FORMAT 32 + + +static void addquoted (luaL_Buffer *b, const char *s, size_t len) { + luaL_addchar(b, '"'); + while (len--) { + if (*s == '"' || *s == '\\' || *s == '\n') { + luaL_addchar(b, '\\'); + luaL_addchar(b, *s); + } + else if (iscntrl(cast_uchar(*s))) { + char buff[10]; + if (!isdigit(cast_uchar(*(s+1)))) + l_sprintf(buff, sizeof(buff), "\\%d", (int)cast_uchar(*s)); + else + l_sprintf(buff, sizeof(buff), "\\%03d", (int)cast_uchar(*s)); + luaL_addstring(b, buff); + } + else + luaL_addchar(b, *s); + s++; + } + luaL_addchar(b, '"'); +} + + +/* +** Serialize a floating-point number in such a way that it can be +** scanned back by Lua. Use hexadecimal format for "common" numbers +** (to preserve precision); inf, -inf, and NaN are handled separately. +** (NaN cannot be expressed as a numeral, so we write '(0/0)' for it.) +*/ +static int quotefloat (lua_State *L, char *buff, lua_Number n) { + const char *s; /* for the fixed representations */ + if (n == (lua_Number)HUGE_VAL) /* inf? */ + s = "1e9999"; + else if (n == -(lua_Number)HUGE_VAL) /* -inf? */ + s = "-1e9999"; + else if (n != n) /* NaN? */ + s = "(0/0)"; + else { /* format number as hexadecimal */ + int nb = lua_number2strx(L, buff, MAX_ITEM, + "%" LUA_NUMBER_FRMLEN "a", n); + /* ensures that 'buff' string uses a dot as the radix character */ + if (memchr(buff, '.', cast_uint(nb)) == NULL) { /* no dot? */ + char point = lua_getlocaledecpoint(); /* try locale point */ + char *ppoint = (char *)memchr(buff, point, cast_uint(nb)); + if (ppoint) *ppoint = '.'; /* change it to a dot */ + } + return nb; + } + /* for the fixed representations */ + return l_sprintf(buff, MAX_ITEM, "%s", s); +} + + +static void addliteral (lua_State *L, luaL_Buffer *b, int arg) { + switch (lua_type(L, arg)) { + case LUA_TSTRING: { + size_t len; + const char *s = lua_tolstring(L, arg, &len); + addquoted(b, s, len); + break; + } + case LUA_TNUMBER: { + char *buff = luaL_prepbuffsize(b, MAX_ITEM); + int nb; + if (!lua_isinteger(L, arg)) /* float? */ + nb = quotefloat(L, buff, lua_tonumber(L, arg)); + else { /* integers */ + lua_Integer n = lua_tointeger(L, arg); + const char *format = (n == LUA_MININTEGER) /* corner case? */ + ? "0x%" LUA_INTEGER_FRMLEN "x" /* use hex */ + : LUA_INTEGER_FMT; /* else use default format */ + nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n); + } + luaL_addsize(b, cast_uint(nb)); + break; + } + case LUA_TNIL: case LUA_TBOOLEAN: { + luaL_tolstring(L, arg, NULL); + luaL_addvalue(b); + break; + } + default: { + luaL_argerror(L, arg, "value has no literal form"); + } + } +} + + +static const char *get2digits (const char *s) { + if (isdigit(cast_uchar(*s))) { + s++; + if (isdigit(cast_uchar(*s))) s++; /* (2 digits at most) */ + } + return s; +} + + +/* +** Check whether a conversion specification is valid. When called, +** first character in 'form' must be '%' and last character must +** be a valid conversion specifier. 'flags' are the accepted flags; +** 'precision' signals whether to accept a precision. +*/ +static void checkformat (lua_State *L, const char *form, const char *flags, + int precision) { + const char *spec = form + 1; /* skip '%' */ + spec += strspn(spec, flags); /* skip flags */ + if (*spec != '0') { /* a width cannot start with '0' */ + spec = get2digits(spec); /* skip width */ + if (*spec == '.' && precision) { + spec++; + spec = get2digits(spec); /* skip precision */ + } + } + if (!isalpha(cast_uchar(*spec))) /* did not go to the end? */ + luaL_error(L, "invalid conversion specification: '%s'", form); +} + + +/* +** Get a conversion specification and copy it to 'form'. +** Return the address of its last character. +*/ +static const char *getformat (lua_State *L, const char *strfrmt, + char *form) { + /* spans flags, width, and precision ('0' is included as a flag) */ + size_t len = strspn(strfrmt, L_FMTFLAGSF "123456789."); + len++; /* adds following character (should be the specifier) */ + /* still needs space for '%', '\0', plus a length modifier */ + if (len >= MAX_FORMAT - 10) + luaL_error(L, "invalid format (too long)"); + *(form++) = '%'; + memcpy(form, strfrmt, len * sizeof(char)); + *(form + len) = '\0'; + return strfrmt + len - 1; +} + + +/* +** add length modifier into formats +*/ +static void addlenmod (char *form, const char *lenmod) { + size_t l = strlen(form); + size_t lm = strlen(lenmod); + char spec = form[l - 1]; + strcpy(form + l - 1, lenmod); + form[l + lm - 1] = spec; + form[l + lm] = '\0'; +} + + +static int str_format (lua_State *L) { + int top = lua_gettop(L); + int arg = 1; + size_t sfl; + const char *strfrmt = luaL_checklstring(L, arg, &sfl); + const char *strfrmt_end = strfrmt+sfl; + const char *flags; + luaL_Buffer b; + luaL_buffinit(L, &b); + while (strfrmt < strfrmt_end) { + if (*strfrmt != L_ESC) + luaL_addchar(&b, *strfrmt++); + else if (*++strfrmt == L_ESC) + luaL_addchar(&b, *strfrmt++); /* %% */ + else { /* format item */ + char form[MAX_FORMAT]; /* to store the format ('%...') */ + unsigned maxitem = MAX_ITEM; /* maximum length for the result */ + char *buff = luaL_prepbuffsize(&b, maxitem); /* to put result */ + int nb = 0; /* number of bytes in result */ + if (++arg > top) + return luaL_argerror(L, arg, "no value"); + strfrmt = getformat(L, strfrmt, form); + switch (*strfrmt++) { + case 'c': { + checkformat(L, form, L_FMTFLAGSC, 0); + nb = l_sprintf(buff, maxitem, form, (int)luaL_checkinteger(L, arg)); + break; + } + case 'd': case 'i': + flags = L_FMTFLAGSI; + goto intcase; + case 'u': + flags = L_FMTFLAGSU; + goto intcase; + case 'o': case 'x': case 'X': + flags = L_FMTFLAGSX; + intcase: { + lua_Integer n = luaL_checkinteger(L, arg); + checkformat(L, form, flags, 1); + addlenmod(form, LUA_INTEGER_FRMLEN); + nb = l_sprintf(buff, maxitem, form, (LUAI_UACINT)n); + break; + } + case 'a': case 'A': + checkformat(L, form, L_FMTFLAGSF, 1); + addlenmod(form, LUA_NUMBER_FRMLEN); + nb = lua_number2strx(L, buff, maxitem, form, + luaL_checknumber(L, arg)); + break; + case 'f': + maxitem = MAX_ITEMF; /* extra space for '%f' */ + buff = luaL_prepbuffsize(&b, maxitem); + /* FALLTHROUGH */ + case 'e': case 'E': case 'g': case 'G': { + lua_Number n = luaL_checknumber(L, arg); + checkformat(L, form, L_FMTFLAGSF, 1); + addlenmod(form, LUA_NUMBER_FRMLEN); + nb = l_sprintf(buff, maxitem, form, (LUAI_UACNUMBER)n); + break; + } + case 'p': { + const void *p = lua_topointer(L, arg); + checkformat(L, form, L_FMTFLAGSC, 0); + if (p == NULL) { /* avoid calling 'printf' with argument NULL */ + p = "(null)"; /* result */ + form[strlen(form) - 1] = 's'; /* format it as a string */ + } + nb = l_sprintf(buff, maxitem, form, p); + break; + } + case 'q': { + if (form[2] != '\0') /* modifiers? */ + return luaL_error(L, "specifier '%%q' cannot have modifiers"); + addliteral(L, &b, arg); + break; + } + case 's': { + size_t l; + const char *s = luaL_tolstring(L, arg, &l); + if (form[2] == '\0') /* no modifiers? */ + luaL_addvalue(&b); /* keep entire string */ + else { + luaL_argcheck(L, l == strlen(s), arg, "string contains zeros"); + checkformat(L, form, L_FMTFLAGSC, 1); + if (strchr(form, '.') == NULL && 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, maxitem, form, s); + lua_pop(L, 1); /* remove result from 'luaL_tolstring' */ + } + } + break; + } + default: { /* also treat cases 'pnLlh' */ + return luaL_error(L, "invalid conversion '%s' to 'format'", form); + } + } + lua_assert(cast_uint(nb) < maxitem); + luaL_addsize(&b, cast_uint(nb)); + } + } + luaL_pushresult(&b); + return 1; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** PACK/UNPACK +** ======================================================= +*/ + + +/* value used for padding */ +#if !defined(LUAL_PACKPADBYTE) +#define LUAL_PACKPADBYTE 0x00 +#endif + +/* maximum size for the binary representation of an integer */ +#define MAXINTSIZE 16 + +/* number of bits in a character */ +#define NB CHAR_BIT + +/* mask for one character (NB 1's) */ +#define MC ((1 << NB) - 1) + +/* size of a lua_Integer */ +#define SZINT ((int)sizeof(lua_Integer)) + + +/* dummy union to get native endianness */ +static const union { + int dummy; + char little; /* true iff machine is little endian */ +} nativeendian = {1}; + + +/* +** information to pack/unpack stuff +*/ +typedef struct Header { + lua_State *L; + int islittle; + unsigned maxalign; +} Header; + + +/* +** options for pack/unpack +*/ +typedef enum KOption { + Kint, /* signed integers */ + Kuint, /* unsigned integers */ + Kfloat, /* single-precision floating-point numbers */ + Knumber, /* Lua "native" floating-point numbers */ + Kdouble, /* double-precision floating-point numbers */ + Kchar, /* fixed-length strings */ + Kstring, /* strings with prefixed length */ + Kzstr, /* zero-terminated strings */ + Kpadding, /* padding */ + Kpaddalign, /* padding for alignment */ + Knop /* no-op (configuration or spaces) */ +} KOption; + + +/* +** Read an integer numeral from string 'fmt' or return 'df' if +** there is no numeral +*/ +static int digit (int c) { return '0' <= c && c <= '9'; } + +static size_t getnum (const char **fmt, size_t df) { + if (!digit(**fmt)) /* no number? */ + return df; /* return default value */ + else { + size_t a = 0; + do { + a = a*10 + cast_uint(*((*fmt)++) - '0'); + } while (digit(**fmt) && a <= (MAX_SIZE - 9)/10); + return a; + } +} + + +/* +** Read an integer numeral and raises an error if it is larger +** than the maximum size of integers. +*/ +static unsigned getnumlimit (Header *h, const char **fmt, size_t df) { + size_t sz = getnum(fmt, df); + if (l_unlikely((sz - 1u) >= MAXINTSIZE)) + return cast_uint(luaL_error(h->L, + "integral size (%d) out of limits [1,%d]", sz, MAXINTSIZE)); + return cast_uint(sz); +} + + +/* +** Initialize Header +*/ +static void initheader (lua_State *L, Header *h) { + h->L = L; + h->islittle = nativeendian.little; + h->maxalign = 1; +} + + +/* +** Read and classify next option. 'size' is filled with option's size. +*/ +static KOption getoption (Header *h, const char **fmt, size_t *size) { + /* dummy structure to get native alignment requirements */ + struct cD { char c; union { LUAI_MAXALIGN; } u; }; + int opt = *((*fmt)++); + *size = 0; /* default */ + switch (opt) { + case 'b': *size = sizeof(char); return Kint; + case 'B': *size = sizeof(char); return Kuint; + case 'h': *size = sizeof(short); return Kint; + case 'H': *size = sizeof(short); return Kuint; + case 'l': *size = sizeof(long); return Kint; + case 'L': *size = sizeof(long); return Kuint; + case 'j': *size = sizeof(lua_Integer); return Kint; + case 'J': *size = sizeof(lua_Integer); return Kuint; + case 'T': *size = sizeof(size_t); return Kuint; + case 'f': *size = sizeof(float); return Kfloat; + case 'n': *size = sizeof(lua_Number); return Knumber; + case 'd': *size = sizeof(double); return Kdouble; + case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint; + case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint; + case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring; + case 'c': + *size = getnum(fmt, cast_sizet(-1)); + if (l_unlikely(*size == cast_sizet(-1))) + luaL_error(h->L, "missing size for format option 'c'"); + return Kchar; + case 'z': return Kzstr; + case 'x': *size = 1; return Kpadding; + case 'X': return Kpaddalign; + case ' ': break; + case '<': h->islittle = 1; break; + case '>': h->islittle = 0; break; + case '=': h->islittle = nativeendian.little; break; + case '!': { + const size_t maxalign = offsetof(struct cD, u); + h->maxalign = getnumlimit(h, fmt, maxalign); + break; + } + default: luaL_error(h->L, "invalid format option '%c'", opt); + } + return Knop; +} + + +/* +** Read, classify, and fill other details about the next option. +** 'psize' is filled with option's size, 'notoalign' with its +** alignment requirements. +** Local variable 'size' gets the size to be aligned. (Kpadal option +** always gets its full alignment, other options are limited by +** the maximum alignment ('maxalign'). Kchar option needs no alignment +** despite its size. +*/ +static KOption getdetails (Header *h, size_t totalsize, const char **fmt, + size_t *psize, unsigned *ntoalign) { + KOption opt = getoption(h, fmt, psize); + size_t align = *psize; /* usually, alignment follows size */ + if (opt == Kpaddalign) { /* 'X' gets alignment from following option */ + if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0) + luaL_argerror(h->L, 1, "invalid next option for option 'X'"); + } + if (align <= 1 || opt == Kchar) /* need no alignment? */ + *ntoalign = 0; + else { + if (align > h->maxalign) /* enforce maximum alignment */ + align = h->maxalign; + if (l_unlikely(!ispow2(align))) { /* not a power of 2? */ + *ntoalign = 0; /* to avoid warnings */ + luaL_argerror(h->L, 1, "format asks for alignment not power of 2"); + } + else { + /* 'szmoda' = totalsize % align */ + unsigned szmoda = cast_uint(totalsize & (align - 1)); + *ntoalign = cast_uint((align - szmoda) & (align - 1)); + } + } + return opt; +} + + +/* +** Pack integer 'n' with 'size' bytes and 'islittle' endianness. +** The final 'if' handles the case when 'size' is larger than +** the size of a Lua integer, correcting the extra sign-extension +** bytes if necessary (by default they would be zeros). +*/ +static void packint (luaL_Buffer *b, lua_Unsigned n, + int islittle, unsigned size, int neg) { + char *buff = luaL_prepbuffsize(b, size); + unsigned i; + buff[islittle ? 0 : size - 1] = (char)(n & MC); /* first byte */ + for (i = 1; i < size; i++) { + n >>= NB; + buff[islittle ? i : size - 1 - i] = (char)(n & MC); + } + if (neg && size > SZINT) { /* negative number need sign extension? */ + for (i = SZINT; i < size; i++) /* correct extra bytes */ + buff[islittle ? i : size - 1 - i] = (char)MC; + } + luaL_addsize(b, size); /* add result to buffer */ +} + + +/* +** Copy 'size' bytes from 'src' to 'dest', correcting endianness if +** given 'islittle' is different from native endianness. +*/ +static void copywithendian (char *dest, const char *src, + unsigned size, int islittle) { + if (islittle == nativeendian.little) + memcpy(dest, src, size); + else { + dest += size - 1; + while (size-- != 0) + *(dest--) = *(src++); + } +} + + +static int str_pack (lua_State *L) { + luaL_Buffer b; + Header h; + const char *fmt = luaL_checkstring(L, 1); /* format string */ + int arg = 1; /* current argument to pack */ + size_t totalsize = 0; /* accumulate total size of result */ + initheader(L, &h); + lua_pushnil(L); /* mark to separate arguments from string buffer */ + luaL_buffinit(L, &b); + while (*fmt != '\0') { + unsigned ntoalign; + size_t size; + KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); + luaL_argcheck(L, size + ntoalign <= MAX_SIZE - totalsize, arg, + "result too long"); + totalsize += ntoalign + size; + while (ntoalign-- > 0) + luaL_addchar(&b, LUAL_PACKPADBYTE); /* fill alignment */ + arg++; + switch (opt) { + case Kint: { /* signed integers */ + lua_Integer n = luaL_checkinteger(L, arg); + if (size < SZINT) { /* need overflow check? */ + lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1); + luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow"); + } + packint(&b, (lua_Unsigned)n, h.islittle, cast_uint(size), (n < 0)); + break; + } + case Kuint: { /* unsigned integers */ + lua_Integer n = luaL_checkinteger(L, arg); + if (size < SZINT) /* need overflow check? */ + luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)), + arg, "unsigned overflow"); + packint(&b, (lua_Unsigned)n, h.islittle, cast_uint(size), 0); + break; + } + case Kfloat: { /* C float */ + float f = (float)luaL_checknumber(L, arg); /* get argument */ + char *buff = luaL_prepbuffsize(&b, sizeof(f)); + /* move 'f' to final result, correcting endianness if needed */ + copywithendian(buff, (char *)&f, sizeof(f), h.islittle); + luaL_addsize(&b, size); + break; + } + case Knumber: { /* Lua float */ + lua_Number f = luaL_checknumber(L, arg); /* get argument */ + char *buff = luaL_prepbuffsize(&b, sizeof(f)); + /* move 'f' to final result, correcting endianness if needed */ + copywithendian(buff, (char *)&f, sizeof(f), h.islittle); + luaL_addsize(&b, size); + break; + } + case Kdouble: { /* C double */ + double f = (double)luaL_checknumber(L, arg); /* get argument */ + char *buff = luaL_prepbuffsize(&b, sizeof(f)); + /* move 'f' to final result, correcting endianness if needed */ + copywithendian(buff, (char *)&f, sizeof(f), h.islittle); + luaL_addsize(&b, size); + break; + } + case Kchar: { /* fixed-size string */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, len <= size, arg, "string longer than given size"); + luaL_addlstring(&b, s, len); /* add string */ + if (len < size) { /* does it need padding? */ + size_t psize = size - len; /* pad size */ + char *buff = luaL_prepbuffsize(&b, psize); + memset(buff, LUAL_PACKPADBYTE, psize); + luaL_addsize(&b, psize); + } + break; + } + case Kstring: { /* strings with length count */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, size >= sizeof(lua_Unsigned) || + len < ((lua_Unsigned)1 << (size * NB)), + arg, "string length does not fit in given size"); + /* pack length */ + packint(&b, (lua_Unsigned)len, h.islittle, cast_uint(size), 0); + luaL_addlstring(&b, s, len); + totalsize += len; + break; + } + case Kzstr: { /* zero-terminated string */ + size_t len; + const char *s = luaL_checklstring(L, arg, &len); + luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros"); + luaL_addlstring(&b, s, len); + luaL_addchar(&b, '\0'); /* add zero at the end */ + totalsize += len + 1; + break; + } + case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE); /* FALLTHROUGH */ + case Kpaddalign: case Knop: + arg--; /* undo increment */ + break; + } + } + luaL_pushresult(&b); + return 1; +} + + +static int str_packsize (lua_State *L) { + Header h; + const char *fmt = luaL_checkstring(L, 1); /* format string */ + size_t totalsize = 0; /* accumulate total size of result */ + initheader(L, &h); + while (*fmt != '\0') { + unsigned ntoalign; + size_t size; + KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign); + luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1, + "variable-length format"); + size += ntoalign; /* total space used by option */ + luaL_argcheck(L, totalsize <= LUA_MAXINTEGER - size, + 1, "format result too large"); + totalsize += size; + } + lua_pushinteger(L, cast_st2S(totalsize)); + return 1; +} + + +/* +** Unpack an integer with 'size' bytes and 'islittle' endianness. +** If size is smaller than the size of a Lua integer and integer +** is signed, must do sign extension (propagating the sign to the +** higher bits); if size is larger than the size of a Lua integer, +** it must check the unread bytes to see whether they do not cause an +** overflow. +*/ +static lua_Integer unpackint (lua_State *L, const char *str, + int islittle, int size, int issigned) { + lua_Unsigned res = 0; + int i; + int limit = (size <= SZINT) ? size : SZINT; + for (i = limit - 1; i >= 0; i--) { + res <<= NB; + res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i]; + } + if (size < SZINT) { /* real size smaller than lua_Integer? */ + if (issigned) { /* needs sign extension? */ + lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1); + res = ((res ^ mask) - mask); /* do sign extension */ + } + } + else if (size > SZINT) { /* must check unread bytes */ + int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC; + for (i = limit; i < size; i++) { + if (l_unlikely((unsigned char)str[islittle ? i : size - 1 - i] != mask)) + luaL_error(L, "%d-byte integer does not fit into Lua Integer", size); + } + } + return (lua_Integer)res; +} + + +static int str_unpack (lua_State *L) { + Header h; + const char *fmt = luaL_checkstring(L, 1); + size_t ld; + const char *data = luaL_checklstring(L, 2, &ld); + size_t pos = posrelatI(luaL_optinteger(L, 3, 1), ld) - 1; + int n = 0; /* number of results */ + luaL_argcheck(L, pos <= ld, 3, "initial position out of string"); + initheader(L, &h); + while (*fmt != '\0') { + unsigned ntoalign; + size_t size; + KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign); + luaL_argcheck(L, ntoalign + size <= ld - pos, 2, + "data string too short"); + pos += ntoalign; /* skip alignment */ + /* stack space for item + next position */ + luaL_checkstack(L, 2, "too many results"); + n++; + switch (opt) { + case Kint: + case Kuint: { + lua_Integer res = unpackint(L, data + pos, h.islittle, + cast_int(size), (opt == Kint)); + lua_pushinteger(L, res); + break; + } + case Kfloat: { + float f; + copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); + lua_pushnumber(L, (lua_Number)f); + break; + } + case Knumber: { + lua_Number f; + copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); + lua_pushnumber(L, f); + break; + } + case Kdouble: { + double f; + copywithendian((char *)&f, data + pos, sizeof(f), h.islittle); + lua_pushnumber(L, (lua_Number)f); + break; + } + case Kchar: { + lua_pushlstring(L, data + pos, size); + break; + } + case Kstring: { + lua_Unsigned len = (lua_Unsigned)unpackint(L, data + pos, + h.islittle, cast_int(size), 0); + luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short"); + lua_pushlstring(L, data + pos + size, cast_sizet(len)); + pos += cast_sizet(len); /* skip string */ + break; + } + case Kzstr: { + size_t len = strlen(data + pos); + luaL_argcheck(L, pos + len < ld, 2, + "unfinished string for format 'z'"); + lua_pushlstring(L, data + pos, len); + pos += len + 1; /* skip string plus final '\0' */ + break; + } + case Kpaddalign: case Kpadding: case Knop: + n--; /* undo increment */ + break; + } + pos += size; + } + lua_pushinteger(L, cast_st2S(pos) + 1); /* next position */ + return n + 1; +} + +/* }====================================================== */ + + +static const luaL_Reg strlib[] = { + {"byte", str_byte}, + {"char", str_char}, + {"dump", str_dump}, + {"find", str_find}, + {"format", str_format}, + {"gmatch", gmatch}, + {"gsub", str_gsub}, + {"len", str_len}, + {"lower", str_lower}, + {"match", str_match}, + {"rep", str_rep}, + {"reverse", str_reverse}, + {"sub", str_sub}, + {"upper", str_upper}, + {"pack", str_pack}, + {"packsize", str_packsize}, + {"unpack", str_unpack}, + {NULL, NULL} +}; + + +static void createmetatable (lua_State *L) { + /* table to be metatable for strings */ + luaL_newlibtable(L, stringmetamethods); + luaL_setfuncs(L, stringmetamethods, 0); + lua_pushliteral(L, ""); /* dummy string */ + lua_pushvalue(L, -2); /* copy table */ + lua_setmetatable(L, -2); /* set table as metatable for strings */ + lua_pop(L, 1); /* pop dummy string */ + lua_pushvalue(L, -2); /* get string library */ + lua_setfield(L, -2, "__index"); /* metatable.__index = string */ + lua_pop(L, 1); /* pop metatable */ +} + + +/* +** Open string library +*/ +LUAMOD_API int luaopen_string (lua_State *L) { + luaL_newlib(L, strlib); + createmetatable(L); + return 1; +} + diff --git a/source/external/lua/ltable.c b/source/external/lua/ltable.c new file mode 100644 index 0000000..b7f88f6 --- /dev/null +++ b/source/external/lua/ltable.c @@ -0,0 +1,1355 @@ +/* +** $Id: ltable.c $ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + +#define ltable_c +#define LUA_CORE + +#include "lprefix.h" + + +/* +** Implementation of tables (aka arrays, objects, or hash tables). +** Tables keep its elements in two parts: an array part and a hash part. +** Non-negative integer keys are all candidates to be kept in the array +** part. The actual size of the array is the largest 'n' such that +** more than half the slots between 1 and n are in use. +** Hash uses a mix of chained scatter table with Brent's variation. +** A main invariant of these tables is that, if an element is not +** in its main position (i.e. the 'original' position that its hash gives +** to it), then the colliding element is in its own main position. +** Hence even when the load factor reaches 100%, performance remains good. +*/ + +#include +#include +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "lvm.h" + + +/* +** Only hash parts with at least 2^LIMFORLAST have a 'lastfree' field +** that optimizes finding a free slot. That field is stored just before +** the array of nodes, in the same block. Smaller tables do a complete +** search when looking for a free slot. +*/ +#define LIMFORLAST 3 /* log2 of real limit (8) */ + +/* +** The union 'Limbox' stores 'lastfree' and ensures that what follows it +** is properly aligned to store a Node. +*/ +typedef struct { Node *dummy; Node follows_pNode; } Limbox_aux; + +typedef union { + Node *lastfree; + char padding[offsetof(Limbox_aux, follows_pNode)]; +} Limbox; + +#define haslastfree(t) ((t)->lsizenode >= LIMFORLAST) +#define getlastfree(t) ((cast(Limbox *, (t)->node) - 1)->lastfree) + + +/* +** MAXABITS is the largest integer such that 2^MAXABITS fits in an +** unsigned int. +*/ +#define MAXABITS (l_numbits(int) - 1) + + +/* +** MAXASIZEB is the maximum number of elements in the array part such +** that the size of the array fits in 'size_t'. +*/ +#define MAXASIZEB (MAX_SIZET/(sizeof(Value) + 1)) + + +/* +** MAXASIZE is the maximum size of the array part. It is the minimum +** between 2^MAXABITS and MAXASIZEB. +*/ +#define MAXASIZE \ + (((1u << MAXABITS) < MAXASIZEB) ? (1u << MAXABITS) : cast_uint(MAXASIZEB)) + +/* +** MAXHBITS is the largest integer such that 2^MAXHBITS fits in a +** signed int. +*/ +#define MAXHBITS (MAXABITS - 1) + + +/* +** MAXHSIZE is the maximum size of the hash part. It is the minimum +** between 2^MAXHBITS and the maximum size such that, measured in bytes, +** it fits in a 'size_t'. +*/ +#define MAXHSIZE luaM_limitN(1 << MAXHBITS, Node) + + +/* +** When the original hash value is good, hashing by a power of 2 +** avoids the cost of '%'. +*/ +#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) + +/* +** for other types, it is better to avoid modulo by power of 2, as +** they can have many 2 factors. +*/ +#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1u)|1u)))) + + +#define hashstr(t,str) hashpow2(t, (str)->hash) +#define hashboolean(t,p) hashpow2(t, p) + + +#define hashpointer(t,p) hashmod(t, point2uint(p)) + + +#define dummynode (&dummynode_) + +/* +** Common hash part for tables with empty hash parts. That allows all +** tables to have a hash part, avoiding an extra check ("is there a hash +** part?") when indexing. Its sole node has an empty value and a key +** (DEADKEY, NULL) that is different from any valid TValue. +*/ +static const Node dummynode_ = { + {{NULL}, LUA_VEMPTY, /* value's value and type */ + LUA_TDEADKEY, 0, {NULL}} /* key type, next, and key value */ +}; + + +static const TValue absentkey = {ABSTKEYCONSTANT}; + + +/* +** Hash for integers. To allow a good hash, use the remainder operator +** ('%'). If integer fits as a non-negative int, compute an int +** remainder, which is faster. Otherwise, use an unsigned-integer +** remainder, which uses all bits and ensures a non-negative result. +*/ +static Node *hashint (const Table *t, lua_Integer i) { + lua_Unsigned ui = l_castS2U(i); + if (ui <= cast_uint(INT_MAX)) + return gnode(t, cast_int(ui) % cast_int((sizenode(t)-1) | 1)); + else + return hashmod(t, ui); +} + + +/* +** Hash for floating-point numbers. +** The main computation should be just +** n = frexp(n, &i); return (n * INT_MAX) + i +** but there are some numerical subtleties. +** In a two-complement representation, INT_MAX may not have an exact +** representation as a float, but INT_MIN does; because the absolute +** value of 'frexp' is smaller than 1 (unless 'n' is inf/NaN), the +** absolute value of the product 'frexp * -INT_MIN' is smaller or equal +** to INT_MAX. Next, the use of 'unsigned int' avoids overflows when +** adding 'i'; the use of '~u' (instead of '-u') avoids problems with +** INT_MIN. +*/ +#if !defined(l_hashfloat) +static unsigned l_hashfloat (lua_Number n) { + int i; + lua_Integer ni; + n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); + if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ + lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); + return 0; + } + else { /* normal case */ + unsigned int u = cast_uint(i) + cast_uint(ni); + return (u <= cast_uint(INT_MAX) ? u : ~u); + } +} +#endif + + +/* +** returns the 'main' position of an element in a table (that is, +** the index of its hash value). +*/ +static Node *mainpositionTV (const Table *t, const TValue *key) { + switch (ttypetag(key)) { + case LUA_VNUMINT: { + lua_Integer i = ivalue(key); + return hashint(t, i); + } + case LUA_VNUMFLT: { + lua_Number n = fltvalue(key); + return hashmod(t, l_hashfloat(n)); + } + case LUA_VSHRSTR: { + TString *ts = tsvalue(key); + return hashstr(t, ts); + } + case LUA_VLNGSTR: { + TString *ts = tsvalue(key); + return hashpow2(t, luaS_hashlongstr(ts)); + } + case LUA_VFALSE: + return hashboolean(t, 0); + case LUA_VTRUE: + return hashboolean(t, 1); + case LUA_VLIGHTUSERDATA: { + void *p = pvalue(key); + return hashpointer(t, p); + } + case LUA_VLCF: { + lua_CFunction f = fvalue(key); + return hashpointer(t, f); + } + default: { + GCObject *o = gcvalue(key); + return hashpointer(t, o); + } + } +} + + +l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) { + TValue key; + getnodekey(cast(lua_State *, NULL), &key, nd); + return mainpositionTV(t, &key); +} + + +/* +** Check whether key 'k1' is equal to the key in node 'n2'. This +** equality is raw, so there are no metamethods. Floats with integer +** values have been normalized, so integers cannot be equal to +** floats. It is assumed that 'eqshrstr' is simply pointer equality, +** so that short strings are handled in the default case. The flag +** 'deadok' means to accept dead keys as equal to their original values. +** (Only collectable objects can produce dead keys.) Note that dead +** long strings are also compared by identity. Once a key is dead, +** its corresponding value may be collected, and then another value +** can be created with the same address. If this other value is given +** to 'next', 'equalkey' will signal a false positive. In a regular +** traversal, this situation should never happen, as all keys given to +** 'next' came from the table itself, and therefore could not have been +** collected. Outside a regular traversal, we have garbage in, garbage +** out. What is relevant is that this false positive does not break +** anything. (In particular, 'next' will return some other valid item +** on the table or nil.) +*/ +static int equalkey (const TValue *k1, const Node *n2, int deadok) { + if (rawtt(k1) != keytt(n2)) { /* not the same variants? */ + if (keyisshrstr(n2) && ttislngstring(k1)) { + /* an external string can be equal to a short-string key */ + return luaS_eqstr(tsvalue(k1), keystrval(n2)); + } + else if (deadok && keyisdead(n2) && iscollectable(k1)) { + /* a collectable value can be equal to a dead key */ + return gcvalue(k1) == gcvalueraw(keyval(n2)); + } + else + return 0; /* otherwise, different variants cannot be equal */ + } + else { /* equal variants */ + switch (keytt(n2)) { + case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: + return 1; + case LUA_VNUMINT: + return (ivalue(k1) == keyival(n2)); + case LUA_VNUMFLT: + return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); + case LUA_VLIGHTUSERDATA: + return pvalue(k1) == pvalueraw(keyval(n2)); + case LUA_VLCF: + return fvalue(k1) == fvalueraw(keyval(n2)); + case ctb(LUA_VLNGSTR): + return luaS_eqstr(tsvalue(k1), keystrval(n2)); + default: + return gcvalue(k1) == gcvalueraw(keyval(n2)); + } + } +} + + +/* +** "Generic" get version. (Not that generic: not valid for integers, +** which may be in array part, nor for floats with integral values.) +** See explanation about 'deadok' in function 'equalkey'. +*/ +static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { + Node *n = mainpositionTV(t, key); + for (;;) { /* check whether 'key' is somewhere in the chain */ + if (equalkey(key, n, deadok)) + return gval(n); /* that's it */ + else { + int nx = gnext(n); + if (nx == 0) + return &absentkey; /* not found */ + n += nx; + } + } +} + + +/* +** Return the index 'k' (converted to an unsigned) if it is inside +** the range [1, limit]. +*/ +static unsigned checkrange (lua_Integer k, unsigned limit) { + return (l_castS2U(k) - 1u < limit) ? cast_uint(k) : 0; +} + + +/* +** Return the index 'k' if 'k' is an appropriate key to live in the +** array part of a table, 0 otherwise. +*/ +#define arrayindex(k) checkrange(k, MAXASIZE) + + +/* +** Check whether an integer key is in the array part of a table and +** return its index there, or zero. +*/ +#define ikeyinarray(t,k) checkrange(k, t->asize) + + +/* +** Check whether a key is in the array part of a table and return its +** index there, or zero. +*/ +static unsigned keyinarray (Table *t, const TValue *key) { + return (ttisinteger(key)) ? ikeyinarray(t, ivalue(key)) : 0; +} + + +/* +** returns the index of a 'key' for table traversals. First goes all +** elements in the array part, then elements in the hash part. The +** beginning of a traversal is signaled by 0. +*/ +static unsigned findindex (lua_State *L, Table *t, TValue *key, + unsigned asize) { + unsigned int i; + if (ttisnil(key)) return 0; /* first iteration */ + i = keyinarray(t, key); + if (i != 0) /* is 'key' inside array part? */ + return i; /* yes; that's the index */ + else { + const TValue *n = getgeneric(t, key, 1); + if (l_unlikely(isabstkey(n))) + luaG_runerror(L, "invalid key to 'next'"); /* key not found */ + i = cast_uint(nodefromval(n) - gnode(t, 0)); /* key index in hash table */ + /* hash elements are numbered after array ones */ + return (i + 1) + asize; + } +} + + +int luaH_next (lua_State *L, Table *t, StkId key) { + unsigned int asize = t->asize; + unsigned int i = findindex(L, t, s2v(key), asize); /* find original key */ + for (; i < asize; i++) { /* try first array part */ + lu_byte tag = *getArrTag(t, i); + if (!tagisempty(tag)) { /* a non-empty entry? */ + setivalue(s2v(key), cast_int(i) + 1); + farr2val(t, i, tag, s2v(key + 1)); + return 1; + } + } + for (i -= asize; i < sizenode(t); i++) { /* hash part */ + if (!isempty(gval(gnode(t, i)))) { /* a non-empty entry? */ + Node *n = gnode(t, i); + getnodekey(L, s2v(key), n); + setobj2s(L, key + 1, gval(n)); + return 1; + } + } + return 0; /* no more elements */ +} + + +/* Extra space in Node array if it has a lastfree entry */ +#define extraLastfree(t) (haslastfree(t) ? sizeof(Limbox) : 0) + +/* 'node' size in bytes */ +static size_t sizehash (Table *t) { + return cast_sizet(sizenode(t)) * sizeof(Node) + extraLastfree(t); +} + + +static void freehash (lua_State *L, Table *t) { + if (!isdummy(t)) { + /* get pointer to the beginning of Node array */ + char *arr = cast_charp(t->node) - extraLastfree(t); + luaM_freearray(L, arr, sizehash(t)); + } +} + + +/* +** {============================================================= +** Rehash +** ============================================================== +*/ + +static int insertkey (Table *t, const TValue *key, TValue *value); +static void newcheckedkey (Table *t, const TValue *key, TValue *value); + + +/* +** Structure to count the keys in a table. +** 'total' is the total number of keys in the table. +** 'na' is the number of *array indices* in the table (see 'arrayindex'). +** 'deleted' is true if there are deleted nodes in the hash part. +** 'nums' is a "count array" where 'nums[i]' is the number of integer +** keys between 2^(i - 1) + 1 and 2^i. Note that 'na' is the summation +** of 'nums'. +*/ +typedef struct { + unsigned total; + unsigned na; + int deleted; + unsigned nums[MAXABITS + 1]; +} Counters; + + +/* +** Check whether it is worth to use 'na' array entries instead of 'nh' +** hash nodes. (A hash node uses ~3 times more memory than an array +** entry: Two values plus 'next' versus one value.) Evaluate with size_t +** to avoid overflows. +*/ +#define arrayXhash(na,nh) (cast_sizet(na) <= cast_sizet(nh) * 3) + +/* +** Compute the optimal size for the array part of table 't'. +** This size maximizes the number of elements going to the array part +** while satisfying the condition 'arrayXhash' with the use of memory if +** all those elements went to the hash part. +** 'ct->na' enters with the total number of array indices in the table +** and leaves with the number of keys that will go to the array part; +** return the optimal size for the array part. +*/ +static unsigned computesizes (Counters *ct) { + int i; + unsigned int twotoi; /* 2^i (candidate for optimal size) */ + unsigned int a = 0; /* number of elements smaller than 2^i */ + unsigned int na = 0; /* number of elements to go to array part */ + unsigned int optimal = 0; /* optimal size for array part */ + /* traverse slices while 'twotoi' does not overflow and total of array + indices still can satisfy 'arrayXhash' against the array size */ + for (i = 0, twotoi = 1; + twotoi > 0 && arrayXhash(twotoi, ct->na); + i++, twotoi *= 2) { + unsigned nums = ct->nums[i]; + a += nums; + if (nums > 0 && /* grows array only if it gets more elements... */ + arrayXhash(twotoi, a)) { /* ...while using "less memory" */ + optimal = twotoi; /* optimal size (till now) */ + na = a; /* all elements up to 'optimal' will go to array part */ + } + } + ct->na = na; + return optimal; +} + + +static void countint (lua_Integer key, Counters *ct) { + unsigned int k = arrayindex(key); + if (k != 0) { /* is 'key' an array index? */ + ct->nums[luaO_ceillog2(k)]++; /* count as such */ + ct->na++; + } +} + + +l_sinline int arraykeyisempty (const Table *t, unsigned key) { + int tag = *getArrTag(t, key - 1); + return tagisempty(tag); +} + + +/* +** Count keys in array part of table 't'. +*/ +static void numusearray (const Table *t, Counters *ct) { + int lg; + unsigned int ttlg; /* 2^lg */ + unsigned int ause = 0; /* summation of 'nums' */ + unsigned int i = 1; /* index to traverse all array keys */ + unsigned int asize = t->asize; + /* traverse each slice */ + for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { + unsigned int lc = 0; /* counter */ + unsigned int lim = ttlg; + if (lim > asize) { + lim = asize; /* adjust upper limit */ + if (i > lim) + break; /* no more elements to count */ + } + /* count elements in range (2^(lg - 1), 2^lg] */ + for (; i <= lim; i++) { + if (!arraykeyisempty(t, i)) + lc++; + } + ct->nums[lg] += lc; + ause += lc; + } + ct->total += ause; + ct->na += ause; +} + + +/* +** Count keys in hash part of table 't'. As this only happens during +** a rehash, all nodes have been used. A node can have a nil value only +** if it was deleted after being created. +*/ +static void numusehash (const Table *t, Counters *ct) { + unsigned i = sizenode(t); + unsigned total = 0; + while (i--) { + Node *n = &t->node[i]; + if (isempty(gval(n))) { + lua_assert(!keyisnil(n)); /* entry was deleted; key cannot be nil */ + ct->deleted = 1; + } + else { + total++; + if (keyisinteger(n)) + countint(keyival(n), ct); + } + } + ct->total += total; +} + + +/* +** Convert an "abstract size" (number of slots in an array) to +** "concrete size" (number of bytes in the array). +*/ +static size_t concretesize (unsigned int size) { + if (size == 0) + return 0; + else /* space for the two arrays plus an unsigned in between */ + return size * (sizeof(Value) + 1) + sizeof(unsigned); +} + + +/* +** Resize the array part of a table. If new size is equal to the old, +** do nothing. Else, if new size is zero, free the old array. (It must +** be present, as the sizes are different.) Otherwise, allocate a new +** array, move the common elements to new proper position, and then +** frees the old array. +** We could reallocate the array, but we still would need to move the +** elements to their new position, so the copy implicit in realloc is a +** waste. Moreover, most allocators will move the array anyway when the +** new size is double the old one (the most common case). +*/ +static Value *resizearray (lua_State *L , Table *t, + unsigned oldasize, + unsigned newasize) { + if (oldasize == newasize) + return t->array; /* nothing to be done */ + else if (newasize == 0) { /* erasing array? */ + Value *op = t->array - oldasize; /* original array's real address */ + luaM_freemem(L, op, concretesize(oldasize)); /* free it */ + return NULL; + } + else { + size_t newasizeb = concretesize(newasize); + Value *np = cast(Value *, + luaM_reallocvector(L, NULL, 0, newasizeb, lu_byte)); + if (np == NULL) /* allocation error? */ + return NULL; + np += newasize; /* shift pointer to the end of value segment */ + if (oldasize > 0) { + /* move common elements to new position */ + size_t oldasizeb = concretesize(oldasize); + Value *op = t->array; /* original array */ + unsigned tomove = (oldasize < newasize) ? oldasize : newasize; + size_t tomoveb = (oldasize < newasize) ? oldasizeb : newasizeb; + lua_assert(tomoveb > 0); + memcpy(np - tomove, op - tomove, tomoveb); + luaM_freemem(L, op - oldasize, oldasizeb); /* free old block */ + } + return np; + } +} + + +/* +** Creates an array for the hash part of a table with the given +** size, or reuses the dummy node if size is zero. +** The computation for size overflow is in two steps: the first +** comparison ensures that the shift in the second one does not +** overflow. +*/ +static void setnodevector (lua_State *L, Table *t, unsigned size) { + if (size == 0) { /* no elements to hash part? */ + t->node = cast(Node *, dummynode); /* use common 'dummynode' */ + t->lsizenode = 0; + setdummy(t); /* signal that it is using dummy node */ + } + else { + int i; + int lsize = luaO_ceillog2(size); + if (lsize > MAXHBITS || (1 << lsize) > MAXHSIZE) + luaG_runerror(L, "table overflow"); + size = twoto(lsize); + if (lsize < LIMFORLAST) /* no 'lastfree' field? */ + t->node = luaM_newvector(L, size, Node); + else { + size_t bsize = size * sizeof(Node) + sizeof(Limbox); + char *node = luaM_newblock(L, bsize); + t->node = cast(Node *, node + sizeof(Limbox)); + getlastfree(t) = gnode(t, size); /* all positions are free */ + } + t->lsizenode = cast_byte(lsize); + setnodummy(t); + for (i = 0; i < cast_int(size); i++) { + Node *n = gnode(t, i); + gnext(n) = 0; + setnilkey(n); + setempty(gval(n)); + } + } +} + + +/* +** (Re)insert all elements from the hash part of 'ot' into table 't'. +*/ +static void reinserthash (lua_State *L, Table *ot, Table *t) { + unsigned j; + unsigned size = sizenode(ot); + for (j = 0; j < size; j++) { + Node *old = gnode(ot, j); + if (!isempty(gval(old))) { + /* doesn't need barrier/invalidate cache, as entry was + already present in the table */ + TValue k; + getnodekey(L, &k, old); + newcheckedkey(t, &k, gval(old)); + } + } +} + + +/* +** Exchange the hash part of 't1' and 't2'. (In 'flags', only the +** dummy bit must be exchanged: The 'isrealasize' is not related +** to the hash part, and the metamethod bits do not change during +** a resize, so the "real" table can keep their values.) +*/ +static void exchangehashpart (Table *t1, Table *t2) { + lu_byte lsizenode = t1->lsizenode; + Node *node = t1->node; + int bitdummy1 = t1->flags & BITDUMMY; + t1->lsizenode = t2->lsizenode; + t1->node = t2->node; + t1->flags = cast_byte((t1->flags & NOTBITDUMMY) | (t2->flags & BITDUMMY)); + t2->lsizenode = lsizenode; + t2->node = node; + t2->flags = cast_byte((t2->flags & NOTBITDUMMY) | bitdummy1); +} + + +/* +** Re-insert into the new hash part of a table the elements from the +** vanishing slice of the array part. +*/ +static void reinsertOldSlice (Table *t, unsigned oldasize, + unsigned newasize) { + unsigned i; + for (i = newasize; i < oldasize; i++) { /* traverse vanishing slice */ + lu_byte tag = *getArrTag(t, i); + if (!tagisempty(tag)) { /* a non-empty entry? */ + TValue key, aux; + setivalue(&key, l_castU2S(i) + 1); /* make the key */ + farr2val(t, i, tag, &aux); /* copy value into 'aux' */ + insertkey(t, &key, &aux); /* insert entry into the hash part */ + } + } +} + + +/* +** Clear new slice of the array. +*/ +static void clearNewSlice (Table *t, unsigned oldasize, unsigned newasize) { + for (; oldasize < newasize; oldasize++) + *getArrTag(t, oldasize) = LUA_VEMPTY; +} + + +/* +** Resize table 't' for the new given sizes. Both allocations (for +** the hash part and for the array part) can fail, which creates some +** subtleties. If the first allocation, for the hash part, fails, an +** error is raised and that is it. Otherwise, it copies the elements from +** the shrinking part of the array (if it is shrinking) into the new +** hash. Then it reallocates the array part. If that fails, the table +** is in its original state; the function frees the new hash part and then +** raises the allocation error. Otherwise, it sets the new hash part +** into the table, initializes the new part of the array (if any) with +** nils and reinserts the elements of the old hash back into the new +** parts of the table. +** Note that if the new size for the array part ('newasize') is equal to +** the old one ('oldasize'), this function will do nothing with that +** part. +*/ +void luaH_resize (lua_State *L, Table *t, unsigned newasize, + unsigned nhsize) { + Table newt; /* to keep the new hash part */ + unsigned oldasize = t->asize; + Value *newarray; + if (newasize > MAXASIZE) + luaG_runerror(L, "table overflow"); + /* create new hash part with appropriate size into 'newt' */ + newt.flags = 0; + setnodevector(L, &newt, nhsize); + if (newasize < oldasize) { /* will array shrink? */ + /* re-insert into the new hash the elements from vanishing slice */ + exchangehashpart(t, &newt); /* pretend table has new hash */ + reinsertOldSlice(t, oldasize, newasize); + exchangehashpart(t, &newt); /* restore old hash (in case of errors) */ + } + /* allocate new array */ + newarray = resizearray(L, t, oldasize, newasize); + if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ + freehash(L, &newt); /* release new hash part */ + luaM_error(L); /* raise error (with array unchanged) */ + } + /* allocation ok; initialize new part of the array */ + exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ + t->array = newarray; /* set new array part */ + t->asize = newasize; + if (newarray != NULL) + *lenhint(t) = newasize / 2u; /* set an initial hint */ + clearNewSlice(t, oldasize, newasize); + /* re-insert elements from old hash part into new parts */ + reinserthash(L, &newt, t); /* 'newt' now has the old hash */ + freehash(L, &newt); /* free old hash part */ +} + + +void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { + unsigned nsize = allocsizenode(t); + luaH_resize(L, t, nasize, nsize); +} + + +/* +** Rehash a table. First, count its keys. If there are array indices +** outside the array part, compute the new best size for that part. +** Then, resize the table. +*/ +static void rehash (lua_State *L, Table *t, const TValue *ek) { + unsigned asize; /* optimal size for array part */ + Counters ct; + unsigned i; + unsigned nsize; /* size for the hash part */ + /* reset counts */ + for (i = 0; i <= MAXABITS; i++) ct.nums[i] = 0; + ct.na = 0; + ct.deleted = 0; + ct.total = 1; /* count extra key */ + if (ttisinteger(ek)) + countint(ivalue(ek), &ct); /* extra key may go to array */ + numusehash(t, &ct); /* count keys in hash part */ + if (ct.na == 0) { + /* no new keys to enter array part; keep it with the same size */ + asize = t->asize; + } + else { /* compute best size for array part */ + numusearray(t, &ct); /* count keys in array part */ + asize = computesizes(&ct); /* compute new size for array part */ + } + /* all keys not in the array part go to the hash part */ + nsize = ct.total - ct.na; + if (ct.deleted) { /* table has deleted entries? */ + /* insertion-deletion-insertion: give hash some extra size to + avoid repeated resizings */ + nsize += nsize >> 2; + } + /* resize the table to new computed sizes */ + luaH_resize(L, t, asize, nsize); +} + +/* +** }============================================================= +*/ + + +Table *luaH_new (lua_State *L) { + GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); + Table *t = gco2t(o); + t->metatable = NULL; + t->flags = maskflags; /* table has no metamethod fields */ + t->array = NULL; + t->asize = 0; + setnodevector(L, t, 0); + return t; +} + + +lu_mem luaH_size (Table *t) { + lu_mem sz = cast(lu_mem, sizeof(Table)) + concretesize(t->asize); + if (!isdummy(t)) + sz += sizehash(t); + return sz; +} + + +/* +** Frees a table. +*/ +void luaH_free (lua_State *L, Table *t) { + freehash(L, t); + resizearray(L, t, t->asize, 0); + luaM_free(L, t); +} + + +static Node *getfreepos (Table *t) { + if (haslastfree(t)) { /* does it have 'lastfree' information? */ + /* look for a spot before 'lastfree', updating 'lastfree' */ + while (getlastfree(t) > t->node) { + Node *free = --getlastfree(t); + if (keyisnil(free)) + return free; + } + } + else { /* no 'lastfree' information */ + unsigned i = sizenode(t); + while (i--) { /* do a linear search */ + Node *free = gnode(t, i); + if (keyisnil(free)) + return free; + } + } + return NULL; /* could not find a free place */ +} + + + +/* +** Inserts a new key into a hash table; first, check whether key's main +** position is free. If not, check whether colliding node is in its main +** position or not: if it is not, move colliding node to an empty place +** and put new key in its main position; otherwise (colliding node is in +** its main position), new key goes to an empty position. Return 0 if +** could not insert key (could not find a free space). +*/ +static int insertkey (Table *t, const TValue *key, TValue *value) { + Node *mp = mainpositionTV(t, key); + /* table cannot already contain the key */ + lua_assert(isabstkey(getgeneric(t, key, 0))); + if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ + Node *othern; + Node *f = getfreepos(t); /* get a free place */ + if (f == NULL) /* cannot find a free place? */ + return 0; + lua_assert(!isdummy(t)); + othern = mainpositionfromnode(t, mp); + if (othern != mp) { /* is colliding node out of its main position? */ + /* yes; move colliding node into free position */ + while (othern + gnext(othern) != mp) /* find previous */ + othern += gnext(othern); + gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ + *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ + if (gnext(mp) != 0) { + gnext(f) += cast_int(mp - f); /* correct 'next' */ + gnext(mp) = 0; /* now 'mp' is free */ + } + setempty(gval(mp)); + } + else { /* colliding node is in its own main position */ + /* new node will go into free position */ + if (gnext(mp) != 0) + gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ + else lua_assert(gnext(f) == 0); + gnext(mp) = cast_int(f - mp); + mp = f; + } + } + setnodekey(mp, key); + lua_assert(isempty(gval(mp))); + setobj2t(cast(lua_State *, 0), gval(mp), value); + return 1; +} + + +/* +** Insert a key in a table where there is space for that key, the +** key is valid, and the value is not nil. +*/ +static void newcheckedkey (Table *t, const TValue *key, TValue *value) { + unsigned i = keyinarray(t, key); + if (i > 0) /* is key in the array part? */ + obj2arr(t, i - 1, value); /* set value in the array */ + else { + int done = insertkey(t, key, value); /* insert key in the hash part */ + lua_assert(done); /* it cannot fail */ + cast(void, done); /* to avoid warnings */ + } +} + + +static void luaH_newkey (lua_State *L, Table *t, const TValue *key, + TValue *value) { + if (!ttisnil(value)) { /* do not insert nil values */ + int done = insertkey(t, key, value); + if (!done) { /* could not find a free place? */ + rehash(L, t, key); /* grow table */ + newcheckedkey(t, key, value); /* insert key in grown table */ + } + luaC_barrierback(L, obj2gco(t), key); + /* for debugging only: any new key may force an emergency collection */ + condchangemem(L, (void)0, (void)0, 1); + } +} + + +static const TValue *getintfromhash (Table *t, lua_Integer key) { + Node *n = hashint(t, key); + lua_assert(!ikeyinarray(t, key)); + for (;;) { /* check whether 'key' is somewhere in the chain */ + if (keyisinteger(n) && keyival(n) == key) + return gval(n); /* that's it */ + else { + int nx = gnext(n); + if (nx == 0) break; + n += nx; + } + } + return &absentkey; +} + + +static int hashkeyisempty (Table *t, lua_Unsigned key) { + const TValue *val = getintfromhash(t, l_castU2S(key)); + return isempty(val); +} + + +static lu_byte finishnodeget (const TValue *val, TValue *res) { + if (!ttisnil(val)) { + setobj(((lua_State*)NULL), res, val); + } + return ttypetag(val); +} + + +lu_byte luaH_getint (Table *t, lua_Integer key, TValue *res) { + unsigned k = ikeyinarray(t, key); + if (k > 0) { + lu_byte tag = *getArrTag(t, k - 1); + if (!tagisempty(tag)) + farr2val(t, k - 1, tag, res); + return tag; + } + else + return finishnodeget(getintfromhash(t, key), res); +} + + +/* +** search function for short strings +*/ +const TValue *luaH_Hgetshortstr (Table *t, TString *key) { + Node *n = hashstr(t, key); + lua_assert(strisshr(key)); + for (;;) { /* check whether 'key' is somewhere in the chain */ + if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) + return gval(n); /* that's it */ + else { + int nx = gnext(n); + if (nx == 0) + return &absentkey; /* not found */ + n += nx; + } + } +} + + +lu_byte luaH_getshortstr (Table *t, TString *key, TValue *res) { + return finishnodeget(luaH_Hgetshortstr(t, key), res); +} + + +static const TValue *Hgetlongstr (Table *t, TString *key) { + TValue ko; + lua_assert(!strisshr(key)); + setsvalue(cast(lua_State *, NULL), &ko, key); + return getgeneric(t, &ko, 0); /* for long strings, use generic case */ +} + + +static const TValue *Hgetstr (Table *t, TString *key) { + if (strisshr(key)) + return luaH_Hgetshortstr(t, key); + else + return Hgetlongstr(t, key); +} + + +lu_byte luaH_getstr (Table *t, TString *key, TValue *res) { + return finishnodeget(Hgetstr(t, key), res); +} + + +/* +** main search function +*/ +lu_byte luaH_get (Table *t, const TValue *key, TValue *res) { + const TValue *slot; + switch (ttypetag(key)) { + case LUA_VSHRSTR: + slot = luaH_Hgetshortstr(t, tsvalue(key)); + break; + case LUA_VNUMINT: + return luaH_getint(t, ivalue(key), res); + case LUA_VNIL: + slot = &absentkey; + break; + case LUA_VNUMFLT: { + lua_Integer k; + if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ + return luaH_getint(t, k, res); /* use specialized version */ + /* else... */ + } /* FALLTHROUGH */ + default: + slot = getgeneric(t, key, 0); + break; + } + return finishnodeget(slot, res); +} + + +/* +** When a 'pset' cannot be completed, this function returns an encoding +** of its result, to be used by 'luaH_finishset'. +*/ +static int retpsetcode (Table *t, const TValue *slot) { + if (isabstkey(slot)) + return HNOTFOUND; /* no slot with that key */ + else /* return node encoded */ + return cast_int((cast(Node*, slot) - t->node)) + HFIRSTNODE; +} + + +static int finishnodeset (Table *t, const TValue *slot, TValue *val) { + if (!ttisnil(slot)) { + setobj(((lua_State*)NULL), cast(TValue*, slot), val); + return HOK; /* success */ + } + else + return retpsetcode(t, slot); +} + + +static int rawfinishnodeset (const TValue *slot, TValue *val) { + if (isabstkey(slot)) + return 0; /* no slot with that key */ + else { + setobj(((lua_State*)NULL), cast(TValue*, slot), val); + return 1; /* success */ + } +} + + +int luaH_psetint (Table *t, lua_Integer key, TValue *val) { + lua_assert(!ikeyinarray(t, key)); + return finishnodeset(t, getintfromhash(t, key), val); +} + + +static int psetint (Table *t, lua_Integer key, TValue *val) { + int hres; + luaH_fastseti(t, key, val, hres); + return hres; +} + + +/* +** This function could be just this: +** return finishnodeset(t, luaH_Hgetshortstr(t, key), val); +** However, it optimizes the common case created by constructors (e.g., +** {x=1, y=2}), which creates a key in a table that has no metatable, +** it is not old/black, and it already has space for the key. +*/ + +int luaH_psetshortstr (Table *t, TString *key, TValue *val) { + const TValue *slot = luaH_Hgetshortstr(t, key); + if (!ttisnil(slot)) { /* key already has a value? (all too common) */ + setobj(((lua_State*)NULL), cast(TValue*, slot), val); /* update it */ + return HOK; /* done */ + } + else if (checknoTM(t->metatable, TM_NEWINDEX)) { /* no metamethod? */ + if (ttisnil(val)) /* new value is nil? */ + return HOK; /* done (value is already nil/absent) */ + if (isabstkey(slot) && /* key is absent? */ + !(isblack(t) && iswhite(key))) { /* and don't need barrier? */ + TValue tk; /* key as a TValue */ + setsvalue(cast(lua_State *, NULL), &tk, key); + if (insertkey(t, &tk, val)) { /* insert key, if there is space */ + invalidateTMcache(t); + return HOK; + } + } + } + /* Else, either table has new-index metamethod, or it needs barrier, + or it needs to rehash for the new key. In any of these cases, the + operation cannot be completed here. Return a code for the caller. */ + return retpsetcode(t, slot); +} + + +int luaH_psetstr (Table *t, TString *key, TValue *val) { + if (strisshr(key)) + return luaH_psetshortstr(t, key, val); + else + return finishnodeset(t, Hgetlongstr(t, key), val); +} + + +int luaH_pset (Table *t, const TValue *key, TValue *val) { + switch (ttypetag(key)) { + case LUA_VSHRSTR: return luaH_psetshortstr(t, tsvalue(key), val); + case LUA_VNUMINT: return psetint(t, ivalue(key), val); + case LUA_VNIL: return HNOTFOUND; + case LUA_VNUMFLT: { + lua_Integer k; + if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ + return psetint(t, k, val); /* use specialized version */ + /* else... */ + } /* FALLTHROUGH */ + default: + return finishnodeset(t, getgeneric(t, key, 0), val); + } +} + +/* +** Finish a raw "set table" operation, where 'hres' encodes where the +** value should have been (the result of a previous 'pset' operation). +** Beware: when using this function the caller probably need to check a +** GC barrier and invalidate the TM cache. +*/ +void luaH_finishset (lua_State *L, Table *t, const TValue *key, + TValue *value, int hres) { + lua_assert(hres != HOK); + if (hres == HNOTFOUND) { + TValue aux; + if (l_unlikely(ttisnil(key))) + luaG_runerror(L, "table index is nil"); + else if (ttisfloat(key)) { + lua_Number f = fltvalue(key); + lua_Integer k; + if (luaV_flttointeger(f, &k, F2Ieq)) { + setivalue(&aux, k); /* key is equal to an integer */ + key = &aux; /* insert it as an integer */ + } + else if (l_unlikely(luai_numisnan(f))) + luaG_runerror(L, "table index is NaN"); + } + else if (isextstr(key)) { /* external string? */ + /* If string is short, must internalize it to be used as table key */ + TString *ts = luaS_normstr(L, tsvalue(key)); + setsvalue2s(L, L->top.p++, ts); /* anchor 'ts' (EXTRA_STACK) */ + luaH_newkey(L, t, s2v(L->top.p - 1), value); + L->top.p--; + return; + } + luaH_newkey(L, t, key, value); + } + else if (hres > 0) { /* regular Node? */ + setobj2t(L, gval(gnode(t, hres - HFIRSTNODE)), value); + } + else { /* array entry */ + hres = ~hres; /* real index */ + obj2arr(t, cast_uint(hres), value); + } +} + + +/* +** beware: when using this function you probably need to check a GC +** barrier and invalidate the TM cache. +*/ +void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { + int hres = luaH_pset(t, key, value); + if (hres != HOK) + luaH_finishset(L, t, key, value, hres); +} + + +/* +** Ditto for a GC barrier. (No need to invalidate the TM cache, as +** integers cannot be keys to metamethods.) +*/ +void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) { + unsigned ik = ikeyinarray(t, key); + if (ik > 0) + obj2arr(t, ik - 1, value); + else { + int ok = rawfinishnodeset(getintfromhash(t, key), value); + if (!ok) { + TValue k; + setivalue(&k, key); + luaH_newkey(L, t, &k, value); + } + } +} + + +/* +** Try to find a boundary in the hash part of table 't'. From the +** caller, we know that 'asize + 1' is present. We want to find a larger +** key that is absent from the table, so that we can do a binary search +** between the two keys to find a boundary. We keep doubling 'j' until +** we get an absent index. If the doubling would overflow, we try +** LUA_MAXINTEGER. If it is absent, we are ready for the binary search. +** ('j', being max integer, is larger or equal to 'i', but it cannot be +** equal because it is absent while 'i' is present.) Otherwise, 'j' is a +** boundary. ('j + 1' cannot be a present integer key because it is not +** a valid integer in Lua.) +** About 'rnd': If we used a fixed algorithm, a bad actor could fill +** a table with only the keys that would be probed, in such a way that +** a small table could result in a huge length. To avoid that, we use +** the state's seed as a source of randomness. For the first probe, +** we "randomly double" 'i' by adding to it a random number roughly its +** width. +*/ +static lua_Unsigned hash_search (lua_State *L, Table *t, unsigned asize) { + lua_Unsigned i = asize + 1; /* caller ensures t[i] is present */ + unsigned rnd = G(L)->seed; + int n = (asize > 0) ? luaO_ceillog2(asize) : 0; /* width of 'asize' */ + unsigned mask = (1u << n) - 1; /* 11...111 with the width of 'asize' */ + unsigned incr = (rnd & mask) + 1; /* first increment (at least 1) */ + lua_Unsigned j = (incr <= l_castS2U(LUA_MAXINTEGER) - i) ? i + incr : i + 1; + rnd >>= n; /* used 'n' bits from 'rnd' */ + while (!hashkeyisempty(t, j)) { /* repeat until an absent t[j] */ + i = j; /* 'i' is a present index */ + if (j <= l_castS2U(LUA_MAXINTEGER)/2 - 1) { + j = j*2 + (rnd & 1); /* try again with 2j or 2j+1 */ + rnd >>= 1; + } + else { + j = LUA_MAXINTEGER; + if (hashkeyisempty(t, j)) /* t[j] not present? */ + break; /* 'j' now is an absent index */ + else /* weird case */ + return j; /* well, max integer is a boundary... */ + } + } + /* i < j && t[i] present && t[j] absent */ + while (j - i > 1u) { /* do a binary search between them */ + lua_Unsigned m = (i + j) / 2; + if (hashkeyisempty(t, m)) j = m; + else i = m; + } + return i; +} + + +static unsigned int binsearch (Table *array, unsigned int i, unsigned int j) { + lua_assert(i <= j); + while (j - i > 1u) { /* binary search */ + unsigned int m = (i + j) / 2; + if (arraykeyisempty(array, m)) j = m; + else i = m; + } + return i; +} + + +/* return a border, saving it as a hint for next call */ +static lua_Unsigned newhint (Table *t, unsigned hint) { + lua_assert(hint <= t->asize); + *lenhint(t) = hint; + return hint; +} + + +/* +** Try to find a border in table 't'. (A 'border' is an integer index +** such that t[i] is present and t[i+1] is absent, or 0 if t[1] is absent, +** or 'maxinteger' if t[maxinteger] is present.) +** If there is an array part, try to find a border there. First try +** to find it in the vicinity of the previous result (hint), to handle +** cases like 't[#t + 1] = val' or 't[#t] = nil', that move the border +** by one entry. Otherwise, do a binary search to find the border. +** If there is no array part, or its last element is non empty, the +** border may be in the hash part. +*/ +lua_Unsigned luaH_getn (lua_State *L, Table *t) { + unsigned asize = t->asize; + if (asize > 0) { /* is there an array part? */ + const unsigned maxvicinity = 4; + unsigned limit = *lenhint(t); /* start with the hint */ + if (limit == 0) + limit = 1; /* make limit a valid index in the array */ + if (arraykeyisempty(t, limit)) { /* t[limit] empty? */ + /* there must be a border before 'limit' */ + unsigned i; + /* look for a border in the vicinity of the hint */ + for (i = 0; i < maxvicinity && limit > 1; i++) { + limit--; + if (!arraykeyisempty(t, limit)) + return newhint(t, limit); /* 'limit' is a border */ + } + /* t[limit] still empty; search for a border in [0, limit) */ + return newhint(t, binsearch(t, 0, limit)); + } + else { /* 'limit' is present in table; look for a border after it */ + unsigned i; + /* look for a border in the vicinity of the hint */ + for (i = 0; i < maxvicinity && limit < asize; i++) { + limit++; + if (arraykeyisempty(t, limit)) + return newhint(t, limit - 1); /* 'limit - 1' is a border */ + } + if (arraykeyisempty(t, asize)) { /* last element empty? */ + /* t[limit] not empty; search for a border in [limit, asize) */ + return newhint(t, binsearch(t, limit, asize)); + } + } + /* last element non empty; set a hint to speed up finding that again */ + /* (keys in the hash part cannot be hints) */ + *lenhint(t) = asize; + } + /* no array part or t[asize] is not empty; check the hash part */ + lua_assert(asize == 0 || !arraykeyisempty(t, asize)); + if (isdummy(t) || hashkeyisempty(t, asize + 1)) + return asize; /* 'asize + 1' is empty */ + else /* 'asize + 1' is also non empty */ + return hash_search(L, t, asize); +} + + + +#if defined(LUA_DEBUG) + +/* export this function for the test library */ + +Node *luaH_mainposition (const Table *t, const TValue *key) { + return mainpositionTV(t, key); +} + +#endif diff --git a/source/external/lua/ltablib.c b/source/external/lua/ltablib.c new file mode 100644 index 0000000..46ecb5e --- /dev/null +++ b/source/external/lua/ltablib.c @@ -0,0 +1,426 @@ +/* +** $Id: ltablib.c $ +** Library for Table Manipulation +** See Copyright Notice in lua.h +*/ + +#define ltablib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +/* +** Operations that an object must define to mimic a table +** (some functions only need some of them) +*/ +#define TAB_R 1 /* read */ +#define TAB_W 2 /* write */ +#define TAB_L 4 /* length */ +#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)) + + +static int checkfield (lua_State *L, const char *key, int n) { + lua_pushstring(L, key); + return (lua_rawget(L, -n) != LUA_TNIL); +} + + +/* +** 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_checktype(L, arg, LUA_TTABLE); /* force an error */ + } +} + + +static int tcreate (lua_State *L) { + lua_Unsigned sizeseq = (lua_Unsigned)luaL_checkinteger(L, 1); + lua_Unsigned sizerest = (lua_Unsigned)luaL_optinteger(L, 2, 0); + luaL_argcheck(L, sizeseq <= cast_uint(INT_MAX), 1, "out of range"); + luaL_argcheck(L, sizerest <= cast_uint(INT_MAX), 2, "out of range"); + lua_createtable(L, cast_int(sizeseq), cast_int(sizerest)); + return 1; +} + + +static int tinsert (lua_State *L) { + lua_Integer pos; /* where to insert new element */ + lua_Integer e = aux_getn(L, 1, TAB_RW); + e = luaL_intop(+, e, 1); /* first empty element */ + switch (lua_gettop(L)) { + case 2: { /* called with only 2 arguments */ + pos = e; /* insert new element at the end */ + break; + } + case 3: { + lua_Integer i; + pos = luaL_checkinteger(L, 2); /* 2nd argument is the position */ + /* check whether 'pos' is in [1, e] */ + luaL_argcheck(L, (lua_Unsigned)pos - 1u < (lua_Unsigned)e, 2, + "position out of bounds"); + for (i = e; i > pos; i--) { /* move up elements */ + lua_geti(L, 1, i - 1); + lua_seti(L, 1, i); /* t[i] = t[i - 1] */ + } + break; + } + default: { + return luaL_error(L, "wrong number of arguments to 'insert'"); + } + } + lua_seti(L, 1, pos); /* t[pos] = v */ + return 0; +} + + +static int tremove (lua_State *L) { + lua_Integer size = aux_getn(L, 1, TAB_RW); + lua_Integer pos = luaL_optinteger(L, 2, size); + if (pos != size) /* validate 'pos' if given */ + /* check whether 'pos' is in [1, size + 1] */ + luaL_argcheck(L, (lua_Unsigned)pos - 1u <= (lua_Unsigned)size, 2, + "position out of bounds"); + lua_geti(L, 1, pos); /* result = t[pos] */ + for ( ; pos < size; pos++) { + lua_geti(L, 1, pos + 1); + lua_seti(L, 1, pos); /* t[pos] = t[pos + 1] */ + } + lua_pushnil(L); + lua_seti(L, 1, pos); /* remove entry t[pos] */ + 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) { + lua_Integer f = luaL_checkinteger(L, 2); + lua_Integer e = luaL_checkinteger(L, 3); + lua_Integer t = luaL_checkinteger(L, 4); + 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 */ + lua_Integer n, i; + luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3, + "too many elements to move"); + n = e - f + 1; /* number of elements to move */ + luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4, + "destination wrap around"); + if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) { + for (i = 0; i < n; i++) { + lua_geti(L, 1, f + i); + lua_seti(L, tt, t + i); + } + } + else { + for (i = n - 1; i >= 0; i--) { + lua_geti(L, 1, f + i); + lua_seti(L, tt, t + i); + } + } + } + lua_pushvalue(L, tt); /* return destination table */ + return 1; +} + + +static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) { + lua_geti(L, 1, i); + if (l_unlikely(!lua_isstring(L, -1))) + luaL_error(L, "invalid value (%s) at index %I in table for 'concat'", + luaL_typename(L, -1), (LUAI_UACINT)i); + luaL_addvalue(b); +} + + +static int tconcat (lua_State *L) { + luaL_Buffer b; + lua_Integer last = aux_getn(L, 1, TAB_R); + size_t lsep; + const char *sep = luaL_optlstring(L, 2, "", &lsep); + lua_Integer i = luaL_optinteger(L, 3, 1); + last = luaL_optinteger(L, 4, last); + luaL_buffinit(L, &b); + for (; i < last; i++) { + addfield(L, &b, i); + luaL_addlstring(&b, sep, lsep); + } + if (i == last) /* add last value (if interval was not empty) */ + addfield(L, &b, i); + luaL_pushresult(&b); + return 1; +} + + +/* +** {====================================================== +** Pack/unpack +** ======================================================= +*/ + +static int tpack (lua_State *L) { + int i; + int n = lua_gettop(L); /* number of elements to pack */ + lua_createtable(L, n, 1); /* create result table */ + lua_insert(L, 1); /* put it at index 1 */ + for (i = n; i >= 1; i--) /* assign elements */ + lua_seti(L, 1, i); + lua_pushinteger(L, n); + lua_setfield(L, 1, "n"); /* t.n = number of elements */ + return 1; /* return table */ +} + + +static int tunpack (lua_State *L) { + lua_Unsigned n; + lua_Integer i = luaL_optinteger(L, 2, 1); + lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1)); + if (i > e) return 0; /* empty range */ + n = l_castS2U(e) - l_castS2U(i); /* number of elements minus 1 */ + if (l_unlikely(n >= (unsigned int)INT_MAX || + !lua_checkstack(L, (int)(++n)))) + return luaL_error(L, "too many results to unpack"); + for (; i < e; i++) { /* push arg[i..e - 1] (to avoid overflows) */ + lua_geti(L, 1, i); + } + lua_geti(L, 1, e); /* push last element */ + return (int)n; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** Quicksort +** (based on 'Algorithms in MODULA-3', Robert Sedgewick; +** Addison-Wesley, 1993.) +** ======================================================= +*/ + + +/* +** Type for array indices. These indices are always limited by INT_MAX, +** so it is safe to cast them to lua_Integer even for Lua 32 bits. +*/ +typedef unsigned int IdxT; + + +/* Versions of lua_seti/lua_geti specialized for IdxT */ +#define geti(L,idt,idx) lua_geti(L, idt, l_castU2S(idx)) +#define seti(L,idt,idx) lua_seti(L, idt, l_castU2S(idx)) + + +/* +** Produce a "random" 'unsigned int' to randomize pivot choice. This +** 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) +#define l_randomizePivot(L) luaL_makeseed(L) +#endif /* } */ + + +/* arrays larger than 'RANLIMIT' may use randomized pivots */ +#define RANLIMIT 100u + + +static void set2 (lua_State *L, IdxT i, IdxT j) { + seti(L, 1, i); + 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) { + if (lua_isnil(L, 2)) /* no function? */ + return lua_compare(L, a, b, LUA_OPLT); /* a < b */ + else { /* function */ + int res; + lua_pushvalue(L, 2); /* push function */ + lua_pushvalue(L, a-1); /* -1 to compensate function */ + lua_pushvalue(L, b-2); /* -2 to compensate function and 'a' */ + lua_call(L, 2, 1); /* call function */ + res = lua_toboolean(L, -1); /* get result */ + lua_pop(L, 1); /* pop result */ + return res; + } +} + + +/* +** Does the partition: Pivot P is at the top of the stack. +** precondition: a[lo] <= P == a[up-1] <= a[up], +** so it only needs to do the partition from lo + 1 to up - 2. +** Pos-condition: a[lo .. i - 1] <= a[i] == P <= a[i + 1 .. up] +** returns 'i'. +*/ +static IdxT partition (lua_State *L, IdxT lo, IdxT up) { + IdxT i = lo; /* will be incremented before first use */ + IdxT 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 ((void)geti(L, 1, ++i), sort_comp(L, -1, -2)) { + if (l_unlikely(i == up - 1)) /* a[up - 1] < P == a[up - 1] */ + 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 (a) */ + /* next loop: repeat --j while P < a[j] */ + while ((void)geti(L, 1, --j), sort_comp(L, -3, -1)) { + if (l_unlikely(j < i)) /* j <= i - 1 and a[j] > P, contradicts (a) */ + 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 IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) { + IdxT r4 = (up - lo) / 4; /* range/4 */ + IdxT p = (rnd ^ lo ^ up) % (r4 * 2) + (lo + r4); + lua_assert(lo + r4 <= p && p <= up - r4); + return p; +} + + +/* +** Quicksort algorithm (recursive function) +*/ +static void auxsort (lua_State *L, IdxT lo, IdxT up, unsigned rnd) { + while (lo < up) { /* loop for tail recursion */ + IdxT p; /* Pivot index */ + IdxT n; /* to be used later */ + /* sort elements 'lo', 'p', and 'up' */ + geti(L, 1, lo); + geti(L, 1, up); + if (sort_comp(L, -1, -2)) /* a[up] < a[lo]? */ + set2(L, lo, up); /* swap a[lo] - a[up] */ + else + lua_pop(L, 2); /* remove both values */ + if (up - lo == 1) /* only 2 elements? */ + return; /* already sorted */ + if (up - lo < RANLIMIT || rnd == 0) /* small interval or no randomize? */ + p = (lo + up)/2; /* middle element is a good pivot */ + else /* for larger intervals, it is worth a random pivot */ + p = choosePivot(lo, up, rnd); + geti(L, 1, p); + geti(L, 1, lo); + if (sort_comp(L, -2, -1)) /* a[p] < a[lo]? */ + set2(L, p, lo); /* swap a[p] - a[lo] */ + else { + lua_pop(L, 1); /* remove a[lo] */ + geti(L, 1, up); + if (sort_comp(L, -1, -2)) /* a[up] < a[p]? */ + set2(L, p, up); /* swap a[up] - a[p] */ + else + lua_pop(L, 2); + } + if (up - lo == 2) /* only 3 elements? */ + return; /* already sorted */ + geti(L, 1, p); /* get middle element (Pivot) */ + lua_pushvalue(L, -1); /* push Pivot */ + geti(L, 1, up - 1); /* push a[up - 1] */ + set2(L, p, up - 1); /* swap Pivot (a[p]) with a[up - 1] */ + p = partition(L, lo, up); + /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */ + if (p - lo < up - p) { /* lower interval is smaller? */ + auxsort(L, lo, p - 1, rnd); /* call recursively for lower interval */ + n = p - lo; /* size of smaller interval */ + lo = p + 1; /* tail call for [p + 1 .. up] (upper interval) */ + } + else { + 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) */ + } + if ((up - lo) / 128 > n) /* partition too imbalanced? */ + rnd = l_randomizePivot(L); /* try a new randomization */ + } /* tail call auxsort(L, lo, up, rnd) */ +} + + +static int sort (lua_State *L) { + lua_Integer n = aux_getn(L, 1, TAB_RW); + if (n > 1) { /* non-trivial interval? */ + luaL_argcheck(L, n < INT_MAX, 1, "array too big"); + if (!lua_isnoneornil(L, 2)) /* is there a 2nd argument? */ + luaL_checktype(L, 2, LUA_TFUNCTION); /* must be a function */ + lua_settop(L, 2); /* make sure there are two arguments */ + auxsort(L, 1, (IdxT)n, 0); + } + return 0; +} + +/* }====================================================== */ + + +static const luaL_Reg tab_funcs[] = { + {"concat", tconcat}, + {"create", tcreate}, + {"insert", tinsert}, + {"pack", tpack}, + {"unpack", tunpack}, + {"remove", tremove}, + {"move", tmove}, + {"sort", sort}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_table (lua_State *L) { + luaL_newlib(L, tab_funcs); + return 1; +} + diff --git a/source/external/lua/ltm.c b/source/external/lua/ltm.c new file mode 100644 index 0000000..f2a373f --- /dev/null +++ b/source/external/lua/ltm.c @@ -0,0 +1,364 @@ +/* +** $Id: ltm.c $ +** Tag methods +** See Copyright Notice in lua.h +*/ + +#define ltm_c +#define LUA_CORE + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + +static const char udatatypename[] = "userdata"; + +LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTYPES] = { + "no value", + "nil", "boolean", udatatypename, "number", + "string", "table", "function", udatatypename, "thread", + "upvalue", "proto" /* these last cases are used for tests only */ +}; + + +void luaT_init (lua_State *L) { + static const char *const luaT_eventname[] = { /* ORDER TM */ + "__index", "__newindex", + "__gc", "__mode", "__len", "__eq", + "__add", "__sub", "__mul", "__mod", "__pow", + "__div", "__idiv", + "__band", "__bor", "__bxor", "__shl", "__shr", + "__unm", "__bnot", "__lt", "__le", + "__concat", "__call", "__close" + }; + int i; + for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); + luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ + } +} + + +/* +** function to be used with macro "fasttm": optimized for absence of +** tag methods +*/ +const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { + const TValue *tm = luaH_Hgetshortstr(events, ename); + lua_assert(event <= TM_EQ); + if (notm(tm)) { /* no tag method? */ + events->flags |= cast_byte(1u<metatable; + break; + case LUA_TUSERDATA: + mt = uvalue(o)->metatable; + break; + default: + mt = G(L)->mt[ttype(o)]; + } + return (mt ? luaH_Hgetshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); +} + + +/* +** Return the name of the type of an object. For tables and userdata +** with metatable, use their '__name' metafield, if present. +*/ +const char *luaT_objtypename (lua_State *L, const TValue *o) { + Table *mt; + if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || + (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { + const TValue *name = luaH_Hgetshortstr(mt, luaS_new(L, "__name")); + if (ttisstring(name)) /* is '__name' a string? */ + return getstr(tsvalue(name)); /* use it as type name */ + } + return ttypename(ttype(o)); /* else use standard type name */ +} + + +void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, const TValue *p3) { + StkId func = L->top.p; + setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */ + setobj2s(L, func + 1, p1); /* 1st argument */ + setobj2s(L, func + 2, p2); /* 2nd argument */ + setobj2s(L, func + 3, p3); /* 3rd argument */ + L->top.p = func + 4; + /* metamethod may yield only when called from Lua code */ + if (isLuacode(L->ci)) + luaD_call(L, func, 0); + else + luaD_callnoyield(L, func, 0); +} + + +lu_byte luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1, + const TValue *p2, StkId res) { + ptrdiff_t result = savestack(L, res); + StkId func = L->top.p; + setobj2s(L, func, f); /* push function (assume EXTRA_STACK) */ + setobj2s(L, func + 1, p1); /* 1st argument */ + setobj2s(L, func + 2, p2); /* 2nd argument */ + L->top.p += 3; + /* metamethod may yield only when called from Lua code */ + if (isLuacode(L->ci)) + luaD_call(L, func, 1); + else + luaD_callnoyield(L, func, 1); + res = restorestack(L, result); + setobjs2s(L, res, --L->top.p); /* move result to its place */ + return ttypetag(s2v(res)); /* return tag of the result */ +} + + +static int callbinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event) { + const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ + if (notm(tm)) + tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ + if (notm(tm)) + return -1; /* tag method not found */ + else /* call tag method and return the tag of the result */ + return luaT_callTMres(L, tm, p1, p2, res); +} + + +void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2, + StkId res, TMS event) { + if (l_unlikely(callbinTM(L, p1, p2, res, event) < 0)) { + switch (event) { + case TM_BAND: case TM_BOR: case TM_BXOR: + case TM_SHL: case TM_SHR: case TM_BNOT: { + if (ttisnumber(p1) && ttisnumber(p2)) + luaG_tointerror(L, p1, p2); + else + luaG_opinterror(L, p1, p2, "perform bitwise operation on"); + } + /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ + default: + luaG_opinterror(L, p1, p2, "perform arithmetic on"); + } + } +} + + +/* +** The use of 'p1' after 'callbinTM' is safe because, when a tag +** method is not found, 'callbinTM' cannot change the stack. +*/ +void luaT_tryconcatTM (lua_State *L) { + StkId p1 = L->top.p - 2; /* first argument */ + if (l_unlikely(callbinTM(L, s2v(p1), s2v(p1 + 1), p1, TM_CONCAT) < 0)) + luaG_concaterror(L, s2v(p1), s2v(p1 + 1)); +} + + +void luaT_trybinassocTM (lua_State *L, const TValue *p1, const TValue *p2, + int flip, StkId res, TMS event) { + if (flip) + luaT_trybinTM(L, p2, p1, res, event); + else + luaT_trybinTM(L, p1, p2, res, event); +} + + +void luaT_trybiniTM (lua_State *L, const TValue *p1, lua_Integer i2, + int flip, StkId res, TMS event) { + TValue aux; + setivalue(&aux, i2); + luaT_trybinassocTM(L, p1, &aux, flip, res, event); +} + + +/* +** Calls an order tag method. +*/ +int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2, + TMS event) { + int tag = callbinTM(L, p1, p2, L->top.p, event); /* try original event */ + if (tag >= 0) /* found tag method? */ + return !tagisfalse(tag); + luaG_ordererror(L, p1, p2); /* no metamethod found */ + return 0; /* to avoid warnings */ +} + + +int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2, + int flip, int isfloat, TMS event) { + TValue aux; const TValue *p2; + if (isfloat) { + setfltvalue(&aux, cast_num(v2)); + } + else + setivalue(&aux, v2); + if (flip) { /* arguments were exchanged? */ + p2 = p1; p1 = &aux; /* correct them */ + } + else + p2 = &aux; + return luaT_callorderTM(L, p1, p2, event); +} + + +/* +** Create a vararg table at the top of the stack, with 'n' elements +** starting at 'f'. +*/ +static void createvarargtab (lua_State *L, StkId f, int n) { + int i; + TValue key, value; + Table *t = luaH_new(L); + sethvalue(L, s2v(L->top.p), t); + L->top.p++; + luaH_resize(L, t, cast_uint(n), 1); + setsvalue(L, &key, luaS_new(L, "n")); /* key is "n" */ + setivalue(&value, n); /* value is n */ + /* No need to anchor the key: Due to the resize, the next operation + cannot trigger a garbage collection */ + luaH_set(L, t, &key, &value); /* t.n = n */ + for (i = 0; i < n; i++) + luaH_setint(L, t, i + 1, s2v(f + i)); + luaC_checkGC(L); +} + + +/* +** initial stack: func arg1 ... argn extra1 ... +** ^ ci->func ^ L->top +** final stack: func nil ... nil extra1 ... func arg1 ... argn +** ^ ci->func +*/ +static void buildhiddenargs (lua_State *L, CallInfo *ci, const Proto *p, + int totalargs, int nfixparams, int nextra) { + int i; + ci->u.l.nextraargs = nextra; + luaD_checkstack(L, p->maxstacksize + 1); + /* copy function to the top of the stack, after extra arguments */ + setobjs2s(L, L->top.p++, ci->func.p); + /* move fixed parameters to after the copied function */ + for (i = 1; i <= nfixparams; i++) { + setobjs2s(L, L->top.p++, ci->func.p + i); + setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */ + } + ci->func.p += totalargs + 1; /* 'func' now lives after hidden arguments */ + ci->top.p += totalargs + 1; +} + + +void luaT_adjustvarargs (lua_State *L, CallInfo *ci, const Proto *p) { + int totalargs = cast_int(L->top.p - ci->func.p) - 1; + int nfixparams = p->numparams; + int nextra = totalargs - nfixparams; /* number of extra arguments */ + if (p->flag & PF_VATAB) { /* does it need a vararg table? */ + lua_assert(!(p->flag & PF_VAHID)); + createvarargtab(L, ci->func.p + nfixparams + 1, nextra); + /* move table to proper place (last parameter) */ + setobjs2s(L, ci->func.p + nfixparams + 1, L->top.p - 1); + } + else { /* no table */ + lua_assert(p->flag & PF_VAHID); + buildhiddenargs(L, ci, p, totalargs, nfixparams, nextra); + /* set vararg parameter to nil */ + setnilvalue(s2v(ci->func.p + nfixparams + 1)); + lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p); + } +} + + +void luaT_getvararg (CallInfo *ci, StkId ra, TValue *rc) { + int nextra = ci->u.l.nextraargs; + lua_Integer n; + if (tointegerns(rc, &n)) { /* integral value? */ + if (l_castS2U(n) - 1 < cast_uint(nextra)) { + StkId slot = ci->func.p - nextra + cast_int(n) - 1; + setobjs2s(((lua_State*)NULL), ra, slot); + return; + } + } + else if (ttisstring(rc)) { /* string value? */ + size_t len; + const char *s = getlstr(tsvalue(rc), len); + if (len == 1 && s[0] == 'n') { /* key is "n"? */ + setivalue(s2v(ra), nextra); + return; + } + } + setnilvalue(s2v(ra)); /* else produce nil */ +} + + +/* +** Get the number of extra arguments in a vararg function. If vararg +** table has been optimized away, that number is in the call info. +** Otherwise, get the field 'n' from the vararg table and check that it +** has a proper value (non-negative integer not larger than the stack +** limit). +*/ +static int getnumargs (lua_State *L, CallInfo *ci, Table *h) { + if (h == NULL) /* no vararg table? */ + return ci->u.l.nextraargs; + else { + TValue res; + if (luaH_getshortstr(h, luaS_new(L, "n"), &res) != LUA_VNUMINT || + l_castS2U(ivalue(&res)) > cast_uint(INT_MAX/2)) + luaG_runerror(L, "vararg table has no proper 'n'"); + return cast_int(ivalue(&res)); + } +} + + +/* +** Get 'wanted' vararg arguments and put them in 'where'. 'vatab' is +** the register of the vararg table or -1 if there is no vararg table. +*/ +void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted, + int vatab) { + Table *h = (vatab < 0) ? NULL : hvalue(s2v(ci->func.p + vatab + 1)); + int nargs = getnumargs(L, ci, h); /* number of available vararg args. */ + int i, touse; /* 'touse' is minimum between 'wanted' and 'nargs' */ + if (wanted < 0) { + touse = wanted = nargs; /* get all extra arguments available */ + checkstackp(L, nargs, where); /* ensure stack space */ + L->top.p = where + nargs; /* next instruction will need top */ + } + else + touse = (nargs > wanted) ? wanted : nargs; + if (h == NULL) { /* no vararg table? */ + for (i = 0; i < touse; i++) /* get vararg values from the stack */ + setobjs2s(L, where + i, ci->func.p - nargs + i); + } + else { /* get vararg values from vararg table */ + for (i = 0; i < touse; i++) { + lu_byte tag = luaH_getint(h, i + 1, s2v(where + i)); + if (tagisempty(tag)) + setnilvalue(s2v(where + i)); + } + } + for (; i < wanted; i++) /* complete required results with nil */ + setnilvalue(s2v(where + i)); +} + diff --git a/source/external/lua/lua.hpp b/source/external/lua/lua.hpp index 2853364..307de01 100644 --- a/source/external/lua/lua.hpp +++ b/source/external/lua/lua.hpp @@ -3,8 +3,8 @@ // 'extern "C" not supplied automatically in lua.h and other headers // because Lua also compiles as C++ -extern "C" { +//extern "C" { #include "lua.h" #include "lualib.h" #include "lauxlib.h" -} +//} diff --git a/source/external/lua/lundump.c b/source/external/lua/lundump.c new file mode 100644 index 0000000..3b61cc8 --- /dev/null +++ b/source/external/lua/lundump.c @@ -0,0 +1,424 @@ +/* +** $Id: lundump.c $ +** load precompiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#define lundump_c +#define LUA_CORE + +#include "lprefix.h" + + +#include +#include + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstring.h" +#include "ltable.h" +#include "lundump.h" +#include "lzio.h" + + +#if !defined(luai_verifycode) +#define luai_verifycode(L,f) /* empty */ +#endif + + +typedef struct { + lua_State *L; + ZIO *Z; + const char *name; + Table *h; /* list for string reuse */ + size_t offset; /* current position relative to beginning of dump */ + lua_Unsigned nstr; /* number of strings in the list */ + lu_byte fixed; /* dump is fixed in memory */ +} LoadState; + + +static l_noret error (LoadState *S, const char *why) { + luaO_pushfstring(S->L, "%s: bad binary format (%s)", S->name, why); + luaD_throw(S->L, LUA_ERRSYNTAX); +} + + +/* +** All high-level loads go through loadVector; you can change it to +** adapt to the endianness of the input +*/ +#define loadVector(S,b,n) loadBlock(S,b,cast_sizet(n)*sizeof((b)[0])) + +static void loadBlock (LoadState *S, void *b, size_t size) { + if (luaZ_read(S->Z, b, size) != 0) + error(S, "truncated chunk"); + S->offset += size; +} + + +static void loadAlign (LoadState *S, unsigned align) { + unsigned padding = align - cast_uint(S->offset % align); + if (padding < align) { /* (padding == align) means no padding */ + lua_Integer paddingContent; + loadBlock(S, &paddingContent, padding); + lua_assert(S->offset % align == 0); + } +} + + +#define getaddr(S,n,t) cast(t *, getaddr_(S,cast_sizet(n) * sizeof(t))) + +static const void *getaddr_ (LoadState *S, size_t size) { + const void *block = luaZ_getaddr(S->Z, size); + S->offset += size; + if (block == NULL) + error(S, "truncated fixed buffer"); + return block; +} + + +#define loadVar(S,x) loadVector(S,&x,1) + + +static lu_byte loadByte (LoadState *S) { + int b = zgetc(S->Z); + if (b == EOZ) + error(S, "truncated chunk"); + S->offset++; + return cast_byte(b); +} + + +static lua_Unsigned loadVarint (LoadState *S, lua_Unsigned limit) { + lua_Unsigned x = 0; + int b; + limit >>= 7; + do { + b = loadByte(S); + if (x > limit) + error(S, "integer overflow"); + x = (x << 7) | (b & 0x7f); + } while ((b & 0x80) != 0); + return x; +} + + +static size_t loadSize (LoadState *S) { + return cast_sizet(loadVarint(S, MAX_SIZE)); +} + + +static int loadInt (LoadState *S) { + return cast_int(loadVarint(S, cast_sizet(INT_MAX))); +} + + + +static lua_Number loadNumber (LoadState *S) { + lua_Number x; + loadVar(S, x); + return x; +} + + +static lua_Integer loadInteger (LoadState *S) { + lua_Unsigned cx = loadVarint(S, LUA_MAXUNSIGNED); + /* decode unsigned to signed */ + if ((cx & 1) != 0) + return l_castU2S(~(cx >> 1)); + else + return l_castU2S(cx >> 1); +} + + +/* +** Load a nullable string into slot 'sl' from prototype 'p'. The +** assignment to the slot and the barrier must be performed before any +** possible GC activity, to anchor the string. (Both 'loadVector' and +** 'luaH_setint' can call the GC.) +*/ +static void loadString (LoadState *S, Proto *p, TString **sl) { + lua_State *L = S->L; + TString *ts; + TValue sv; + size_t size = loadSize(S); + if (size == 0) { /* previously saved string? */ + lua_Unsigned idx = loadVarint(S, LUA_MAXUNSIGNED); /* get its index */ + TValue stv; + if (idx == 0) { /* no string? */ + lua_assert(*sl == NULL); /* must be prefilled */ + return; + } + if (novariant(luaH_getint(S->h, l_castU2S(idx), &stv)) != LUA_TSTRING) + error(S, "invalid string index"); + *sl = ts = tsvalue(&stv); /* get its value */ + luaC_objbarrier(L, p, ts); + return; /* do not save it again */ + } + else if ((size -= 1) <= LUAI_MAXSHORTLEN) { /* short string? */ + char buff[LUAI_MAXSHORTLEN + 1]; /* extra space for '\0' */ + loadVector(S, buff, size + 1); /* load string into buffer */ + *sl = ts = luaS_newlstr(L, buff, size); /* create string */ + luaC_objbarrier(L, p, ts); + } + else if (S->fixed) { /* for a fixed buffer, use a fixed string */ + const char *s = getaddr(S, size + 1, char); /* get content address */ + *sl = ts = luaS_newextlstr(L, s, size, NULL, NULL); + luaC_objbarrier(L, p, ts); + } + else { /* create internal copy */ + *sl = ts = luaS_createlngstrobj(L, size); /* create string */ + luaC_objbarrier(L, p, ts); + loadVector(S, getlngstr(ts), size + 1); /* load directly in final place */ + } + /* add string to list of saved strings */ + S->nstr++; + setsvalue(L, &sv, ts); + luaH_setint(L, S->h, l_castU2S(S->nstr), &sv); + luaC_objbarrierback(L, obj2gco(S->h), ts); +} + + +static void loadCode (LoadState *S, Proto *f) { + int n = loadInt(S); + loadAlign(S, sizeof(f->code[0])); + if (S->fixed) { + f->code = getaddr(S, n, Instruction); + f->sizecode = n; + } + else { + f->code = luaM_newvectorchecked(S->L, n, Instruction); + f->sizecode = n; + loadVector(S, f->code, n); + } +} + + +static void loadFunction(LoadState *S, Proto *f); + + +static void loadConstants (LoadState *S, Proto *f) { + int i; + int n = loadInt(S); + f->k = luaM_newvectorchecked(S->L, n, TValue); + f->sizek = n; + for (i = 0; i < n; i++) + setnilvalue(&f->k[i]); + for (i = 0; i < n; i++) { + TValue *o = &f->k[i]; + int t = loadByte(S); + switch (t) { + case LUA_VNIL: + setnilvalue(o); + break; + case LUA_VFALSE: + setbfvalue(o); + break; + case LUA_VTRUE: + setbtvalue(o); + break; + case LUA_VNUMFLT: + setfltvalue(o, loadNumber(S)); + break; + case LUA_VNUMINT: + setivalue(o, loadInteger(S)); + break; + case LUA_VSHRSTR: + case LUA_VLNGSTR: { + lua_assert(f->source == NULL); + loadString(S, f, &f->source); /* use 'source' to anchor string */ + if (f->source == NULL) + error(S, "bad format for constant string"); + setsvalue2n(S->L, o, f->source); /* save it in the right place */ + f->source = NULL; + break; + } + default: error(S, "invalid constant"); + } + } +} + + +static void loadProtos (LoadState *S, Proto *f) { + int i; + int n = loadInt(S); + f->p = luaM_newvectorchecked(S->L, n, Proto *); + f->sizep = n; + for (i = 0; i < n; i++) + f->p[i] = NULL; + for (i = 0; i < n; i++) { + f->p[i] = luaF_newproto(S->L); + luaC_objbarrier(S->L, f, f->p[i]); + loadFunction(S, f->p[i]); + } +} + + +/* +** Load the upvalues for a function. The names must be filled first, +** because the filling of the other fields can raise read errors and +** the creation of the error message can call an emergency collection; +** in that case all prototypes must be consistent for the GC. +*/ +static void loadUpvalues (LoadState *S, Proto *f) { + int i; + int n = loadInt(S); + f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc); + f->sizeupvalues = n; + for (i = 0; i < n; i++) /* make array valid for GC */ + f->upvalues[i].name = NULL; + for (i = 0; i < n; i++) { /* following calls can raise errors */ + f->upvalues[i].instack = loadByte(S); + f->upvalues[i].idx = loadByte(S); + f->upvalues[i].kind = loadByte(S); + } +} + + +static void loadDebug (LoadState *S, Proto *f) { + int i; + int n = loadInt(S); + if (S->fixed) { + f->lineinfo = getaddr(S, n, ls_byte); + f->sizelineinfo = n; + } + else { + f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte); + f->sizelineinfo = n; + loadVector(S, f->lineinfo, n); + } + n = loadInt(S); + if (n > 0) { + loadAlign(S, sizeof(int)); + if (S->fixed) { + f->abslineinfo = getaddr(S, n, AbsLineInfo); + f->sizeabslineinfo = n; + } + else { + f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo); + f->sizeabslineinfo = n; + loadVector(S, f->abslineinfo, n); + } + } + n = loadInt(S); + f->locvars = luaM_newvectorchecked(S->L, n, LocVar); + f->sizelocvars = n; + for (i = 0; i < n; i++) + f->locvars[i].varname = NULL; + for (i = 0; i < n; i++) { + loadString(S, f, &f->locvars[i].varname); + f->locvars[i].startpc = loadInt(S); + f->locvars[i].endpc = loadInt(S); + } + n = loadInt(S); + if (n != 0) /* does it have debug information? */ + n = f->sizeupvalues; /* must be this many */ + for (i = 0; i < n; i++) + loadString(S, f, &f->upvalues[i].name); +} + + +static void loadFunction (LoadState *S, Proto *f) { + f->linedefined = loadInt(S); + f->lastlinedefined = loadInt(S); + f->numparams = loadByte(S); + /* get only the meaningful flags */ + f->flag = cast_byte(loadByte(S) & ~PF_FIXED); + if (S->fixed) + f->flag |= PF_FIXED; /* signal that code is fixed */ + f->maxstacksize = loadByte(S); + loadCode(S, f); + loadConstants(S, f); + loadUpvalues(S, f); + loadProtos(S, f); + loadString(S, f, &f->source); + loadDebug(S, f); +} + + +static void checkliteral (LoadState *S, const char *s, const char *msg) { + char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */ + size_t len = strlen(s); + loadVector(S, buff, len); + if (memcmp(s, buff, len) != 0) + error(S, msg); +} + + +static l_noret numerror (LoadState *S, const char *what, const char *tname) { + const char *msg = luaO_pushfstring(S->L, "%s %s mismatch", tname, what); + error(S, msg); +} + + +static void checknumsize (LoadState *S, int size, const char *tname) { + if (size != loadByte(S)) + numerror(S, "size", tname); +} + + +static void checknumformat (LoadState *S, int eq, const char *tname) { + if (!eq) + numerror(S, "format", tname); +} + + +#define checknum(S,tvar,value,tname) \ + { tvar i; checknumsize(S, sizeof(i), tname); \ + loadVar(S, i); \ + checknumformat(S, i == value, tname); } + + +static void checkHeader (LoadState *S) { + /* skip 1st char (already read and checked) */ + checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk"); + if (loadByte(S) != LUAC_VERSION) + error(S, "version mismatch"); + if (loadByte(S) != LUAC_FORMAT) + error(S, "format mismatch"); + checkliteral(S, LUAC_DATA, "corrupted chunk"); + checknum(S, int, LUAC_INT, "int"); + checknum(S, Instruction, LUAC_INST, "instruction"); + checknum(S, lua_Integer, LUAC_INT, "Lua integer"); + checknum(S, lua_Number, LUAC_NUM, "Lua number"); +} + + +/* +** Load precompiled chunk. +*/ +LClosure *luaU_undump (lua_State *L, ZIO *Z, const char *name, int fixed) { + LoadState S; + LClosure *cl; + if (*name == '@' || *name == '=') + name = name + 1; + else if (*name == LUA_SIGNATURE[0]) + name = "binary string"; + S.name = name; + S.L = L; + S.Z = Z; + S.fixed = cast_byte(fixed); + S.offset = 1; /* fist byte was already read */ + checkHeader(&S); + cl = luaF_newLclosure(L, loadByte(&S)); + setclLvalue2s(L, L->top.p, cl); + luaD_inctop(L); + S.h = luaH_new(L); /* create list of saved strings */ + S.nstr = 0; + sethvalue2s(L, L->top.p, S.h); /* anchor it */ + luaD_inctop(L); + cl->p = luaF_newproto(L); + luaC_objbarrier(L, cl, cl->p); + loadFunction(&S, cl->p); + if (cl->nupvalues != cl->p->sizeupvalues) + error(&S, "corrupted chunk"); + luai_verifycode(L, cl->p); + L->top.p--; /* pop table */ + return cl; +} + diff --git a/source/external/lua/lutf8lib.c b/source/external/lua/lutf8lib.c new file mode 100644 index 0000000..b7f3fe1 --- /dev/null +++ b/source/external/lua/lutf8lib.c @@ -0,0 +1,291 @@ +/* +** $Id: lutf8lib.c $ +** Standard library for UTF-8 manipulation +** See Copyright Notice in lua.h +*/ + +#define lutf8lib_c +#define LUA_LIB + +#include "lprefix.h" + + +#include +#include +#include + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" +#include "llimits.h" + + +#define MAXUNICODE 0x10FFFFu + +#define MAXUTF 0x7FFFFFFFu + + +#define MSGInvalid "invalid UTF-8 code" + + +#define iscont(c) (((c) & 0xC0) == 0x80) +#define iscontp(p) iscont(*(p)) + + +/* from strlib */ +/* translate a relative string position: negative means back from end */ +static lua_Integer u_posrelat (lua_Integer pos, size_t len) { + if (pos >= 0) return pos; + else if (0u - (size_t)pos > len) return 0; + else return (lua_Integer)len + pos + 1; +} + + +/* +** Decode one UTF-8 sequence, returning NULL if byte sequence is +** invalid. The array 'limits' stores the minimum value for each +** sequence length, to check for overlong representations. Its first +** entry forces an error for non-ASCII bytes with no continuation +** bytes (count == 0). +*/ +static const char *utf8_decode (const char *s, l_uint32 *val, int strict) { + static const l_uint32 limits[] = + {~(l_uint32)0, 0x80, 0x800, 0x10000u, 0x200000u, 0x4000000u}; + unsigned int c = (unsigned char)s[0]; + l_uint32 res = 0; /* final result */ + if (c < 0x80) /* ASCII? */ + res = c; + else { + int count = 0; /* to count number of continuation bytes */ + for (; c & 0x40; c <<= 1) { /* while it needs continuation bytes... */ + unsigned int cc = (unsigned char)s[++count]; /* read next byte */ + if (!iscont(cc)) /* not a continuation byte? */ + return NULL; /* invalid byte sequence */ + res = (res << 6) | (cc & 0x3F); /* add lower 6 bits from cont. byte */ + } + res |= ((l_uint32)(c & 0x7F) << (count * 5)); /* add first byte */ + if (count > 5 || res > MAXUTF || res < limits[count]) + return NULL; /* invalid byte sequence */ + s += count; /* skip continuation bytes read */ + } + if (strict) { + /* check for invalid code points; too large or surrogates */ + if (res > MAXUNICODE || (0xD800u <= res && res <= 0xDFFFu)) + return NULL; + } + if (val) *val = res; + return s + 1; /* +1 to include first byte */ +} + + +/* +** utf8len(s [, i [, j [, lax]]]) --> number of characters that +** start in the range [i,j], or nil + current position if 's' is not +** well formed in that interval +*/ +static int utflen (lua_State *L) { + lua_Integer n = 0; /* counter for the number of characters */ + size_t len; /* string length in bytes */ + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); + lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len); + int lax = lua_toboolean(L, 4); + luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2, + "initial position out of bounds"); + luaL_argcheck(L, --posj < (lua_Integer)len, 3, + "final position out of bounds"); + while (posi <= posj) { + const char *s1 = utf8_decode(s + posi, NULL, !lax); + if (s1 == NULL) { /* conversion error? */ + luaL_pushfail(L); /* return fail ... */ + lua_pushinteger(L, posi + 1); /* ... and current position */ + return 2; + } + posi = ct_diff2S(s1 - s); + n++; + } + lua_pushinteger(L, n); + return 1; +} + + +/* +** codepoint(s, [i, [j [, lax]]]) -> returns codepoints for all +** characters that start in the range [i,j] +*/ +static int codepoint (lua_State *L) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len); + lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len); + int lax = lua_toboolean(L, 4); + int n; + const char *se; + luaL_argcheck(L, posi >= 1, 2, "out of bounds"); + luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of bounds"); + if (posi > pose) return 0; /* empty interval; return no values */ + if (pose - posi >= INT_MAX) /* (lua_Integer -> int) overflow? */ + return luaL_error(L, "string slice too long"); + n = (int)(pose - posi) + 1; /* upper bound for number of returns */ + luaL_checkstack(L, n, "string slice too long"); + n = 0; /* count the number of returns */ + se = s + pose; /* string end */ + for (s += posi - 1; s < se;) { + l_uint32 code; + s = utf8_decode(s, &code, !lax); + if (s == NULL) + return luaL_error(L, MSGInvalid); + lua_pushinteger(L, l_castU2S(code)); + n++; + } + return n; +} + + +static void pushutfchar (lua_State *L, int arg) { + lua_Unsigned code = (lua_Unsigned)luaL_checkinteger(L, arg); + luaL_argcheck(L, code <= MAXUTF, arg, "value out of range"); + lua_pushfstring(L, "%U", (long)code); +} + + +/* +** utfchar(n1, n2, ...) -> char(n1)..char(n2)... +*/ +static int utfchar (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + if (n == 1) /* optimize common case of single char */ + pushutfchar(L, 1); + else { + int i; + luaL_Buffer b; + luaL_buffinit(L, &b); + for (i = 1; i <= n; i++) { + pushutfchar(L, i); + luaL_addvalue(&b); + } + luaL_pushresult(&b); + } + return 1; +} + + +/* +** offset(s, n, [i]) -> indices where n-th character counting from +** position 'i' starts and ends; 0 means character at 'i'. +*/ +static int byteoffset (lua_State *L) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Integer n = luaL_checkinteger(L, 2); + lua_Integer posi = (n >= 0) ? 1 : cast_st2S(len) + 1; + posi = u_posrelat(luaL_optinteger(L, 3, posi), len); + luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3, + "position out of bounds"); + if (n == 0) { + /* find beginning of current byte sequence */ + while (posi > 0 && iscontp(s + posi)) posi--; + } + else { + if (iscontp(s + posi)) + return luaL_error(L, "initial position is a continuation byte"); + if (n < 0) { + while (n < 0 && posi > 0) { /* move back */ + do { /* find beginning of previous character */ + posi--; + } while (posi > 0 && iscontp(s + posi)); + n++; + } + } + else { + n--; /* do not move for 1st character */ + while (n > 0 && posi < (lua_Integer)len) { + do { /* find beginning of next character */ + posi++; + } while (iscontp(s + posi)); /* (cannot pass final '\0') */ + n--; + } + } + } + if (n != 0) { /* did not find given character? */ + luaL_pushfail(L); + return 1; + } + lua_pushinteger(L, posi + 1); /* initial position */ + if ((s[posi] & 0x80) != 0) { /* multi-byte character? */ + if (iscont(s[posi])) + return luaL_error(L, "initial position is a continuation byte"); + while (iscontp(s + posi + 1)) + posi++; /* skip to last continuation byte */ + } + /* else one-byte character: final position is the initial one */ + lua_pushinteger(L, posi + 1); /* 'posi' now is the final position */ + return 2; +} + + +static int iter_aux (lua_State *L, int strict) { + size_t len; + const char *s = luaL_checklstring(L, 1, &len); + lua_Unsigned n = (lua_Unsigned)lua_tointeger(L, 2); + if (n < len) { + while (iscontp(s + n)) n++; /* go to next character */ + } + if (n >= len) /* (also handles original 'n' being negative) */ + return 0; /* no more codepoints */ + else { + l_uint32 code; + const char *next = utf8_decode(s + n, &code, strict); + if (next == NULL || iscontp(next)) + return luaL_error(L, MSGInvalid); + lua_pushinteger(L, l_castU2S(n + 1)); + lua_pushinteger(L, l_castU2S(code)); + return 2; + } +} + + +static int iter_auxstrict (lua_State *L) { + return iter_aux(L, 1); +} + +static int iter_auxlax (lua_State *L) { + return iter_aux(L, 0); +} + + +static int iter_codes (lua_State *L) { + int lax = lua_toboolean(L, 2); + const char *s = luaL_checkstring(L, 1); + luaL_argcheck(L, !iscontp(s), 1, MSGInvalid); + lua_pushcfunction(L, lax ? iter_auxlax : iter_auxstrict); + lua_pushvalue(L, 1); + lua_pushinteger(L, 0); + return 3; +} + + +/* pattern to match a single UTF-8 character */ +#define UTF8PATT "[\0-\x7F\xC2-\xFD][\x80-\xBF]*" + + +static const luaL_Reg funcs[] = { + {"offset", byteoffset}, + {"codepoint", codepoint}, + {"char", utfchar}, + {"len", utflen}, + {"codes", iter_codes}, + /* placeholders */ + {"charpattern", NULL}, + {NULL, NULL} +}; + + +LUAMOD_API int luaopen_utf8 (lua_State *L) { + luaL_newlib(L, funcs); + lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1); + lua_setfield(L, -2, "charpattern"); + return 1; +} + diff --git a/source/external/lua/lvm.c b/source/external/lua/lvm.c new file mode 100644 index 0000000..c70e2b8 --- /dev/null +++ b/source/external/lua/lvm.c @@ -0,0 +1,1972 @@ +/* +** $Id: lvm.c $ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#define lvm_c +#define LUA_CORE + +#include "lprefix.h" + +#include +#include +#include +#include +#include +#include + +#include "lua.h" + +#include "lapi.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + +/* +** By default, use jump tables in the main interpreter loop on gcc +** and compatible compilers. +*/ +#if !defined(LUA_USE_JUMPTABLE) +#if defined(__GNUC__) +#define LUA_USE_JUMPTABLE 1 +#else +#define LUA_USE_JUMPTABLE 0 +#endif +#endif + + + +/* limit for table tag-method chains (to avoid infinite loops) */ +#define MAXTAGLOOP 2000 + + +/* +** 'l_intfitsf' checks whether a given integer is in the range that +** can be converted to a float without rounding. Used in comparisons. +*/ + +/* number of bits in the mantissa of a float */ +#define NBM (l_floatatt(MANT_DIG)) + +/* +** Check whether some integers may not fit in a float, testing whether +** (maxinteger >> NBM) > 0. (That implies (1 << NBM) <= maxinteger.) +** (The shifts are done in parts, to avoid shifting by more than the size +** of an integer. In a worst case, NBM == 113 for long double and +** sizeof(long) == 32.) +*/ +#if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \ + >> (NBM - (3 * (NBM / 4)))) > 0 + +/* limit for integers that fit in a float */ +#define MAXINTFITSF ((lua_Unsigned)1 << NBM) + +/* check whether 'i' is in the interval [-MAXINTFITSF, MAXINTFITSF] */ +#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) + +#else /* all integers fit in a float precisely */ + +#define l_intfitsf(i) 1 + +#endif + + +/* +** Try to convert a value from string to a number value. +** If the value is not a string or is a string not representing +** a valid numeral (or if coercions from strings to numbers +** are disabled via macro 'cvt2num'), do not modify 'result' +** and return 0. +*/ +static int l_strton (const TValue *obj, TValue *result) { + lua_assert(obj != result); + if (!cvt2num(obj)) /* is object not a string? */ + return 0; + else { + TString *st = tsvalue(obj); + size_t stlen; + const char *s = getlstr(st, stlen); + return (luaO_str2num(s, result) == stlen + 1); + } +} + + +/* +** Try to convert a value to a float. The float case is already handled +** by the macro 'tonumber'. +*/ +int luaV_tonumber_ (const TValue *obj, lua_Number *n) { + TValue v; + if (ttisinteger(obj)) { + *n = cast_num(ivalue(obj)); + return 1; + } + else if (l_strton(obj, &v)) { /* string coercible to number? */ + *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ + return 1; + } + else + return 0; /* conversion failed */ +} + + +/* +** try to convert a float to an integer, rounding according to 'mode'. +*/ +int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { + lua_Number f = l_floor(n); + if (n != f) { /* not an integral value? */ + if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ + else if (mode == F2Iceil) /* needs ceiling? */ + f += 1; /* convert floor to ceiling (remember: n != f) */ + } + return lua_numbertointeger(f, p); +} + + +/* +** try to convert a value to an integer, rounding according to 'mode', +** without string coercion. +** ("Fast track" handled by macro 'tointegerns'.) +*/ +int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { + if (ttisfloat(obj)) + return luaV_flttointeger(fltvalue(obj), p, mode); + else if (ttisinteger(obj)) { + *p = ivalue(obj); + return 1; + } + else + return 0; +} + + +/* +** try to convert a value to an integer. +*/ +int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) { + TValue v; + if (l_strton(obj, &v)) /* does 'obj' point to a numerical string? */ + obj = &v; /* change it to point to its corresponding number */ + return luaV_tointegerns(obj, p, mode); +} + + +/* +** Try to convert a 'for' limit to an integer, preserving the semantics +** of the loop. Return true if the loop must not run; otherwise, '*p' +** gets the integer limit. +** (The following explanation assumes a positive step; it is valid for +** negative steps mutatis mutandis.) +** If the limit is an integer or can be converted to an integer, +** rounding down, that is the limit. +** Otherwise, check whether the limit can be converted to a float. If +** the float is too large, clip it to LUA_MAXINTEGER. If the float +** is too negative, the loop should not run, because any initial +** integer value is greater than such limit; so, the function returns +** true to signal that. (For this latter case, no integer limit would be +** correct; even a limit of LUA_MININTEGER would run the loop once for +** an initial value equal to LUA_MININTEGER.) +*/ +static int forlimit (lua_State *L, lua_Integer init, const TValue *lim, + lua_Integer *p, lua_Integer step) { + if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) { + /* not coercible to in integer */ + lua_Number flim; /* try to convert to float */ + if (!tonumber(lim, &flim)) /* cannot convert to float? */ + luaG_forerror(L, lim, "limit"); + /* else 'flim' is a float out of integer bounds */ + if (luai_numlt(0, flim)) { /* if it is positive, it is too large */ + if (step < 0) return 1; /* initial value must be less than it */ + *p = LUA_MAXINTEGER; /* truncate */ + } + else { /* it is less than min integer */ + if (step > 0) return 1; /* initial value must be greater than it */ + *p = LUA_MININTEGER; /* truncate */ + } + } + return (step > 0 ? init > *p : init < *p); /* not to run? */ +} + + +/* +** Prepare a numerical for loop (opcode OP_FORPREP). +** Before execution, stack is as follows: +** ra : initial value +** ra + 1 : limit +** ra + 2 : step +** Return true to skip the loop. Otherwise, +** after preparation, stack will be as follows: +** ra : loop counter (integer loops) or limit (float loops) +** ra + 1 : step +** ra + 2 : control variable +*/ +static int forprep (lua_State *L, StkId ra) { + TValue *pinit = s2v(ra); + TValue *plimit = s2v(ra + 1); + TValue *pstep = s2v(ra + 2); + if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ + lua_Integer init = ivalue(pinit); + lua_Integer step = ivalue(pstep); + lua_Integer limit; + if (step == 0) + luaG_runerror(L, "'for' step is zero"); + if (forlimit(L, init, plimit, &limit, step)) + return 1; /* skip the loop */ + else { /* prepare loop counter */ + lua_Unsigned count; + if (step > 0) { /* ascending loop? */ + count = l_castS2U(limit) - l_castS2U(init); + if (step != 1) /* avoid division in the too common case */ + count /= l_castS2U(step); + } + else { /* step < 0; descending loop */ + count = l_castS2U(init) - l_castS2U(limit); + /* 'step+1' avoids negating 'mininteger' */ + count /= l_castS2U(-(step + 1)) + 1u; + } + /* use 'chgivalue' for places that for sure had integers */ + chgivalue(s2v(ra), l_castU2S(count)); /* change init to count */ + setivalue(s2v(ra + 1), step); /* change limit to step */ + chgivalue(s2v(ra + 2), init); /* change step to init */ + } + } + else { /* try making all values floats */ + lua_Number init; lua_Number limit; lua_Number step; + if (l_unlikely(!tonumber(plimit, &limit))) + luaG_forerror(L, plimit, "limit"); + if (l_unlikely(!tonumber(pstep, &step))) + luaG_forerror(L, pstep, "step"); + if (l_unlikely(!tonumber(pinit, &init))) + luaG_forerror(L, pinit, "initial value"); + if (step == 0) + luaG_runerror(L, "'for' step is zero"); + if (luai_numlt(0, step) ? luai_numlt(limit, init) + : luai_numlt(init, limit)) + return 1; /* skip the loop */ + else { + /* make sure all values are floats */ + setfltvalue(s2v(ra), limit); + setfltvalue(s2v(ra + 1), step); + setfltvalue(s2v(ra + 2), init); /* control variable */ + } + } + return 0; +} + + +/* +** Execute a step of a float numerical for loop, returning +** true iff the loop must continue. (The integer case is +** written online with opcode OP_FORLOOP, for performance.) +*/ +static int floatforloop (StkId ra) { + lua_Number step = fltvalue(s2v(ra + 1)); + lua_Number limit = fltvalue(s2v(ra)); + lua_Number idx = fltvalue(s2v(ra + 2)); /* control variable */ + idx = luai_numadd(L, idx, step); /* increment index */ + if (luai_numlt(0, step) ? luai_numle(idx, limit) + : luai_numle(limit, idx)) { + chgfltvalue(s2v(ra + 2), idx); /* update control variable */ + return 1; /* jump back */ + } + else + return 0; /* finish the loop */ +} + + +/* +** Finish the table access 'val = t[key]' and return the tag of the result. +*/ +lu_byte luaV_finishget (lua_State *L, const TValue *t, TValue *key, + StkId val, lu_byte tag) { + int loop; /* counter to avoid infinite loops */ + const TValue *tm; /* metamethod */ + for (loop = 0; loop < MAXTAGLOOP; loop++) { + if (tag == LUA_VNOTABLE) { /* 't' is not a table? */ + lua_assert(!ttistable(t)); + tm = luaT_gettmbyobj(L, t, TM_INDEX); + if (l_unlikely(notm(tm))) + luaG_typeerror(L, t, "index"); /* no metamethod */ + /* else will try the metamethod */ + } + else { /* 't' is a table */ + tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ + if (tm == NULL) { /* no metamethod? */ + setnilvalue(s2v(val)); /* result is nil */ + return LUA_VNIL; + } + /* else will try the metamethod */ + } + if (ttisfunction(tm)) { /* is metamethod a function? */ + tag = luaT_callTMres(L, tm, t, key, val); /* call it */ + return tag; /* return tag of the result */ + } + t = tm; /* else try to access 'tm[key]' */ + luaV_fastget(t, key, s2v(val), luaH_get, tag); + if (!tagisempty(tag)) + return tag; /* done */ + /* else repeat (tail call 'luaV_finishget') */ + } + luaG_runerror(L, "'__index' chain too long; possible loop"); + return 0; /* to avoid warnings */ +} + + +/* +** Finish a table assignment 't[key] = val'. +** About anchoring the table before the call to 'luaH_finishset': +** This call may trigger an emergency collection. When loop>0, +** the table being accessed is a field in some metatable. If this +** metatable is weak and the table is not anchored, this collection +** could collect that table while it is being updated. +*/ +void luaV_finishset (lua_State *L, const TValue *t, TValue *key, + TValue *val, int hres) { + int loop; /* counter to avoid infinite loops */ + for (loop = 0; loop < MAXTAGLOOP; loop++) { + const TValue *tm; /* '__newindex' metamethod */ + if (hres != HNOTATABLE) { /* is 't' a table? */ + Table *h = hvalue(t); /* save 't' table */ + tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ + if (tm == NULL) { /* no metamethod? */ + sethvalue2s(L, L->top.p, h); /* anchor 't' */ + L->top.p++; /* assume EXTRA_STACK */ + luaH_finishset(L, h, key, val, hres); /* set new value */ + L->top.p--; + invalidateTMcache(h); + luaC_barrierback(L, obj2gco(h), val); + return; + } + /* else will try the metamethod */ + } + else { /* not a table; check metamethod */ + tm = luaT_gettmbyobj(L, t, TM_NEWINDEX); + if (l_unlikely(notm(tm))) + luaG_typeerror(L, t, "index"); + } + /* try the metamethod */ + if (ttisfunction(tm)) { + luaT_callTM(L, tm, t, key, val); + return; + } + t = tm; /* else repeat assignment over 'tm' */ + luaV_fastset(t, key, val, hres, luaH_pset); + if (hres == HOK) { + luaV_finishfastset(L, t, val); + return; /* done */ + } + /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */ + } + luaG_runerror(L, "'__newindex' chain too long; possible loop"); +} + + +/* +** Function to be used for 0-terminated string order comparison +*/ +#if !defined(l_strcoll) +#define l_strcoll strcoll +#endif + + +/* +** Compare two strings 'ts1' x 'ts2', returning an integer less-equal- +** -greater than zero if 'ts1' is less-equal-greater than 'ts2'. +** The code is a little tricky because it allows '\0' in the strings +** and it uses 'strcoll' (to respect locales) for each segment +** of the strings. Note that segments can compare equal but still +** have different lengths. +*/ +static int l_strcmp (const TString *ts1, const TString *ts2) { + size_t rl1; /* real length */ + const char *s1 = getlstr(ts1, rl1); + size_t rl2; + const char *s2 = getlstr(ts2, rl2); + for (;;) { /* for each segment */ + int temp = l_strcoll(s1, s2); + if (temp != 0) /* not equal? */ + return temp; /* done */ + else { /* strings are equal up to a '\0' */ + size_t zl1 = strlen(s1); /* index of first '\0' in 's1' */ + size_t zl2 = strlen(s2); /* index of first '\0' in 's2' */ + if (zl2 == rl2) /* 's2' is finished? */ + return (zl1 == rl1) ? 0 : 1; /* check 's1' */ + else if (zl1 == rl1) /* 's1' is finished? */ + return -1; /* 's1' is less than 's2' ('s2' is not finished) */ + /* both strings longer than 'zl'; go on comparing after the '\0' */ + zl1++; zl2++; + s1 += zl1; rl1 -= zl1; s2 += zl2; rl2 -= zl2; + } + } +} + + +/* +** Check whether integer 'i' is less than float 'f'. If 'i' has an +** exact representation as a float ('l_intfitsf'), compare numbers as +** floats. Otherwise, use the equivalence 'i < f <=> i < ceil(f)'. +** If 'ceil(f)' is out of integer range, either 'f' is greater than +** all integers or less than all integers. +** (The test with 'l_intfitsf' is only for performance; the else +** case is correct for all values, but it is slow due to the conversion +** from float to int.) +** When 'f' is NaN, comparisons must result in false. +*/ +l_sinline int LTintfloat (lua_Integer i, lua_Number f) { + if (l_intfitsf(i)) + return luai_numlt(cast_num(i), f); /* compare them as floats */ + else { /* i < f <=> i < ceil(f) */ + lua_Integer fi; + if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ + return i < fi; /* compare them as integers */ + else /* 'f' is either greater or less than all integers */ + return f > 0; /* greater? */ + } +} + + +/* +** Check whether integer 'i' is less than or equal to float 'f'. +** See comments on previous function. +*/ +l_sinline int LEintfloat (lua_Integer i, lua_Number f) { + if (l_intfitsf(i)) + return luai_numle(cast_num(i), f); /* compare them as floats */ + else { /* i <= f <=> i <= floor(f) */ + lua_Integer fi; + if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ + return i <= fi; /* compare them as integers */ + else /* 'f' is either greater or less than all integers */ + return f > 0; /* greater? */ + } +} + + +/* +** Check whether float 'f' is less than integer 'i'. +** See comments on previous function. +*/ +l_sinline int LTfloatint (lua_Number f, lua_Integer i) { + if (l_intfitsf(i)) + return luai_numlt(f, cast_num(i)); /* compare them as floats */ + else { /* f < i <=> floor(f) < i */ + lua_Integer fi; + if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ + return fi < i; /* compare them as integers */ + else /* 'f' is either greater or less than all integers */ + return f < 0; /* less? */ + } +} + + +/* +** Check whether float 'f' is less than or equal to integer 'i'. +** See comments on previous function. +*/ +l_sinline int LEfloatint (lua_Number f, lua_Integer i) { + if (l_intfitsf(i)) + return luai_numle(f, cast_num(i)); /* compare them as floats */ + else { /* f <= i <=> ceil(f) <= i */ + lua_Integer fi; + if (luaV_flttointeger(f, &fi, F2Iceil)) /* fi = ceil(f) */ + return fi <= i; /* compare them as integers */ + else /* 'f' is either greater or less than all integers */ + return f < 0; /* less? */ + } +} + + +/* +** Return 'l < r', for numbers. +*/ +l_sinline int LTnum (const TValue *l, const TValue *r) { + lua_assert(ttisnumber(l) && ttisnumber(r)); + if (ttisinteger(l)) { + lua_Integer li = ivalue(l); + if (ttisinteger(r)) + return li < ivalue(r); /* both are integers */ + else /* 'l' is int and 'r' is float */ + return LTintfloat(li, fltvalue(r)); /* l < r ? */ + } + else { + lua_Number lf = fltvalue(l); /* 'l' must be float */ + if (ttisfloat(r)) + return luai_numlt(lf, fltvalue(r)); /* both are float */ + else /* 'l' is float and 'r' is int */ + return LTfloatint(lf, ivalue(r)); + } +} + + +/* +** Return 'l <= r', for numbers. +*/ +l_sinline int LEnum (const TValue *l, const TValue *r) { + lua_assert(ttisnumber(l) && ttisnumber(r)); + if (ttisinteger(l)) { + lua_Integer li = ivalue(l); + if (ttisinteger(r)) + return li <= ivalue(r); /* both are integers */ + else /* 'l' is int and 'r' is float */ + return LEintfloat(li, fltvalue(r)); /* l <= r ? */ + } + else { + lua_Number lf = fltvalue(l); /* 'l' must be float */ + if (ttisfloat(r)) + return luai_numle(lf, fltvalue(r)); /* both are float */ + else /* 'l' is float and 'r' is int */ + return LEfloatint(lf, ivalue(r)); + } +} + + +/* +** return 'l < r' for non-numbers. +*/ +static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) { + lua_assert(!ttisnumber(l) || !ttisnumber(r)); + if (ttisstring(l) && ttisstring(r)) /* both are strings? */ + return l_strcmp(tsvalue(l), tsvalue(r)) < 0; + else + return luaT_callorderTM(L, l, r, TM_LT); +} + + +/* +** Main operation less than; return 'l < r'. +*/ +int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { + if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ + return LTnum(l, r); + else return lessthanothers(L, l, r); +} + + +/* +** return 'l <= r' for non-numbers. +*/ +static int lessequalothers (lua_State *L, const TValue *l, const TValue *r) { + lua_assert(!ttisnumber(l) || !ttisnumber(r)); + if (ttisstring(l) && ttisstring(r)) /* both are strings? */ + return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; + else + return luaT_callorderTM(L, l, r, TM_LE); +} + + +/* +** Main operation less than or equal to; return 'l <= r'. +*/ +int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) { + if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */ + return LEnum(l, r); + else return lessequalothers(L, l, r); +} + + +/* +** Main operation for equality of Lua values; return 't1 == t2'. +** L == NULL means raw equality (no metamethods) +*/ +int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { + const TValue *tm; + if (ttype(t1) != ttype(t2)) /* not the same type? */ + return 0; + else if (ttypetag(t1) != ttypetag(t2)) { + switch (ttypetag(t1)) { + case LUA_VNUMINT: { /* integer == float? */ + /* integer and float can only be equal if float has an integer + value equal to the integer */ + lua_Integer i2; + return (luaV_flttointeger(fltvalue(t2), &i2, F2Ieq) && + ivalue(t1) == i2); + } + case LUA_VNUMFLT: { /* float == integer? */ + lua_Integer i1; /* see comment in previous case */ + return (luaV_flttointeger(fltvalue(t1), &i1, F2Ieq) && + i1 == ivalue(t2)); + } + case LUA_VSHRSTR: case LUA_VLNGSTR: { + /* compare two strings with different variants: they can be + equal when one string is a short string and the other is + an external string */ + return luaS_eqstr(tsvalue(t1), tsvalue(t2)); + } + default: + /* only numbers (integer/float) and strings (long/short) can have + equal values with different variants */ + return 0; + } + } + else { /* equal variants */ + switch (ttypetag(t1)) { + case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: + return 1; + case LUA_VNUMINT: + return (ivalue(t1) == ivalue(t2)); + case LUA_VNUMFLT: + return (fltvalue(t1) == fltvalue(t2)); + case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); + case LUA_VSHRSTR: + return eqshrstr(tsvalue(t1), tsvalue(t2)); + case LUA_VLNGSTR: + return luaS_eqstr(tsvalue(t1), tsvalue(t2)); + case LUA_VUSERDATA: { + if (uvalue(t1) == uvalue(t2)) return 1; + else if (L == NULL) return 0; + tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); + if (tm == NULL) + tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); + break; /* will try TM */ + } + case LUA_VTABLE: { + if (hvalue(t1) == hvalue(t2)) return 1; + else if (L == NULL) return 0; + tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); + if (tm == NULL) + tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); + break; /* will try TM */ + } + case LUA_VLCF: + return (fvalue(t1) == fvalue(t2)); + default: /* functions and threads */ + return (gcvalue(t1) == gcvalue(t2)); + } + if (tm == NULL) /* no TM? */ + return 0; /* objects are different */ + else { + int tag = luaT_callTMres(L, tm, t1, t2, L->top.p); /* call TM */ + return !tagisfalse(tag); + } + } +} + + +/* macro used by 'luaV_concat' to ensure that element at 'o' is a string */ +#define tostring(L,o) \ + (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) + +/* +** Check whether object is a short empty string to optimize concatenation. +** (External strings can be empty too; they will be concatenated like +** non-empty ones.) +*/ +#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 { + TString *st = tsvalue(s2v(top - n)); + size_t l; /* length of string being copied */ + const char *s = getlstr(st, l); + memcpy(buff + tl, s, l * sizeof(char)); + tl += l; + } while (--n > 0); +} + + +/* +** Main operation for concatenation: concat 'total' values in the stack, +** from 'L->top.p - total' up to 'L->top.p - 1'. +*/ +void luaV_concat (lua_State *L, int total) { + if (total == 1) + return; /* "all" values already concatenated */ + do { + StkId top = L->top.p; + int n = 2; /* number of elements handled in this pass (at least 2) */ + if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || + !tostring(L, s2v(top - 1))) + luaT_tryconcatTM(L); /* may invalidate 'top' */ + else if (isemptystr(s2v(top - 1))) /* second operand is empty? */ + cast_void(tostring(L, s2v(top - 2))); /* result is first operand */ + else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */ + setobjs2s(L, top - 2, top - 1); /* result is second op. */ + } + else { + /* at least two string values; get as many as possible */ + size_t tl = tsslen(tsvalue(s2v(top - 1))); /* total length */ + TString *ts; + /* collect total length and number of strings */ + for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) { + size_t l = tsslen(tsvalue(s2v(top - n - 1))); + if (l_unlikely(l >= MAX_SIZE - sizeof(TString) - tl)) { + L->top.p = top - total; /* pop strings to avoid wasting stack */ + luaG_runerror(L, "string length overflow"); + } + tl += l; + } + if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ + char buff[LUAI_MAXSHORTLEN]; + copy2buff(top, n, buff); /* copy strings to buffer */ + ts = luaS_newlstr(L, buff, tl); + } + else { /* long string; copy strings directly to final result */ + ts = luaS_createlngstrobj(L, tl); + copy2buff(top, n, getlngstr(ts)); + } + setsvalue2s(L, top - n, ts); /* create result */ + } + total -= n - 1; /* got 'n' strings to create one new */ + L->top.p -= n - 1; /* popped 'n' strings and pushed one */ + } while (total > 1); /* repeat until only 1 result left */ +} + + +/* +** Main operation 'ra = #rb'. +*/ +void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { + const TValue *tm; + switch (ttypetag(rb)) { + case LUA_VTABLE: { + Table *h = hvalue(rb); + tm = fasttm(L, h->metatable, TM_LEN); + if (tm) break; /* metamethod? break switch to call it */ + setivalue(s2v(ra), l_castU2S(luaH_getn(L, h))); /* else primitive len */ + return; + } + case LUA_VSHRSTR: { + setivalue(s2v(ra), tsvalue(rb)->shrlen); + return; + } + case LUA_VLNGSTR: { + setivalue(s2v(ra), cast_st2S(tsvalue(rb)->u.lnglen)); + return; + } + default: { /* try metamethod */ + tm = luaT_gettmbyobj(L, rb, TM_LEN); + if (l_unlikely(notm(tm))) /* no metamethod? */ + luaG_typeerror(L, rb, "get length of"); + break; + } + } + luaT_callTMres(L, tm, rb, rb, ra); +} + + +/* +** Integer division; return 'm // n', that is, floor(m/n). +** C division truncates its result (rounds towards zero). +** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer, +** otherwise 'floor(q) == trunc(q) - 1'. +*/ +lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { + if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ + if (n == 0) + luaG_runerror(L, "attempt to divide by zero"); + return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ + } + else { + lua_Integer q = m / n; /* perform C division */ + if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ + q -= 1; /* correct result for different rounding */ + return q; + } +} + + +/* +** Integer modulus; return 'm % n'. (Assume that C '%' with +** negative operands follows C99 behavior. See previous comment +** about luaV_idiv.) +*/ +lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { + if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ + if (n == 0) + luaG_runerror(L, "attempt to perform 'n%%0'"); + return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ + } + else { + lua_Integer r = m % n; + if (r != 0 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */ + r += n; /* correct result for different rounding */ + return r; + } +} + + +/* +** Float modulus +*/ +lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) { + lua_Number r; + luai_nummod(L, m, n, r); + return r; +} + + +/* number of bits in an integer */ +#define NBITS l_numbits(lua_Integer) + + +/* +** Shift left operation. (Shift right just negates 'y'.) +*/ +lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { + if (y < 0) { /* shift right? */ + if (y <= -NBITS) return 0; + else return intop(>>, x, -y); + } + else { /* shift left */ + if (y >= NBITS) return 0; + else return intop(<<, x, y); + } +} + + +/* +** create a new Lua closure, push it in the stack, and initialize +** its upvalues. +*/ +static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base, + StkId ra) { + int nup = p->sizeupvalues; + Upvaldesc *uv = p->upvalues; + int i; + LClosure *ncl = luaF_newLclosure(L, nup); + ncl->p = p; + setclLvalue2s(L, ra, ncl); /* anchor new closure in stack */ + for (i = 0; i < nup; i++) { /* fill in its upvalues */ + if (uv[i].instack) /* upvalue refers to local variable? */ + ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); + else /* get upvalue from enclosing function */ + ncl->upvals[i] = encup[uv[i].idx]; + luaC_objbarrier(L, ncl, ncl->upvals[i]); + } +} + + +/* +** finish execution of an opcode interrupted by a yield +*/ +void luaV_finishOp (lua_State *L) { + CallInfo *ci = L->ci; + StkId base = ci->func.p + 1; + Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ + OpCode op = GET_OPCODE(inst); + switch (op) { /* finish its execution */ + case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { + setobjs2s(L, base + GETARG_A(*(ci->u.l.savedpc - 2)), --L->top.p); + break; + } + case OP_UNM: case OP_BNOT: case OP_LEN: + case OP_GETTABUP: case OP_GETTABLE: case OP_GETI: + case OP_GETFIELD: case OP_SELF: { + setobjs2s(L, base + GETARG_A(inst), --L->top.p); + break; + } + case OP_LT: case OP_LE: + case OP_LTI: case OP_LEI: + case OP_GTI: case OP_GEI: + case OP_EQ: { /* note that 'OP_EQI'/'OP_EQK' cannot yield */ + int res = !l_isfalse(s2v(L->top.p - 1)); + L->top.p--; + lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP); + if (res != GETARG_k(inst)) /* condition failed? */ + ci->u.l.savedpc++; /* skip jump instruction */ + break; + } + case OP_CONCAT: { + StkId top = L->top.p - 1; /* top when 'luaT_tryconcatTM' was called */ + int a = GETARG_A(inst); /* first element to concatenate */ + int total = cast_int(top - 1 - (base + a)); /* yet to concatenate */ + setobjs2s(L, top - 2, top); /* put TM result in proper position */ + L->top.p = top - 1; /* top is one after last element (at top-2) */ + luaV_concat(L, total); /* concat them (may yield again) */ + break; + } + case OP_CLOSE: { /* yielded closing variables */ + ci->u.l.savedpc--; /* repeat instruction to close other vars. */ + break; + } + case OP_RETURN: { /* yielded closing variables */ + StkId ra = base + GETARG_A(inst); + /* adjust top to signal correct number of returns, in case the + return is "up to top" ('isIT') */ + L->top.p = ra + ci->u2.nres; + /* repeat instruction to close other vars. and complete the return */ + ci->u.l.savedpc--; + break; + } + default: { + /* only these other opcodes can yield */ + lua_assert(op == OP_TFORCALL || op == OP_CALL || + op == OP_TAILCALL || op == OP_SETTABUP || op == OP_SETTABLE || + op == OP_SETI || op == OP_SETFIELD); + break; + } + } +} + + + + +/* +** {================================================================== +** Macros for arithmetic/bitwise/comparison opcodes in 'luaV_execute' +** +** All these macros are to be used exclusively inside the main +** iterpreter loop (function luaV_execute) and may access directly +** the local variables of that function (L, i, pc, ci, etc.). +** =================================================================== +*/ + +#define l_addi(L,a,b) intop(+, a, b) +#define l_subi(L,a,b) intop(-, a, b) +#define l_muli(L,a,b) intop(*, a, b) +#define l_band(a,b) intop(&, a, b) +#define l_bor(a,b) intop(|, a, b) +#define l_bxor(a,b) intop(^, a, b) + +#define l_lti(a,b) (a < b) +#define l_lei(a,b) (a <= b) +#define l_gti(a,b) (a > b) +#define l_gei(a,b) (a >= b) + + +/* +** Arithmetic operations with immediate operands. 'iop' is the integer +** operation, 'fop' is the float operation. +*/ +#define op_arithI(L,iop,fop) { \ + TValue *ra = vRA(i); \ + TValue *v1 = vRB(i); \ + int imm = GETARG_sC(i); \ + if (ttisinteger(v1)) { \ + lua_Integer iv1 = ivalue(v1); \ + pc++; setivalue(ra, iop(L, iv1, imm)); \ + } \ + else if (ttisfloat(v1)) { \ + lua_Number nb = fltvalue(v1); \ + lua_Number fimm = cast_num(imm); \ + pc++; setfltvalue(ra, fop(L, nb, fimm)); \ + }} + + +/* +** Auxiliary function for arithmetic operations over floats and others +** with two operands. +*/ +#define op_arithf_aux(L,v1,v2,fop) { \ + lua_Number n1; lua_Number n2; \ + if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ + StkId ra = RA(i); \ + pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ + }} + + +/* +** Arithmetic operations over floats and others with register operands. +*/ +#define op_arithf(L,fop) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = vRC(i); \ + op_arithf_aux(L, v1, v2, fop); } + + +/* +** Arithmetic operations with K operands for floats. +*/ +#define op_arithfK(L,fop) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ + op_arithf_aux(L, v1, v2, fop); } + + +/* +** Arithmetic operations over integers and floats. +*/ +#define op_arith_aux(L,v1,v2,iop,fop) { \ + if (ttisinteger(v1) && ttisinteger(v2)) { \ + StkId ra = RA(i); \ + lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ + pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ + } \ + else op_arithf_aux(L, v1, v2, fop); } + + +/* +** Arithmetic operations with register operands. +*/ +#define op_arith(L,iop,fop) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = vRC(i); \ + op_arith_aux(L, v1, v2, iop, fop); } + + +/* +** Arithmetic operations with K operands. +*/ +#define op_arithK(L,iop,fop) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ + op_arith_aux(L, v1, v2, iop, fop); } + + +/* +** Bitwise operations with constant operand. +*/ +#define op_bitwiseK(L,op) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = KC(i); \ + lua_Integer i1; \ + lua_Integer i2 = ivalue(v2); \ + if (tointegerns(v1, &i1)) { \ + StkId ra = RA(i); \ + pc++; setivalue(s2v(ra), op(i1, i2)); \ + }} + + +/* +** Bitwise operations with register operands. +*/ +#define op_bitwise(L,op) { \ + TValue *v1 = vRB(i); \ + TValue *v2 = vRC(i); \ + lua_Integer i1; lua_Integer i2; \ + if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ + StkId ra = RA(i); \ + pc++; setivalue(s2v(ra), op(i1, i2)); \ + }} + + +/* +** Order operations with register operands. 'opn' actually works +** for all numbers, but the fast track improves performance for +** integers. +*/ +#define op_order(L,opi,opn,other) { \ + TValue *ra = vRA(i); \ + int cond; \ + TValue *rb = vRB(i); \ + if (ttisinteger(ra) && ttisinteger(rb)) { \ + lua_Integer ia = ivalue(ra); \ + lua_Integer ib = ivalue(rb); \ + cond = opi(ia, ib); \ + } \ + else if (ttisnumber(ra) && ttisnumber(rb)) \ + cond = opn(ra, rb); \ + else \ + Protect(cond = other(L, ra, rb)); \ + docondjump(); } + + +/* +** Order operations with immediate operand. (Immediate operand is +** always small enough to have an exact representation as a float.) +*/ +#define op_orderI(L,opi,opf,inv,tm) { \ + TValue *ra = vRA(i); \ + int cond; \ + int im = GETARG_sB(i); \ + if (ttisinteger(ra)) \ + cond = opi(ivalue(ra), im); \ + else if (ttisfloat(ra)) { \ + lua_Number fa = fltvalue(ra); \ + lua_Number fim = cast_num(im); \ + cond = opf(fa, fim); \ + } \ + else { \ + int isf = GETARG_C(i); \ + Protect(cond = luaT_callorderiTM(L, ra, im, inv, isf, tm)); \ + } \ + docondjump(); } + +/* }================================================================== */ + + +/* +** {================================================================== +** Function 'luaV_execute': main interpreter loop +** =================================================================== +*/ + +/* +** some macros for common tasks in 'luaV_execute' +*/ + + +#define RA(i) (base+GETARG_A(i)) +#define vRA(i) s2v(RA(i)) +#define RB(i) (base+GETARG_B(i)) +#define vRB(i) s2v(RB(i)) +#define KB(i) (k+GETARG_B(i)) +#define RC(i) (base+GETARG_C(i)) +#define vRC(i) s2v(RC(i)) +#define KC(i) (k+GETARG_C(i)) +#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) + + + +#define updatetrap(ci) (trap = ci->u.l.trap) + +#define updatebase(ci) (base = ci->func.p + 1) + + +#define updatestack(ci) \ + { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } + + +/* +** Execute a jump instruction. The 'updatetrap' allows signals to stop +** tight loops. (Without it, the local copy of 'trap' could never change.) +*/ +#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } + + +/* for test instructions, execute the jump instruction that follows it */ +#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } + +/* +** do a conditional jump: skip next instruction if 'cond' is not what +** was expected (parameter 'k'), else do next instruction, which must +** be a jump. +*/ +#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); + + +/* +** Correct global 'pc'. +*/ +#define savepc(ci) (ci->u.l.savedpc = pc) + + +/* +** Whenever code can raise errors, the global 'pc' and the global +** 'top' must be correct to report occasional errors. +*/ +#define savestate(L,ci) (savepc(ci), L->top.p = ci->top.p) + + +/* +** Protect code that, in general, can raise errors, reallocate the +** stack, and change the hooks. +*/ +#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) + +/* special version that does not change the top */ +#define ProtectNT(exp) (savepc(ci), (exp), updatetrap(ci)) + +/* +** Protect code that can only raise errors. (That is, it cannot change +** the stack or hooks.) +*/ +#define halfProtect(exp) (savestate(L,ci), (exp)) + +/* +** macro executed during Lua functions at points where the +** function can yield. +*/ +#if !defined(luai_threadyield) +#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} +#endif + +/* 'c' is the limit of live values in the stack */ +#define checkGC(L,c) \ + { luaC_condGC(L, (savepc(ci), L->top.p = (c)), \ + updatetrap(ci)); \ + luai_threadyield(L); } + + +/* fetch an instruction and prepare its execution */ +#define vmfetch() { \ + if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ + trap = luaG_traceexec(L, pc); /* handle hooks */ \ + updatebase(ci); /* correct stack */ \ + } \ + i = *(pc++); \ +} + +#define vmdispatch(o) switch(o) +#define vmcase(l) case l: +#define vmbreak break + + +void luaV_execute (lua_State *L, CallInfo *ci) { + LClosure *cl; + TValue *k; + StkId base; + const Instruction *pc; + int trap; +#if LUA_USE_JUMPTABLE +#include "ljumptab.h" +#endif + startfunc: + trap = L->hookmask; + returning: /* trap already set */ + cl = ci_func(ci); + k = cl->p->k; + pc = ci->u.l.savedpc; + if (l_unlikely(trap)) + trap = luaG_tracecall(L); + base = ci->func.p + 1; + /* main loop of interpreter */ + for (;;) { + Instruction i; /* instruction being executed */ + vmfetch(); + #if 0 + { /* low-level line tracing for debugging Lua */ + #include "lopnames.h" + int pcrel = pcRel(pc, cl->p); + printf("line: %d; %s (%d)\n", luaG_getfuncline(cl->p, pcrel), + opnames[GET_OPCODE(i)], pcrel); + } + #endif + lua_assert(base == ci->func.p + 1); + lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p); + /* for tests, invalidate top for instructions not expecting it */ + lua_assert(luaP_isIT(i) || (cast_void(L->top.p = base), 1)); + vmdispatch (GET_OPCODE(i)) { + vmcase(OP_MOVE) { + StkId ra = RA(i); + setobjs2s(L, ra, RB(i)); + vmbreak; + } + vmcase(OP_LOADI) { + StkId ra = RA(i); + lua_Integer b = GETARG_sBx(i); + setivalue(s2v(ra), b); + vmbreak; + } + vmcase(OP_LOADF) { + StkId ra = RA(i); + int b = GETARG_sBx(i); + setfltvalue(s2v(ra), cast_num(b)); + vmbreak; + } + vmcase(OP_LOADK) { + StkId ra = RA(i); + TValue *rb = k + GETARG_Bx(i); + setobj2s(L, ra, rb); + vmbreak; + } + vmcase(OP_LOADKX) { + StkId ra = RA(i); + TValue *rb; + rb = k + GETARG_Ax(*pc); pc++; + setobj2s(L, ra, rb); + vmbreak; + } + vmcase(OP_LOADFALSE) { + StkId ra = RA(i); + setbfvalue(s2v(ra)); + vmbreak; + } + vmcase(OP_LFALSESKIP) { + StkId ra = RA(i); + setbfvalue(s2v(ra)); + pc++; /* skip next instruction */ + vmbreak; + } + vmcase(OP_LOADTRUE) { + StkId ra = RA(i); + setbtvalue(s2v(ra)); + vmbreak; + } + vmcase(OP_LOADNIL) { + StkId ra = RA(i); + int b = GETARG_B(i); + do { + setnilvalue(s2v(ra++)); + } while (b--); + vmbreak; + } + vmcase(OP_GETUPVAL) { + StkId ra = RA(i); + int b = GETARG_B(i); + setobj2s(L, ra, cl->upvals[b]->v.p); + vmbreak; + } + vmcase(OP_SETUPVAL) { + StkId ra = RA(i); + UpVal *uv = cl->upvals[GETARG_B(i)]; + setobj(L, uv->v.p, s2v(ra)); + luaC_barrier(L, uv, s2v(ra)); + vmbreak; + } + vmcase(OP_GETTABUP) { + StkId ra = RA(i); + TValue *upval = cl->upvals[GETARG_B(i)]->v.p; + TValue *rc = KC(i); + TString *key = tsvalue(rc); /* key must be a short string */ + lu_byte tag; + luaV_fastget(upval, key, s2v(ra), luaH_getshortstr, tag); + if (tagisempty(tag)) + Protect(luaV_finishget(L, upval, rc, ra, tag)); + vmbreak; + } + vmcase(OP_GETTABLE) { + StkId ra = RA(i); + TValue *rb = vRB(i); + TValue *rc = vRC(i); + lu_byte tag; + if (ttisinteger(rc)) { /* fast track for integers? */ + luaV_fastgeti(rb, ivalue(rc), s2v(ra), tag); + } + else + luaV_fastget(rb, rc, s2v(ra), luaH_get, tag); + if (tagisempty(tag)) + Protect(luaV_finishget(L, rb, rc, ra, tag)); + vmbreak; + } + vmcase(OP_GETI) { + StkId ra = RA(i); + TValue *rb = vRB(i); + int c = GETARG_C(i); + lu_byte tag; + luaV_fastgeti(rb, c, s2v(ra), tag); + if (tagisempty(tag)) { + TValue key; + setivalue(&key, c); + Protect(luaV_finishget(L, rb, &key, ra, tag)); + } + vmbreak; + } + vmcase(OP_GETFIELD) { + StkId ra = RA(i); + TValue *rb = vRB(i); + TValue *rc = KC(i); + TString *key = tsvalue(rc); /* key must be a short string */ + lu_byte tag; + luaV_fastget(rb, key, s2v(ra), luaH_getshortstr, tag); + if (tagisempty(tag)) + Protect(luaV_finishget(L, rb, rc, ra, tag)); + vmbreak; + } + vmcase(OP_SETTABUP) { + int hres; + TValue *upval = cl->upvals[GETARG_A(i)]->v.p; + TValue *rb = KB(i); + TValue *rc = RKC(i); + TString *key = tsvalue(rb); /* key must be a short string */ + luaV_fastset(upval, key, rc, hres, luaH_psetshortstr); + if (hres == HOK) + luaV_finishfastset(L, upval, rc); + else + Protect(luaV_finishset(L, upval, rb, rc, hres)); + vmbreak; + } + vmcase(OP_SETTABLE) { + StkId ra = RA(i); + int hres; + TValue *rb = vRB(i); /* key (table is in 'ra') */ + TValue *rc = RKC(i); /* value */ + if (ttisinteger(rb)) { /* fast track for integers? */ + luaV_fastseti(s2v(ra), ivalue(rb), rc, hres); + } + else { + luaV_fastset(s2v(ra), rb, rc, hres, luaH_pset); + } + if (hres == HOK) + luaV_finishfastset(L, s2v(ra), rc); + else + Protect(luaV_finishset(L, s2v(ra), rb, rc, hres)); + vmbreak; + } + vmcase(OP_SETI) { + StkId ra = RA(i); + int hres; + int b = GETARG_B(i); + TValue *rc = RKC(i); + luaV_fastseti(s2v(ra), b, rc, hres); + if (hres == HOK) + luaV_finishfastset(L, s2v(ra), rc); + else { + TValue key; + setivalue(&key, b); + Protect(luaV_finishset(L, s2v(ra), &key, rc, hres)); + } + vmbreak; + } + vmcase(OP_SETFIELD) { + StkId ra = RA(i); + int hres; + TValue *rb = KB(i); + TValue *rc = RKC(i); + TString *key = tsvalue(rb); /* key must be a short string */ + luaV_fastset(s2v(ra), key, rc, hres, luaH_psetshortstr); + if (hres == HOK) + luaV_finishfastset(L, s2v(ra), rc); + else + Protect(luaV_finishset(L, s2v(ra), rb, rc, hres)); + vmbreak; + } + vmcase(OP_NEWTABLE) { + StkId ra = RA(i); + unsigned b = cast_uint(GETARG_vB(i)); /* log2(hash size) + 1 */ + unsigned c = cast_uint(GETARG_vC(i)); /* array size */ + Table *t; + if (b > 0) + b = 1u << (b - 1); /* hash size is 2^(b - 1) */ + if (TESTARG_k(i)) { /* non-zero extra argument? */ + lua_assert(GETARG_Ax(*pc) != 0); + /* add it to array size */ + c += cast_uint(GETARG_Ax(*pc)) * (MAXARG_vC + 1); + } + pc++; /* skip extra argument */ + L->top.p = ra + 1; /* correct top in case of emergency GC */ + t = luaH_new(L); /* memory allocation */ + sethvalue2s(L, ra, t); + if (b != 0 || c != 0) + luaH_resize(L, t, c, b); /* idem */ + checkGC(L, ra + 1); + vmbreak; + } + vmcase(OP_SELF) { + StkId ra = RA(i); + lu_byte tag; + TValue *rb = vRB(i); + TValue *rc = KC(i); + TString *key = tsvalue(rc); /* key must be a short string */ + setobj2s(L, ra + 1, rb); + luaV_fastget(rb, key, s2v(ra), luaH_getshortstr, tag); + if (tagisempty(tag)) + Protect(luaV_finishget(L, rb, rc, ra, tag)); + vmbreak; + } + vmcase(OP_ADDI) { + op_arithI(L, l_addi, luai_numadd); + vmbreak; + } + vmcase(OP_ADDK) { + op_arithK(L, l_addi, luai_numadd); + vmbreak; + } + vmcase(OP_SUBK) { + op_arithK(L, l_subi, luai_numsub); + vmbreak; + } + vmcase(OP_MULK) { + op_arithK(L, l_muli, luai_nummul); + vmbreak; + } + vmcase(OP_MODK) { + savestate(L, ci); /* in case of division by 0 */ + op_arithK(L, luaV_mod, luaV_modf); + vmbreak; + } + vmcase(OP_POWK) { + op_arithfK(L, luai_numpow); + vmbreak; + } + vmcase(OP_DIVK) { + op_arithfK(L, luai_numdiv); + vmbreak; + } + vmcase(OP_IDIVK) { + savestate(L, ci); /* in case of division by 0 */ + op_arithK(L, luaV_idiv, luai_numidiv); + vmbreak; + } + vmcase(OP_BANDK) { + op_bitwiseK(L, l_band); + vmbreak; + } + vmcase(OP_BORK) { + op_bitwiseK(L, l_bor); + vmbreak; + } + vmcase(OP_BXORK) { + op_bitwiseK(L, l_bxor); + vmbreak; + } + vmcase(OP_SHLI) { + StkId ra = RA(i); + TValue *rb = vRB(i); + int ic = GETARG_sC(i); + lua_Integer ib; + if (tointegerns(rb, &ib)) { + pc++; setivalue(s2v(ra), luaV_shiftl(ic, ib)); + } + vmbreak; + } + vmcase(OP_SHRI) { + StkId ra = RA(i); + TValue *rb = vRB(i); + int ic = GETARG_sC(i); + lua_Integer ib; + if (tointegerns(rb, &ib)) { + pc++; setivalue(s2v(ra), luaV_shiftl(ib, -ic)); + } + vmbreak; + } + vmcase(OP_ADD) { + op_arith(L, l_addi, luai_numadd); + vmbreak; + } + vmcase(OP_SUB) { + op_arith(L, l_subi, luai_numsub); + vmbreak; + } + vmcase(OP_MUL) { + op_arith(L, l_muli, luai_nummul); + vmbreak; + } + vmcase(OP_MOD) { + savestate(L, ci); /* in case of division by 0 */ + op_arith(L, luaV_mod, luaV_modf); + vmbreak; + } + vmcase(OP_POW) { + op_arithf(L, luai_numpow); + vmbreak; + } + vmcase(OP_DIV) { /* float division (always with floats) */ + op_arithf(L, luai_numdiv); + vmbreak; + } + vmcase(OP_IDIV) { /* floor division */ + savestate(L, ci); /* in case of division by 0 */ + op_arith(L, luaV_idiv, luai_numidiv); + vmbreak; + } + vmcase(OP_BAND) { + op_bitwise(L, l_band); + vmbreak; + } + vmcase(OP_BOR) { + op_bitwise(L, l_bor); + vmbreak; + } + vmcase(OP_BXOR) { + op_bitwise(L, l_bxor); + vmbreak; + } + vmcase(OP_SHL) { + op_bitwise(L, luaV_shiftl); + vmbreak; + } + vmcase(OP_SHR) { + op_bitwise(L, luaV_shiftr); + vmbreak; + } + vmcase(OP_MMBIN) { + StkId ra = RA(i); + Instruction pi = *(pc - 2); /* original arith. expression */ + TValue *rb = vRB(i); + TMS tm = (TMS)GETARG_C(i); + StkId result = RA(pi); + lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR); + Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm)); + vmbreak; + } + vmcase(OP_MMBINI) { + StkId ra = RA(i); + Instruction pi = *(pc - 2); /* original arith. expression */ + int imm = GETARG_sB(i); + TMS tm = (TMS)GETARG_C(i); + int flip = GETARG_k(i); + StkId result = RA(pi); + Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm)); + vmbreak; + } + vmcase(OP_MMBINK) { + StkId ra = RA(i); + Instruction pi = *(pc - 2); /* original arith. expression */ + TValue *imm = KB(i); + TMS tm = (TMS)GETARG_C(i); + int flip = GETARG_k(i); + StkId result = RA(pi); + Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm)); + vmbreak; + } + vmcase(OP_UNM) { + StkId ra = RA(i); + TValue *rb = vRB(i); + lua_Number nb; + if (ttisinteger(rb)) { + lua_Integer ib = ivalue(rb); + setivalue(s2v(ra), intop(-, 0, ib)); + } + else if (tonumberns(rb, nb)) { + setfltvalue(s2v(ra), luai_numunm(L, nb)); + } + else + Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); + vmbreak; + } + vmcase(OP_BNOT) { + StkId ra = RA(i); + TValue *rb = vRB(i); + lua_Integer ib; + if (tointegerns(rb, &ib)) { + setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib)); + } + else + Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); + vmbreak; + } + vmcase(OP_NOT) { + StkId ra = RA(i); + TValue *rb = vRB(i); + if (l_isfalse(rb)) + setbtvalue(s2v(ra)); + else + setbfvalue(s2v(ra)); + vmbreak; + } + vmcase(OP_LEN) { + StkId ra = RA(i); + Protect(luaV_objlen(L, ra, vRB(i))); + vmbreak; + } + vmcase(OP_CONCAT) { + StkId ra = RA(i); + int n = GETARG_B(i); /* number of elements to concatenate */ + L->top.p = ra + n; /* mark the end of concat operands */ + ProtectNT(luaV_concat(L, n)); + checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */ + vmbreak; + } + vmcase(OP_CLOSE) { + StkId ra = RA(i); + lua_assert(!GETARG_B(i)); /* 'close must be alive */ + Protect(luaF_close(L, ra, LUA_OK, 1)); + vmbreak; + } + vmcase(OP_TBC) { + StkId ra = RA(i); + /* create new to-be-closed upvalue */ + halfProtect(luaF_newtbcupval(L, ra)); + vmbreak; + } + vmcase(OP_JMP) { + dojump(ci, i, 0); + vmbreak; + } + vmcase(OP_EQ) { + StkId ra = RA(i); + int cond; + TValue *rb = vRB(i); + Protect(cond = luaV_equalobj(L, s2v(ra), rb)); + docondjump(); + vmbreak; + } + vmcase(OP_LT) { + op_order(L, l_lti, LTnum, lessthanothers); + vmbreak; + } + vmcase(OP_LE) { + op_order(L, l_lei, LEnum, lessequalothers); + vmbreak; + } + vmcase(OP_EQK) { + StkId ra = RA(i); + TValue *rb = KB(i); + /* basic types do not use '__eq'; we can use raw equality */ + int cond = luaV_rawequalobj(s2v(ra), rb); + docondjump(); + vmbreak; + } + vmcase(OP_EQI) { + StkId ra = RA(i); + int cond; + int im = GETARG_sB(i); + if (ttisinteger(s2v(ra))) + cond = (ivalue(s2v(ra)) == im); + else if (ttisfloat(s2v(ra))) + cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im)); + else + cond = 0; /* other types cannot be equal to a number */ + docondjump(); + vmbreak; + } + vmcase(OP_LTI) { + op_orderI(L, l_lti, luai_numlt, 0, TM_LT); + vmbreak; + } + vmcase(OP_LEI) { + op_orderI(L, l_lei, luai_numle, 0, TM_LE); + vmbreak; + } + vmcase(OP_GTI) { + op_orderI(L, l_gti, luai_numgt, 1, TM_LT); + vmbreak; + } + vmcase(OP_GEI) { + op_orderI(L, l_gei, luai_numge, 1, TM_LE); + vmbreak; + } + vmcase(OP_TEST) { + StkId ra = RA(i); + int cond = !l_isfalse(s2v(ra)); + docondjump(); + vmbreak; + } + vmcase(OP_TESTSET) { + StkId ra = RA(i); + TValue *rb = vRB(i); + if (l_isfalse(rb) == GETARG_k(i)) + pc++; + else { + setobj2s(L, ra, rb); + donextjump(ci); + } + vmbreak; + } + vmcase(OP_CALL) { + StkId ra = RA(i); + CallInfo *newci; + int b = GETARG_B(i); + int nresults = GETARG_C(i) - 1; + if (b != 0) /* fixed number of arguments? */ + L->top.p = ra + b; /* top signals number of arguments */ + /* else previous instruction set top */ + savepc(ci); /* in case of errors */ + if ((newci = luaD_precall(L, ra, nresults)) == NULL) + updatetrap(ci); /* C call; nothing else to be done */ + else { /* Lua call: run function in this same C frame */ + ci = newci; + goto startfunc; + } + vmbreak; + } + vmcase(OP_TAILCALL) { + StkId ra = RA(i); + int b = GETARG_B(i); /* number of arguments + 1 (function) */ + int n; /* number of results when calling a C function */ + int nparams1 = GETARG_C(i); + /* delta is virtual 'func' - real 'func' (vararg functions) */ + int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0; + if (b != 0) + L->top.p = ra + b; + else /* previous instruction set top */ + b = cast_int(L->top.p - ra); + savepc(ci); /* several calls here can raise errors */ + if (TESTARG_k(i)) { + luaF_closeupval(L, base); /* close upvalues from current call */ + lua_assert(L->tbclist.p < base); /* no pending tbc variables */ + lua_assert(base == ci->func.p + 1); + } + if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0) /* Lua function? */ + goto startfunc; /* execute the callee */ + else { /* C function? */ + ci->func.p -= delta; /* restore 'func' (if vararg) */ + luaD_poscall(L, ci, n); /* finish caller */ + updatetrap(ci); /* 'luaD_poscall' can change hooks */ + goto ret; /* caller returns after the tail call */ + } + } + vmcase(OP_RETURN) { + StkId ra = RA(i); + int n = GETARG_B(i) - 1; /* number of results */ + int nparams1 = GETARG_C(i); + if (n < 0) /* not fixed? */ + n = cast_int(L->top.p - ra); /* get what is available */ + savepc(ci); + if (TESTARG_k(i)) { /* may there be open upvalues? */ + ci->u2.nres = n; /* save number of returns */ + if (L->top.p < ci->top.p) + L->top.p = ci->top.p; + luaF_close(L, base, CLOSEKTOP, 1); + updatetrap(ci); + updatestack(ci); + } + if (nparams1) /* vararg function? */ + ci->func.p -= ci->u.l.nextraargs + nparams1; + L->top.p = ra + n; /* set call for 'luaD_poscall' */ + luaD_poscall(L, ci, n); + updatetrap(ci); /* 'luaD_poscall' can change hooks */ + goto ret; + } + vmcase(OP_RETURN0) { + if (l_unlikely(L->hookmask)) { + StkId ra = RA(i); + L->top.p = ra; + savepc(ci); + luaD_poscall(L, ci, 0); /* no hurry... */ + trap = 1; + } + else { /* do the 'poscall' here */ + int nres = get_nresults(ci->callstatus); + L->ci = ci->previous; /* back to caller */ + L->top.p = base - 1; + for (; l_unlikely(nres > 0); nres--) + setnilvalue(s2v(L->top.p++)); /* all results are nil */ + } + goto ret; + } + vmcase(OP_RETURN1) { + if (l_unlikely(L->hookmask)) { + StkId ra = RA(i); + L->top.p = ra + 1; + savepc(ci); + luaD_poscall(L, ci, 1); /* no hurry... */ + trap = 1; + } + else { /* do the 'poscall' here */ + int nres = get_nresults(ci->callstatus); + L->ci = ci->previous; /* back to caller */ + if (nres == 0) + L->top.p = base - 1; /* asked for no results */ + else { + StkId ra = RA(i); + setobjs2s(L, base - 1, ra); /* at least this result */ + L->top.p = base; + for (; l_unlikely(nres > 1); nres--) + setnilvalue(s2v(L->top.p++)); /* complete missing results */ + } + } + ret: /* return from a Lua function */ + if (ci->callstatus & CIST_FRESH) + return; /* end this frame */ + else { + ci = ci->previous; + goto returning; /* continue running caller in this frame */ + } + } + vmcase(OP_FORLOOP) { + StkId ra = RA(i); + if (ttisinteger(s2v(ra + 1))) { /* integer loop? */ + lua_Unsigned count = l_castS2U(ivalue(s2v(ra))); + if (count > 0) { /* still more iterations? */ + lua_Integer step = ivalue(s2v(ra + 1)); + lua_Integer idx = ivalue(s2v(ra + 2)); /* control variable */ + chgivalue(s2v(ra), l_castU2S(count - 1)); /* update counter */ + idx = intop(+, idx, step); /* add step to index */ + chgivalue(s2v(ra + 2), idx); /* update control variable */ + pc -= GETARG_Bx(i); /* jump back */ + } + } + else if (floatforloop(ra)) /* float loop */ + pc -= GETARG_Bx(i); /* jump back */ + updatetrap(ci); /* allows a signal to break the loop */ + vmbreak; + } + vmcase(OP_FORPREP) { + StkId ra = RA(i); + savestate(L, ci); /* in case of errors */ + if (forprep(L, ra)) + pc += GETARG_Bx(i) + 1; /* skip the loop */ + vmbreak; + } + vmcase(OP_TFORPREP) { + /* before: 'ra' has the iterator function, 'ra + 1' has the state, + 'ra + 2' has the initial value for the control variable, and + 'ra + 3' has the closing variable. This opcode then swaps the + control and the closing variables and marks the closing variable + as to-be-closed. + */ + StkId ra = RA(i); + TValue temp; /* to swap control and closing variables */ + setobj(L, &temp, s2v(ra + 3)); + setobjs2s(L, ra + 3, ra + 2); + setobj2s(L, ra + 2, &temp); + /* create to-be-closed upvalue (if closing var. is not nil) */ + halfProtect(luaF_newtbcupval(L, ra + 2)); + pc += GETARG_Bx(i); /* go to end of the loop */ + i = *(pc++); /* fetch next instruction */ + lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i)); + goto l_tforcall; + } + vmcase(OP_TFORCALL) { + l_tforcall: { + /* 'ra' has the iterator function, 'ra + 1' has the state, + 'ra + 2' has the closing variable, and 'ra + 3' has the control + variable. The call will use the stack starting at 'ra + 3', + so that it preserves the first three values, and the first + return will be the new value for the control variable. + */ + StkId ra = RA(i); + setobjs2s(L, ra + 5, ra + 3); /* copy the control variable */ + setobjs2s(L, ra + 4, ra + 1); /* copy state */ + setobjs2s(L, ra + 3, ra); /* copy function */ + L->top.p = ra + 3 + 3; + ProtectNT(luaD_call(L, ra + 3, GETARG_C(i))); /* do the call */ + updatestack(ci); /* stack may have changed */ + i = *(pc++); /* go to next instruction */ + lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i)); + goto l_tforloop; + }} + vmcase(OP_TFORLOOP) { + l_tforloop: { + StkId ra = RA(i); + if (!ttisnil(s2v(ra + 3))) /* continue loop? */ + pc -= GETARG_Bx(i); /* jump back */ + vmbreak; + }} + vmcase(OP_SETLIST) { + StkId ra = RA(i); + unsigned n = cast_uint(GETARG_vB(i)); + unsigned last = cast_uint(GETARG_vC(i)); + Table *h = hvalue(s2v(ra)); + if (n == 0) + n = cast_uint(L->top.p - ra) - 1; /* get up to the top */ + else + L->top.p = ci->top.p; /* correct top in case of emergency GC */ + last += n; + if (TESTARG_k(i)) { + last += cast_uint(GETARG_Ax(*pc)) * (MAXARG_vC + 1); + pc++; + } + /* when 'n' is known, table should have proper size */ + if (last > h->asize) { /* needs more space? */ + /* fixed-size sets should have space preallocated */ + lua_assert(GETARG_vB(i) == 0); + luaH_resizearray(L, h, last); /* preallocate it at once */ + } + for (; n > 0; n--) { + TValue *val = s2v(ra + n); + obj2arr(h, last - 1, val); + last--; + luaC_barrierback(L, obj2gco(h), val); + } + vmbreak; + } + vmcase(OP_CLOSURE) { + StkId ra = RA(i); + Proto *p = cl->p->p[GETARG_Bx(i)]; + halfProtect(pushclosure(L, p, cl->upvals, base, ra)); + checkGC(L, ra + 1); + vmbreak; + } + vmcase(OP_VARARG) { + StkId ra = RA(i); + int n = GETARG_C(i) - 1; /* required results (-1 means all) */ + int vatab = GETARG_k(i) ? GETARG_B(i) : -1; + Protect(luaT_getvarargs(L, ci, ra, n, vatab)); + vmbreak; + } + vmcase(OP_GETVARG) { + StkId ra = RA(i); + TValue *rc = vRC(i); + luaT_getvararg(ci, ra, rc); + vmbreak; + } + vmcase(OP_ERRNNIL) { + TValue *ra = vRA(i); + if (!ttisnil(ra)) + halfProtect(luaG_errnnil(L, cl, GETARG_Bx(i))); + vmbreak; + } + vmcase(OP_VARARGPREP) { + ProtectNT(luaT_adjustvarargs(L, ci, cl->p)); + if (l_unlikely(trap)) { /* previous "Protect" updated trap */ + luaD_hookcall(L, ci); + L->oldpc = 1; /* next opcode will be seen as a "new" line */ + } + updatebase(ci); /* function has new base after adjustment */ + vmbreak; + } + vmcase(OP_EXTRAARG) { + lua_assert(0); + vmbreak; + } + } + } +} + +/* }================================================================== */ diff --git a/source/external/lua/lzio.c b/source/external/lua/lzio.c new file mode 100644 index 0000000..301df4b --- /dev/null +++ b/source/external/lua/lzio.c @@ -0,0 +1,89 @@ +/* +** $Id: lzio.c $ +** Buffered streams +** See Copyright Notice in lua.h +*/ + +#define lzio_c +#define LUA_CORE + +#include "lprefix.h" + + +#include + +#include "lua.h" + +#include "lapi.h" +#include "llimits.h" +#include "lmem.h" +#include "lstate.h" +#include "lzio.h" + + +int luaZ_fill (ZIO *z) { + size_t size; + lua_State *L = z->L; + const char *buff; + lua_unlock(L); + buff = z->reader(L, z->data, &size); + lua_lock(L); + if (buff == NULL || size == 0) + return EOZ; + z->n = size - 1; /* discount char being returned */ + z->p = buff; + return cast_uchar(*(z->p++)); +} + + +void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { + z->L = L; + z->reader = reader; + z->data = data; + z->n = 0; + z->p = NULL; +} + + +/* --------------------------------------------------------------- read --- */ + +static int checkbuffer (ZIO *z) { + if (z->n == 0) { /* no bytes in buffer? */ + if (luaZ_fill(z) == EOZ) /* try to read more */ + return 0; /* no more input */ + else { + z->n++; /* luaZ_fill consumed first byte; put it back */ + z->p--; + } + } + return 1; /* now buffer has something */ +} + + +size_t luaZ_read (ZIO *z, void *b, size_t n) { + while (n) { + size_t m; + if (!checkbuffer(z)) + return n; /* no more input; return number of missing bytes */ + m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ + memcpy(b, z->p, m); + z->n -= m; + z->p += m; + b = (char *)b + m; + n -= m; + } + return 0; +} + + +const void *luaZ_getaddr (ZIO* z, size_t n) { + const void *res; + if (!checkbuffer(z)) + return NULL; /* no more input */ + if (z->n < n) /* not enough bytes? */ + return NULL; /* block not whole; cannot give an address */ + res = z->p; /* get block address */ + z->n -= n; /* consume these bytes */ + z->p += n; + return res; +} diff --git a/source/mini/version.h b/source/mini/version.h index ce7ba34..5328fef 100644 --- a/source/mini/version.h +++ b/source/mini/version.h @@ -1,3 +1,3 @@ #pragma once -#define MINI_VERSION "1.5.4" +#define MINI_VERSION "1.5.5"