From 06ec7904c37b897b2e87f4321198926ff22da1d9 Mon Sep 17 00:00:00 2001 From: Benoit Giannangeli Date: Fri, 17 Feb 2017 16:04:42 +0100 Subject: Basis to load std lib --- src/lauxlib.js | 142 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 139 insertions(+), 3 deletions(-) (limited to 'src/lauxlib.js') diff --git a/src/lauxlib.js b/src/lauxlib.js index 6cc3d3c..af09df7 100644 --- a/src/lauxlib.js +++ b/src/lauxlib.js @@ -5,6 +5,8 @@ const assert = require('assert'); const lstate = require('./lstate.js'); const lapi = require('./lapi.js'); +const lua = require('./lua.js'); +const CT = lua.constant_types; const panic = function(L) { console.log(`PANIC: unprotected error in call to Lua API (...)`); @@ -20,8 +22,142 @@ const luaL_newstate = function() { const luaL_typename = function(L, i) { return lapi.lua_typename(L, lapi.lua_type(L, i)); -} +}; + +const luaL_checkany = function(L, arg) { + if (lapi.lua_type(L, arg) === CT.LUA_TNONE) + throw new Error("value expected"); // TODO: luaL_argerror(L, arg, "value expected"); +}; + +const luaL_getmetafield = function(L, obj, event) { + if (!lapi.lua_getmetatable(L, obj)) + return CT.LUA_TNIL; + else { + lapi.lua_pushstring(L, event); + let tt = lapi.lua_rawget(L, -2); + if (tt === CT.LUA_TNIL) + lapi.lua_pop(L, 2); + return tt; + } +}; + +const luaL_callmeta = function(L, obj, event) { + obj = lapi.lua_absindex(L, obj); + if (luaL_getmetafield(L, obj, event) === CT.LUA_TNIL) + return false; + + lapi.lua_pushvalue(L, obj); + lapi.lua_call(L, 1, 1); + + return true; +}; +const luaL_tolstring = function(L, idx, len) { + if (luaL_callmeta(L, idx, "__tostring")) { + if (!lapi.lua_isstring(L, -1)) + throw new Error("'__tostring' must return a string"); // TODO: luaL_error + } else { + switch(lapi.lua_type(L, idx)) { + case CT.LUA_TNUMBER: + case CT.LUA_TSTRING: + case CT.LUA_TBOOLEAN: + lapi.lua_pushstring(L, `${lapi.index2addr(L, idx).value}`); + break; + case CT.LUA_TNIL: + lapi.lua_pushstring(L, `nil`); + break; + default: + let tt = luaL_getmetafield(L, idx, "__name"); + let kind = tt === CT.LUA_TSTRING ? lua_tostring(L, -1) : luaL_typename(L, idx); + lapi.lua_pushstring(L, `${kind}`); // We can't print memory address in JS + if (tt !== CT.LUA_TNIL) + lapi.lua_remove(L, -2); + break; + } + } + + return lapi.lua_tolstring(L, -1, len); +}; + +/* +** 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. +*/ +const luaL_requiref = function(L, modname, openf, glb) { + luaL_getsubtable(L, lua.LUA_REGISTRYINDEX, lua.LUA_LOADED_TABLE); + lapi.lua_getfield(L, -1, modname); /* LOADED[modname] */ + if (!lapi.lua_toboolean(L, -1)) { /* package not already loaded? */ + lapi.lua_pop(L, 1); /* remove field */ + lapi.lua_pushcfunction(L, openf); + lapi.lua_pushstring(L, modname); /* argument to open function */ + lapi.lua_call(L, 1, 1); /* call 'openf' to open module */ + lapi.lua_pushvalue(L, -1); /* make copy of module (call result) */ + lapi.lua_setfield(L, -3, modname); /* LOADED[modname] = module */ + } + lapi.lua_remove(L, -2); /* remove LOADED table */ + if (glb) { + lua_pushvalue(L, -1); /* copy of module */ + lua_setglobal(L, modname); /* _G[modname] = module */ + } +}; + +/* +** ensure that stack[idx][fname] has a table and push that table +** into the stack +*/ +const luaL_getsubtable = function(L, idx, fname) { + if (lapi.lua_getfield(L, idx, fname) === CT.LUA_TTABLE) + return true; /* table already there */ + else { + lapi.lua_pop(L, 1); /* remove previous result */ + idx = lapi.lua_absindex(L, idx); + lapi.lua_newtable(L); + lapi.lua_pushvalue(L, -1); /* copy to be left at top */ + lapi.lua_setfield(L, idx, fname); /* assign new table to field */ + return false; /* false, because did not find table there */ + } +}; + +/* +** 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. +*/ +const luaL_setfuncs = function(L, l, nup) { + luaL_checkstack(L, nup, "too many upvalues"); + for (lib in l) { /* fill the table with given functions */ + for (let i = 0; i < nup; i++) /* copy upvalues to the top */ + lapi.lua_pushvalue(L, -nup); + lapi.lua_pushcclosure(L, l[lib], nup); /* closure with those upvalues */ + lapi.lua_setfield(L, -(nup + 2), lib); + } + lapi.lua_pop(l, nup); /* remove upvalues */ +}; + +/* +** 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'.) +*/ +const luaL_checkstack = function(L, space, msg) { + if (!lapi.luaL_checkstack(L, space)) { + if (msg) + throw new Error(L, `stack overflow (${msg})`); + else + throw new Error(L, 'stack overflow'); // TODO: luaL_error + } +}; -module.exports.luaL_newstate = luaL_newstate; -module.exports.luaL_typename = luaL_typename; \ No newline at end of file +module.exports.luaL_newstate = luaL_newstate; +module.exports.luaL_typename = luaL_typename; +module.exports.luaL_checkany = luaL_checkany; +module.exports.luaL_callmeta = luaL_callmeta; +module.exports.luaL_getmetafield = luaL_getmetafield; +module.exports.luaL_requiref = luaL_requiref; +module.exports.luaL_getsubtable = luaL_getsubtable; +module.exports.luaL_setfuncs = luaL_setfuncs; +module.exports.luaL_checkstack = luaL_checkstack; \ No newline at end of file -- cgit v1.2.3-54-g00ecf