diff options
| -rw-r--r-- | lualibs-lua.lua | 393 |
1 files changed, 393 insertions, 0 deletions
diff --git a/lualibs-lua.lua b/lualibs-lua.lua new file mode 100644 index 0000000..538c65d --- /dev/null +++ b/lualibs-lua.lua @@ -0,0 +1,393 @@ +if not modules then modules = { } end modules ['l-lua'] = { + version = 1.001, + comment = "companion to luat-lib.mkiv", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} + +-- compatibility hacks ... try to avoid usage + +local major, minor = string.match(_VERSION,"^[^%d]+(%d+)%.(%d+).*$") + +_MAJORVERSION = tonumber(major) or 5 +_MINORVERSION = tonumber(minor) or 1 +_LUAVERSION = _MAJORVERSION + _MINORVERSION/10 + +-- lpeg + +if not lpeg then + lpeg = require("lpeg") +end + +-- basics: + +if loadstring then + + local loadnormal = load + + function load(first,...) + if type(first) == "string" then + return loadstring(first,...) + else + return loadnormal(first,...) + end + end + +else + + loadstring = load + +end + +-- table: + +-- At some point it was announced that i[pairs would be dropped, which makes +-- sense. As we already used the for loop and # in most places the impact on +-- ConTeXt was not that large; the remaining ipairs already have been replaced. +-- Hm, actually ipairs was retained, but we no longer use it anyway (nor +-- pairs). +-- +-- Just in case, we provide the fallbacks as discussed in Programming +-- in Lua (http://www.lua.org/pil/7.3.html): + +if not ipairs then + + -- for k, v in ipairs(t) do ... end + -- for k=1,#t do local v = t[k] ... end + + local function iterate(a,i) + i = i + 1 + local v = a[i] + if v ~= nil then + return i, v --, nil + end + end + + function ipairs(a) + return iterate, a, 0 + end + +end + +if not pairs then + + -- for k, v in pairs(t) do ... end + -- for k, v in next, t do ... end + + function pairs(t) + return next, t -- , nil + end + +end + +-- The unpack function has been moved to the table table, and for compatiility +-- reasons we provide both now. + +if not table.unpack then + + table.unpack = _G.unpack + +elseif not unpack then + + _G.unpack = table.unpack + +end + +-- package: + +-- if not package.seachers then +-- +-- package.searchers = package.loaders -- 5.2 +-- +-- elseif not package.loaders then +-- +-- package.loaders = package.searchers +-- +-- end + +if not package.loaders then -- brr, searchers is a special "loadlib function" userdata type + + package.loaders = package.searchers + +end + +-- moved from util-deb to here: + +local print, select, tostring = print, select, tostring + +local inspectors = { } + +function setinspector(inspector) -- global function + inspectors[#inspectors+1] = inspector +end + +function inspect(...) -- global function + for s=1,select("#",...) do + local value = select(s,...) + local done = false + for i=1,#inspectors do + done = inspectors[i](value) + if done then + break + end + end + if not done then + print(tostring(value)) + end + end +end + +-- + +local dummy = function() end + +function optionalrequire(...) + local ok, result = xpcall(require,dummy,...) + if ok then + return result + end +end + +-- Code moved from data-lua and changed into a plug-in. + +-- We overload the regular loader. We do so because we operate mostly in +-- tds and use our own loader code. Alternatively we could use a more +-- extensive definition of package.path and package.cpath but even then +-- we're not done. Also, we now have better tracing. +-- +-- -- local mylib = require("libtest") +-- -- local mysql = require("luasql.mysql") + +local type = type +local gsub, format = string.gsub, string.format + +local package = package +local searchers = package.searchers or package.loaders + +local libpaths = nil +local clibpaths = nil +local libhash = { } +local clibhash = { } +local libextras = { } +local clibextras = { } + +-- dummies + +local filejoin = file and file.join or function(path,name) return path .. "/" .. name end +local isreadable = file and file.is_readable or function(name) local f = io.open(name) if f then f:close() return true end end +local addsuffix = file and file.addsuffix or function(name,suffix) return name .. "." .. suffix end + +-- + +local function cleanpath(path) -- hm, don't we have a helper for this? + return path +end + +local helpers = package.helpers or { + libpaths = function() return { } end, + clibpaths = function() return { } end, + cleanpath = cleanpath, + trace = false, + report = function(...) print(format(...)) end, +} +package.helpers = helpers + +local function getlibpaths() + return libpaths or helpers.libpaths(libhash) +end + +local function getclibpaths() + return clibpaths or helpers.clibpaths(clibhash) +end + +package.libpaths = getlibpaths +package.clibpaths = getclibpaths + +local function addpath(what,paths,extras,hash,...) + local pathlist = { ... } + local cleanpath = helpers.cleanpath + local trace = helpers.trace + local report = helpers.report + -- + local function add(path) + local path = cleanpath(path) + if not hash[path] then + if trace then + report("extra %s path: %s",what,path) + end + paths [#paths +1] = path + extras[#extras+1] = path + end + end + -- + for p=1,#pathlist do + local path = pathlist[p] + if type(path) == "table" then + for i=1,#path do + add(path[i]) + end + else + add(path) + end + end + return paths, extras +end + +function package.extralibpath(...) + libpaths, libextras = addpath("lua", getlibpaths(), libextras, libhash,...) +end + +function package.extraclibpath(...) + clibpaths, clibextras = addpath("lib",getclibpaths(),clibextras,clibhash,...) +end + +-- function package.extralibpath(...) +-- libpaths = getlibpaths() +-- local pathlist = { ... } +-- local cleanpath = helpers.cleanpath +-- local trace = helpers.trace +-- local report = helpers.report +-- -- +-- local function add(path) +-- local path = cleanpath(path) +-- if not libhash[path] then +-- if trace then +-- report("extra lua path: %s",path) +-- end +-- libextras[#libextras+1] = path +-- libpaths [#libpaths +1] = path +-- end +-- end +-- -- +-- for p=1,#pathlist do +-- local path = pathlist[p] +-- if type(path) == "table" then +-- for i=1,#path do +-- add(path[i]) +-- end +-- else +-- add(path) +-- end +-- end +-- end + +-- function package.extraclibpath(...) +-- clibpaths = getclibpaths() +-- local pathlist = { ... } +-- local cleanpath = helpers.cleanpath +-- local trace = helpers.trace +-- local report = helpers.report +-- -- +-- local function add(path) +-- local path = cleanpath(path) +-- if not clibhash[path] then +-- if trace then +-- report("extra lib path: %s",path) +-- end +-- clibextras[#clibextras+1] = path +-- clibpaths [#clibpaths +1] = path +-- end +-- end +-- -- +-- for p=1,#pathlist do +-- local path = pathlist[p] +-- if type(path) == "table" then +-- for i=1,#path do +-- add(path[i]) +-- end +-- else +-- add(path) +-- end +-- end +-- end + +if not searchers[-2] then + -- use package-path and package-cpath + searchers[-2] = searchers[2] +end + +searchers[2] = function(name) + return helpers.loaded(name) +end + +searchers[3] = nil -- get rid of the built in one + +local function loadedaslib(resolved,rawname) + -- local init = "luaopen_" .. string.match(rawname,".-([^%.]+)$") + local init = "luaopen_"..gsub(rawname,"%.","_") + if helpers.trace then + helpers.report("calling loadlib with '%s' with init '%s'",resolved,init) + end + return package.loadlib(resolved,init) +end + +local function loadedbylua(name) + if helpers.trace then + helpers.report("locating '%s' using normal loader",name) + end + return true, searchers[-2](name) -- the original +end + +local function loadedbypath(name,rawname,paths,islib,what) + local trace = helpers.trace + local report = helpers.report + if trace then + report("locating '%s' as '%s' on '%s' paths",rawname,name,what) + end + for p=1,#paths do + local path = paths[p] + local resolved = filejoin(path,name) + if trace then -- mode detail + report("checking for '%s' using '%s' path '%s'",name,what,path) + end + if isreadable(resolved) then + if trace then + report("lib '%s' located on '%s'",name,resolved) + end + if islib then + return true, loadedaslib(resolved,rawname) + else + return true, loadfile(resolved) + end + end + end +end + +local function notloaded(name) + if helpers.trace then + helpers.report("? unable to locate library '%s'",name) + end +end + +helpers.loadedaslib = loadedaslib +helpers.loadedbylua = loadedbylua +helpers.loadedbypath = loadedbypath +helpers.notloaded = notloaded + +-- alternatively we could set the package.searchers + +function helpers.loaded(name) + local thename = gsub(name,"%.","/") + local luaname = addsuffix(thename,"lua") + local libname = addsuffix(thename,os.libsuffix or "so") -- brrr + local libpaths = getlibpaths() + local clibpaths = getclibpaths() + local done, result = loadedbypath(luaname,name,libpaths,false,"lua") + if done then + return result + end + local done, result = loadedbypath(luaname,name,clibpaths,false,"lua") + if done then + return result + end + local done, result = loadedbypath(libname,name,clibpaths,true,"lib") + if done then + return result + end + local done, result = loadedbylua(name) + if done then + return result + end + return notloaded(name) +end |