diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/lapi.js | 130 | ||||
| -rw-r--r-- | src/lauxlib.js | 8 | ||||
| -rw-r--r-- | src/lcorolib.js | 86 | ||||
| -rw-r--r-- | src/ldo.js | 227 | ||||
| -rw-r--r-- | src/linit.js | 5 | ||||
| -rw-r--r-- | src/lstate.js | 55 | ||||
| -rw-r--r-- | src/lualib.js | 23 | ||||
| -rw-r--r-- | src/lvm.js | 96 |
8 files changed, 537 insertions, 93 deletions
diff --git a/src/lapi.js b/src/lapi.js index e9f15c2..2f2802f 100644 --- a/src/lapi.js +++ b/src/lapi.js @@ -82,6 +82,19 @@ const lua_checkstack = function(L, n) { return L.stack.length < luaconf.LUAI_MAXSTACK; }; +const lua_xmove = function(from, to, n) { + if (from === to) return; + assert(n < (from.top - from.ci.funcOff), "not enough elements in the stack"); + assert(from.l_G === to.l_G, "moving among independent states"); + assert(to.ci.top - to.top >= n, "stack overflow"); + + from.top -= n; + for (let i = 0; i < n; i++) { + to.stack[to.top] = from.stack[from.top + i]; + to.top++; + } +}; + /* ** basic stack manipulation */ @@ -490,6 +503,11 @@ const lua_tonumber = function(L, idx) { return lvm.tonumber(index2addr(L, idx)) }; +const lua_tothread = function(L, idx) { + let o = index2addr(L, idx); + return o.ttisthread() ? o.value : null; +}; + const lua_topointer = function(L, idx) { let o = index2addr(L, idx); switch (o.ttype()) { @@ -564,8 +582,12 @@ const lua_load = function(L, data, chunckname) { return status; }; +const lua_status = function(L) { + return L.status; +}; + const lua_callk = function(L, nargs, nresults, ctx, k) { - assert(k === null || !(L.ci.callstatus & CIST_LUA), "cannot use continuations inside hooks"); + assert(k === null || !(L.ci.callstatus & lstate.CIST_LUA), "cannot use continuations inside hooks"); assert(nargs + 1 < L.top - L.ci.funcOff, "not enough elements in the stack"); assert(L.status === TS.LUA_OK, "cannot do calls on non-normal thread"); assert(nargs === lua.LUA_MULTRET || (L.ci.top - L.top >= nargs - nresults, "results from function overflow current stack size")); @@ -640,7 +662,6 @@ const lua_pcall = function(L, n, r, f) { return lua_pcallk(L, n, r, f, 0, null); }; - /* ** miscellaneous functions */ @@ -685,66 +706,69 @@ const lua_getextraspace = function () { return null; }; -module.exports.lua_pushvalue = lua_pushvalue; -module.exports.lua_pushnil = lua_pushnil; -module.exports.lua_pushnumber = lua_pushnumber; -module.exports.lua_pushinteger = lua_pushinteger; -module.exports.lua_pushlstring = lua_pushlstring; -module.exports.lua_pushstring = lua_pushstring; -module.exports.lua_pushliteral = lua_pushliteral; -module.exports.lua_pushboolean = lua_pushboolean; -module.exports.lua_pushcclosure = lua_pushcclosure; -module.exports.lua_pushcfunction = lua_pushcfunction; -module.exports.lua_pushjsclosure = lua_pushjsclosure; -module.exports.lua_pushjsfunction = lua_pushjsfunction; -module.exports.lua_version = lua_version; +module.exports.index2addr = index2addr; +module.exports.lua_absindex = lua_absindex; module.exports.lua_atpanic = lua_atpanic; +module.exports.lua_call = lua_call; +module.exports.lua_callk = lua_callk; +module.exports.lua_checkstack = lua_checkstack; +module.exports.lua_concat = lua_concat; +module.exports.lua_copy = lua_copy; +module.exports.lua_createtable = lua_createtable; +module.exports.lua_error = lua_error; +module.exports.lua_gc = lua_gc; +module.exports.lua_getallocf = lua_getallocf; +module.exports.lua_getextraspace = lua_getextraspace; +module.exports.lua_getfield = lua_getfield; +module.exports.lua_getglobal = lua_getglobal; +module.exports.lua_geti = lua_geti; +module.exports.lua_getmetatable = lua_getmetatable; +module.exports.lua_gettable = lua_gettable; module.exports.lua_gettop = lua_gettop; -module.exports.lua_typename = lua_typename; -module.exports.lua_type = lua_type; -module.exports.lua_tonumber = lua_tonumber; -module.exports.lua_tointeger = lua_tointeger; -module.exports.lua_toboolean = lua_toboolean; -module.exports.lua_tolstring = lua_tolstring; -module.exports.lua_tostring = lua_tostring; -module.exports.lua_topointer = lua_topointer; +module.exports.lua_insert = lua_insert; +module.exports.lua_isstring = lua_isstring; +module.exports.lua_istable = lua_istable; module.exports.lua_load = lua_load; -module.exports.lua_callk = lua_callk; -module.exports.lua_call = lua_call; -module.exports.lua_pcallk = lua_pcallk; +module.exports.lua_newtable = lua_newtable; +module.exports.lua_next = lua_next; module.exports.lua_pcall = lua_pcall; +module.exports.lua_pcallk = lua_pcallk; module.exports.lua_pop = lua_pop; -module.exports.lua_setglobal = lua_setglobal; -module.exports.lua_istable = lua_istable; -module.exports.lua_createtable = lua_createtable; -module.exports.lua_newtable = lua_newtable; -module.exports.lua_settable = lua_settable; -module.exports.lua_gettable = lua_gettable; -module.exports.lua_geti = lua_geti; -module.exports.lua_absindex = lua_absindex; -module.exports.index2addr = index2addr; +module.exports.lua_pushboolean = lua_pushboolean; +module.exports.lua_pushcclosure = lua_pushcclosure; +module.exports.lua_pushcfunction = lua_pushcfunction; +module.exports.lua_pushglobaltable = lua_pushglobaltable; +module.exports.lua_pushinteger = lua_pushinteger; +module.exports.lua_pushjsclosure = lua_pushjsclosure; +module.exports.lua_pushjsfunction = lua_pushjsfunction; +module.exports.lua_pushliteral = lua_pushliteral; +module.exports.lua_pushlstring = lua_pushlstring; +module.exports.lua_pushnil = lua_pushnil; +module.exports.lua_pushnumber = lua_pushnumber; +module.exports.lua_pushstring = lua_pushstring; +module.exports.lua_pushvalue = lua_pushvalue; +module.exports.lua_rawequal = lua_rawequal; module.exports.lua_rawget = lua_rawget; -module.exports.lua_rawset = lua_rawset; +module.exports.lua_rawgeti = lua_rawgeti; module.exports.lua_rawlen = lua_rawlen; -module.exports.lua_isstring = lua_isstring; -module.exports.lua_rotate = lua_rotate; +module.exports.lua_rawset = lua_rawset; module.exports.lua_remove = lua_remove; -module.exports.lua_checkstack = lua_checkstack; -module.exports.lua_rawgeti = lua_rawgeti; -module.exports.lua_pushglobaltable = lua_pushglobaltable; +module.exports.lua_rotate = lua_rotate; module.exports.lua_setfield = lua_setfield; -module.exports.lua_getfield = lua_getfield; -module.exports.lua_getglobal = lua_getglobal; -module.exports.lua_getmetatable = lua_getmetatable; +module.exports.lua_setglobal = lua_setglobal; module.exports.lua_setmetatable = lua_setmetatable; +module.exports.lua_settable = lua_settable; module.exports.lua_settop = lua_settop; -module.exports.lua_rawequal = lua_rawequal; -module.exports.lua_concat = lua_concat; -module.exports.lua_error = lua_error; -module.exports.lua_insert = lua_insert; -module.exports.lua_gc = lua_gc; -module.exports.lua_getallocf = lua_getallocf; -module.exports.lua_getextraspace = lua_getextraspace; +module.exports.lua_status = lua_status; module.exports.lua_stringtonumber = lua_stringtonumber; -module.exports.lua_copy = lua_copy; -module.exports.lua_next = lua_next;
\ No newline at end of file +module.exports.lua_toboolean = lua_toboolean; +module.exports.lua_tointeger = lua_tointeger; +module.exports.lua_tolstring = lua_tolstring; +module.exports.lua_tonumber = lua_tonumber; +module.exports.lua_topointer = lua_topointer; +module.exports.lua_tostring = lua_tostring; +module.exports.lua_tothread = lua_tothread; +module.exports.lua_type = lua_type; +module.exports.lua_typename = lua_typename; +module.exports.lua_version = lua_version; +module.exports.lua_xmove = lua_xmove;
\ No newline at end of file diff --git a/src/lauxlib.js b/src/lauxlib.js index 29b223f..a04f3be 100644 --- a/src/lauxlib.js +++ b/src/lauxlib.js @@ -310,6 +310,11 @@ const luaL_checkstack = function(L, space, msg) { } }; +const luaL_newlib = function(L, l) { + lapi.lua_createtable(L); + luaL_setfuncs(L, l, 0); +}; + module.exports.luaL_newstate = luaL_newstate; module.exports.luaL_typename = luaL_typename; module.exports.luaL_checkany = luaL_checkany; @@ -331,4 +336,5 @@ module.exports.luaL_optinteger = luaL_optinteger; module.exports.luaL_opt = luaL_opt; module.exports.luaL_where = luaL_where; module.exports.luaL_error = luaL_error; -module.exports.luaL_argerror = luaL_argerror;
\ No newline at end of file +module.exports.luaL_argerror = luaL_argerror; +module.exports.luaL_newlib = luaL_newlib;
\ No newline at end of file diff --git a/src/lcorolib.js b/src/lcorolib.js new file mode 100644 index 0000000..73699a7 --- /dev/null +++ b/src/lcorolib.js @@ -0,0 +1,86 @@ +/* jshint esversion: 6 */ +"use strict"; + +const assert = require('assert'); + +const lua = require('./lua.js'); +const lapi = require('./lapi.js'); +const lauxlib = require('./lauxlib.js'); +const lstate = require('./lstate.js'); +const ldo = require('./ldo.js'); +const CT = lua.constant_types; +const TS = lua.thread_status; + +const getco = function(L) { + let co = lapi.lua_tothread(L, 1); + lauxlib.luaL_argcheck(L, co, 1, "thread expected"); + return co; +}; + +const auxresume = function(L, co, narg) { + if (!lapi.lua_checkstack(co, narg)) { + lapi.lua_pushliteral(L, "too many arguments to resume"); + return -1; /* error flag */ + } + + if (lapi.lua_status(co) === TS.LUA_OK && lapi.lua_gettop(co) === 0) { + lapi.lua_pushliteral(L, "cannot resume dead coroutine"); + return -1; /* error flag */ + } + + lapi.lua_xmove(L, co, narg); + let status = ldo.lua_resume(co, L, narg); + if (status === TS.LUA_OK || status === TS.LUA_YIELD) { + let nres = lapi.lua_gettop(L); + if (!lapi.lua_checkstack(L, nres + 1)) { + lapi.lua_pop(co, nres); /* remove results anyway */ + lapi.lua_pushliteral(L, "too many results to resume"); + return -1; /* error flag */ + } + + lapi.lua_xmove(co, L, nres); /* move yielded values */ + return nres; + } else { + lapi.lua_xmove(co, L, 1); /* move error message */ + return -1; /* error flag */ + } +}; + +const luaB_resume = function(L) { + let co = getco(L); + let r = auxresume(L, co, lapi.lua_gettop(L) - 1); + if (r < 0) { + lapi.lua_pushboolean(L, 0); + lapi.lua_insert(L, -2); + return 2; /* return false + error message */ + } else { + lapi.lua_pushboolean(L, 1); + lapi.lua_insert(L, -(r + 1)); + return r + 1; /* return true + 'resume' returns */ + } +}; + +const luaB_cocreate = function(L) { + lauxlib.luaL_checktype(L, 1, CT.LUA_TFUNCTION); + let NL = lstate.lua_newthread(L); + lapi.lua_pushvalue(L, 1); /* move function to top */ + lapi.lua_xmove(L, NL, 1); /* move function from L to NL */ + return 1; +}; + +const luaB_yield = function(L) { + return ldo.lua_yield(L, lapi.lua_gettop(L)); +}; + +const co_funcs = { + "create": luaB_cocreate, + "yield": luaB_yield, + "resume": luaB_resume +}; + +const luaopen_coroutine = function(L) { + lauxlib.luaL_newlib(L, co_funcs); + return 1; +}; + +module.exports.luaopen_coroutine = luaopen_coroutine;
\ No newline at end of file @@ -27,6 +27,7 @@ const seterrorobj = function(L, errcode, oldtop) { } case TS.LUA_ERRERR: { L.stack[oldtop] = new TValue(CT.LUA_TLNGSTR, "error in error handling"); + break; } default: { L.stack[oldtop] = L.stack[L.top - 1]; @@ -79,7 +80,6 @@ const luaD_precall = function(L, off, nresults) { luaD_poscall(L, ci, L.top - n, n); return true; - break; } case CT.LUA_TLCL: { let p = func.p; @@ -260,7 +260,7 @@ const luaD_rawrunprotected = function(L, f, ud) { try { f(L, ud); } catch (e) { - if (lj.status == 0) lj.status = -1; + if (lj.status === 0) lj.status = -1; } L.errorJmp = lj.previous; @@ -270,6 +270,209 @@ const luaD_rawrunprotected = function(L, f, ud) { }; +/* +** Completes the execution of an interrupted C function, calling its +** continuation function. +*/ +const finishCcall = function(L, status) { + let ci = L.ci; + + /* must have a continuation and must be able to call it */ + assert(ci.u.c.k !== null && L.nny === 0); + /* error status can only happen in a protected call */ + assert(ci.callstatus & lstate.CIST_YPCALL || status === TS.LUA_YIELD); + + if (ci.callstatus & TS.CIST_YPCALL) { /* was inside a pcall? */ + ci.callstatus &= ~TS.CIST_YPCALL; /* continuation is also inside it */ + L.errfunc = ci.u.c.old_errfunc; /* with the same error function */ + } + + /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already + handled */ + if (ci.nresults === LUA_MULTRET && L.ci.top < L.top) L.ci.top = L.top; + let n = ci.u.c.k(L, status, ci.u.c.ctx); /* call continuation function */ + assert(n < (L.top - L.ci.funcOff), "not enough elements in the stack"); + luaD_poscall(L, ci, L.top - n, n); /* finish 'luaD_precall' */ +}; + +/* +** 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). If the coroutine is +** recovering from an error, 'ud' points to the error status, which must +** be passed to the first continuation function (otherwise the default +** status is LUA_YIELD). +*/ +const unroll = function(L, ud) { + if (ud !== null) /* error status? */ + finishCcall(L, ud); /* finish 'lua_pcallk' callee */ + + while (L.ci !== L.base_ci) { /* something in the stack */ + if (!(L.ci.callstatus & lstate.CIST_LUA)) /* C function? */ + finishCcall(L, lstate.LUA_YIELD); /* complete its execution */ + else { /* Lua function */ + lvm.luaV_finishOp(L); /* finish interrupted instruction */ + lvm.luaV_execute(L); /* execute down to higher C 'boundary' */ + } + } +}; + +/* +** Try to find a suspended protected call (a "recover point") for the +** given thread. +*/ +const findpcall = function(L) { + for (let ci = L.ci; ci !== null; ci = ci.previous) { /* search for a pcall */ + if (ci.callstatus & lstate.CIST_YPCALL) + return ci; + } + + return null; /* no pending pcall */ +}; + +/* +** Recovers from an error in a coroutine. Finds a recover point (if +** there is one) and completes the execution of the interrupted +** 'luaD_pcall'. If there is no recover point, returns zero. +*/ +const recover = function(L, status) { + let ci = findpcall(L); + if (ci === null) return 0; /* no recovery point */ + /* "finish" luaD_pcall */ + let oldtop = L.stack[ci.extra]; + lfunc.luaF_close(L, oldtop); + seterrorobj(L, status, oldtop); + L.ci = ci; + L.allowhook = ci.callstatus & lstate.CIST_OAH; /* restore original 'allowhook' */ + L.nny = 0; /* should be zero to be yieldable */ + L.errfunc = ci.u.c.old_errfunc; + return 1; /* continue running the coroutine */ +}; + +/* +** 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.) +*/ +const resume_error = function(L, msg, narg) { + L.top -= narg; /* remove args from the stack */ + L.stack[L.top++] = new TValue(CT.LUA_TLNGSTR, msg); /* push error message */ + assert(L.top <= L.ci.top, "stack overflow"); + return TS.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. +*/ +const resume = function(L, n) { + let firstArg = L.top - n; /* first argument */ + let ci = L.ci; + if (L.status === TS.LUA_OK) { /* starting a coroutine? */ + if (!luaD_precall(L, firstArg - 1, lua.LUA_MULTRET)) /* Lua function? */ + lvm.luaV_execute(L); /* call it */ + } else { /* resuming from previous yield */ + assert(L.status === TS.LUA_YIELD); + L.status = TS.LUA_OK; /* mark that it is running (again) */ + ci.funcOff = ci.extra; + ci.func = L.stack[ci.funcOff]; + + if (ci.callstatus & lstate.CIST_LUA) /* yielded inside a hook? */ + lvm.luaV_execute(L); /* just continue running Lua code */ + else { /* 'common' yield */ + if (ci.u.c.k !== null) { /* does it have a continuation function? */ + n = ci.u.c.k(L, TS.LUA_YIELD, ci.u.c.ctx); /* call continuation */ + assert(n < (L.top - L.ci.funcOff), "not enough elements in the stack"); + firstArg = L.top - n; /* yield results come from continuation */ + } + + luaD_poscall(L, ci, firstArg, n); /* finish 'luaD_precall' */ + } + + unroll(L, null); /* run continuation */ + } +}; + +const lua_resume = function(L, from, nargs) { + let oldnny = L.nny; /* save "number of non-yieldable" calls */ + + if (L.status === TS.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.status !== TS.LUA_YIELD) + return resume_error(L, "cannot resume dead coroutine", nargs); + + L.nCcalls = from ? from.nCcalls + 1 : 1; + if (L.nCcalls >= llimit.LUAI_MAXCCALLS) + return resume_error(L, "JS stack overflow", nargs); + + L.nny = 0; /* allow yields */ + + assert((L.status === TS.LUA_OK ? nargs + 1: nargs) < (L.top - L.ci.funcOff), + "not enough elements in the stack"); + + let status = luaD_rawrunprotected(L, resume, nargs); + if (status === -1) /* error calling 'lua_resume'? */ + status = TS.LUA_ERRRUN; + else { /* continue running after recoverable errors */ + while (status > TS.LUA_YIELD && recover(L, status)) { + /* unroll continuation */ + status = luaD_rawrunprotected(L, unroll, status); + } + + if (status > TS.LUA_YIELD) { /* unrecoverable error? */ + L.status = status; /* mark thread as 'dead' */ + seterrorobj(L, status, L.top); /* push error message */ + L.ci.top = L.top; + } else + assert(status === L.status); /* normal end or yield */ + } + + L.nny = oldnny; /* restore 'nny' */ + L.nCcalls--; + assert(L.nCcalls === (from ? from.nCcalls : 0)); + return status; +}; + +const lua_isyieldable = function(L) { + return L.nny === 0; +}; + +const lua_yieldk = function(L, nresults, ctx, k) { + let ci = L.ci; + assert(nresults < (L.top - L.ci.funcOff), "not enough elements in the stack"); + + if (L.nny > 0) { + if (L !== L.l_G.mainthread) + ldebug.luaG_runerror(L, "attempt to yield across a JS-call boundary"); + else + ldebug.luaG_runerror(L, "attempt to yield from outside a coroutine"); + } + + L.status = TS.LUA_YIELD; + ci.extra = ci.funcOff; /* save current 'func' */ + if (ci.callstatus & lstate.CIST_LUA) /* inside a hook? */ + assert(k === null, "hooks cannot continue after yielding"); + else { + ci.u.c.k = k; + if (k !== null) /* is there a continuation? */ + ci.u.c.ctx = ctx; /* save context */ + ci.funcOff = L.top - nresults - 1; /* protect stack below results */ + ci.func = L.stack[ci.funcOff]; + luaD_throw(L, TS.LUA_YIELD); + } + + assert(ci.callstatus & lstate.CIST_HOOKED); /* must be inside a hook */ + return 0; /* return to 'luaD_hook' */ +}; + +const lua_yield = function(L, n) { + lua_yieldk(L, n, 0, null); +}; + const luaD_pcall = function(L, func, u, old_top, ef) { let old_ci = L.ci; // TODO: lu_byte old_allowhooks = L->allowhook; @@ -321,16 +524,20 @@ const luaD_protectedparser = function(L, data, name) { return status; }; -module.exports.nil = nil; -module.exports.luaD_precall = luaD_precall; -module.exports.luaD_poscall = luaD_poscall; -module.exports.moveresults = moveresults; module.exports.adjust_varargs = adjust_varargs; -module.exports.tryfuncTM = tryfuncTM; -module.exports.stackerror = stackerror; +module.exports.lua_isyieldable = lua_isyieldable; +module.exports.lua_resume = lua_resume; +module.exports.lua_yield = lua_yield; +module.exports.lua_yieldk = lua_yieldk; module.exports.luaD_call = luaD_call; module.exports.luaD_callnoyield = luaD_callnoyield; module.exports.luaD_pcall = luaD_pcall; -module.exports.luaD_throw = luaD_throw; +module.exports.luaD_poscall = luaD_poscall; +module.exports.luaD_precall = luaD_precall; +module.exports.luaD_protectedparser = luaD_protectedparser; module.exports.luaD_rawrunprotected = luaD_rawrunprotected; -module.exports.luaD_protectedparser = luaD_protectedparser;
\ No newline at end of file +module.exports.luaD_throw = luaD_throw; +module.exports.moveresults = moveresults; +module.exports.nil = nil; +module.exports.stackerror = stackerror; +module.exports.tryfuncTM = tryfuncTM;
\ No newline at end of file diff --git a/src/linit.js b/src/linit.js index fc2a54d..d52b640 100644 --- a/src/linit.js +++ b/src/linit.js @@ -5,10 +5,13 @@ const assert = require('assert'); const lapi = require('./lapi.js'); const lauxlib = require('./lauxlib.js'); +const lualib = require('./lualib.js'); const lbaselib = require('./lbaselib.js'); +const lcorolib = require('./lcorolib.js'); const loadedlibs = { - "_G": lbaselib.luaopen_base + [lualib.LUA_COLIBNAME]: lcorolib.luaopen_coroutine, + "_G": lbaselib.luaopen_base }; const luaL_openlibs = function(L) { diff --git a/src/lstate.js b/src/lstate.js index eec9fae..9a9c9e0 100644 --- a/src/lstate.js +++ b/src/lstate.js @@ -1,8 +1,10 @@ /*jshint esversion: 6 */ "use strict"; +const assert = require('assert'); + const lua = require('./lua.js'); -const Table = require('./lobject.js').Table; +const lobject = require('./lobject.js'); const ldo = require('./ldo.js'); const lapi = require('./lapi.js'); const nil = ldo.nil; @@ -41,9 +43,10 @@ class CallInfo { } -class lua_State { +class lua_State extends lobject.TValue { - constructor(cl) { + constructor() { + super(CT.LUA_TTHREAD, null); this.base_ci = new CallInfo(); // Will be populated later this.top = 0; this.ci = null; @@ -52,12 +55,12 @@ class lua_State { this.openupval = []; this.status = TS.LUA_OK; this.next = null; - this.tt = CT.LUA_TTHREAD; this.twups = [this]; this.errorJmp = null; - // TODO: hooks this.nny = 1; this.errfunc = 0; + + this.value = this; } } @@ -94,10 +97,10 @@ const stack_init = function(L1, L) { ** Create registry table and its predefined values */ const init_registry = function(L, g) { - let registry = new Table(); + let registry = new lobject.Table(); g.l_registry = registry; registry.value.set(lua.LUA_RIDX_MAINTHREAD - 1, L); - registry.value.set(lua.LUA_RIDX_GLOBALS - 1, new Table()); + registry.value.set(lua.LUA_RIDX_GLOBALS - 1, new lobject.Table()); }; /* @@ -113,11 +116,44 @@ const f_luaopen = function(L) { g.version = lapi.lua_version(null); }; +const preinit_thread = function(L, g) { + L.l_G = g; + L.stack = []; + L.ci = null; + L.nci = 0; + L.twups = [L]; /* thread has no upvalues */ + L.errorJmp = null; + L.nCcalls = 0; + L.hook = null; + L.hookmask = 0; + L.basehookcount = 0; + L.allowhook = 1; + L.hookcount = L.basehookcount; + L.openupval = []; + L.nny = 1; + L.status = TS.LUA_OK; + L.errfunc = 0; +}; + +const lua_newthread = function(L) { + let g = L.l_G; + let L1 = new lua_State(); + L.stack[L.top++] = L1; + assert(L.top <= L.ci.top, "stack overflow"); + preinit_thread(L1, g); + L1.hookmask = L.hookmask; + L1.basehookcount = L.basehookcount; + L1.hook = L.hook; + L1.hookcount = L1.basehookcount; + stack_init(L1, L); + return L1; +}; + const lua_newstate = function() { let L = new lua_State(); let g = new global_State(L); - L.l_G = g; + preinit_thread(L, g); if (luaD_rawrunprotected(L, f_luaopen, null) !== TS.LUA_OK) { L = null; @@ -137,4 +173,5 @@ module.exports.CIST_TAIL = (1<<5); /* call was tail called */ module.exports.CIST_HOOKYIELD = (1<<6); /* last hook called yielded */ module.exports.CIST_LEQ = (1<<7); /* using __lt for __le */ module.exports.CIST_FIN = (1<<8); /* call is running a finalizer */ -module.exports.lua_newstate = lua_newstate;
\ No newline at end of file +module.exports.lua_newstate = lua_newstate; +module.exports.lua_newthread = lua_newthread;
\ No newline at end of file diff --git a/src/lualib.js b/src/lualib.js index 1eff812..d87cfbc 100644 --- a/src/lualib.js +++ b/src/lualib.js @@ -7,5 +7,26 @@ const lua = require('./lua.js'); const LUA_VERSUFFIX = "_" + lua.LUA_VERSION_MAJOR + "_" + lua.LUA_VERSION_MINOR; +const LUA_COLIBNAME = "coroutine"; +const LUA_TABLIBNAME = "table" +const LUA_IOLIBNAME = "io" +const LUA_OSLIBNAME = "os" +const LUA_STRLIBNAME = "string" +const LUA_UTF8LIBNAME = "utf8" +const LUA_BITLIBNAME = "bit32" +const LUA_MATHLIBNAME = "math" +const LUA_DBLIBNAME = "debug" +const LUA_LOADLIBNAME = "package" -module.exports.LUA_VERSUFFIX = LUA_VERSUFFIX;
\ No newline at end of file + +module.exports.LUA_BITLIBNAME = LUA_BITLIBNAME; +module.exports.LUA_COLIBNAME = LUA_COLIBNAME; +module.exports.LUA_DBLIBNAME = LUA_DBLIBNAME; +module.exports.LUA_IOLIBNAME = LUA_IOLIBNAME; +module.exports.LUA_LOADLIBNAME = LUA_LOADLIBNAME; +module.exports.LUA_MATHLIBNAME = LUA_MATHLIBNAME; +module.exports.LUA_OSLIBNAME = LUA_OSLIBNAME; +module.exports.LUA_STRLIBNAME = LUA_STRLIBNAME; +module.exports.LUA_TABLIBNAME = LUA_TABLIBNAME; +module.exports.LUA_UTF8LIBNAME = LUA_UTF8LIBNAME; +module.exports.LUA_VERSUFFIX = LUA_VERSUFFIX;
\ No newline at end of file @@ -22,6 +22,65 @@ const ltm = require('./ltm.js'); const ltable = require('./ltable.js'); const ldebug = require('./ldebug.js'); +/* +** finish execution of an opcode interrupted by an yield +*/ +const luaV_finishOp = function(L) { + let ci = L.ci; + let base = ci.u.l.base; + let inst = ci.u.l.savedpc[ci.pcOff - 1]; /* interrupted instruction */ + let op = OC.OpCodes[inst.opcode]; + + switch (op) { /* finish its execution */ + case "OP_ADD": case "OP_SUB": case "OP_MUL": case "OP_DIV": case "OP_IDIV": + case "OP_BAND": case "OP_BOR": case "OP_BXOR": case "OP_SHL": case "OP_SHR": + case "OP_MOD": case "OP_POW": + case "OP_UNM": case "OP_BNOT": case "OP_LEN": + case "OP_GETTABUP": case "OP_GETTABLE": case "OP_SELF": { + L.stack[base + inst.A] = L.stack[--L.top]; + break; + } + case "OP_LE": case "OP_LT": case "OP_EQ": { + let res = !L.stack[L.top - 1].l_isfalse(); + L.top--; + if (ci.callstatus & lstate.CIST_LEQ) { /* "<=" using "<" instead? */ + assert(op === "OP_LE"); + ci.callstatus ^= lstate.CIST_LEQ; /* clear mark */ + res = res !== 1 ? 1 : 0; /* negate result */ + } + assert(OC.OpCodes[ci.u.l.savedpc[ci.pcOff]] === "OP_JMP"); + if (res !== inst.A) /* condition failed? */ + ci.pcOff++; /* skip jump instruction */ + break; + } + case "OP_CONCAT": { + let top = L.top - 1; /* top when 'luaT_trybinTM' was called */ + let b = inst.B; /* first element to concatenate */ + let total = top - 1 - (base + b); /* yet to concatenate */ + L.stack[L.top - 2] = L.stack[top]; /* put TM result in proper position */ + if (total > 1) { /* are there elements to concat? */ + L.top = top - 1; /* top is one after last element (at top-2) */ + luaV_concat(L, total); /* concat them (may yield again) */ + } + + /* move final result to final position */ + L.stack[ci.u.l.base + inst.A] = L.stack[L.top - 1]; + L.top = ci.top; /* restore top */ + break; + } + case "OP_TFORCALL": { + assert(OC.OpCodes[ci.u.l.savedpc[ci.pcOff]] === "OP_TFORLOOP"); + L.top = ci.top; /* correct top */ + break; + } + case "OP_CALL": { + if (inst.C - 1 >= 0) /* nresults >= 0? */ + L.top = ci.top; /* adjust results */ + break; + } + } +}; + const RA = function(L, base, i) { return base + i.A; }; @@ -1013,28 +1072,29 @@ const luaV_finishset = function(L, t, key, val, slot, recur) { } -module.exports.RA = RA; -module.exports.RB = RB; -module.exports.RC = RC; -module.exports.RKB = RKB; -module.exports.RKC = RKC; -module.exports.luaV_execute = luaV_execute; module.exports.dojump = dojump; module.exports.donextjump = donextjump; -module.exports.luaV_lessequal = luaV_lessequal; -module.exports.luaV_lessthan = luaV_lessthan; -module.exports.luaV_equalobj = luaV_equalobj; module.exports.forlimit = forlimit; -module.exports.luaV_tointeger = luaV_tointeger; -module.exports.tonumber = tonumber; -module.exports.tointeger = tointeger; -module.exports.LTnum = LTnum; -module.exports.LEnum = LEnum; +module.exports.gettable = gettable; +module.exports.l_strcmp = l_strcmp; module.exports.LEintfloat = LEintfloat; +module.exports.LEnum = LEnum; module.exports.LTintfloat = LTintfloat; -module.exports.l_strcmp = l_strcmp; -module.exports.luaV_objlen = luaV_objlen; +module.exports.LTnum = LTnum; +module.exports.luaV_concat = luaV_concat; +module.exports.luaV_equalobj = luaV_equalobj; +module.exports.luaV_execute = luaV_execute; +module.exports.luaV_finishOp = luaV_finishOp; module.exports.luaV_finishset = luaV_finishset; -module.exports.gettable = gettable; +module.exports.luaV_lessequal = luaV_lessequal; +module.exports.luaV_lessthan = luaV_lessthan; +module.exports.luaV_objlen = luaV_objlen; +module.exports.luaV_tointeger = luaV_tointeger; +module.exports.RA = RA; +module.exports.RB = RB; +module.exports.RC = RC; +module.exports.RKB = RKB; +module.exports.RKC = RKC; module.exports.settable = settable; -module.exports.luaV_concat = luaV_concat;
\ No newline at end of file +module.exports.tointeger = tointeger; +module.exports.tonumber = tonumber;
\ No newline at end of file |