| Current Path : /bin/ |
Linux ift1.ift-informatik.de 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64 |
| Current File : //bin/mtxrun |
#!/usr/bin/env texlua
if not modules then modules = { } end modules ['mtxrun'] = {
version = 1.001,
comment = "runner, lua replacement for texmfstart.rb",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
license = "see context related readme files"
}
-- one can make a stub:
-- mtxrun :
--
-- #!/bin/sh
-- env LUATEXDIR=/....../texmf/scripts/context/lua luatex --luaonly mtxrun.lua "$@"
-- mtxrun.cmd :
--
-- @luatex --luaonly %~d0%~p0mtxrun.lua %*
-- filename : mtxrun.lua
-- comment : companion to context.tex
-- author : Hans Hagen, PRAGMA-ADE, Hasselt NL
-- copyright: PRAGMA ADE / ConTeXt Development Team
-- license : see context related readme files
-- This script is based on texmfstart.rb but does not use kpsewhich to locate files.
-- Although kpse is a library it never came to opening up its interface to other
-- programs (esp scripting languages) and so we do it ourselves. The lua variant
-- evolved out of an experimental ruby one. Interesting is that using a scripting
-- language instead of c does not have a speed penalty. Actually the lua variant is
-- more efficient, especially when multiple calls to kpsewhich are involved. The lua
-- library also gives way more control.
-- When libraries used here are updates you can run
--
-- mtxrun --selfmerge
--
-- to update the embedded code. After that you might need to run
--
-- mtxrun --selfupdate
--
-- to copy the new script (from scripts/context/lua) to location where
-- binaries are expected. If you want to remove the embedded code you can run
--
-- mtxxun --selfclean
-- to be done / considered
--
-- support for --exec or make it default
-- support for jar files (or maybe not, never used, too messy)
-- support for $RUBYINPUTS cum suis (if still needed)
-- remember for subruns: _CTX_K_V_#{original}_
-- remember for subruns: _CTX_K_S_#{original}_
-- remember for subruns: TEXMFSTART.#{original} [tex.rb texmfstart.rb]
-- begin library merge
do -- create closure to overcome 200 locals limit
package.loaded["l-bit32"] = package.loaded["l-bit32"] or true
-- original size: 3607, stripped down to: 3009
if not modules then modules={} end modules ['l-bit32']={
version=1.001,
license="the same as regular Lua",
source="bitwise.lua, v 1.24 2014/12/26 17:20:53 roberto",
comment="drop-in for bit32, adapted a bit by Hans Hagen",
}
if bit32 then
elseif utf8 then
load ([[
local select = select -- instead of: arg = { ... }
bit32 = {
bnot = function (a)
return ~a & 0xFFFFFFFF
end,
band = function (x, y, z, ...)
if not z then
return ((x or -1) & (y or -1)) & 0xFFFFFFFF
else
local res = x & y & z
for i=1,select("#",...) do
res = res & select(i,...)
end
return res & 0xFFFFFFFF
end
end,
bor = function (x, y, z, ...)
if not z then
return ((x or 0) | (y or 0)) & 0xFFFFFFFF
else
local res = x | y | z
for i=1,select("#",...) do
res = res | select(i,...)
end
return res & 0xFFFFFFFF
end
end,
bxor = function (x, y, z, ...)
if not z then
return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
else
local res = x ~ y ~ z
for i=1,select("#",...) do
res = res ~ select(i,...)
end
return res & 0xFFFFFFFF
end
end,
btest = function (x, y, z, ...)
if not z then
return (((x or -1) & (y or -1)) & 0xFFFFFFFF) ~= 0
else
local res = x & y & z
for i=1,select("#",...) do
res = res & select(i,...)
end
return (res & 0xFFFFFFFF) ~= 0
end
end,
lshift = function (a, b)
return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
end,
rshift = function (a, b)
return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
end,
arshift = function (a, b)
a = a & 0xFFFFFFFF
if b <= 0 or (a & 0x80000000) == 0 then
return (a >> b) & 0xFFFFFFFF
else
return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
end
end,
lrotate = function (a ,b)
b = b & 31
a = a & 0xFFFFFFFF
a = (a << b) | (a >> (32 - b))
return a & 0xFFFFFFFF
end,
rrotate = function (a, b)
b = -b & 31
a = a & 0xFFFFFFFF
a = (a << b) | (a >> (32 - b))
return a & 0xFFFFFFFF
end,
extract = function (a, f, w)
return (a >> f) & ~(-1 << (w or 1))
end,
replace = function (a, v, f, w)
local mask = ~(-1 << (w or 1))
return ((a & ~(mask << f)) | ((v & mask) << f)) & 0xFFFFFFFF
end,
}
]] ) ()
elseif bit then
load ([[
local band, bnot, rshift, lshift = bit.band, bit.bnot, bit.rshift, bit.lshift
bit32 = {
arshift = bit.arshift,
band = band,
bnot = bnot,
bor = bit.bor,
bxor = bit.bxor,
btest = function(...)
return band(...) ~= 0
end,
extract = function(a,f,w)
return band(rshift(a,f),2^(w or 1)-1)
end,
lrotate = bit.rol,
lshift = lshift,
replace = function(a,v,f,w)
local mask = 2^(w or 1)-1
return band(a,bnot(lshift(mask,f)))+lshift(band(v,mask),f)
end,
rrotate = bit.ror,
rshift = rshift,
}
]] ) ()
else
xpcall(function() local _,t=require("bit32") if t then bit32=t end return end,function() end)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-lua"] = package.loaded["l-lua"] or true
-- original size: 6330, stripped down to: 2831
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"
}
local next,type,tonumber=next,type,tonumber
LUAMAJORVERSION,LUAMINORVERSION=string.match(_VERSION,"^[^%d]+(%d+)%.(%d+).*$")
LUAMAJORVERSION=tonumber(LUAMAJORVERSION) or 5
LUAMINORVERSION=tonumber(LUAMINORVERSION) or 1
LUAVERSION=LUAMAJORVERSION+LUAMINORVERSION/10
if LUAVERSION<5.2 and jit then
MINORVERSION=2
LUAVERSION=5.2
end
if not lpeg then
lpeg=require("lpeg")
end
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
if not ipairs then
local function iterate(a,i)
i=i+1
local v=a[i]
if v~=nil then
return i,v
end
end
function ipairs(a)
return iterate,a,0
end
end
if not pairs then
function pairs(t)
return next,t
end
end
if not table.unpack then
table.unpack=_G.unpack
elseif not unpack then
_G.unpack=table.unpack
end
if not package.loaders then
package.loaders=package.searchers
end
local print,select,tostring=print,select,tostring
local inspectors={}
function setinspector(kind,inspector)
inspectors[kind]=inspector
end
function inspect(...)
for s=1,select("#",...) do
local value=select(s,...)
if value==nil then
print("nil")
else
local done=false
local kind=type(value)
local inspector=inspectors[kind]
if inspector then
done=inspector(value)
if done then
break
end
end
for kind,inspector in next,inspectors do
done=inspector(value)
if done then
break
end
end
if not done then
print(tostring(value))
end
end
end
end
local dummy=function() end
function optionalrequire(...)
local ok,result=xpcall(require,dummy,...)
if ok then
return result
end
end
if lua then
lua.mask=load([[τεχ = 1]]) and "utf" or "ascii"
end
local flush=io.flush
if flush then
local execute=os.execute if execute then function os.execute(...) flush() return execute(...) end end
local exec=os.exec if exec then function os.exec (...) flush() return exec (...) end end
local spawn=os.spawn if spawn then function os.spawn (...) flush() return spawn (...) end end
local popen=io.popen if popen then function io.popen (...) flush() return popen (...) end end
end
FFISUPPORTED=type(ffi)=="table" and ffi.os~="" and ffi.arch~="" and ffi.load
if not FFISUPPORTED then
local okay;okay,ffi=pcall(require,"ffi")
FFISUPPORTED=type(ffi)=="table" and ffi.os~="" and ffi.arch~="" and ffi.load
end
if not FFISUPPORTED then
ffi=nil
elseif not ffi.number then
ffi.number=tonumber
end
if LUAVERSION>5.3 then
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-macro"] = package.loaded["l-macro"] or true
-- original size: 10131, stripped down to: 5991
if not modules then modules={} end modules ['l-macros']={
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"
}
local S,P,R,V,C,Cs,Cc,Ct,Carg=lpeg.S,lpeg.P,lpeg.R,lpeg.V,lpeg.C,lpeg.Cs,lpeg.Cc,lpeg.Ct,lpeg.Carg
local lpegmatch=lpeg.match
local concat=table.concat
local format,sub,match=string.format,string.sub,string.match
local next,load,type=next,load,type
local newline=S("\n\r")^1
local continue=P("\\")*newline
local whitespace=S(" \t\n\r")
local spaces=S(" \t")+continue
local nametoken=R("az","AZ","__","09")
local name=nametoken^1
local body=((continue/""+1)-newline)^1
local lparent=P("(")
local rparent=P(")")
local noparent=1-(lparent+rparent)
local nested=P { lparent*(noparent+V(1))^0*rparent }
local escaped=P("\\")*P(1)
local squote=P("'")
local dquote=P('"')
local quoted=dquote*(escaped+(1-dquote))^0*dquote+squote*(escaped+(1-squote))^0*squote
local arguments=lparent*Ct((Cs((nested+(quoted+1-S("),")))^1)+S(", "))^0)*rparent
local macros=lua.macros or {}
lua.macros=macros
local patterns={}
local definitions={}
local resolve
local subparser
local report_lua=function(...)
if logs and logs.reporter then
report_lua=logs.reporter("system","lua")
report_lua(...)
else
print(format(...))
end
end
local safeguard=P("local")*whitespace^1*name*(whitespace+P("="))
resolve=safeguard+C(C(name)*(arguments^-1))/function(raw,s,a)
local d=definitions[s]
if d then
if a then
local n=#a
local p=patterns[s][n]
if p then
local d=d[n]
for i=1,n do
a[i]=lpegmatch(subparser,a[i]) or a[i]
end
return lpegmatch(p,d,1,a) or d
else
return raw
end
else
return d[0] or raw
end
elseif a then
for i=1,#a do
a[i]=lpegmatch(subparser,a[i]) or a[i]
end
return s.."("..concat(a,",")..")"
else
return raw
end
end
subparser=Cs((resolve+P(1))^1)
local enddefine=P("#enddefine")/""
local beginregister=(C(name)*(arguments+Cc(false))*C((1-enddefine)^1)*enddefine)/function(k,a,v)
local n=0
if a then
n=#a
local pattern=P(false)
for i=1,n do
pattern=pattern+(P(a[i])*Carg(1))/function(t) return t[i] end
end
pattern=Cs((pattern+P(1))^1)
local p=patterns[k]
if not p then
p={ [0]=false,false,false,false,false,false,false,false,false }
patterns[k]=p
end
p[n]=pattern
end
local d=definitions[k]
if not d then
d={ a=a,[0]=false,false,false,false,false,false,false,false,false }
definitions[k]=d
end
d[n]=lpegmatch(subparser,v) or v
return ""
end
local register=(Cs(name)*(arguments+Cc(false))*spaces^0*Cs(body))/function(k,a,v)
local n=0
if a then
n=#a
local pattern=P(false)
for i=1,n do
pattern=pattern+(P(a[i])*Carg(1))/function(t) return t[i] end
end
pattern=Cs((pattern+P(1))^1)
local p=patterns[k]
if not p then
p={ [0]=false,false,false,false,false,false,false,false,false }
patterns[k]=p
end
p[n]=pattern
end
local d=definitions[k]
if not d then
d={ a=a,[0]=false,false,false,false,false,false,false,false,false }
definitions[k]=d
end
d[n]=lpegmatch(subparser,v) or v
return ""
end
local unregister=(C(name)*spaces^0*(arguments+Cc(false)))/function(k,a)
local n=0
if a then
n=#a
local p=patterns[k]
if p then
p[n]=false
end
end
local d=definitions[k]
if d then
d[n]=false
end
return ""
end
local begindefine=(P("begindefine")*spaces^0/"")*beginregister
local define=(P("define" )*spaces^0/"")*register
local undefine=(P("undefine" )*spaces^0/"")*unregister
local parser=Cs((((P("#")/"")*(define+begindefine+undefine)*(newline^0/"") )+resolve+P(1) )^0 )
function macros.reset()
definitions={}
patterns={}
end
function macros.showdefinitions()
for name,list in table.sortedhash(definitions) do
local arguments=list.a
if arguments then
arguments="("..concat(arguments,",")..")"
else
arguments=""
end
print("macro: "..name..arguments)
for i=0,#list do
local l=list[i]
if l then
print(" "..l)
end
end
end
end
function macros.resolvestring(str)
return lpegmatch(parser,str) or str
end
function macros.resolving()
return next(patterns)
end
local function reload(path,name,data)
local only=match(name,".-([^/]+)%.lua")
if only and only~="" then
local name=path.."/"..only
local f=io.open(name,"wb")
f:write(data)
f:close()
local f=loadfile(name)
os.remove(name)
return f
end
end
local function reload(path,name,data)
if path and path~="" then
local only=string.match(name,".-([^/]+)%.lua")
if only and only~="" then
local name=path.."/"..only.."-macro.lua"
local f=io.open(name,"wb")
if f then
f:write(data)
f:close()
local l=loadfile(name)
os.remove(name)
return l
end
end
end
return load(data,name)
end
local function loaded(name,trace,detail)
local f=io.open(name,"rb")
if not f then
return false,format("file '%s' not found",name)
end
local c=f:read("*a")
if not c then
return false,format("file '%s' is invalid",name)
end
f:close()
local n=lpegmatch(parser,c)
if trace then
if #n~=#c then
report_lua("macros expanded in '%s' (%i => %i bytes)",name,#c,#n)
if detail then
report_lua()
report_lua(n)
report_lua()
end
elseif detail then
report_lua("no macros expanded in '%s'",name)
end
end
return reload(lfs and lfs.currentdir(),name,n)
end
macros.loaded=loaded
function required(name,trace)
local filename=file.addsuffix(name,"lua")
local fullname=resolvers and resolvers.find_file(filename) or filename
if not fullname or fullname=="" then
return false
end
local codeblob=package.loaded[fullname]
if codeblob then
return codeblob
end
local code,message=loaded(fullname,macros,trace,trace)
if type(code)=="function" then
code=code()
else
report_lua("error when loading '%s'",fullname)
return false,message
end
if code==nil then
code=false
end
package.loaded[fullname]=code
return code
end
macros.required=required
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-sandbox"] = package.loaded["l-sandbox"] or true
-- original size: 9747, stripped down to: 6313
if not modules then modules={} end modules ['l-sandbox']={
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"
}
local global=_G
local next=next
local unpack=unpack or table.unpack
local type=type
local tprint=texio and texio.write_nl or print
local tostring=tostring
local format=string.format
local concat=table.concat
local sort=table.sort
local gmatch=string.gmatch
local gsub=string.gsub
local requiem=require
sandbox={}
local sandboxed=false
local overloads={}
local skiploads={}
local initializers={}
local finalizers={}
local originals={}
local comments={}
local trace=false
local logger=false
local blocked={}
local function report(...)
tprint("sandbox ! "..format(...))
end
sandbox.report=report
function sandbox.setreporter(r)
report=r
sandbox.report=r
end
function sandbox.settrace(v)
trace=v
end
function sandbox.setlogger(l)
logger=type(l)=="function" and l or false
end
local function register(func,overload,comment)
if type(func)=="function" then
if type(overload)=="string" then
comment=overload
overload=nil
end
local function f(...)
if sandboxed then
local overload=overloads[f]
if overload then
if logger then
local result={ overload(func,...) }
logger {
comment=comments[f] or tostring(f),
arguments={... },
result=result[1] and true or false,
}
return unpack(result)
else
return overload(func,...)
end
else
end
else
return func(...)
end
end
if comment then
comments[f]=comment
if trace then
report("registering function: %s",comment)
end
end
overloads[f]=overload or false
originals[f]=func
return f
end
end
local function redefine(func,comment)
if type(func)=="function" then
skiploads[func]=comment or comments[func] or "unknown"
if overloads[func]==false then
overloads[func]=nil
end
end
end
sandbox.register=register
sandbox.redefine=redefine
function sandbox.original(func)
return originals and originals[func] or func
end
function sandbox.overload(func,overload,comment)
comment=comment or comments[func] or "?"
if type(func)~="function" then
if trace then
report("overloading unknown function: %s",comment)
end
elseif type(overload)~="function" then
if trace then
report("overloading function with bad overload: %s",comment)
end
elseif overloads[func]==nil then
if trace then
report("function is not registered: %s",comment)
end
elseif skiploads[func] then
if trace then
report("function is not skipped: %s",comment)
end
else
if trace then
report("overloading function: %s",comment)
end
overloads[func]=overload
end
return func
end
local function whatever(specification,what,target)
if type(specification)~="table" then
report("%s needs a specification",what)
elseif type(specification.category)~="string" or type(specification.action)~="function" then
report("%s needs a category and action",what)
elseif not sandboxed then
target[#target+1]=specification
elseif trace then
report("already enabled, discarding %s",what)
end
end
function sandbox.initializer(specification)
whatever(specification,"initializer",initializers)
end
function sandbox.finalizer(specification)
whatever(specification,"finalizer",finalizers)
end
function require(name)
local n=gsub(name,"^.*[\\/]","")
local n=gsub(n,"[%.].*$","")
local b=blocked[n]
if b==false then
return nil
elseif b then
if trace then
report("using blocked: %s",n)
end
return b
else
if trace then
report("requiring: %s",name)
end
return requiem(name)
end
end
function blockrequire(name,lib)
if trace then
report("preventing reload of: %s",name)
end
blocked[name]=lib or _G[name] or false
end
function sandbox.enable()
if not sandboxed then
debug={
traceback=debug.traceback,
}
for i=1,#initializers do
initializers[i].action()
end
for i=1,#finalizers do
finalizers[i].action()
end
local nnot=0
local nyes=0
local cnot={}
local cyes={}
local skip={}
for k,v in next,overloads do
local c=comments[k]
if v then
if c then
cyes[#cyes+1]=c
else
nyes=nyes+1
end
else
if c then
cnot[#cnot+1]=c
else
nnot=nnot+1
end
end
end
for k,v in next,skiploads do
skip[#skip+1]=v
end
if #cyes>0 then
sort(cyes)
report("overloaded known: %s",concat(cyes," | "))
end
if nyes>0 then
report("overloaded unknown: %s",nyes)
end
if #cnot>0 then
sort(cnot)
report("not overloaded known: %s",concat(cnot," | "))
end
if nnot>0 then
report("not overloaded unknown: %s",nnot)
end
if #skip>0 then
sort(skip)
report("not overloaded redefined: %s",concat(skip," | "))
end
initializers=nil
finalizers=nil
originals=nil
sandboxed=true
end
end
blockrequire("lfs",lfs)
blockrequire("io",io)
blockrequire("os",os)
blockrequire("ffi",ffi)
local function supported(library)
local l=_G[library]
return l
end
loadfile=register(loadfile,"loadfile")
if supported("io") then
io.open=register(io.open,"io.open")
io.popen=register(io.popen,"io.popen")
io.lines=register(io.lines,"io.lines")
io.output=register(io.output,"io.output")
io.input=register(io.input,"io.input")
end
if supported("os") then
os.execute=register(os.execute,"os.execute")
os.spawn=register(os.spawn,"os.spawn")
os.exec=register(os.exec,"os.exec")
os.rename=register(os.rename,"os.rename")
os.remove=register(os.remove,"os.remove")
end
if supported("lfs") then
lfs.chdir=register(lfs.chdir,"lfs.chdir")
lfs.mkdir=register(lfs.mkdir,"lfs.mkdir")
lfs.rmdir=register(lfs.rmdir,"lfs.rmdir")
lfs.isfile=register(lfs.isfile,"lfs.isfile")
lfs.isdir=register(lfs.isdir,"lfs.isdir")
lfs.attributes=register(lfs.attributes,"lfs.attributes")
lfs.dir=register(lfs.dir,"lfs.dir")
lfs.lock_dir=register(lfs.lock_dir,"lfs.lock_dir")
lfs.touch=register(lfs.touch,"lfs.touch")
lfs.link=register(lfs.link,"lfs.link")
lfs.setmode=register(lfs.setmode,"lfs.setmode")
lfs.readlink=register(lfs.readlink,"lfs.readlink")
lfs.shortname=register(lfs.shortname,"lfs.shortname")
lfs.symlinkattributes=register(lfs.symlinkattributes,"lfs.symlinkattributes")
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-package"] = package.loaded["l-package"] or true
-- original size: 11605, stripped down to: 8299
if not modules then modules={} end modules ['l-package']={
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"
}
local type=type
local gsub,format,find=string.gsub,string.format,string.find
local insert,remove=table.insert,table.remove
local P,S,Cs,lpegmatch=lpeg.P,lpeg.S,lpeg.Cs,lpeg.match
local package=package
local searchers=package.searchers or package.loaders
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)
return path
end
local pattern=Cs((((1-S("\\/"))^0*(S("\\/")^1/"/"))^0*(P(".")^1/"/"+P(1))^1)*-1)
local function lualibfile(name)
return lpegmatch(pattern,name) or name
end
local offset=luarocks and 1 or 0
local helpers=package.helpers or {
cleanpath=cleanpath,
lualibfile=lualibfile,
trace=false,
report=function(...) print(format(...)) end,
builtin={
["preload table"]=searchers[1+offset],
["path specification"]=searchers[2+offset],
["cpath specification"]=searchers[3+offset],
["all in one fallback"]=searchers[4+offset],
},
methods={},
sequence={
"already loaded",
"preload table",
"qualified path",
"lua extra list",
"lib extra list",
"path specification",
"cpath specification",
"all in one fallback",
"not loaded",
}
}
package.helpers=helpers
local methods=helpers.methods
local builtin=helpers.builtin
local extraluapaths={}
local extralibpaths={}
local luapaths=nil
local libpaths=nil
local oldluapath=nil
local oldlibpath=nil
local nofextralua=-1
local nofextralib=-1
local nofpathlua=-1
local nofpathlib=-1
local function listpaths(what,paths)
local nofpaths=#paths
if nofpaths>0 then
for i=1,nofpaths do
helpers.report("using %s path %i: %s",what,i,paths[i])
end
else
helpers.report("no %s paths defined",what)
end
return nofpaths
end
local function getextraluapaths()
if helpers.trace and #extraluapaths~=nofextralua then
nofextralua=listpaths("extra lua",extraluapaths)
end
return extraluapaths
end
local function getextralibpaths()
if helpers.trace and #extralibpaths~=nofextralib then
nofextralib=listpaths("extra lib",extralibpaths)
end
return extralibpaths
end
local function getluapaths()
local luapath=package.path or ""
if oldluapath~=luapath then
luapaths=file.splitpath(luapath,";")
oldluapath=luapath
nofpathlua=-1
end
if helpers.trace and #luapaths~=nofpathlua then
nofpathlua=listpaths("builtin lua",luapaths)
end
return luapaths
end
local function getlibpaths()
local libpath=package.cpath or ""
if oldlibpath~=libpath then
libpaths=file.splitpath(libpath,";")
oldlibpath=libpath
nofpathlib=-1
end
if helpers.trace and #libpaths~=nofpathlib then
nofpathlib=listpaths("builtin lib",libpaths)
end
return libpaths
end
package.luapaths=getluapaths
package.libpaths=getlibpaths
package.extraluapaths=getextraluapaths
package.extralibpaths=getextralibpaths
local hashes={
lua={},
lib={},
}
local function registerpath(tag,what,target,...)
local pathlist={... }
local cleanpath=helpers.cleanpath
local trace=helpers.trace
local report=helpers.report
local hash=hashes[what]
local function add(path)
local path=cleanpath(path)
if not hash[path] then
target[#target+1]=path
hash[path]=true
if trace then
report("registered %s path %s: %s",tag,#target,path)
end
else
if trace then
report("duplicate %s path: %s",tag,path)
end
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
local function pushpath(tag,what,target,path)
local path=helpers.cleanpath(path)
insert(target,1,path)
if helpers.trace then
helpers.report("pushing %s path in front: %s",tag,path)
end
end
local function poppath(tag,what,target)
local path=remove(target,1)
if helpers.trace then
if path then
helpers.report("popping %s path from front: %s",tag,path)
else
helpers.report("no %s path to pop",tag)
end
end
end
helpers.registerpath=registerpath
function package.extraluapath(...)
registerpath("extra lua","lua",extraluapaths,...)
end
function package.pushluapath(path)
pushpath("extra lua","lua",extraluapaths,path)
end
function package.popluapath()
poppath("extra lua","lua",extraluapaths)
end
function package.extralibpath(...)
registerpath("extra lib","lib",extralibpaths,...)
end
function package.pushlibpath(path)
pushpath("extra lib","lib",extralibpaths,path)
end
function package.poplibpath()
poppath("extra lib","lua",extralibpaths)
end
local function loadedaslib(resolved,rawname)
local base=gsub(rawname,"%.","_")
local init="luaopen_"..gsub(base,"%.","_")
if helpers.trace then
helpers.report("calling loadlib with '%s' with init '%s'",resolved,init)
end
return package.loadlib(resolved,init)
end
helpers.loadedaslib=loadedaslib
local function loadedbypath(name,rawname,paths,islib,what)
local trace=helpers.trace
for p=1,#paths do
local path=paths[p]
local resolved=filejoin(path,name)
if trace then
helpers.report("%s path, identifying '%s' on '%s'",what,name,path)
end
if isreadable(resolved) then
if trace then
helpers.report("%s path, '%s' found on '%s'",what,name,resolved)
end
if islib then
return loadedaslib(resolved,rawname)
else
return loadfile(resolved)
end
end
end
end
helpers.loadedbypath=loadedbypath
local function loadedbyname(name,rawname)
if find(name,"^/") or find(name,"^[a-zA-Z]:/") then
local trace=helpers.trace
if trace then
helpers.report("qualified name, identifying '%s'",what,name)
end
if isreadable(name) then
if trace then
helpers.report("qualified name, '%s' found",what,name)
end
return loadfile(name)
end
end
end
helpers.loadedbyname=loadedbyname
methods["already loaded"]=function(name)
return package.loaded[name]
end
methods["preload table"]=function(name)
return builtin["preload table"](name)
end
methods["qualified path"]=function(name)
return loadedbyname(addsuffix(lualibfile(name),"lua"),name)
end
methods["lua extra list"]=function(name)
return loadedbypath(addsuffix(lualibfile(name),"lua"),name,getextraluapaths(),false,"lua")
end
methods["lib extra list"]=function(name)
return loadedbypath(addsuffix(lualibfile(name),os.libsuffix),name,getextralibpaths(),true,"lib")
end
methods["path specification"]=function(name)
getluapaths()
return builtin["path specification"](name)
end
methods["cpath specification"]=function(name)
getlibpaths()
return builtin["cpath specification"](name)
end
methods["all in one fallback"]=function(name)
return builtin["all in one fallback"](name)
end
methods["not loaded"]=function(name)
if helpers.trace then
helpers.report("unable to locate '%s'",name or "?")
end
return nil
end
local level=0
local used={}
helpers.traceused=false
function helpers.loaded(name)
local sequence=helpers.sequence
level=level+1
for i=1,#sequence do
local method=sequence[i]
if helpers.trace then
helpers.report("%s, level '%s', method '%s', name '%s'","locating",level,method,name)
end
local result,rest=methods[method](name)
if type(result)=="function" then
if helpers.trace then
helpers.report("%s, level '%s', method '%s', name '%s'","found",level,method,name)
end
if helpers.traceused then
used[#used+1]={ level=level,name=name }
end
level=level-1
return result,rest
end
end
level=level-1
return nil
end
function helpers.showused()
local n=#used
if n>0 then
helpers.report("%s libraries loaded:",n)
helpers.report()
for i=1,n do
local u=used[i]
helpers.report("%i %a",u.level,u.name)
end
helpers.report()
end
end
function helpers.unload(name)
if helpers.trace then
if package.loaded[name] then
helpers.report("unloading, name '%s', %s",name,"done")
else
helpers.report("unloading, name '%s', %s",name,"not loaded")
end
end
package.loaded[name]=nil
end
table.insert(searchers,1,helpers.loaded)
if context then
package.path=""
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-lpeg"] = package.loaded["l-lpeg"] or true
-- original size: 38434, stripped down to: 19310
if not modules then modules={} end modules ['l-lpeg']={
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"
}
lpeg=require("lpeg")
local lpeg=lpeg
if not lpeg.print then function lpeg.print(...) print(lpeg.pcode(...)) end end
local type,next,tostring=type,next,tostring
local byte,char,gmatch,format=string.byte,string.char,string.gmatch,string.format
local floor=math.floor
local P,R,S,V,Ct,C,Cs,Cc,Cp,Cmt=lpeg.P,lpeg.R,lpeg.S,lpeg.V,lpeg.Ct,lpeg.C,lpeg.Cs,lpeg.Cc,lpeg.Cp,lpeg.Cmt
local lpegtype,lpegmatch,lpegprint=lpeg.type,lpeg.match,lpeg.print
if setinspector then
setinspector("lpeg",function(v) if lpegtype(v) then lpegprint(v) return true end end)
end
lpeg.patterns=lpeg.patterns or {}
local patterns=lpeg.patterns
local anything=P(1)
local endofstring=P(-1)
local alwaysmatched=P(true)
patterns.anything=anything
patterns.endofstring=endofstring
patterns.beginofstring=alwaysmatched
patterns.alwaysmatched=alwaysmatched
local sign=S('+-')
local zero=P('0')
local digit=R('09')
local digits=digit^1
local octdigit=R("07")
local octdigits=octdigit^1
local lowercase=R("az")
local uppercase=R("AZ")
local underscore=P("_")
local hexdigit=digit+lowercase+uppercase
local hexdigits=hexdigit^1
local cr,lf,crlf=P("\r"),P("\n"),P("\r\n")
local newline=P("\r")*(P("\n")+P(true))+P("\n")
local escaped=P("\\")*anything
local squote=P("'")
local dquote=P('"')
local space=P(" ")
local period=P(".")
local comma=P(",")
local utfbom_32_be=P('\000\000\254\255')
local utfbom_32_le=P('\255\254\000\000')
local utfbom_16_be=P('\254\255')
local utfbom_16_le=P('\255\254')
local utfbom_8=P('\239\187\191')
local utfbom=utfbom_32_be+utfbom_32_le+utfbom_16_be+utfbom_16_le+utfbom_8
local utftype=utfbom_32_be*Cc("utf-32-be")+utfbom_32_le*Cc("utf-32-le")+utfbom_16_be*Cc("utf-16-be")+utfbom_16_le*Cc("utf-16-le")+utfbom_8*Cc("utf-8")+alwaysmatched*Cc("utf-8")
local utfstricttype=utfbom_32_be*Cc("utf-32-be")+utfbom_32_le*Cc("utf-32-le")+utfbom_16_be*Cc("utf-16-be")+utfbom_16_le*Cc("utf-16-le")+utfbom_8*Cc("utf-8")
local utfoffset=utfbom_32_be*Cc(4)+utfbom_32_le*Cc(4)+utfbom_16_be*Cc(2)+utfbom_16_le*Cc(2)+utfbom_8*Cc(3)+Cc(0)
local utf8next=R("\128\191")
patterns.utfbom_32_be=utfbom_32_be
patterns.utfbom_32_le=utfbom_32_le
patterns.utfbom_16_be=utfbom_16_be
patterns.utfbom_16_le=utfbom_16_le
patterns.utfbom_8=utfbom_8
patterns.utf_16_be_nl=P("\000\r\000\n")+P("\000\r")+P("\000\n")
patterns.utf_16_le_nl=P("\r\000\n\000")+P("\r\000")+P("\n\000")
patterns.utf_32_be_nl=P("\000\000\000\r\000\000\000\n")+P("\000\000\000\r")+P("\000\000\000\n")
patterns.utf_32_le_nl=P("\r\000\000\000\n\000\000\000")+P("\r\000\000\000")+P("\n\000\000\000")
patterns.utf8one=R("\000\127")
patterns.utf8two=R("\194\223")*utf8next
patterns.utf8three=R("\224\239")*utf8next*utf8next
patterns.utf8four=R("\240\244")*utf8next*utf8next*utf8next
patterns.utfbom=utfbom
patterns.utftype=utftype
patterns.utfstricttype=utfstricttype
patterns.utfoffset=utfoffset
local utf8char=patterns.utf8one+patterns.utf8two+patterns.utf8three+patterns.utf8four
local validutf8char=utf8char^0*endofstring*Cc(true)+Cc(false)
local utf8character=P(1)*R("\128\191")^0
patterns.utf8=utf8char
patterns.utf8char=utf8char
patterns.utf8character=utf8character
patterns.validutf8=validutf8char
patterns.validutf8char=validutf8char
local eol=S("\n\r")
local spacer=S(" \t\f\v")
local whitespace=eol+spacer
local nonspacer=1-spacer
local nonwhitespace=1-whitespace
patterns.eol=eol
patterns.spacer=spacer
patterns.whitespace=whitespace
patterns.nonspacer=nonspacer
patterns.nonwhitespace=nonwhitespace
local stripper=spacer^0*C((spacer^0*nonspacer^1)^0)
local fullstripper=whitespace^0*C((whitespace^0*nonwhitespace^1)^0)
local collapser=Cs(spacer^0/""*nonspacer^0*((spacer^0/" "*nonspacer^1)^0))
local nospacer=Cs((whitespace^1/""+nonwhitespace^1)^0)
local b_collapser=Cs(whitespace^0/""*(nonwhitespace^1+whitespace^1/" ")^0)
local e_collapser=Cs((whitespace^1*endofstring/""+nonwhitespace^1+whitespace^1/" ")^0)
local m_collapser=Cs((nonwhitespace^1+whitespace^1/" ")^0)
local b_stripper=Cs(spacer^0/""*(nonspacer^1+spacer^1/" ")^0)
local e_stripper=Cs((spacer^1*endofstring/""+nonspacer^1+spacer^1/" ")^0)
local m_stripper=Cs((nonspacer^1+spacer^1/" ")^0)
patterns.stripper=stripper
patterns.fullstripper=fullstripper
patterns.collapser=collapser
patterns.nospacer=nospacer
patterns.b_collapser=b_collapser
patterns.m_collapser=m_collapser
patterns.e_collapser=e_collapser
patterns.b_stripper=b_stripper
patterns.m_stripper=m_stripper
patterns.e_stripper=e_stripper
patterns.lowercase=lowercase
patterns.uppercase=uppercase
patterns.letter=patterns.lowercase+patterns.uppercase
patterns.space=space
patterns.tab=P("\t")
patterns.spaceortab=patterns.space+patterns.tab
patterns.newline=newline
patterns.emptyline=newline^1
patterns.equal=P("=")
patterns.comma=comma
patterns.commaspacer=comma*spacer^0
patterns.period=period
patterns.colon=P(":")
patterns.semicolon=P(";")
patterns.underscore=underscore
patterns.escaped=escaped
patterns.squote=squote
patterns.dquote=dquote
patterns.nosquote=(escaped+(1-squote))^0
patterns.nodquote=(escaped+(1-dquote))^0
patterns.unsingle=(squote/"")*patterns.nosquote*(squote/"")
patterns.undouble=(dquote/"")*patterns.nodquote*(dquote/"")
patterns.unquoted=patterns.undouble+patterns.unsingle
patterns.unspacer=((patterns.spacer^1)/"")^0
patterns.singlequoted=squote*patterns.nosquote*squote
patterns.doublequoted=dquote*patterns.nodquote*dquote
patterns.quoted=patterns.doublequoted+patterns.singlequoted
patterns.digit=digit
patterns.digits=digits
patterns.octdigit=octdigit
patterns.octdigits=octdigits
patterns.hexdigit=hexdigit
patterns.hexdigits=hexdigits
patterns.sign=sign
patterns.cardinal=digits
patterns.integer=sign^-1*digits
patterns.unsigned=digit^0*period*digits
patterns.float=sign^-1*patterns.unsigned
patterns.cunsigned=digit^0*comma*digits
patterns.cpunsigned=digit^0*(period+comma)*digits
patterns.cfloat=sign^-1*patterns.cunsigned
patterns.cpfloat=sign^-1*patterns.cpunsigned
patterns.number=patterns.float+patterns.integer
patterns.cnumber=patterns.cfloat+patterns.integer
patterns.cpnumber=patterns.cpfloat+patterns.integer
patterns.oct=zero*octdigits
patterns.octal=patterns.oct
patterns.HEX=zero*P("X")*(digit+uppercase)^1
patterns.hex=zero*P("x")*(digit+lowercase)^1
patterns.hexadecimal=zero*S("xX")*hexdigits
patterns.hexafloat=sign^-1*zero*S("xX")*(hexdigit^0*period*hexdigits+hexdigits*period*hexdigit^0+hexdigits)*(S("pP")*sign^-1*hexdigits)^-1
patterns.decafloat=sign^-1*(digit^0*period*digits+digits*period*digit^0+digits)*S("eE")*sign^-1*digits
patterns.propername=(uppercase+lowercase+underscore)*(uppercase+lowercase+underscore+digit)^0*endofstring
patterns.somecontent=(anything-newline-space)^1
patterns.beginline=#(1-newline)
patterns.longtostring=Cs(whitespace^0/""*((patterns.quoted+nonwhitespace^1+whitespace^1/""*(endofstring+Cc(" ")))^0))
function anywhere(pattern)
return (1-P(pattern))^0*P(pattern)
end
lpeg.anywhere=anywhere
function lpeg.instringchecker(p)
p=anywhere(p)
return function(str)
return lpegmatch(p,str) and true or false
end
end
function lpeg.splitter(pattern,action)
if action then
return (((1-P(pattern))^1)/action+1)^0
else
return (Cs((1-P(pattern))^1)+1)^0
end
end
function lpeg.tsplitter(pattern,action)
if action then
return Ct((((1-P(pattern))^1)/action+1)^0)
else
return Ct((Cs((1-P(pattern))^1)+1)^0)
end
end
local splitters_s,splitters_m,splitters_t={},{},{}
local function splitat(separator,single)
local splitter=(single and splitters_s[separator]) or splitters_m[separator]
if not splitter then
separator=P(separator)
local other=C((1-separator)^0)
if single then
local any=anything
splitter=other*(separator*C(any^0)+"")
splitters_s[separator]=splitter
else
splitter=other*(separator*other)^0
splitters_m[separator]=splitter
end
end
return splitter
end
local function tsplitat(separator)
local splitter=splitters_t[separator]
if not splitter then
splitter=Ct(splitat(separator))
splitters_t[separator]=splitter
end
return splitter
end
lpeg.splitat=splitat
lpeg.tsplitat=tsplitat
function string.splitup(str,separator)
if not separator then
separator=","
end
return lpegmatch(splitters_m[separator] or splitat(separator),str)
end
local cache={}
function lpeg.split(separator,str)
local c=cache[separator]
if not c then
c=tsplitat(separator)
cache[separator]=c
end
return lpegmatch(c,str)
end
function string.split(str,separator)
if separator then
local c=cache[separator]
if not c then
c=tsplitat(separator)
cache[separator]=c
end
return lpegmatch(c,str)
else
return { str }
end
end
local spacing=patterns.spacer^0*newline
local empty=spacing*Cc("")
local nonempty=Cs((1-spacing)^1)*spacing^-1
local content=(empty+nonempty)^1
patterns.textline=content
local linesplitter=tsplitat(newline)
patterns.linesplitter=linesplitter
function string.splitlines(str)
return lpegmatch(linesplitter,str)
end
local cache={}
function lpeg.checkedsplit(separator,str)
local c=cache[separator]
if not c then
separator=P(separator)
local other=C((1-separator)^1)
c=Ct(separator^0*other*(separator^1*other)^0)
cache[separator]=c
end
return lpegmatch(c,str)
end
function string.checkedsplit(str,separator)
local c=cache[separator]
if not c then
separator=P(separator)
local other=C((1-separator)^1)
c=Ct(separator^0*other*(separator^1*other)^0)
cache[separator]=c
end
return lpegmatch(c,str)
end
local function f2(s) local c1,c2=byte(s,1,2) return c1*64+c2-12416 end
local function f3(s) local c1,c2,c3=byte(s,1,3) return (c1*64+c2)*64+c3-925824 end
local function f4(s) local c1,c2,c3,c4=byte(s,1,4) return ((c1*64+c2)*64+c3)*64+c4-63447168 end
local utf8byte=patterns.utf8one/byte+patterns.utf8two/f2+patterns.utf8three/f3+patterns.utf8four/f4
patterns.utf8byte=utf8byte
local cache={}
function lpeg.stripper(str)
if type(str)=="string" then
local s=cache[str]
if not s then
s=Cs(((S(str)^1)/""+1)^0)
cache[str]=s
end
return s
else
return Cs(((str^1)/""+1)^0)
end
end
local cache={}
function lpeg.keeper(str)
if type(str)=="string" then
local s=cache[str]
if not s then
s=Cs((((1-S(str))^1)/""+1)^0)
cache[str]=s
end
return s
else
return Cs((((1-str)^1)/""+1)^0)
end
end
function lpeg.frontstripper(str)
return (P(str)+P(true))*Cs(anything^0)
end
function lpeg.endstripper(str)
return Cs((1-P(str)*endofstring)^0)
end
function lpeg.replacer(one,two,makefunction,isutf)
local pattern
local u=isutf and utf8char or 1
if type(one)=="table" then
local no=#one
local p=P(false)
if no==0 then
for k,v in next,one do
p=p+P(k)/v
end
pattern=Cs((p+u)^0)
elseif no==1 then
local o=one[1]
one,two=P(o[1]),o[2]
pattern=Cs((one/two+u)^0)
else
for i=1,no do
local o=one[i]
p=p+P(o[1])/o[2]
end
pattern=Cs((p+u)^0)
end
else
pattern=Cs((P(one)/(two or "")+u)^0)
end
if makefunction then
return function(str)
return lpegmatch(pattern,str)
end
else
return pattern
end
end
function lpeg.finder(lst,makefunction,isutf)
local pattern
if type(lst)=="table" then
pattern=P(false)
if #lst==0 then
for k,v in next,lst do
pattern=pattern+P(k)
end
else
for i=1,#lst do
pattern=pattern+P(lst[i])
end
end
else
pattern=P(lst)
end
if isutf then
pattern=((utf8char or 1)-pattern)^0*pattern
else
pattern=(1-pattern)^0*pattern
end
if makefunction then
return function(str)
return lpegmatch(pattern,str)
end
else
return pattern
end
end
local splitters_f,splitters_s={},{}
function lpeg.firstofsplit(separator)
local splitter=splitters_f[separator]
if not splitter then
local pattern=P(separator)
splitter=C((1-pattern)^0)
splitters_f[separator]=splitter
end
return splitter
end
function lpeg.secondofsplit(separator)
local splitter=splitters_s[separator]
if not splitter then
local pattern=P(separator)
splitter=(1-pattern)^0*pattern*C(anything^0)
splitters_s[separator]=splitter
end
return splitter
end
local splitters_s,splitters_p={},{}
function lpeg.beforesuffix(separator)
local splitter=splitters_s[separator]
if not splitter then
local pattern=P(separator)
splitter=C((1-pattern)^0)*pattern*endofstring
splitters_s[separator]=splitter
end
return splitter
end
function lpeg.afterprefix(separator)
local splitter=splitters_p[separator]
if not splitter then
local pattern=P(separator)
splitter=pattern*C(anything^0)
splitters_p[separator]=splitter
end
return splitter
end
function lpeg.balancer(left,right)
left,right=P(left),P(right)
return P { left*((1-left-right)+V(1))^0*right }
end
function lpeg.counter(pattern,action)
local n=0
local pattern=(P(pattern)/function() n=n+1 end+anything)^0
if action then
return function(str) n=0;lpegmatch(pattern,str);action(n) end
else
return function(str) n=0;lpegmatch(pattern,str);return n end
end
end
function lpeg.is_lpeg(p)
return p and lpegtype(p)=="pattern"
end
function lpeg.oneof(list,...)
if type(list)~="table" then
list={ list,... }
end
local p=P(list[1])
for l=2,#list do
p=p+P(list[l])
end
return p
end
local sort=table.sort
local function copyindexed(old)
local new={}
for i=1,#old do
new[i]=old
end
return new
end
local function sortedkeys(tab)
local keys,s={},0
for key,_ in next,tab do
s=s+1
keys[s]=key
end
sort(keys)
return keys
end
function lpeg.append(list,pp,delayed,checked)
local p=pp
if #list>0 then
local keys=copyindexed(list)
sort(keys)
for i=#keys,1,-1 do
local k=keys[i]
if p then
p=P(k)+p
else
p=P(k)
end
end
elseif delayed then
local keys=sortedkeys(list)
if p then
for i=1,#keys,1 do
local k=keys[i]
local v=list[k]
p=P(k)/list+p
end
else
for i=1,#keys do
local k=keys[i]
local v=list[k]
if p then
p=P(k)+p
else
p=P(k)
end
end
if p then
p=p/list
end
end
elseif checked then
local keys=sortedkeys(list)
for i=1,#keys do
local k=keys[i]
local v=list[k]
if p then
if k==v then
p=P(k)+p
else
p=P(k)/v+p
end
else
if k==v then
p=P(k)
else
p=P(k)/v
end
end
end
else
local keys=sortedkeys(list)
for i=1,#keys do
local k=keys[i]
local v=list[k]
if p then
p=P(k)/v+p
else
p=P(k)/v
end
end
end
return p
end
local p_false=P(false)
local p_true=P(true)
local lower=utf and utf.lower or string.lower
local upper=utf and utf.upper or string.upper
function lpeg.setutfcasers(l,u)
lower=l or lower
upper=u or upper
end
local function make1(t,rest)
local p=p_false
local keys=sortedkeys(t)
for i=1,#keys do
local k=keys[i]
if k~="" then
local v=t[k]
if v==true then
p=p+P(k)*p_true
elseif v==false then
else
p=p+P(k)*make1(v,v[""])
end
end
end
if rest then
p=p+p_true
end
return p
end
local function make2(t,rest)
local p=p_false
local keys=sortedkeys(t)
for i=1,#keys do
local k=keys[i]
if k~="" then
local v=t[k]
if v==true then
p=p+(P(lower(k))+P(upper(k)))*p_true
elseif v==false then
else
p=p+(P(lower(k))+P(upper(k)))*make2(v,v[""])
end
end
end
if rest then
p=p+p_true
end
return p
end
local function utfchartabletopattern(list,insensitive)
local tree={}
local n=#list
if n==0 then
for s in next,list do
local t=tree
local p,pk
for c in gmatch(s,".") do
if t==true then
t={ [c]=true,[""]=true }
p[pk]=t
p=t
t=false
elseif t==false then
t={ [c]=false }
p[pk]=t
p=t
t=false
else
local tc=t[c]
if not tc then
tc=false
t[c]=false
end
p=t
t=tc
end
pk=c
end
if t==false then
p[pk]=true
elseif t==true then
else
t[""]=true
end
end
else
for i=1,n do
local s=list[i]
local t=tree
local p,pk
for c in gmatch(s,".") do
if t==true then
t={ [c]=true,[""]=true }
p[pk]=t
p=t
t=false
elseif t==false then
t={ [c]=false }
p[pk]=t
p=t
t=false
else
local tc=t[c]
if not tc then
tc=false
t[c]=false
end
p=t
t=tc
end
pk=c
end
if t==false then
p[pk]=true
elseif t==true then
else
t[""]=true
end
end
end
return (insensitive and make2 or make1)(tree)
end
lpeg.utfchartabletopattern=utfchartabletopattern
function lpeg.utfreplacer(list,insensitive)
local pattern=Cs((utfchartabletopattern(list,insensitive)/list+utf8character)^0)
return function(str)
return lpegmatch(pattern,str) or str
end
end
patterns.containseol=lpeg.finder(eol)
local function nextstep(n,step,result)
local m=n%step
local d=floor(n/step)
if d>0 then
local v=V(tostring(step))
local s=result.start
for i=1,d do
if s then
s=v*s
else
s=v
end
end
result.start=s
end
if step>1 and result.start then
local v=V(tostring(step/2))
result[tostring(step)]=v*v
end
if step>0 then
return nextstep(m,step/2,result)
else
return result
end
end
function lpeg.times(pattern,n)
return P(nextstep(n,2^16,{ "start",["1"]=pattern }))
end
do
local trailingzeros=zero^0*-digit
local stripper=Cs((
digits*(
period*trailingzeros/""+period*(digit-trailingzeros)^1*(trailingzeros/"")
)+1
)^0)
lpeg.patterns.stripzeros=stripper
local nonzero=digit-zero
local trailingzeros=zero^1*endofstring
local stripper=Cs((1-period)^0*(
period*trailingzeros/""+period*(nonzero^1+(trailingzeros/"")+zero^1)^0+endofstring
))
lpeg.patterns.stripzero=stripper
end
local byte_to_HEX={}
local byte_to_hex={}
local byte_to_dec={}
local hex_to_byte={}
for i=0,255 do
local H=format("%02X",i)
local h=format("%02x",i)
local d=format("%03i",i)
local c=char(i)
byte_to_HEX[c]=H
byte_to_hex[c]=h
byte_to_dec[c]=d
hex_to_byte[h]=c
hex_to_byte[H]=c
end
local hextobyte=P(2)/hex_to_byte
local bytetoHEX=P(1)/byte_to_HEX
local bytetohex=P(1)/byte_to_hex
local bytetodec=P(1)/byte_to_dec
local hextobytes=Cs(hextobyte^0)
local bytestoHEX=Cs(bytetoHEX^0)
local bytestohex=Cs(bytetohex^0)
local bytestodec=Cs(bytetodec^0)
patterns.hextobyte=hextobyte
patterns.bytetoHEX=bytetoHEX
patterns.bytetohex=bytetohex
patterns.bytetodec=bytetodec
patterns.hextobytes=hextobytes
patterns.bytestoHEX=bytestoHEX
patterns.bytestohex=bytestohex
patterns.bytestodec=bytestodec
function string.toHEX(s)
if not s or s=="" then
return s
else
return lpegmatch(bytestoHEX,s)
end
end
function string.tohex(s)
if not s or s=="" then
return s
else
return lpegmatch(bytestohex,s)
end
end
function string.todec(s)
if not s or s=="" then
return s
else
return lpegmatch(bytestodec,s)
end
end
function string.tobytes(s)
if not s or s=="" then
return s
else
return lpegmatch(hextobytes,s)
end
end
local patterns={}
local function containsws(what)
local p=patterns[what]
if not p then
local p1=P(what)*(whitespace+endofstring)*Cc(true)
local p2=whitespace*P(p1)
p=P(p1)+P(1-p2)^0*p2+Cc(false)
patterns[what]=p
end
return p
end
lpeg.containsws=containsws
function string.containsws(str,what)
return lpegmatch(patterns[what] or containsws(what),str)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-function"] = package.loaded["l-function"] or true
-- original size: 361, stripped down to: 317
if not modules then modules={} end modules ['l-functions']={
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"
}
functions=functions or {}
function functions.dummy() end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-string"] = package.loaded["l-string"] or true
-- original size: 6461, stripped down to: 3255
if not modules then modules={} end modules ['l-string']={
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"
}
local string=string
local sub,gmatch,format,char,byte,rep,lower=string.sub,string.gmatch,string.format,string.char,string.byte,string.rep,string.lower
local lpegmatch,patterns=lpeg.match,lpeg.patterns
local P,S,C,Ct,Cc,Cs=lpeg.P,lpeg.S,lpeg.C,lpeg.Ct,lpeg.Cc,lpeg.Cs
local unquoted=patterns.squote*C(patterns.nosquote)*patterns.squote+patterns.dquote*C(patterns.nodquote)*patterns.dquote
function string.unquoted(str)
return lpegmatch(unquoted,str) or str
end
function string.quoted(str)
return format("%q",str)
end
function string.count(str,pattern)
local n=0
for _ in gmatch(str,pattern) do
n=n+1
end
return n
end
function string.limit(str,n,sentinel)
if #str>n then
sentinel=sentinel or "..."
return sub(str,1,(n-#sentinel))..sentinel
else
return str
end
end
local stripper=patterns.stripper
local fullstripper=patterns.fullstripper
local collapser=patterns.collapser
local nospacer=patterns.nospacer
local longtostring=patterns.longtostring
function string.strip(str)
return str and lpegmatch(stripper,str) or ""
end
function string.fullstrip(str)
return str and lpegmatch(fullstripper,str) or ""
end
function string.collapsespaces(str)
return str and lpegmatch(collapser,str) or ""
end
function string.nospaces(str)
return str and lpegmatch(nospacer,str) or ""
end
function string.longtostring(str)
return str and lpegmatch(longtostring,str) or ""
end
local pattern=P(" ")^0*P(-1)
function string.is_empty(str)
if not str or str=="" then
return true
else
return lpegmatch(pattern,str) and true or false
end
end
local anything=patterns.anything
local allescapes=Cc("%")*S(".-+%?()[]*")
local someescapes=Cc("%")*S(".-+%()[]")
local matchescapes=Cc(".")*S("*?")
local pattern_a=Cs ((allescapes+anything )^0 )
local pattern_b=Cs ((someescapes+matchescapes+anything )^0 )
local pattern_c=Cs (Cc("^")*(someescapes+matchescapes+anything )^0*Cc("$") )
function string.escapedpattern(str,simple)
return lpegmatch(simple and pattern_b or pattern_a,str)
end
function string.topattern(str,lowercase,strict)
if str=="" or type(str)~="string" then
return ".*"
elseif strict then
str=lpegmatch(pattern_c,str)
else
str=lpegmatch(pattern_b,str)
end
if lowercase then
return lower(str)
else
return str
end
end
function string.valid(str,default)
return (type(str)=="string" and str~="" and str) or default or nil
end
string.itself=function(s) return s end
local pattern_c=Ct(C(1)^0)
local pattern_b=Ct((C(1)/byte)^0)
function string.totable(str,bytes)
return lpegmatch(bytes and pattern_b or pattern_c,str)
end
local replacer=lpeg.replacer("@","%%")
function string.tformat(fmt,...)
return format(lpegmatch(replacer,fmt),...)
end
string.quote=string.quoted
string.unquote=string.unquoted
if not string.bytetable then
local limit=5000
function string.bytetable(str)
local n=#str
if n>limit then
local t={ byte(str,1,limit) }
for i=limit+1,n do
t[i]=byte(str,i)
end
return t
else
return { byte(str,1,n) }
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-table"] = package.loaded["l-table"] or true
-- original size: 41332, stripped down to: 21508
if not modules then modules={} end modules ['l-table']={
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"
}
local type,next,tostring,tonumber,select=type,next,tostring,tonumber,select
local table,string=table,string
local concat,sort=table.concat,table.sort
local format,lower,dump=string.format,string.lower,string.dump
local getmetatable,setmetatable=getmetatable,setmetatable
local lpegmatch,patterns=lpeg.match,lpeg.patterns
local floor=math.floor
local stripper=patterns.stripper
function table.getn(t)
return t and #t
end
function table.strip(tab)
local lst={}
local l=0
for i=1,#tab do
local s=lpegmatch(stripper,tab[i]) or ""
if s=="" then
else
l=l+1
lst[l]=s
end
end
return lst
end
function table.keys(t)
if t then
local keys={}
local k=0
for key in next,t do
k=k+1
keys[k]=key
end
return keys
else
return {}
end
end
local function compare(a,b)
local ta=type(a)
if ta=="number" then
local tb=type(b)
if ta==tb then
return a<b
elseif tb=="string" then
return tostring(a)<b
end
elseif ta=="string" then
local tb=type(b)
if ta==tb then
return a<b
else
return a<tostring(b)
end
end
return tostring(a)<tostring(b)
end
local function sortedkeys(tab)
if tab then
local srt={}
local category=0
local s=0
for key in next,tab do
s=s+1
srt[s]=key
if category~=3 then
local tkey=type(key)
if category==1 then
if tkey~="string" then
category=3
end
elseif category==2 then
if tkey~="number" then
category=3
end
else
if tkey=="string" then
category=1
elseif tkey=="number" then
category=2
else
category=3
end
end
end
end
if s<2 then
elseif category==3 then
sort(srt,compare)
else
sort(srt)
end
return srt
else
return {}
end
end
local function sortedhashonly(tab)
if tab then
local srt={}
local s=0
for key in next,tab do
if type(key)=="string" then
s=s+1
srt[s]=key
end
end
if s>1 then
sort(srt)
end
return srt
else
return {}
end
end
local function sortedindexonly(tab)
if tab then
local srt={}
local s=0
for key in next,tab do
if type(key)=="number" then
s=s+1
srt[s]=key
end
end
if s>1 then
sort(srt)
end
return srt
else
return {}
end
end
local function sortedhashkeys(tab,cmp)
if tab then
local srt={}
local s=0
for key in next,tab do
if key then
s=s+1
srt[s]=key
end
end
if s>1 then
sort(srt,cmp)
end
return srt
else
return {}
end
end
function table.allkeys(t)
local keys={}
for k,v in next,t do
for k in next,v do
keys[k]=true
end
end
return sortedkeys(keys)
end
table.sortedkeys=sortedkeys
table.sortedhashonly=sortedhashonly
table.sortedindexonly=sortedindexonly
table.sortedhashkeys=sortedhashkeys
local function nothing() end
local function sortedhash(t,cmp)
if t then
local s
if cmp then
s=sortedhashkeys(t,function(a,b) return cmp(t,a,b) end)
else
s=sortedkeys(t)
end
local m=#s
if m==1 then
return next,t
elseif m>0 then
local n=0
return function()
if n<m then
n=n+1
local k=s[n]
return k,t[k]
end
end
end
end
return nothing
end
table.sortedhash=sortedhash
table.sortedpairs=sortedhash
function table.append(t,list)
local n=#t
for i=1,#list do
n=n+1
t[n]=list[i]
end
return t
end
function table.prepend(t,list)
local nl=#list
local nt=nl+#t
for i=#t,1,-1 do
t[nt]=t[i]
nt=nt-1
end
for i=1,#list do
t[i]=list[i]
end
return t
end
function table.merge(t,...)
if not t then
t={}
end
for i=1,select("#",...) do
for k,v in next,(select(i,...)) do
t[k]=v
end
end
return t
end
function table.merged(...)
local t={}
for i=1,select("#",...) do
for k,v in next,(select(i,...)) do
t[k]=v
end
end
return t
end
function table.imerge(t,...)
local nt=#t
for i=1,select("#",...) do
local nst=select(i,...)
for j=1,#nst do
nt=nt+1
t[nt]=nst[j]
end
end
return t
end
function table.imerged(...)
local tmp={}
local ntmp=0
for i=1,select("#",...) do
local nst=select(i,...)
for j=1,#nst do
ntmp=ntmp+1
tmp[ntmp]=nst[j]
end
end
return tmp
end
local function fastcopy(old,metatabletoo)
if old then
local new={}
for k,v in next,old do
if type(v)=="table" then
new[k]=fastcopy(v,metatabletoo)
else
new[k]=v
end
end
if metatabletoo then
local mt=getmetatable(old)
if mt then
setmetatable(new,mt)
end
end
return new
else
return {}
end
end
local function copy(t,tables)
if not tables then
tables={}
end
local tcopy={}
if not tables[t] then
tables[t]=tcopy
end
for i,v in next,t do
if type(i)=="table" then
if tables[i] then
i=tables[i]
else
i=copy(i,tables)
end
end
if type(v)~="table" then
tcopy[i]=v
elseif tables[v] then
tcopy[i]=tables[v]
else
tcopy[i]=copy(v,tables)
end
end
local mt=getmetatable(t)
if mt then
setmetatable(tcopy,mt)
end
return tcopy
end
table.fastcopy=fastcopy
table.copy=copy
function table.derive(parent)
local child={}
if parent then
setmetatable(child,{ __index=parent })
end
return child
end
function table.tohash(t,value)
local h={}
if t then
if value==nil then value=true end
for _,v in next,t do
h[v]=value
end
end
return h
end
function table.fromhash(t)
local hsh={}
local h=0
for k,v in next,t do
if v then
h=h+1
hsh[h]=k
end
end
return hsh
end
local noquotes,hexify,handle,compact,inline,functions,metacheck
local reserved=table.tohash {
'and','break','do','else','elseif','end','false','for','function','if',
'in','local','nil','not','or','repeat','return','then','true','until','while',
'NaN','goto',
}
local function is_simple_table(t,hexify)
local nt=#t
if nt>0 then
local n=0
for _,v in next,t do
n=n+1
if type(v)=="table" then
return nil
end
end
local haszero=rawget(t,0)
if n==nt then
local tt={}
for i=1,nt do
local v=t[i]
local tv=type(v)
if tv=="number" then
if hexify then
tt[i]=format("0x%X",v)
else
tt[i]=v
end
elseif tv=="string" then
tt[i]=format("%q",v)
elseif tv=="boolean" then
tt[i]=v and "true" or "false"
else
return nil
end
end
return tt
elseif haszero and (n==nt+1) then
local tt={}
for i=0,nt do
local v=t[i]
local tv=type(v)
if tv=="number" then
if hexify then
tt[i+1]=format("0x%X",v)
else
tt[i+1]=v
end
elseif tv=="string" then
tt[i+1]=format("%q",v)
elseif tv=="boolean" then
tt[i+1]=v and "true" or "false"
else
return nil
end
end
tt[1]="[0] = "..tt[1]
return tt
end
end
return nil
end
table.is_simple_table=is_simple_table
local propername=patterns.propername
local function dummy() end
local function do_serialize(root,name,depth,level,indexed)
if level>0 then
depth=depth.." "
if indexed then
handle(format("%s{",depth))
else
local tn=type(name)
if tn=="number" then
if hexify then
handle(format("%s[0x%X]={",depth,name))
else
handle(format("%s[%s]={",depth,name))
end
elseif tn=="string" then
if noquotes and not reserved[name] and lpegmatch(propername,name) then
handle(format("%s%s={",depth,name))
else
handle(format("%s[%q]={",depth,name))
end
elseif tn=="boolean" then
handle(format("%s[%s]={",depth,name and "true" or "false"))
else
handle(format("%s{",depth))
end
end
end
if root and next(root)~=nil then
local first=nil
local last=0
if compact then
last=#root
for k=1,last do
if rawget(root,k)==nil then
last=k-1
break
end
end
if last>0 then
first=1
end
end
local sk=sortedkeys(root)
for i=1,#sk do
local k=sk[i]
local v=root[k]
local tv=type(v)
local tk=type(k)
if compact and first and tk=="number" and k>=first and k<=last then
if tv=="number" then
if hexify then
handle(format("%s 0x%X,",depth,v))
else
handle(format("%s %s,",depth,v))
end
elseif tv=="string" then
handle(format("%s %q,",depth,v))
elseif tv=="table" then
if next(v)==nil then
handle(format("%s {},",depth))
elseif inline then
local st=is_simple_table(v,hexify)
if st then
handle(format("%s { %s },",depth,concat(st,", ")))
else
do_serialize(v,k,depth,level+1,true)
end
else
do_serialize(v,k,depth,level+1,true)
end
elseif tv=="boolean" then
handle(format("%s %s,",depth,v and "true" or "false"))
elseif tv=="function" then
if functions then
handle(format('%s load(%q),',depth,dump(v)))
else
handle(format('%s "function",',depth))
end
else
handle(format("%s %q,",depth,tostring(v)))
end
elseif k=="__p__" then
if false then
handle(format("%s __p__=nil,",depth))
end
elseif tv=="number" then
if tk=="number" then
if hexify then
handle(format("%s [0x%X]=0x%X,",depth,k,v))
else
handle(format("%s [%s]=%s,",depth,k,v))
end
elseif tk=="boolean" then
if hexify then
handle(format("%s [%s]=0x%X,",depth,k and "true" or "false",v))
else
handle(format("%s [%s]=%s,",depth,k and "true" or "false",v))
end
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
if hexify then
handle(format("%s %s=0x%X,",depth,k,v))
else
handle(format("%s %s=%s,",depth,k,v))
end
else
if hexify then
handle(format("%s [%q]=0x%X,",depth,k,v))
else
handle(format("%s [%q]=%s,",depth,k,v))
end
end
elseif tv=="string" then
if tk=="number" then
if hexify then
handle(format("%s [0x%X]=%q,",depth,k,v))
else
handle(format("%s [%s]=%q,",depth,k,v))
end
elseif tk=="boolean" then
handle(format("%s [%s]=%q,",depth,k and "true" or "false",v))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s=%q,",depth,k,v))
else
handle(format("%s [%q]=%q,",depth,k,v))
end
elseif tv=="table" then
if next(v)==nil then
if tk=="number" then
if hexify then
handle(format("%s [0x%X]={},",depth,k))
else
handle(format("%s [%s]={},",depth,k))
end
elseif tk=="boolean" then
handle(format("%s [%s]={},",depth,k and "true" or "false"))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s={},",depth,k))
else
handle(format("%s [%q]={},",depth,k))
end
elseif inline then
local st=is_simple_table(v,hexify)
if st then
if tk=="number" then
if hexify then
handle(format("%s [0x%X]={ %s },",depth,k,concat(st,", ")))
else
handle(format("%s [%s]={ %s },",depth,k,concat(st,", ")))
end
elseif tk=="boolean" then
handle(format("%s [%s]={ %s },",depth,k and "true" or "false",concat(st,", ")))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s={ %s },",depth,k,concat(st,", ")))
else
handle(format("%s [%q]={ %s },",depth,k,concat(st,", ")))
end
else
do_serialize(v,k,depth,level+1)
end
else
do_serialize(v,k,depth,level+1)
end
elseif tv=="boolean" then
if tk=="number" then
if hexify then
handle(format("%s [0x%X]=%s,",depth,k,v and "true" or "false"))
else
handle(format("%s [%s]=%s,",depth,k,v and "true" or "false"))
end
elseif tk=="boolean" then
handle(format("%s [%s]=%s,",depth,tostring(k),v and "true" or "false"))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s=%s,",depth,k,v and "true" or "false"))
else
handle(format("%s [%q]=%s,",depth,k,v and "true" or "false"))
end
elseif tv=="function" then
if functions then
local getinfo=debug and debug.getinfo
if getinfo then
local f=getinfo(v).what=="C" and dump(dummy) or dump(v)
if tk=="number" then
if hexify then
handle(format("%s [0x%X]=load(%q),",depth,k,f))
else
handle(format("%s [%s]=load(%q),",depth,k,f))
end
elseif tk=="boolean" then
handle(format("%s [%s]=load(%q),",depth,k and "true" or "false",f))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s=load(%q),",depth,k,f))
else
handle(format("%s [%q]=load(%q),",depth,k,f))
end
end
end
else
if tk=="number" then
if hexify then
handle(format("%s [0x%X]=%q,",depth,k,tostring(v)))
else
handle(format("%s [%s]=%q,",depth,k,tostring(v)))
end
elseif tk=="boolean" then
handle(format("%s [%s]=%q,",depth,k and "true" or "false",tostring(v)))
elseif tk~="string" then
elseif noquotes and not reserved[k] and lpegmatch(propername,k) then
handle(format("%s %s=%q,",depth,k,tostring(v)))
else
handle(format("%s [%q]=%q,",depth,k,tostring(v)))
end
end
end
end
if level>0 then
handle(format("%s},",depth))
end
end
local function serialize(_handle,root,name,specification)
local tname=type(name)
if type(specification)=="table" then
noquotes=specification.noquotes
hexify=specification.hexify
handle=_handle or specification.handle or print
functions=specification.functions
compact=specification.compact
inline=specification.inline and compact
metacheck=specification.metacheck
if functions==nil then
functions=true
end
if compact==nil then
compact=true
end
if inline==nil then
inline=compact
end
if metacheck==nil then
metacheck=true
end
else
noquotes=false
hexify=false
handle=_handle or print
compact=true
inline=true
functions=true
metacheck=true
end
if tname=="string" then
if name=="return" then
handle("return {")
else
handle(name.."={")
end
elseif tname=="number" then
if hexify then
handle(format("[0x%X]={",name))
else
handle("["..name.."]={")
end
elseif tname=="boolean" then
if name then
handle("return {")
else
handle("{")
end
else
handle("t={")
end
if root then
if metacheck and getmetatable(root) then
local dummy=root._w_h_a_t_e_v_e_r_
root._w_h_a_t_e_v_e_r_=nil
end
if next(root)~=nil then
do_serialize(root,name,"",0)
end
end
handle("}")
end
function table.serialize(root,name,specification)
local t={}
local n=0
local function flush(s)
n=n+1
t[n]=s
end
serialize(flush,root,name,specification)
return concat(t,"\n")
end
table.tohandle=serialize
local maxtab=2*1024
function table.tofile(filename,root,name,specification)
local f=io.open(filename,'w')
if f then
if maxtab>1 then
local t={}
local n=0
local function flush(s)
n=n+1
t[n]=s
if n>maxtab then
f:write(concat(t,"\n"),"\n")
t={}
n=0
end
end
serialize(flush,root,name,specification)
f:write(concat(t,"\n"),"\n")
else
local function flush(s)
f:write(s,"\n")
end
serialize(flush,root,name,specification)
end
f:close()
io.flush()
end
end
local function flattened(t,f,depth)
if f==nil then
f={}
depth=0xFFFF
elseif tonumber(f) then
depth=f
f={}
elseif not depth then
depth=0xFFFF
end
for k,v in next,t do
if type(k)~="number" then
if depth>0 and type(v)=="table" then
flattened(v,f,depth-1)
else
f[#f+1]=v
end
end
end
for k=1,#t do
local v=t[k]
if depth>0 and type(v)=="table" then
flattened(v,f,depth-1)
else
f[#f+1]=v
end
end
return f
end
table.flattened=flattened
local function collapsed(t,f,h)
if f==nil then
f={}
h={}
end
for k=1,#t do
local v=t[k]
if type(v)=="table" then
collapsed(v,f,h)
elseif not h[v] then
f[#f+1]=v
h[v]=true
end
end
return f
end
local function collapsedhash(t,h)
if h==nil then
h={}
end
for k=1,#t do
local v=t[k]
if type(v)=="table" then
collapsedhash(v,h)
else
h[v]=true
end
end
return h
end
table.collapsed=collapsed
table.collapsedhash=collapsedhash
local function unnest(t,f)
if not f then
f={}
end
for i=1,#t do
local v=t[i]
if type(v)=="table" then
if type(v[1])=="table" then
unnest(v,f)
else
f[#f+1]=v
end
else
f[#f+1]=v
end
end
return f
end
function table.unnest(t)
return unnest(t)
end
local function are_equal(a,b,n,m)
if a==b then
return true
elseif a and b and #a==#b then
if not n then
n=1
end
if not m then
m=#a
end
for i=n,m do
local ai,bi=a[i],b[i]
if ai==bi then
elseif type(ai)=="table" and type(bi)=="table" then
if not are_equal(ai,bi) then
return false
end
else
return false
end
end
return true
else
return false
end
end
local function identical(a,b)
if a~=b then
for ka,va in next,a do
local vb=b[ka]
if va==vb then
elseif type(va)=="table" and type(vb)=="table" then
if not identical(va,vb) then
return false
end
else
return false
end
end
end
return true
end
table.identical=identical
table.are_equal=are_equal
local function sparse(old,nest,keeptables)
local new={}
for k,v in next,old do
if not (v=="" or v==false) then
if nest and type(v)=="table" then
v=sparse(v,nest)
if keeptables or next(v)~=nil then
new[k]=v
end
else
new[k]=v
end
end
end
return new
end
table.sparse=sparse
function table.compact(t)
return sparse(t,true,true)
end
function table.contains(t,v)
if t then
for i=1,#t do
if t[i]==v then
return i
end
end
end
return false
end
function table.count(t)
local n=0
for k,v in next,t do
n=n+1
end
return n
end
function table.swapped(t,s)
local n={}
if s then
for k,v in next,s do
n[k]=v
end
end
for k,v in next,t do
n[v]=k
end
return n
end
function table.hashed(t)
for i=1,#t do
t[t[i]]=i
end
return t
end
function table.mirrored(t)
local n={}
for k,v in next,t do
n[v]=k
n[k]=v
end
return n
end
function table.reversed(t)
if t then
local tt={}
local tn=#t
if tn>0 then
local ttn=0
for i=tn,1,-1 do
ttn=ttn+1
tt[ttn]=t[i]
end
end
return tt
end
end
function table.reverse(t)
if t then
local n=#t
local m=n+1
for i=1,floor(n/2) do
local j=m-i
t[i],t[j]=t[j],t[i]
end
return t
end
end
local function sequenced(t,sep,simple)
if not t then
return ""
elseif type(t)=="string" then
return t
end
local n=#t
local s={}
if n>0 then
for i=1,n do
local v=t[i]
if type(v)=="table" then
s[i]="{"..sequenced(v,sep,simple).."}"
else
s[i]=tostring(t[i])
end
end
else
n=0
for k,v in sortedhash(t) do
if simple then
if v==true then
n=n+1
s[n]=k
elseif v and v~="" then
n=n+1
if type(v)=="table" then
s[n]=k.."={"..sequenced(v,sep,simple).."}"
else
s[n]=k.."="..tostring(v)
end
end
else
n=n+1
if type(v)=="table" then
s[n]=k.."={"..sequenced(v,sep,simple).."}"
else
s[n]=k.."="..tostring(v)
end
end
end
end
return concat(s,sep or " | ")
end
table.sequenced=sequenced
function table.print(t,...)
if type(t)~="table" then
print(tostring(t))
else
serialize(print,t,...)
end
end
if setinspector then
setinspector("table",function(v) if type(v)=="table" then serialize(print,v,"table") return true end end)
end
function table.sub(t,i,j)
return { unpack(t,i,j) }
end
function table.is_empty(t)
return not t or next(t)==nil
end
function table.has_one_entry(t)
return t and next(t,next(t))==nil
end
function table.loweredkeys(t)
local l={}
for k,v in next,t do
l[lower(k)]=v
end
return l
end
function table.unique(old)
local hash={}
local new={}
local n=0
for i=1,#old do
local oi=old[i]
if not hash[oi] then
n=n+1
new[n]=oi
hash[oi]=true
end
end
return new
end
function table.sorted(t,...)
sort(t,...)
return t
end
function table.values(t,s)
if t then
local values={}
local keys={}
local v=0
for key,value in next,t do
if not keys[value] then
v=v+1
values[v]=value
keys[k]=key
end
end
if s then
sort(values)
end
return values
else
return {}
end
end
function table.filtered(t,pattern,sort,cmp)
if t and type(pattern)=="string" then
if sort then
local s
if cmp then
s=sortedhashkeys(t,function(a,b) return cmp(t,a,b) end)
else
s=sortedkeys(t)
end
local n=0
local m=#s
local function kv(s)
while n<m do
n=n+1
local k=s[n]
if find(k,pattern) then
return k,t[k]
end
end
end
return kv,s
else
local n=next(t)
local function iterator()
while n~=nil do
local k=n
n=next(t,k)
if find(k,pattern) then
return k,t[k]
end
end
end
return iterator,t
end
else
return nothing
end
end
if not table.move then
function table.move(a1,f,e,t,a2)
if a2 and a1~=a2 then
for i=f,e do
a2[t]=a1[i]
t=t+1
end
return a2
else
t=t+e-f
for i=e,f,-1 do
a1[t]=a1[i]
t=t-1
end
return a1
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-io"] = package.loaded["l-io"] or true
-- original size: 11823, stripped down to: 6325
if not modules then modules={} end modules ['l-io']={
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"
}
local io=io
local open,flush,write,read=io.open,io.flush,io.write,io.read
local byte,find,gsub,format=string.byte,string.find,string.gsub,string.format
local concat=table.concat
local type=type
if string.find(os.getenv("PATH"),";",1,true) then
io.fileseparator,io.pathseparator="\\",";"
else
io.fileseparator,io.pathseparator="/",":"
end
local large=0x01000000
local medium=0x00100000
local small=0x00020000
local function readall(f)
local size=f:seek("end")
if size>0 then
f:seek("set",0)
return f:read(size)
else
return ""
end
end
io.readall=readall
function io.loaddata(filename,textmode)
local f=open(filename,(textmode and 'r') or 'rb')
if f then
local size=f:seek("end")
local data=nil
if size>0 then
f:seek("set",0)
data=f:read(size)
end
f:close()
return data
end
end
function io.copydata(source,target,action)
local f=open(source,"rb")
if f then
local g=open(target,"wb")
if g then
local size=f:seek("end")
if size>0 then
f:seek("set",0)
local data=f:read(size)
if action then
data=action(data)
end
if data then
g:write(data)
end
end
g:close()
end
f:close()
flush()
end
end
function io.savedata(filename,data,joiner)
local f=open(filename,"wb")
if f then
if type(data)=="table" then
f:write(concat(data,joiner or ""))
elseif type(data)=="function" then
data(f)
else
f:write(data or "")
end
f:close()
flush()
return true
else
return false
end
end
if fio and fio.readline then
local readline=fio.readline
function io.loadlines(filename,n)
local f=open(filename,'r')
if not f then
elseif n then
local lines={}
for i=1,n do
local line=readline(f)
if line then
lines[i]=line
else
break
end
end
f:close()
lines=concat(lines,"\n")
if #lines>0 then
return lines
end
else
local line=readline(f)
f:close()
if line and #line>0 then
return line
end
end
end
else
function io.loadlines(filename,n)
local f=open(filename,'r')
if not f then
elseif n then
local lines={}
for i=1,n do
local line=f:read("*lines")
if line then
lines[i]=line
else
break
end
end
f:close()
lines=concat(lines,"\n")
if #lines>0 then
return lines
end
else
local line=f:read("*line") or ""
f:close()
if #line>0 then
return line
end
end
end
end
function io.loadchunk(filename,n)
local f=open(filename,'rb')
if f then
local data=f:read(n or 1024)
f:close()
if #data>0 then
return data
end
end
end
function io.exists(filename)
local f=open(filename)
if f==nil then
return false
else
f:close()
return true
end
end
function io.size(filename)
local f=open(filename)
if f==nil then
return 0
else
local s=f:seek("end")
f:close()
return s
end
end
local function noflines(f)
if type(f)=="string" then
local f=open(filename)
if f then
local n=f and noflines(f) or 0
f:close()
return n
else
return 0
end
else
local n=0
for _ in f:lines() do
n=n+1
end
f:seek('set',0)
return n
end
end
io.noflines=noflines
local nextchar={
[ 4]=function(f)
return f:read(1,1,1,1)
end,
[ 2]=function(f)
return f:read(1,1)
end,
[ 1]=function(f)
return f:read(1)
end,
[-2]=function(f)
local a,b=f:read(1,1)
return b,a
end,
[-4]=function(f)
local a,b,c,d=f:read(1,1,1,1)
return d,c,b,a
end
}
function io.characters(f,n)
if f then
return nextchar[n or 1],f
end
end
local nextbyte={
[4]=function(f)
local a,b,c,d=f:read(1,1,1,1)
if d then
return byte(a),byte(b),byte(c),byte(d)
end
end,
[3]=function(f)
local a,b,c=f:read(1,1,1)
if b then
return byte(a),byte(b),byte(c)
end
end,
[2]=function(f)
local a,b=f:read(1,1)
if b then
return byte(a),byte(b)
end
end,
[1]=function (f)
local a=f:read(1)
if a then
return byte(a)
end
end,
[-2]=function (f)
local a,b=f:read(1,1)
if b then
return byte(b),byte(a)
end
end,
[-3]=function(f)
local a,b,c=f:read(1,1,1)
if b then
return byte(c),byte(b),byte(a)
end
end,
[-4]=function(f)
local a,b,c,d=f:read(1,1,1,1)
if d then
return byte(d),byte(c),byte(b),byte(a)
end
end
}
function io.bytes(f,n)
if f then
return nextbyte[n or 1],f
else
return nil,nil
end
end
function io.ask(question,default,options)
while true do
write(question)
if options then
write(format(" [%s]",concat(options,"|")))
end
if default then
write(format(" [%s]",default))
end
write(format(" "))
flush()
local answer=read()
answer=gsub(answer,"^%s*(.*)%s*$","%1")
if answer=="" and default then
return default
elseif not options then
return answer
else
for k=1,#options do
if options[k]==answer then
return answer
end
end
local pattern="^"..answer
for k=1,#options do
local v=options[k]
if find(v,pattern) then
return v
end
end
end
end
end
local function readnumber(f,n,m)
if m then
f:seek("set",n)
n=m
end
if n==1 then
return byte(f:read(1))
elseif n==2 then
local a,b=byte(f:read(2),1,2)
return 0x100*a+b
elseif n==3 then
local a,b,c=byte(f:read(3),1,3)
return 0x10000*a+0x100*b+c
elseif n==4 then
local a,b,c,d=byte(f:read(4),1,4)
return 0x1000000*a+0x10000*b+0x100*c+d
elseif n==8 then
local a,b=readnumber(f,4),readnumber(f,4)
return 0x100*a+b
elseif n==12 then
local a,b,c=readnumber(f,4),readnumber(f,4),readnumber(f,4)
return 0x10000*a+0x100*b+c
elseif n==-2 then
local b,a=byte(f:read(2),1,2)
return 0x100*a+b
elseif n==-3 then
local c,b,a=byte(f:read(3),1,3)
return 0x10000*a+0x100*b+c
elseif n==-4 then
local d,c,b,a=byte(f:read(4),1,4)
return 0x1000000*a+0x10000*b+0x100*c+d
elseif n==-8 then
local h,g,f,e,d,c,b,a=byte(f:read(8),1,8)
return 0x100000000000000*a+0x1000000000000*b+0x10000000000*c+0x100000000*d+0x1000000*e+0x10000*f+0x100*g+h
else
return 0
end
end
io.readnumber=readnumber
function io.readstring(f,n,m)
if m then
f:seek("set",n)
n=m
end
local str=gsub(f:read(n),"\000","")
return str
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-number"] = package.loaded["l-number"] or true
-- original size: 5720, stripped down to: 2176
if not modules then modules={} end modules ['l-number']={
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"
}
local tostring,tonumber=tostring,tonumber
local format,floor,match,rep=string.format,math.floor,string.match,string.rep
local concat,insert=table.concat,table.insert
local lpegmatch=lpeg.match
local floor=math.floor
number=number or {}
local number=number
if bit32 then
local bextract=bit32.extract
local t={
"0","0","0","0","0","0","0","0",
"0","0","0","0","0","0","0","0",
"0","0","0","0","0","0","0","0",
"0","0","0","0","0","0","0","0",
}
function number.tobitstring(b,m,w)
if not w then
w=32
end
local n=w
for i=0,w-1 do
local v=bextract(b,i)
local k=w-i
if v==1 then
n=k
t[k]="1"
else
t[k]="0"
end
end
if w then
return concat(t,"",1,w)
elseif m then
m=33-m*8
if m<1 then
m=1
end
return concat(t,"",1,m)
elseif n<8 then
return concat(t)
elseif n<16 then
return concat(t,"",9)
elseif n<24 then
return concat(t,"",17)
else
return concat(t,"",25)
end
end
else
function number.tobitstring(n,m)
if n>0 then
local t={}
while n>0 do
insert(t,1,n%2>0 and 1 or 0)
n=floor(n/2)
end
local nn=8-#t%8
if nn>0 and nn<8 then
for i=1,nn do
insert(t,1,0)
end
end
if m then
m=m*8-#t
if m>0 then
insert(t,1,rep("0",m))
end
end
return concat(t)
elseif m then
rep("00000000",m)
else
return "00000000"
end
end
end
function number.valid(str,default)
return tonumber(str) or default or nil
end
function number.toevenhex(n)
local s=format("%X",n)
if #s%2==0 then
return s
else
return "0"..s
end
end
function number.bytetodecimal(b)
local d=floor(b*100/255+0.5)
if d>100 then
return 100
elseif d<-100 then
return -100
else
return d
end
end
function number.decimaltobyte(d)
local b=floor(d*255/100+0.5)
if b>255 then
return 255
elseif b<-255 then
return -255
else
return b
end
end
function number.idiv(i,d)
return floor(i/d)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-set"] = package.loaded["l-set"] or true
-- original size: 1923, stripped down to: 1044
if not modules then modules={} end modules ['l-set']={
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"
}
set=set or {}
local nums={}
local tabs={}
local concat=table.concat
local next,type=next,type
set.create=table.tohash
function set.tonumber(t)
if next(t) then
local s=""
for k,v in next,t do
if v then
s=s.." "..k
end
end
local n=nums[s]
if not n then
n=#tabs+1
tabs[n]=t
nums[s]=n
end
return n
else
return 0
end
end
function set.totable(n)
if n==0 then
return {}
else
return tabs[n] or {}
end
end
function set.tolist(n)
if n==0 or not tabs[n] then
return ""
else
local t,n={},0
for k,v in next,tabs[n] do
if v then
n=n+1
t[n]=k
end
end
return concat(t," ")
end
end
function set.contains(n,s)
if type(n)=="table" then
return n[s]
elseif n==0 then
return false
else
local t=tabs[n]
return t and t[s]
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-os"] = package.loaded["l-os"] or true
-- original size: 18916, stripped down to: 10126
if not modules then modules={} end modules ['l-os']={
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"
}
local os=os
local date,time=os.date,os.time
local find,format,gsub,upper,gmatch=string.find,string.format,string.gsub,string.upper,string.gmatch
local concat=table.concat
local random,ceil,randomseed=math.random,math.ceil,math.randomseed
local rawget,rawset,type,getmetatable,setmetatable,tonumber,tostring=rawget,rawset,type,getmetatable,setmetatable,tonumber,tostring
do
local selfdir=os.selfdir
if selfdir=="" then
selfdir=nil
end
if not selfdir then
if arg then
for i=1,#arg do
local a=arg[i]
if find(a,"^%-%-[c:]*texmfbinpath=") then
selfdir=gsub(a,"^.-=","")
break
end
end
end
if not selfdir then
selfdir=os.selfbin or "luatex"
if find(selfdir,"[/\\]") then
selfdir=gsub(selfdir,"[/\\][^/\\]*$","")
elseif os.getenv then
local path=os.getenv("PATH")
local name=gsub(selfdir,"^.*[/\\][^/\\]","")
local patt="[^:]+"
if os.type=="windows" then
patt="[^;]+"
name=name..".exe"
end
local isfile
if lfs then
local attributes=lfs.attributes
isfile=function(name)
local a=attributes(name,"mode")
return a=="file" or a=="link" or nil
end
else
local open=io.open
isfile=function(name)
local f=open(name)
if f then
f:close()
return true
end
end
end
for p in gmatch(path,patt) do
if isfile(p.."/"..name) then
selfdir=p
break
end
end
end
end
os.selfdir=selfdir or "."
end
end
math.initialseed=tonumber(string.sub(string.reverse(tostring(ceil(socket and socket.gettime()*10000 or time()))),1,6))
randomseed(math.initialseed)
if not os.__getenv__ then
os.__getenv__=os.getenv
os.__setenv__=os.setenv
if os.env then
local osgetenv=os.getenv
local ossetenv=os.setenv
local osenv=os.env local _=osenv.PATH
function os.setenv(k,v)
if v==nil then
v=""
end
local K=upper(k)
osenv[K]=v
if type(v)=="table" then
v=concat(v,";")
end
ossetenv(K,v)
end
function os.getenv(k)
local K=upper(k)
local v=osenv[K] or osenv[k] or osgetenv(K) or osgetenv(k)
if v=="" then
return nil
else
return v
end
end
else
local ossetenv=os.setenv
local osgetenv=os.getenv
local osenv={}
function os.setenv(k,v)
if v==nil then
v=""
end
local K=upper(k)
osenv[K]=v
end
function os.getenv(k)
local K=upper(k)
local v=osenv[K] or osgetenv(K) or osgetenv(k)
if v=="" then
return nil
else
return v
end
end
local function __index(t,k)
return os.getenv(k)
end
local function __newindex(t,k,v)
os.setenv(k,v)
end
os.env={}
setmetatable(os.env,{ __index=__index,__newindex=__newindex } )
end
end
local execute=os.execute
local iopopen=io.popen
local function resultof(command)
local handle=iopopen(command,"r")
if handle then
local result=handle:read("*all") or ""
handle:close()
return result
else
return ""
end
end
os.resultof=resultof
function os.pipeto(command)
return iopopen(command,"w")
end
if not io.fileseparator then
if find(os.getenv("PATH"),";",1,true) then
io.fileseparator,io.pathseparator,os.type="\\",";",os.type or "windows"
else
io.fileseparator,io.pathseparator,os.type="/",":",os.type or "unix"
end
end
os.type=os.type or (io.pathseparator==";" and "windows") or "unix"
os.name=os.name or (os.type=="windows" and "mswin" ) or "linux"
if os.type=="windows" then
os.libsuffix,os.binsuffix,os.binsuffixes='dll','exe',{ 'exe','cmd','bat' }
else
os.libsuffix,os.binsuffix,os.binsuffixes='so','',{ '' }
end
local launchers={
windows="start %s",
macosx="open %s",
unix="xdg-open %s &> /dev/null &",
}
function os.launch(str)
execute(format(launchers[os.name] or launchers.unix,str))
end
local gettimeofday=os.gettimeofday or os.clock
os.gettimeofday=gettimeofday
local startuptime=gettimeofday()
function os.runtime()
return gettimeofday()-startuptime
end
local resolvers=os.resolvers or {}
os.resolvers=resolvers
setmetatable(os,{ __index=function(t,k)
local r=resolvers[k]
return r and r(t,k) or nil
end })
local name,platform=os.name or "linux",os.getenv("MTX_PLATFORM") or ""
if platform~="" then
os.platform=platform
elseif os.type=="windows" then
function resolvers.platform(t,k)
local architecture=os.getenv("PROCESSOR_ARCHITECTURE") or ""
local platform=""
if find(architecture,"AMD64",1,true) then
platform="win64"
else
platform="mswin"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
elseif name=="linux" then
function resolvers.platform(t,k)
local architecture=os.getenv("HOSTTYPE") or resultof("uname -m") or ""
local platform=os.getenv("MTX_PLATFORM") or ""
local musl=find(os.selfdir or "","linuxmusl")
if platform~="" then
elseif find(architecture,"x86_64",1,true) then
platform=musl and "linuxmusl" or "linux-64"
elseif find(architecture,"ppc",1,true) then
platform="linux-ppc"
else
platform=musl and "linuxmusl" or "linux"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
elseif name=="macosx" then
function resolvers.platform(t,k)
local architecture=resultof("echo $HOSTTYPE") or ""
local platform=""
if architecture=="" then
platform="osx-intel"
elseif find(architecture,"i386",1,true) then
platform="osx-intel"
elseif find(architecture,"x86_64",1,true) then
platform="osx-64"
else
platform="osx-ppc"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
elseif name=="sunos" then
function resolvers.platform(t,k)
local architecture=resultof("uname -m") or ""
local platform=""
if find(architecture,"sparc",1,true) then
platform="solaris-sparc"
else
platform="solaris-intel"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
elseif name=="freebsd" then
function resolvers.platform(t,k)
local architecture=resultof("uname -m") or ""
local platform=""
if find(architecture,"amd64",1,true) then
platform="freebsd-amd64"
else
platform="freebsd"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
elseif name=="kfreebsd" then
function resolvers.platform(t,k)
local architecture=os.getenv("HOSTTYPE") or resultof("uname -m") or ""
local platform=""
if find(architecture,"x86_64",1,true) then
platform="kfreebsd-amd64"
else
platform="kfreebsd-i386"
end
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
else
function resolvers.platform(t,k)
local platform="linux"
os.setenv("MTX_PLATFORM",platform)
os.platform=platform
return platform
end
end
os.newline=name=="windows" and "\013\010" or "\010"
function resolvers.bits(t,k)
local bits=find(os.platform,"64",1,true) and 64 or 32
os.bits=bits
return bits
end
local t={ 8,9,"a","b" }
function os.uuid()
return format("%04x%04x-4%03x-%s%03x-%04x-%04x%04x%04x",
random(0xFFFF),random(0xFFFF),
random(0x0FFF),
t[ceil(random(4))] or 8,random(0x0FFF),
random(0xFFFF),
random(0xFFFF),random(0xFFFF),random(0xFFFF)
)
end
local d
function os.timezone(delta)
d=d or tonumber(tonumber(date("%H")-date("!%H")))
if delta then
if d>0 then
return format("+%02i:00",d)
else
return format("-%02i:00",-d)
end
else
return 1
end
end
local timeformat=format("%%s%s",os.timezone(true))
local dateformat="!%Y-%m-%d %H:%M:%S"
local lasttime=nil
local lastdate=nil
function os.fulltime(t,default)
t=t and tonumber(t) or 0
if t>0 then
elseif default then
return default
else
t=time()
end
if t~=lasttime then
lasttime=t
lastdate=format(timeformat,date(dateformat))
end
return lastdate
end
local dateformat="%Y-%m-%d %H:%M:%S"
local lasttime=nil
local lastdate=nil
function os.localtime(t,default)
t=t and tonumber(t) or 0
if t>0 then
elseif default then
return default
else
t=time()
end
if t~=lasttime then
lasttime=t
lastdate=date(dateformat,t)
end
return lastdate
end
function os.converttime(t,default)
local t=tonumber(t)
if t and t>0 then
return date(dateformat,t)
else
return default or "-"
end
end
local memory={}
local function which(filename)
local fullname=memory[filename]
if fullname==nil then
local suffix=file.suffix(filename)
local suffixes=suffix=="" and os.binsuffixes or { suffix }
for directory in gmatch(os.getenv("PATH"),"[^"..io.pathseparator.."]+") do
local df=file.join(directory,filename)
for i=1,#suffixes do
local dfs=file.addsuffix(df,suffixes[i])
if io.exists(dfs) then
fullname=dfs
break
end
end
end
if not fullname then
fullname=false
end
memory[filename]=fullname
end
return fullname
end
os.which=which
os.where=which
function os.today()
return date("!*t")
end
function os.now()
return date("!%Y-%m-%d %H:%M:%S")
end
if not os.sleep then
local socket=socket
function os.sleep(n)
if not socket then
socket=require("socket")
end
socket.sleep(n)
end
end
local function isleapyear(year)
return (year%4==0) and (year%100~=0 or year%400==0)
end
os.isleapyear=isleapyear
local days={ 31,28,31,30,31,30,31,31,30,31,30,31 }
local function nofdays(year,month)
if not month then
return isleapyear(year) and 365 or 364
else
return month==2 and isleapyear(year) and 29 or days[month]
end
end
os.nofdays=nofdays
function os.weekday(day,month,year)
return date("%w",time { year=year,month=month,day=day })+1
end
function os.validdate(year,month,day)
if month<1 then
month=1
elseif month>12 then
month=12
end
if day<1 then
day=1
else
local max=nofdays(year,month)
if day>max then
day=max
end
end
return year,month,day
end
local osexit=os.exit
local exitcode=nil
function os.setexitcode(code)
exitcode=code
end
function os.exit(c)
if exitcode~=nil then
return osexit(exitcode)
end
if c~=nil then
return osexit(c)
end
return osexit()
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-file"] = package.loaded["l-file"] or true
-- original size: 21984, stripped down to: 10148
if not modules then modules={} end modules ['l-file']={
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"
}
file=file or {}
local file=file
if not lfs then
lfs=optionalrequire("lfs")
end
local insert,concat=table.insert,table.concat
local match,find,gmatch=string.match,string.find,string.gmatch
local lpegmatch=lpeg.match
local getcurrentdir,attributes=lfs.currentdir,lfs.attributes
local checkedsplit=string.checkedsplit
local P,R,S,C,Cs,Cp,Cc,Ct=lpeg.P,lpeg.R,lpeg.S,lpeg.C,lpeg.Cs,lpeg.Cp,lpeg.Cc,lpeg.Ct
local attributes=lfs.attributes
function lfs.isdir(name)
return attributes(name,"mode")=="directory"
end
function lfs.isfile(name)
local a=attributes(name,"mode")
return a=="file" or a=="link" or nil
end
function lfs.isfound(name)
local a=attributes(name,"mode")
return (a=="file" or a=="link") and name or nil
end
if sandbox then
sandbox.redefine(lfs.isfile,"lfs.isfile")
sandbox.redefine(lfs.isdir,"lfs.isdir")
sandbox.redefine(lfs.isfound,"lfs.isfound")
end
local colon=P(":")
local period=P(".")
local periods=P("..")
local fwslash=P("/")
local bwslash=P("\\")
local slashes=S("\\/")
local noperiod=1-period
local noslashes=1-slashes
local name=noperiod^1
local suffix=period/""*(1-period-slashes)^1*-1
local pattern=C((1-(slashes^1*noslashes^1*-1))^1)*P(1)
local function pathpart(name,default)
return name and lpegmatch(pattern,name) or default or ""
end
local pattern=(noslashes^0*slashes)^1*C(noslashes^1)*-1
local function basename(name)
return name and lpegmatch(pattern,name) or name
end
local pattern=(noslashes^0*slashes^1)^0*Cs((1-suffix)^1)*suffix^0
local function nameonly(name)
return name and lpegmatch(pattern,name) or name
end
local pattern=(noslashes^0*slashes)^0*(noperiod^1*period)^1*C(noperiod^1)*-1
local function suffixonly(name)
return name and lpegmatch(pattern,name) or ""
end
local pattern=(noslashes^0*slashes)^0*noperiod^1*((period*C(noperiod^1))^1)*-1+Cc("")
local function suffixesonly(name)
if name then
return lpegmatch(pattern,name)
else
return ""
end
end
file.pathpart=pathpart
file.basename=basename
file.nameonly=nameonly
file.suffixonly=suffixonly
file.suffix=suffixonly
file.suffixesonly=suffixesonly
file.suffixes=suffixesonly
file.dirname=pathpart
file.extname=suffixonly
local drive=C(R("az","AZ"))*colon
local path=C((noslashes^0*slashes)^0)
local suffix=period*C(P(1-period)^0*P(-1))
local base=C((1-suffix)^0)
local rest=C(P(1)^0)
drive=drive+Cc("")
path=path+Cc("")
base=base+Cc("")
suffix=suffix+Cc("")
local pattern_a=drive*path*base*suffix
local pattern_b=path*base*suffix
local pattern_c=C(drive*path)*C(base*suffix)
local pattern_d=path*rest
function file.splitname(str,splitdrive)
if not str then
elseif splitdrive then
return lpegmatch(pattern_a,str)
else
return lpegmatch(pattern_b,str)
end
end
function file.splitbase(str)
if str then
return lpegmatch(pattern_d,str)
else
return "",str
end
end
function file.nametotable(str,splitdrive)
if str then
local path,drive,subpath,name,base,suffix=lpegmatch(pattern_c,str)
if splitdrive then
return {
path=path,
drive=drive,
subpath=subpath,
name=name,
base=base,
suffix=suffix,
}
else
return {
path=path,
name=name,
base=base,
suffix=suffix,
}
end
end
end
local pattern=Cs(((period*(1-period-slashes)^1*-1)/""+1)^1)
function file.removesuffix(name)
return name and lpegmatch(pattern,name)
end
local suffix=period/""*(1-period-slashes)^1*-1
local pattern=Cs((noslashes^0*slashes^1)^0*((1-suffix)^1))*Cs(suffix)
function file.addsuffix(filename,suffix,criterium)
if not filename or not suffix or suffix=="" then
return filename
elseif criterium==true then
return filename.."."..suffix
elseif not criterium then
local n,s=lpegmatch(pattern,filename)
if not s or s=="" then
return filename.."."..suffix
else
return filename
end
else
local n,s=lpegmatch(pattern,filename)
if s and s~="" then
local t=type(criterium)
if t=="table" then
for i=1,#criterium do
if s==criterium[i] then
return filename
end
end
elseif t=="string" then
if s==criterium then
return filename
end
end
end
return (n or filename).."."..suffix
end
end
local suffix=period*(1-period-slashes)^1*-1
local pattern=Cs((1-suffix)^0)
function file.replacesuffix(name,suffix)
if name and suffix and suffix~="" then
return lpegmatch(pattern,name).."."..suffix
else
return name
end
end
local reslasher=lpeg.replacer(P("\\"),"/")
function file.reslash(str)
return str and lpegmatch(reslasher,str)
end
if lfs.isreadablefile and lfs.iswritablefile then
file.is_readable=lfs.isreadablefile
file.is_writable=lfs.iswritablefile
else
function file.is_writable(name)
if not name then
elseif lfs.isdir(name) then
name=name.."/m_t_x_t_e_s_t.tmp"
local f=io.open(name,"wb")
if f then
f:close()
os.remove(name)
return true
end
elseif lfs.isfile(name) then
local f=io.open(name,"ab")
if f then
f:close()
return true
end
else
local f=io.open(name,"ab")
if f then
f:close()
os.remove(name)
return true
end
end
return false
end
local readable=P("r")*Cc(true)
function file.is_readable(name)
if name then
local a=attributes(name)
return a and lpegmatch(readable,a.permissions) or false
else
return false
end
end
end
file.isreadable=file.is_readable
file.iswritable=file.is_writable
function file.size(name)
if name then
local a=attributes(name)
return a and a.size or 0
else
return 0
end
end
function file.splitpath(str,separator)
return str and checkedsplit(lpegmatch(reslasher,str),separator or io.pathseparator)
end
function file.joinpath(tab,separator)
return tab and concat(tab,separator or io.pathseparator)
end
local someslash=S("\\/")
local stripper=Cs(P(fwslash)^0/""*reslasher)
local isnetwork=someslash*someslash*(1-someslash)+(1-fwslash-colon)^1*colon
local isroot=fwslash^1*-1
local hasroot=fwslash^1
local reslasher=lpeg.replacer(S("\\/"),"/")
local deslasher=lpeg.replacer(S("\\/")^1,"/")
function file.join(one,two,three,...)
if not two then
return one=="" and one or lpegmatch(reslasher,one)
end
if one=="" then
return lpegmatch(stripper,three and concat({ two,three,... },"/") or two)
end
if lpegmatch(isnetwork,one) then
local one=lpegmatch(reslasher,one)
local two=lpegmatch(deslasher,three and concat({ two,three,... },"/") or two)
if lpegmatch(hasroot,two) then
return one..two
else
return one.."/"..two
end
elseif lpegmatch(isroot,one) then
local two=lpegmatch(deslasher,three and concat({ two,three,... },"/") or two)
if lpegmatch(hasroot,two) then
return two
else
return "/"..two
end
else
return lpegmatch(deslasher,concat({ one,two,three,... },"/"))
end
end
local drivespec=R("az","AZ")^1*colon
local anchors=fwslash+drivespec
local untouched=periods+(1-period)^1*P(-1)
local mswindrive=Cs(drivespec*(bwslash/"/"+fwslash)^0)
local mswinuncpath=(bwslash+fwslash)*(bwslash+fwslash)*Cc("//")
local splitstarter=(mswindrive+mswinuncpath+Cc(false))*Ct(lpeg.splitat(S("/\\")^1))
local absolute=fwslash
function file.collapsepath(str,anchor)
if not str then
return
end
if anchor==true and not lpegmatch(anchors,str) then
str=getcurrentdir().."/"..str
end
if str=="" or str=="." then
return "."
elseif lpegmatch(untouched,str) then
return lpegmatch(reslasher,str)
end
local starter,oldelements=lpegmatch(splitstarter,str)
local newelements={}
local i=#oldelements
while i>0 do
local element=oldelements[i]
if element=='.' then
elseif element=='..' then
local n=i-1
while n>0 do
local element=oldelements[n]
if element~='..' and element~='.' then
oldelements[n]='.'
break
else
n=n-1
end
end
if n<1 then
insert(newelements,1,'..')
end
elseif element~="" then
insert(newelements,1,element)
end
i=i-1
end
if #newelements==0 then
return starter or "."
elseif starter then
return starter..concat(newelements,'/')
elseif lpegmatch(absolute,str) then
return "/"..concat(newelements,'/')
else
newelements=concat(newelements,'/')
if anchor=="." and find(str,"^%./") then
return "./"..newelements
else
return newelements
end
end
end
local validchars=R("az","09","AZ","--","..")
local pattern_a=lpeg.replacer(1-validchars)
local pattern_a=Cs((validchars+P(1)/"-")^1)
local whatever=P("-")^0/""
local pattern_b=Cs(whatever*(1-whatever*-1)^1)
function file.robustname(str,strict)
if str then
str=lpegmatch(pattern_a,str) or str
if strict then
return lpegmatch(pattern_b,str) or str
else
return str
end
end
end
local loaddata=io.loaddata
local savedata=io.savedata
file.readdata=loaddata
file.savedata=savedata
function file.copy(oldname,newname)
if oldname and newname then
local data=loaddata(oldname)
if data and data~="" then
savedata(newname,data)
end
end
end
local letter=R("az","AZ")+S("_-+")
local separator=P("://")
local qualified=period^0*fwslash+letter*colon+letter^1*separator+letter^1*fwslash
local rootbased=fwslash+letter*colon
lpeg.patterns.qualified=qualified
lpeg.patterns.rootbased=rootbased
function file.is_qualified_path(filename)
return filename and lpegmatch(qualified,filename)~=nil
end
function file.is_rootbased_path(filename)
return filename and lpegmatch(rootbased,filename)~=nil
end
function file.strip(name,dir)
if name then
local b,a=match(name,"^(.-)"..dir.."(.*)$")
return a~="" and a or name
end
end
function lfs.mkdirs(path)
local full=""
for sub in gmatch(path,"(/*[^\\/]+)") do
full=full..sub
lfs.mkdir(full)
end
end
function file.withinbase(path)
local l=0
if not find(path,"^/") then
path="/"..path
end
for dir in gmatch(path,"/([^/]+)") do
if dir==".." then
l=l-1
elseif dir~="." then
l=l+1
end
if l<0 then
return false
end
end
return true
end
local symlinkattributes=lfs.symlinkattributes
function lfs.readlink(name)
return symlinkattributes(name,"target") or nil
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-gzip"] = package.loaded["l-gzip"] or true
-- original size: 1211, stripped down to: 951
if not modules then modules={} end modules ['l-gzip']={
version=1.001,
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
if not gzip then
return
end
local suffix,suffixes=file.suffix,file.suffixes
function gzip.load(filename)
local f=io.open(filename,"rb")
if not f then
elseif suffix(filename)=="gz" then
f:close()
local g=gzip.open(filename,"rb")
if g then
local str=g:read("*all")
g:close()
return str
end
else
local str=f:read("*all")
f:close()
return str
end
end
function gzip.save(filename,data)
if suffix(filename)~="gz" then
filename=filename..".gz"
end
local f=io.open(filename,"wb")
if f then
local s=zlib.compress(data or "",9,nil,15+16)
f:write(s)
f:close()
return #s
end
end
function gzip.suffix(filename)
local suffix,extra=suffixes(filename)
local gzipped=extra=="gz"
return suffix,gzipped
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-md5"] = package.loaded["l-md5"] or true
-- original size: 3309, stripped down to: 2218
if not modules then modules={} end modules ['l-md5']={
version=1.001,
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
if not md5 then
md5=optionalrequire("md5")
end
if not md5 then
md5={
sum=function(str) print("error: md5 is not loaded (sum ignored)") return str end,
sumhexa=function(str) print("error: md5 is not loaded (sumhexa ignored)") return str end,
}
end
local md5,file=md5,file
local gsub=string.gsub
do
local patterns=lpeg and lpeg.patterns
if patterns then
local bytestoHEX=patterns.bytestoHEX
local bytestohex=patterns.bytestohex
local bytestodec=patterns.bytestodec
local lpegmatch=lpeg.match
local md5sum=md5.sum
if not md5.HEX then function md5.HEX(str) if str then return lpegmatch(bytestoHEX,md5sum(str)) end end end
if not md5.hex then function md5.hex(str) if str then return lpegmatch(bytestohex,md5sum(str)) end end end
if not md5.dec then function md5.dec(str) if str then return lpegmatch(bytestodec,md5sum(str)) end end end
md5.sumhexa=md5.hex
md5.sumHEXA=md5.HEX
end
end
function file.needsupdating(oldname,newname,threshold)
local oldtime=lfs.attributes(oldname,"modification")
if oldtime then
local newtime=lfs.attributes(newname,"modification")
if not newtime then
return true
elseif newtime>=oldtime then
return false
elseif oldtime-newtime<(threshold or 1) then
return false
else
return true
end
else
return false
end
end
file.needs_updating=file.needsupdating
function file.syncmtimes(oldname,newname)
local oldtime=lfs.attributes(oldname,"modification")
if oldtime and lfs.isfile(newname) then
lfs.touch(newname,oldtime,oldtime)
end
end
function file.checksum(name)
if md5 then
local data=io.loaddata(name)
if data then
return md5.HEX(data)
end
end
return nil
end
function file.loadchecksum(name)
if md5 then
local data=io.loaddata(name..".md5")
return data and (gsub(data,"%s",""))
end
return nil
end
function file.savechecksum(name,checksum)
if not checksum then checksum=file.checksum(name) end
if checksum then
io.savedata(name..".md5",checksum)
return checksum
end
return nil
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-sha"] = package.loaded["l-sha"] or true
-- original size: 1085, stripped down to: 969
if not modules then modules={} end modules ['l-sha']={
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"
}
if sha2 then
local lpegmatch=lpeg.match
local lpegpatterns=lpeg.patterns
local bytestohex=lpegpatterns.bytestohex
local bytestoHEX=lpegpatterns.bytestoHEX
local digest256=sha2.digest256
local digest384=sha2.digest384
local digest512=sha2.digest512
sha2.hash256=function(str) return lpegmatch(bytestohex,digest256(str)) end
sha2.hash384=function(str) return lpegmatch(bytestohex,digest384(str)) end
sha2.hash512=function(str) return lpegmatch(bytestohex,digest512(str)) end
sha2.HASH256=function(str) return lpegmatch(bytestoHEX,digest256(str)) end
sha2.HASH384=function(str) return lpegmatch(bytestoHEX,digest384(str)) end
sha2.HASH512=function(str) return lpegmatch(bytestoHEX,digest512(str)) end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-url"] = package.loaded["l-url"] or true
-- original size: 14755, stripped down to: 6981
if not modules then modules={} end modules ['l-url']={
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"
}
local char,format,byte=string.char,string.format,string.byte
local concat=table.concat
local tonumber,type,next=tonumber,type,next
local P,C,R,S,Cs,Cc,Ct,Cf,Cg,V=lpeg.P,lpeg.C,lpeg.R,lpeg.S,lpeg.Cs,lpeg.Cc,lpeg.Ct,lpeg.Cf,lpeg.Cg,lpeg.V
local lpegmatch,lpegpatterns,replacer=lpeg.match,lpeg.patterns,lpeg.replacer
local sortedhash=table.sortedhash
url=url or {}
local url=url
local unescapes={}
local escapes={}
setmetatable(unescapes,{ __index=function(t,k)
local v=char(tonumber(k,16))
t[k]=v
return v
end })
setmetatable(escapes,{ __index=function(t,k)
local v=format("%%%02X",byte(k))
t[k]=v
return v
end })
local colon=P(":")
local qmark=P("?")
local hash=P("#")
local slash=P("/")
local atsign=P("@")
local percent=P("%")
local endofstring=P(-1)
local hexdigit=R("09","AF","af")
local plus=P("+")
local nothing=Cc("")
local okay=R("09","AZ","az")+S("-_.,:=+*~!'()@&$")
local escapedchar=(percent*C(hexdigit*hexdigit))/unescapes
local unescapedchar=P(1)/escapes
local escaped=(plus/" ")+escapedchar
local noslash=P("/")/""
local plustospace=P("+")/" "
local decoder=Cs((
plustospace+escapedchar+P("\r\n")/"\n"+P(1)
)^0 )
local encoder=Cs((
R("09","AZ","az")^1+S("-./_")^1+P(" ")/"+"+P("\n")/"\r\n"+unescapedchar
)^0 )
lpegpatterns.urldecoder=decoder
lpegpatterns.urlencoder=encoder
function url.decode (str) return str and lpegmatch(decoder,str) or str end
function url.encode (str) return str and lpegmatch(encoder,str) or str end
function url.unescape(str) return str and lpegmatch(unescaper,str) or str end
local schemestr=Cs((escaped+(1-colon-slash-qmark-hash))^2)
local authoritystr=Cs((escaped+(1- slash-qmark-hash))^0)
local pathstr=Cs((escaped+(1- qmark-hash))^0)
local querystr=Cs(((1- hash))^0)
local fragmentstr=Cs((escaped+(1- endofstring))^0)
local scheme=schemestr*colon+nothing
local authority=slash*slash*authoritystr+nothing
local path=slash*pathstr+nothing
local query=qmark*querystr+nothing
local fragment=hash*fragmentstr+nothing
local validurl=scheme*authority*path*query*fragment
local parser=Ct(validurl)
lpegpatterns.url=validurl
lpegpatterns.urlsplitter=parser
local escaper=Cs((R("09","AZ","az")^1+P(" ")/"%%20"+S("-./_:")^1+P(1)/escapes)^0)
local unescaper=Cs((escapedchar+1)^0)
local getcleaner=Cs((P("+++")/"%%2B"+P("+")/"%%20"+P(1))^1)
lpegpatterns.urlunescaped=escapedchar
lpegpatterns.urlescaper=escaper
lpegpatterns.urlunescaper=unescaper
lpegpatterns.urlgetcleaner=getcleaner
function url.unescapeget(str)
return lpegmatch(getcleaner,str)
end
local function split(str)
return (type(str)=="string" and lpegmatch(parser,str)) or str
end
local isscheme=schemestr*colon*slash*slash
local function hasscheme(str)
if str then
local scheme=lpegmatch(isscheme,str)
return scheme~="" and scheme or false
else
return false
end
end
local rootletter=R("az","AZ")+S("_-+")
local separator=P("://")
local qualified=P(".")^0*P("/")+rootletter*P(":")+rootletter^1*separator+rootletter^1*P("/")
local rootbased=P("/")+rootletter*P(":")
local barswapper=replacer("|",":")
local backslashswapper=replacer("\\","/")
local equal=P("=")
local amp=P("&")
local key=Cs(((plustospace+escapedchar+1)-equal )^0)
local value=Cs(((plustospace+escapedchar+1)-amp-endofstring)^0)
local splitquery=Cf (Ct("")*P { "sequence",
sequence=V("pair")*(amp*V("pair"))^0,
pair=Cg(key*equal*value),
},rawset)
local userpart=(1-atsign-colon)^1
local serverpart=(1-colon)^1
local splitauthority=((Cs(userpart)*colon*Cs(userpart)+Cs(userpart)*Cc(nil))*atsign+Cc(nil)*Cc(nil))*Cs(serverpart)*(colon*(serverpart/tonumber)+Cc(nil))
local function hashed(str)
if not str or str=="" then
return {
scheme="invalid",
original=str,
}
end
local detailed=split(str)
local rawscheme=""
local rawquery=""
local somescheme=false
local somequery=false
if detailed then
rawscheme=detailed[1]
rawquery=detailed[4]
somescheme=rawscheme~=""
somequery=rawquery~=""
end
if not somescheme and not somequery then
return {
scheme="file",
authority="",
path=str,
query="",
fragment="",
original=str,
noscheme=true,
filename=str,
}
end
local authority=detailed[2]
local path=detailed[3]
local filename
local username
local password
local host
local port
if authority~="" then
username,password,host,port=lpegmatch(splitauthority,authority)
end
if authority=="" then
filename=path
elseif path=="" then
filename=""
else
filename=authority.."/"..path
end
return {
scheme=rawscheme,
authority=authority,
path=path,
query=lpegmatch(unescaper,rawquery),
queries=lpegmatch(splitquery,rawquery),
fragment=detailed[5],
original=str,
noscheme=false,
filename=filename,
host=host,
port=port,
}
end
url.split=split
url.hasscheme=hasscheme
url.hashed=hashed
function url.addscheme(str,scheme)
if hasscheme(str) then
return str
elseif not scheme then
return "file:///"..str
else
return scheme..":///"..str
end
end
function url.construct(hash)
local result,r={},0
local scheme=hash.scheme
local authority=hash.authority
local path=hash.path
local queries=hash.queries
local fragment=hash.fragment
if scheme and scheme~="" then
r=r+1;result[r]=lpegmatch(escaper,scheme)
r=r+1;result[r]="://"
end
if authority and authority~="" then
r=r+1;result[r]=lpegmatch(escaper,authority)
end
if path and path~="" then
r=r+1;result[r]="/"
r=r+1;result[r]=lpegmatch(escaper,path)
end
if queries then
local done=false
for k,v in sortedhash(queries) do
r=r+1;result[r]=done and "&" or "?"
r=r+1;result[r]=lpegmatch(escaper,k)
r=r+1;result[r]="="
r=r+1;result[r]=lpegmatch(escaper,v)
done=true
end
end
if fragment and fragment~="" then
r=r+1;result[r]="#"
r=r+1;result[r]=lpegmatch(escaper,fragment)
end
return concat(result)
end
local pattern=Cs(slash^-1/""*R("az","AZ")*((S(":|")/":")+P(":"))*slash*P(1)^0)
function url.filename(filename)
local spec=hashed(filename)
local path=spec.path
return (spec.scheme=="file" and path and lpegmatch(pattern,path)) or filename
end
local function escapestring(str)
return lpegmatch(escaper,str)
end
url.escape=escapestring
function url.query(str)
if type(str)=="string" then
return lpegmatch(splitquery,str) or ""
else
return str
end
end
function url.toquery(data)
local td=type(data)
if td=="string" then
return #str and escape(data) or nil
elseif td=="table" then
if next(data) then
local t={}
for k,v in next,data do
t[#t+1]=format("%s=%s",k,escapestring(v))
end
return concat(t,"&")
end
else
end
end
local pattern=Cs(noslash^0*(1-noslash*P(-1))^0)
function url.barepath(path)
if not path or path=="" then
return ""
else
return lpegmatch(pattern,path)
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-dir"] = package.loaded["l-dir"] or true
-- original size: 18253, stripped down to: 10816
if not modules then modules={} end modules ['l-dir']={
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"
}
local type,select=type,select
local find,gmatch,match,gsub,sub=string.find,string.gmatch,string.match,string.gsub,string.sub
local concat,insert,remove,unpack=table.concat,table.insert,table.remove,table.unpack
local lpegmatch=lpeg.match
local P,S,R,C,Cc,Cs,Ct,Cv,V=lpeg.P,lpeg.S,lpeg.R,lpeg.C,lpeg.Cc,lpeg.Cs,lpeg.Ct,lpeg.Cv,lpeg.V
dir=dir or {}
local dir=dir
local lfs=lfs
local attributes=lfs.attributes
local walkdir=lfs.dir
local isdir=lfs.isdir
local isfile=lfs.isfile
local currentdir=lfs.currentdir
local chdir=lfs.chdir
local mkdir=lfs.mkdir
local onwindows=os.type=="windows" or find(os.getenv("PATH"),";",1,true)
if onwindows then
local tricky=S("/\\")*P(-1)
isdir=function(name)
if lpegmatch(tricky,name) then
return attributes(name,"mode")=="directory"
else
return attributes(name.."/.","mode")=="directory"
end
end
isfile=function(name)
return attributes(name,"mode")=="file"
end
lfs.isdir=isdir
lfs.isfile=isfile
else
isdir=function(name)
return attributes(name,"mode")=="directory"
end
isfile=function(name)
return attributes(name,"mode")=="file"
end
lfs.isdir=isdir
lfs.isfile=isfile
end
function dir.current()
return (gsub(currentdir(),"\\","/"))
end
local function glob_pattern_function(path,patt,recurse,action)
if isdir(path) then
local usedpath
if path=="/" then
usedpath="/."
elseif not find(path,"/$") then
usedpath=path.."/."
path=path.."/"
else
usedpath=path
end
local dirs
local nofdirs=0
for name,mode,size,time in walkdir(usedpath) do
if name~="." and name~=".." then
local full=path..name
if mode==nil then
mode=attributes(full,'mode')
end
if mode=='file' then
if not patt or find(full,patt) then
action(full,size,time)
end
elseif recurse and mode=="directory" then
if dirs then
nofdirs=nofdirs+1
dirs[nofdirs]=full
else
nofdirs=1
dirs={ full }
end
end
end
end
if dirs then
for i=1,nofdirs do
glob_pattern_function(dirs[i],patt,recurse,action)
end
end
end
end
local function glob_pattern_table(path,patt,recurse,result)
if not result then
result={}
end
local usedpath
if path=="/" then
usedpath="/."
elseif not find(path,"/$") then
usedpath=path.."/."
path=path.."/"
else
usedpath=path
end
local dirs
local nofdirs=0
local noffiles=#result
for name,mode in walkdir(usedpath) do
if name~="." and name~=".." then
local full=path..name
if mode==nil then
mode=attributes(full,'mode')
end
if mode=='file' then
if not patt or find(full,patt) then
noffiles=noffiles+1
result[noffiles]=full
end
elseif recurse and mode=="directory" then
if dirs then
nofdirs=nofdirs+1
dirs[nofdirs]=full
else
nofdirs=1
dirs={ full }
end
end
end
end
if dirs then
for i=1,nofdirs do
glob_pattern_table(dirs[i],patt,recurse,result)
end
end
return result
end
local function globpattern(path,patt,recurse,method)
local kind=type(method)
if patt and sub(patt,1,-3)==path then
patt=false
end
local okay=isdir(path)
if kind=="function" then
return okay and glob_pattern_function(path,patt,recurse,method) or {}
elseif kind=="table" then
return okay and glob_pattern_table(path,patt,recurse,method) or method
else
return okay and glob_pattern_table(path,patt,recurse,{}) or {}
end
end
dir.globpattern=globpattern
local function collectpattern(path,patt,recurse,result)
local ok,scanner
result=result or {}
if path=="/" then
ok,scanner,first=xpcall(function() return walkdir(path..".") end,function() end)
else
ok,scanner,first=xpcall(function() return walkdir(path) end,function() end)
end
if ok and type(scanner)=="function" then
if not find(path,"/$") then
path=path..'/'
end
for name in scanner,first do
if name=="." then
elseif name==".." then
else
local full=path..name
local attr=attributes(full)
local mode=attr.mode
if mode=='file' then
if find(full,patt) then
result[name]=attr
end
elseif recurse and mode=="directory" then
attr.list=collectpattern(full,patt,recurse)
result[name]=attr
end
end
end
end
return result
end
dir.collectpattern=collectpattern
local separator,pattern
if onwindows then
local slash=S("/\\")/"/"
pattern={
[1]=(Cs(P(".")+slash^1)+Cs(R("az","AZ")*P(":")*slash^0)+Cc("./"))*V(2)*V(3),
[2]=Cs(((1-S("*?/\\"))^0*slash)^0),
[3]=Cs(P(1)^0)
}
else
pattern={
[1]=(C(P(".")+P("/")^1)+Cc("./"))*V(2)*V(3),
[2]=C(((1-S("*?/"))^0*P("/"))^0),
[3]=C(P(1)^0)
}
end
local filter=Cs ((
P("**")/".*"+P("*")/"[^/]*"+P("?")/"[^/]"+P(".")/"%%."+P("+")/"%%+"+P("-")/"%%-"+P(1)
)^0 )
local function glob(str,t)
if type(t)=="function" then
if type(str)=="table" then
for s=1,#str do
glob(str[s],t)
end
elseif isfile(str) then
t(str)
else
local root,path,base=lpegmatch(pattern,str)
if root and path and base then
local recurse=find(base,"**",1,true)
local start=root..path
local result=lpegmatch(filter,start..base)
globpattern(start,result,recurse,t)
end
end
else
if type(str)=="table" then
local t=t or {}
for s=1,#str do
glob(str[s],t)
end
return t
elseif isfile(str) then
if t then
t[#t+1]=str
return t
else
return { str }
end
else
local root,path,base=lpegmatch(pattern,str)
if root and path and base then
local recurse=find(base,"**",1,true)
local start=root..path
local result=lpegmatch(filter,start..base)
return globpattern(start,result,recurse,t)
else
return {}
end
end
end
end
dir.glob=glob
local function globfiles(path,recurse,func,files)
if type(func)=="string" then
local s=func
func=function(name) return find(name,s) end
end
files=files or {}
local noffiles=#files
for name,mode in walkdir(path) do
if find(name,"^%.") then
else
if mode==nil then
mode=attributes(name,'mode')
end
if mode=="directory" then
if recurse then
globfiles(path.."/"..name,recurse,func,files)
end
elseif mode=="file" then
if not func or func(name) then
noffiles=noffiles+1
files[noffiles]=path.."/"..name
end
end
end
end
return files
end
dir.globfiles=globfiles
local function globdirs(path,recurse,func,files)
if type(func)=="string" then
local s=func
func=function(name) return find(name,s) end
end
files=files or {}
local noffiles=#files
for name,mode in walkdir(path) do
if find(name,"^%.") then
else
if mode==nil then
mode=attributes(name,'mode')
end
if mode=="directory" then
if not func or func(name) then
noffiles=noffiles+1
files[noffiles]=path.."/"..name
if recurse then
globdirs(path.."/"..name,recurse,func,files)
end
end
end
end
end
return files
end
dir.globdirs=globdirs
function dir.ls(pattern)
return concat(glob(pattern),"\n")
end
local make_indeed=true
if onwindows then
function dir.mkdirs(...)
local n=select("#",...)
local str
if n==1 then
str=select(1,...)
if isdir(str) then
return str,true
end
else
str=""
for i=1,n do
local s=select(i,...)
if s=="" then
elseif str=="" then
str=s
else
str=str.."/"..s
end
end
end
local pth=""
local drive=false
local first,middle,last=match(str,"^(//)(//*)(.*)$")
if first then
else
first,last=match(str,"^(//)/*(.-)$")
if first then
middle,last=match(str,"([^/]+)/+(.-)$")
if middle then
pth="//"..middle
else
pth="//"..last
last=""
end
else
first,middle,last=match(str,"^([a-zA-Z]:)(/*)(.-)$")
if first then
pth,drive=first..middle,true
else
middle,last=match(str,"^(/*)(.-)$")
if not middle then
last=str
end
end
end
end
for s in gmatch(last,"[^/]+") do
if pth=="" then
pth=s
elseif drive then
pth,drive=pth..s,false
else
pth=pth.."/"..s
end
if make_indeed and not isdir(pth) then
mkdir(pth)
end
end
return pth,(isdir(pth)==true)
end
else
function dir.mkdirs(...)
local n=select("#",...)
local str,pth
if n==1 then
str=select(1,...)
if isdir(str) then
return str,true
end
else
str=""
for i=1,n do
local s=select(i,...)
if s and s~="" then
if str~="" then
str=str.."/"..s
else
str=s
end
end
end
end
str=gsub(str,"/+","/")
if find(str,"^/") then
pth="/"
for s in gmatch(str,"[^/]+") do
local first=(pth=="/")
if first then
pth=pth..s
else
pth=pth.."/"..s
end
if make_indeed and not first and not isdir(pth) then
mkdir(pth)
end
end
else
pth="."
for s in gmatch(str,"[^/]+") do
pth=pth.."/"..s
if make_indeed and not isdir(pth) then
mkdir(pth)
end
end
end
return pth,(isdir(pth)==true)
end
end
dir.makedirs=dir.mkdirs
do
local chdir=sandbox and sandbox.original(chdir) or chdir
if onwindows then
local xcurrentdir=dir.current
function dir.expandname(str)
local first,nothing,last=match(str,"^(//)(//*)(.*)$")
if first then
first=xcurrentdir().."/"
end
if not first then
first,last=match(str,"^(//)/*(.*)$")
end
if not first then
first,last=match(str,"^([a-zA-Z]:)(.*)$")
if first and not find(last,"^/") then
local d=currentdir()
if chdir(first) then
first=xcurrentdir()
end
chdir(d)
end
end
if not first then
first,last=xcurrentdir(),str
end
last=gsub(last,"//","/")
last=gsub(last,"/%./","/")
last=gsub(last,"^/*","")
first=gsub(first,"/*$","")
if last=="" or last=="." then
return first
else
return first.."/"..last
end
end
else
function dir.expandname(str)
if not find(str,"^/") then
str=currentdir().."/"..str
end
str=gsub(str,"//","/")
str=gsub(str,"/%./","/")
str=gsub(str,"(.)/%.$","%1")
return str
end
end
end
file.expandname=dir.expandname
local stack={}
function dir.push(newdir)
local curdir=currentdir()
insert(stack,curdir)
if newdir and newdir~="" and chdir(newdir) then
return newdir
else
return curdir
end
end
function dir.pop()
local d=remove(stack)
if d then
chdir(d)
end
return d
end
local function found(...)
for i=1,select("#",...) do
local path=select(i,...)
local kind=type(path)
if kind=="string" then
if isdir(path) then
return path
end
elseif kind=="table" then
local path=found(unpack(path))
if path then
return path
end
end
end
end
dir.found=found
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-boolean"] = package.loaded["l-boolean"] or true
-- original size: 1850, stripped down to: 1498
if not modules then modules={} end modules ['l-boolean']={
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"
}
local type,tonumber=type,tonumber
boolean=boolean or {}
local boolean=boolean
function boolean.tonumber(b)
if b then return 1 else return 0 end
end
function toboolean(str,tolerant)
if str==nil then
return false
elseif str==false then
return false
elseif str==true then
return true
elseif str=="true" then
return true
elseif str=="false" then
return false
elseif not tolerant then
return false
elseif str==0 then
return false
elseif (tonumber(str) or 0)>0 then
return true
else
return str=="yes" or str=="on" or str=="t"
end
end
string.toboolean=toboolean
function string.booleanstring(str)
if str=="0" then
return false
elseif str=="1" then
return true
elseif str=="" then
return false
elseif str=="false" then
return false
elseif str=="true" then
return true
elseif (tonumber(str) or 0)>0 then
return true
else
return str=="yes" or str=="on" or str=="t"
end
end
function string.is_boolean(str,default,strict)
if type(str)=="string" then
if str=="true" or str=="yes" or str=="on" or str=="t" or (not strict and str=="1") then
return true
elseif str=="false" or str=="no" or str=="off" or str=="f" or (not strict and str=="0") then
return false
end
end
return default
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-unicode"] = package.loaded["l-unicode"] or true
-- original size: 41047, stripped down to: 17171
if not modules then modules={} end modules ['l-unicode']={
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"
}
utf=utf or {}
unicode=nil
if not string.utfcharacters then
local gmatch=string.gmatch
function string.characters(str)
return gmatch(str,".[\128-\191]*")
end
end
utf.characters=string.utfcharacters
local type=type
local char,byte,format,sub,gmatch=string.char,string.byte,string.format,string.sub,string.gmatch
local concat=table.concat
local P,C,R,Cs,Ct,Cmt,Cc,Carg,Cp=lpeg.P,lpeg.C,lpeg.R,lpeg.Cs,lpeg.Ct,lpeg.Cmt,lpeg.Cc,lpeg.Carg,lpeg.Cp
local lpegmatch=lpeg.match
local patterns=lpeg.patterns
local tabletopattern=lpeg.utfchartabletopattern
local bytepairs=string.bytepairs
local finder=lpeg.finder
local replacer=lpeg.replacer
local p_utftype=patterns.utftype
local p_utfstricttype=patterns.utfstricttype
local p_utfoffset=patterns.utfoffset
local p_utf8character=patterns.utf8character
local p_utf8char=patterns.utf8char
local p_utf8byte=patterns.utf8byte
local p_utfbom=patterns.utfbom
local p_newline=patterns.newline
local p_whitespace=patterns.whitespace
if not utf.char then
utf.char=string.utfcharacter or (utf8 and utf8.char)
if not utf.char then
local char=string.char
if bit32 then
local rshift=bit32.rshift
function utf.char(n)
if n<0x80 then
return char(n)
elseif n<0x800 then
return char(
0xC0+rshift(n,6),
0x80+(n%0x40)
)
elseif n<0x10000 then
return char(
0xE0+rshift(n,12),
0x80+(rshift(n,6)%0x40),
0x80+(n%0x40)
)
elseif n<0x200000 then
return char(
0xF0+rshift(n,18),
0x80+(rshift(n,12)%0x40),
0x80+(rshift(n,6)%0x40),
0x80+(n%0x40)
)
else
return ""
end
end
else
local floor=math.floor
function utf.char(n)
if n<0x80 then
return char(n)
elseif n<0x800 then
return char(
0xC0+floor(n/0x40),
0x80+(n%0x40)
)
elseif n<0x10000 then
return char(
0xE0+floor(n/0x1000),
0x80+(floor(n/0x40)%0x40),
0x80+(n%0x40)
)
elseif n<0x200000 then
return char(
0xF0+floor(n/0x40000),
0x80+(floor(n/0x1000)%0x40),
0x80+(floor(n/0x40)%0x40),
0x80+(n%0x40)
)
else
return ""
end
end
end
end
end
if not utf.byte then
utf.byte=string.utfvalue or (utf8 and utf8.codepoint)
if not utf.byte then
function utf.byte(c)
return lpegmatch(p_utf8byte,c)
end
end
end
local utfchar,utfbyte=utf.char,utf.byte
function utf.filetype(data)
return data and lpegmatch(p_utftype,data) or "unknown"
end
local toentities=Cs (
(
patterns.utf8one+(
patterns.utf8two+patterns.utf8three+patterns.utf8four
)/function(s) local b=utfbyte(s) if b<127 then return s else return format("&#%X;",b) end end
)^0
)
patterns.toentities=toentities
function utf.toentities(str)
return lpegmatch(toentities,str)
end
local one=P(1)
local two=C(1)*C(1)
local four=C(R(utfchar(0xD8),utfchar(0xFF)))*C(1)*C(1)*C(1)
local pattern=P("\254\255")*Cs((
four/function(a,b,c,d)
local ab=0xFF*byte(a)+byte(b)
local cd=0xFF*byte(c)+byte(d)
return utfchar((ab-0xD800)*0x400+(cd-0xDC00)+0x10000)
end+two/function(a,b)
return utfchar(byte(a)*256+byte(b))
end+one
)^1 )+P("\255\254")*Cs((
four/function(b,a,d,c)
local ab=0xFF*byte(a)+byte(b)
local cd=0xFF*byte(c)+byte(d)
return utfchar((ab-0xD800)*0x400+(cd-0xDC00)+0x10000)
end+two/function(b,a)
return utfchar(byte(a)*256+byte(b))
end+one
)^1 )
function string.toutf(s)
return lpegmatch(pattern,s) or s
end
local validatedutf=Cs (
(
patterns.utf8one+patterns.utf8two+patterns.utf8three+patterns.utf8four+P(1)/"�"
)^0
)
patterns.validatedutf=validatedutf
function utf.is_valid(str)
return type(str)=="string" and lpegmatch(validatedutf,str) or false
end
if not utf.len then
utf.len=string.utflength or (utf8 and utf8.len)
if not utf.len then
local n,f=0,1
local utfcharcounter=patterns.utfbom^-1*Cmt (
Cc(1)*patterns.utf8one^1+Cc(2)*patterns.utf8two^1+Cc(3)*patterns.utf8three^1+Cc(4)*patterns.utf8four^1,
function(_,t,d)
n=n+(t-f)/d
f=t
return true
end
)^0
function utf.len(str)
n,f=0,1
lpegmatch(utfcharcounter,str or "")
return n
end
end
end
utf.length=utf.len
if not utf.sub then
local utflength=utf.length
local b,e,n,first,last=0,0,0,0,0
local function slide_zero(s,p)
n=n+1
if n>=last then
e=p-1
else
return p
end
end
local function slide_one(s,p)
n=n+1
if n==first then
b=p
end
if n>=last then
e=p-1
else
return p
end
end
local function slide_two(s,p)
n=n+1
if n==first then
b=p
else
return true
end
end
local pattern_zero=Cmt(p_utf8character,slide_zero)^0
local pattern_one=Cmt(p_utf8character,slide_one )^0
local pattern_two=Cmt(p_utf8character,slide_two )^0
local pattern_first=C(p_utf8character)
function utf.sub(str,start,stop)
if not start then
return str
end
if start==0 then
start=1
end
if not stop then
if start<0 then
local l=utflength(str)
start=l+start
else
start=start-1
end
b,n,first=0,0,start
lpegmatch(pattern_two,str)
if n>=first then
return sub(str,b)
else
return ""
end
end
if start<0 or stop<0 then
local l=utf.length(str)
if start<0 then
start=l+start
if start<=0 then
start=1
else
start=start+1
end
end
if stop<0 then
stop=l+stop
if stop==0 then
stop=1
else
stop=stop+1
end
end
end
if start==1 and stop==1 then
return lpegmatch(pattern_first,str) or ""
elseif start>stop then
return ""
elseif start>1 then
b,e,n,first,last=0,0,0,start-1,stop
lpegmatch(pattern_one,str)
if n>=first and e==0 then
e=#str
end
return sub(str,b,e)
else
b,e,n,last=1,0,0,stop
lpegmatch(pattern_zero,str)
if e==0 then
e=#str
end
return sub(str,b,e)
end
end
end
function utf.remapper(mapping,option,action)
local variant=type(mapping)
if variant=="table" then
action=action or mapping
if option=="dynamic" then
local pattern=false
table.setmetatablenewindex(mapping,function(t,k,v) rawset(t,k,v) pattern=false end)
return function(str)
if not str or str=="" then
return ""
else
if not pattern then
pattern=Cs((tabletopattern(mapping)/action+p_utf8character)^0)
end
return lpegmatch(pattern,str)
end
end
elseif option=="pattern" then
return Cs((tabletopattern(mapping)/action+p_utf8character)^0)
else
local pattern=Cs((tabletopattern(mapping)/action+p_utf8character)^0)
return function(str)
if not str or str=="" then
return ""
else
return lpegmatch(pattern,str)
end
end,pattern
end
elseif variant=="function" then
if option=="pattern" then
return Cs((p_utf8character/mapping+p_utf8character)^0)
else
local pattern=Cs((p_utf8character/mapping+p_utf8character)^0)
return function(str)
if not str or str=="" then
return ""
else
return lpegmatch(pattern,str)
end
end,pattern
end
else
return function(str)
return str or ""
end
end
end
function utf.replacer(t)
local r=replacer(t,false,false,true)
return function(str)
return lpegmatch(r,str)
end
end
function utf.subtituter(t)
local f=finder (t)
local r=replacer(t,false,false,true)
return function(str)
local i=lpegmatch(f,str)
if not i then
return str
elseif i>#str then
return str
else
return lpegmatch(r,str)
end
end
end
local utflinesplitter=p_utfbom^-1*lpeg.tsplitat(p_newline)
local utfcharsplitter_ows=p_utfbom^-1*Ct(C(p_utf8character)^0)
local utfcharsplitter_iws=p_utfbom^-1*Ct((p_whitespace^1+C(p_utf8character))^0)
local utfcharsplitter_raw=Ct(C(p_utf8character)^0)
patterns.utflinesplitter=utflinesplitter
function utf.splitlines(str)
return lpegmatch(utflinesplitter,str or "")
end
function utf.split(str,ignorewhitespace)
if ignorewhitespace then
return lpegmatch(utfcharsplitter_iws,str or "")
else
return lpegmatch(utfcharsplitter_ows,str or "")
end
end
function utf.totable(str)
return lpegmatch(utfcharsplitter_raw,str)
end
function utf.magic(f)
local str=f:read(4) or ""
local off=lpegmatch(p_utfoffset,str)
if off<4 then
f:seek('set',off)
end
return lpegmatch(p_utftype,str)
end
local utf16_to_utf8_be,utf16_to_utf8_le
local utf32_to_utf8_be,utf32_to_utf8_le
local utf_16_be_getbom=patterns.utfbom_16_be^-1
local utf_16_le_getbom=patterns.utfbom_16_le^-1
local utf_32_be_getbom=patterns.utfbom_32_be^-1
local utf_32_le_getbom=patterns.utfbom_32_le^-1
local utf_16_be_linesplitter=utf_16_be_getbom*lpeg.tsplitat(patterns.utf_16_be_nl)
local utf_16_le_linesplitter=utf_16_le_getbom*lpeg.tsplitat(patterns.utf_16_le_nl)
local utf_32_be_linesplitter=utf_32_be_getbom*lpeg.tsplitat(patterns.utf_32_be_nl)
local utf_32_le_linesplitter=utf_32_le_getbom*lpeg.tsplitat(patterns.utf_32_le_nl)
local more=0
local p_utf16_to_utf8_be=C(1)*C(1)/function(left,right)
local now=256*byte(left)+byte(right)
if more>0 then
now=(more-0xD800)*0x400+(now-0xDC00)+0x10000
more=0
return utfchar(now)
elseif now>=0xD800 and now<=0xDBFF then
more=now
return ""
else
return utfchar(now)
end
end
local p_utf16_to_utf8_le=C(1)*C(1)/function(right,left)
local now=256*byte(left)+byte(right)
if more>0 then
now=(more-0xD800)*0x400+(now-0xDC00)+0x10000
more=0
return utfchar(now)
elseif now>=0xD800 and now<=0xDBFF then
more=now
return ""
else
return utfchar(now)
end
end
local p_utf32_to_utf8_be=C(1)*C(1)*C(1)*C(1)/function(a,b,c,d)
return utfchar(256*256*256*byte(a)+256*256*byte(b)+256*byte(c)+byte(d))
end
local p_utf32_to_utf8_le=C(1)*C(1)*C(1)*C(1)/function(a,b,c,d)
return utfchar(256*256*256*byte(d)+256*256*byte(c)+256*byte(b)+byte(a))
end
p_utf16_to_utf8_be=P(true)/function() more=0 end*utf_16_be_getbom*Cs(p_utf16_to_utf8_be^0)
p_utf16_to_utf8_le=P(true)/function() more=0 end*utf_16_le_getbom*Cs(p_utf16_to_utf8_le^0)
p_utf32_to_utf8_be=P(true)/function() more=0 end*utf_32_be_getbom*Cs(p_utf32_to_utf8_be^0)
p_utf32_to_utf8_le=P(true)/function() more=0 end*utf_32_le_getbom*Cs(p_utf32_to_utf8_le^0)
patterns.utf16_to_utf8_be=p_utf16_to_utf8_be
patterns.utf16_to_utf8_le=p_utf16_to_utf8_le
patterns.utf32_to_utf8_be=p_utf32_to_utf8_be
patterns.utf32_to_utf8_le=p_utf32_to_utf8_le
utf16_to_utf8_be=function(s)
if s and s~="" then
return lpegmatch(p_utf16_to_utf8_be,s)
else
return s
end
end
local utf16_to_utf8_be_t=function(t)
if not t then
return nil
elseif type(t)=="string" then
t=lpegmatch(utf_16_be_linesplitter,t)
end
for i=1,#t do
local s=t[i]
if s~="" then
t[i]=lpegmatch(p_utf16_to_utf8_be,s)
end
end
return t
end
utf16_to_utf8_le=function(s)
if s and s~="" then
return lpegmatch(p_utf16_to_utf8_le,s)
else
return s
end
end
local utf16_to_utf8_le_t=function(t)
if not t then
return nil
elseif type(t)=="string" then
t=lpegmatch(utf_16_le_linesplitter,t)
end
for i=1,#t do
local s=t[i]
if s~="" then
t[i]=lpegmatch(p_utf16_to_utf8_le,s)
end
end
return t
end
utf32_to_utf8_be=function(s)
if s and s~="" then
return lpegmatch(p_utf32_to_utf8_be,s)
else
return s
end
end
local utf32_to_utf8_be_t=function(t)
if not t then
return nil
elseif type(t)=="string" then
t=lpegmatch(utf_32_be_linesplitter,t)
end
for i=1,#t do
local s=t[i]
if s~="" then
t[i]=lpegmatch(p_utf32_to_utf8_be,s)
end
end
return t
end
utf32_to_utf8_le=function(s)
if s and s~="" then
return lpegmatch(p_utf32_to_utf8_le,s)
else
return s
end
end
local utf32_to_utf8_le_t=function(t)
if not t then
return nil
elseif type(t)=="string" then
t=lpegmatch(utf_32_le_linesplitter,t)
end
for i=1,#t do
local s=t[i]
if s~="" then
t[i]=lpegmatch(p_utf32_to_utf8_le,s)
end
end
return t
end
utf.utf16_to_utf8_le_t=utf16_to_utf8_le_t
utf.utf16_to_utf8_be_t=utf16_to_utf8_be_t
utf.utf32_to_utf8_le_t=utf32_to_utf8_le_t
utf.utf32_to_utf8_be_t=utf32_to_utf8_be_t
utf.utf16_to_utf8_le=utf16_to_utf8_le
utf.utf16_to_utf8_be=utf16_to_utf8_be
utf.utf32_to_utf8_le=utf32_to_utf8_le
utf.utf32_to_utf8_be=utf32_to_utf8_be
function utf.utf8_to_utf8_t(t)
return type(t)=="string" and lpegmatch(utflinesplitter,t) or t
end
function utf.utf16_to_utf8_t(t,endian)
return endian and utf16_to_utf8_be_t(t) or utf16_to_utf8_le_t(t) or t
end
function utf.utf32_to_utf8_t(t,endian)
return endian and utf32_to_utf8_be_t(t) or utf32_to_utf8_le_t(t) or t
end
local function little(b)
if b<0x10000 then
return char(b%256,rshift(b,8))
else
b=b-0x10000
local b1=rshift(b,10)+0xD800
local b2=b%1024+0xDC00
return char(b1%256,rshift(b1,8),b2%256,rshift(b2,8))
end
end
local function big(b)
if b<0x10000 then
return char(rshift(b,8),b%256)
else
b=b-0x10000
local b1=rshift(b,10)+0xD800
local b2=b%1024+0xDC00
return char(rshift(b1,8),b1%256,rshift(b2,8),b2%256)
end
end
local l_remap=Cs((p_utf8byte/little+P(1)/"")^0)
local b_remap=Cs((p_utf8byte/big+P(1)/"")^0)
local function utf8_to_utf16_be(str,nobom)
if nobom then
return lpegmatch(b_remap,str)
else
return char(254,255)..lpegmatch(b_remap,str)
end
end
local function utf8_to_utf16_le(str,nobom)
if nobom then
return lpegmatch(l_remap,str)
else
return char(255,254)..lpegmatch(l_remap,str)
end
end
utf.utf8_to_utf16_be=utf8_to_utf16_be
utf.utf8_to_utf16_le=utf8_to_utf16_le
function utf.utf8_to_utf16(str,littleendian,nobom)
if littleendian then
return utf8_to_utf16_le(str,nobom)
else
return utf8_to_utf16_be(str,nobom)
end
end
local pattern=Cs (
(p_utf8byte/function(unicode ) return format("0x%04X",unicode) end)*(p_utf8byte*Carg(1)/function(unicode,separator) return format("%s0x%04X",separator,unicode) end)^0
)
function utf.tocodes(str,separator)
return lpegmatch(pattern,str,1,separator or " ")
end
function utf.ustring(s)
return format("U+%05X",type(s)=="number" and s or utfbyte(s))
end
function utf.xstring(s)
return format("0x%05X",type(s)=="number" and s or utfbyte(s))
end
function utf.toeight(str)
if not str or str=="" then
return nil
end
local utftype=lpegmatch(p_utfstricttype,str)
if utftype=="utf-8" then
return sub(str,4)
elseif utftype=="utf-16-be" then
return utf16_to_utf8_be(str)
elseif utftype=="utf-16-le" then
return utf16_to_utf8_le(str)
else
return str
end
end
do
local p_nany=p_utf8character/""
local cache={}
function utf.count(str,what)
if type(what)=="string" then
local p=cache[what]
if not p then
p=Cs((P(what)/" "+p_nany)^0)
cache[p]=p
end
return #lpegmatch(p,str)
else
return #lpegmatch(Cs((P(what)/" "+p_nany)^0),str)
end
end
end
if not string.utfvalues then
local find=string.find
local dummy=function()
end
function string.utfvalues(str)
local n=#str
if n==0 then
return dummy
elseif n==1 then
return function() return utfbyte(str) end
else
local p=1
return function()
local b,e=find(str,".[\128-\191]*",p)
if b then
p=e+1
return utfbyte(sub(str,b,e))
end
end
end
end
end
utf.values=string.utfvalues
function utf.chrlen(u)
return
(u<0x80 and 1) or
(u<0xE0 and 2) or
(u<0xF0 and 3) or
(u<0xF8 and 4) or
(u<0xFC and 5) or
(u<0xFE and 6) or 0
end
if bit32 then
local extract=bit32.extract
local char=string.char
function utf.toutf32string(n)
if n<=0xFF then
return
char(n).."\000\000\000"
elseif n<=0xFFFF then
return
char(extract(n,0,8))..char(extract(n,8,8)).."\000\000"
elseif n<=0xFFFFFF then
return
char(extract(n,0,8))..char(extract(n,8,8))..char(extract(n,16,8)).."\000"
else
return
char(extract(n,0,8))..char(extract(n,8,8))..char(extract(n,16,8))..char(extract(n,24,8))
end
end
end
local len=utf.len
local rep=rep
function string.utfpadd(s,n)
if n and n~=0 then
local l=len(s)
if n>0 then
local d=n-l
if d>0 then
return rep(c or " ",d)..s
end
else
local d=- n-l
if d>0 then
return s..rep(c or " ",d)
end
end
end
return s
end
do
local utfcharacters=utf.characters or string.utfcharacters
local utfchar=utf.char or string.utfcharacter
lpeg.UP=P
if utfcharacters then
function lpeg.US(str)
local p=P(false)
for uc in utfcharacters(str) do
p=p+P(uc)
end
return p
end
else
function lpeg.US(str)
local p=P(false)
local f=function(uc)
p=p+P(uc)
end
lpegmatch((p_utf8char/f)^0,str)
return p
end
end
local range=p_utf8byte*p_utf8byte+Cc(false)
function lpeg.UR(str,more)
local first,last
if type(str)=="number" then
first=str
last=more or first
else
first,last=lpegmatch(range,str)
if not last then
return P(str)
end
end
if first==last then
return P(str)
end
if not utfchar then
utfchar=utf.char
end
if utfchar and (last-first<8) then
local p=P(false)
for i=first,last do
p=p+P(utfchar(i))
end
return p
else
local f=function(b)
return b>=first and b<=last
end
return p_utf8byte/f
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["l-math"] = package.loaded["l-math"] or true
-- original size: 2555, stripped down to: 1831
if not modules then modules={} end modules ['l-math']={
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"
}
if not math.ceiling then
math.ceiling=math.ceil
end
if not math.round then
local floor=math.floor
function math.round(x) return floor(x+0.5) end
end
if not math.div then
local floor=math.floor
function math.div(n,m) return floor(n/m) end
end
if not math.mod then
function math.mod(n,m) return n%m end
end
if not math.sind then
local sin,cos,tan=math.sin,math.cos,math.tan
local pipi=2*math.pi/360
function math.sind(d) return sin(d*pipi) end
function math.cosd(d) return cos(d*pipi) end
function math.tand(d) return tan(d*pipi) end
end
if not math.odd then
function math.odd (n) return n%2~=0 end
function math.even(n) return n%2==0 end
end
if not math.cosh then
local exp=math.exp
function math.cosh(x)
local xx=exp(x)
return (xx+1/xx)/2
end
function math.sinh(x)
local xx=exp(x)
return (xx-1/xx)/2
end
function math.tanh(x)
local xx=exp(x)
return (xx-1/xx)/(xx+1/xx)
end
end
if not math.pow then
function math.pow(x,y)
return x^y
end
end
if not math.atan2 then
math.atan2=math.atan
end
if not math.ldexp then
function math.ldexp(x,e)
return x*2.0^e
end
end
if not math.log10 then
local log=math.log
function math.log10(x)
return log(x,10)
end
end
if not math.type then
function math.type()
return "float"
end
end
if not math.tointeger then
math.mininteger=-0x4FFFFFFFFFFF
math.maxinteger=0x4FFFFFFFFFFF
local floor=math.floor
function math.tointeger(n)
local f=floor(n)
return f==n and f or nil
end
end
if not math.ult then
local floor=math.floor
function math.tointeger(m,n)
return floor(m)<floor(n)
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-str"] = package.loaded["util-str"] or true
-- original size: 43488, stripped down to: 21595
if not modules then modules={} end modules ['util-str']={
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"
}
utilities=utilities or {}
utilities.strings=utilities.strings or {}
local strings=utilities.strings
local format,gsub,rep,sub,find=string.format,string.gsub,string.rep,string.sub,string.find
local load,dump=load,string.dump
local tonumber,type,tostring,next,setmetatable=tonumber,type,tostring,next,setmetatable
local unpack,concat=table.unpack,table.concat
local P,V,C,S,R,Ct,Cs,Cp,Carg,Cc=lpeg.P,lpeg.V,lpeg.C,lpeg.S,lpeg.R,lpeg.Ct,lpeg.Cs,lpeg.Cp,lpeg.Carg,lpeg.Cc
local patterns,lpegmatch=lpeg.patterns,lpeg.match
local utfchar,utfbyte,utflen=utf.char,utf.byte,utf.len
local loadstripped=function(str,shortcuts)
if shortcuts then
return load(dump(load(str),true),nil,nil,shortcuts)
else
return load(dump(load(str),true))
end
end
if not number then number={} end
local stripzero=patterns.stripzero
local stripzeros=patterns.stripzeros
local newline=patterns.newline
local endofstring=patterns.endofstring
local anything=patterns.anything
local whitespace=patterns.whitespace
local space=patterns.space
local spacer=patterns.spacer
local spaceortab=patterns.spaceortab
local digit=patterns.digit
local sign=patterns.sign
local period=patterns.period
local ptf=1/65536
local bpf=(7200/7227)/65536
local function points(n)
if n==0 then
return "0pt"
end
n=tonumber(n)
if not n or n==0 then
return "0pt"
end
n=n*ptf
if n%1==0 then
return format("%ipt",n)
end
return lpegmatch(stripzeros,format("%.5fpt",n))
end
local function basepoints(n)
if n==0 then
return "0pt"
end
n=tonumber(n)
if not n or n==0 then
return "0pt"
end
n=n*bpf
if n%1==0 then
return format("%ibp",n)
end
return lpegmatch(stripzeros,format("%.5fbp",n))
end
number.points=points
number.basepoints=basepoints
local rubish=spaceortab^0*newline
local anyrubish=spaceortab+newline
local stripped=(spaceortab^1/"")*newline
local leading=rubish^0/""
local trailing=(anyrubish^1*endofstring)/""
local redundant=rubish^3/"\n"
local pattern=Cs(leading*(trailing+redundant+stripped+anything)^0)
function strings.collapsecrlf(str)
return lpegmatch(pattern,str)
end
local repeaters={}
function strings.newrepeater(str,offset)
offset=offset or 0
local s=repeaters[str]
if not s then
s={}
repeaters[str]=s
end
local t=s[offset]
if t then
return t
end
t={}
setmetatable(t,{ __index=function(t,k)
if not k then
return ""
end
local n=k+offset
local s=n>0 and rep(str,n) or ""
t[k]=s
return s
end })
s[offset]=t
return t
end
local extra,tab,start=0,0,4,0
local nspaces=strings.newrepeater(" ")
string.nspaces=nspaces
local pattern=Carg(1)/function(t)
extra,tab,start=0,t or 7,1
end*Cs((
Cp()*patterns.tab/function(position)
local current=(position-start+1)+extra
local spaces=tab-(current-1)%tab
if spaces>0 then
extra=extra+spaces-1
return nspaces[spaces]
else
return ""
end
end+newline*Cp()/function(position)
extra,start=0,position
end+anything
)^1)
function strings.tabtospace(str,tab)
return lpegmatch(pattern,str,1,tab or 7)
end
function string.utfpadding(s,n)
if not n or n==0 then
return ""
end
local l=utflen(s)
if n>0 then
return nspaces[n-l]
else
return nspaces[-n-l]
end
end
local optionalspace=spacer^0
local nospace=optionalspace/""
local endofline=nospace*newline
local stripend=(whitespace^1*endofstring)/""
local normalline=(nospace*((1-optionalspace*(newline+endofstring))^1)*nospace)
local stripempty=endofline^1/""
local normalempty=endofline^1
local singleempty=endofline*(endofline^0/"")
local doubleempty=endofline*endofline^-1*(endofline^0/"")
local stripstart=stripempty^0
local intospace=whitespace^1/" "
local noleading=whitespace^1/""
local notrailing=noleading*endofstring
local p_prune_normal=Cs (stripstart*(stripend+normalline+normalempty )^0 )
local p_prune_collapse=Cs (stripstart*(stripend+normalline+doubleempty )^0 )
local p_prune_noempty=Cs (stripstart*(stripend+normalline+singleempty )^0 )
local p_prune_intospace=Cs (noleading*(notrailing+intospace+1 )^0 )
local p_retain_normal=Cs ((normalline+normalempty )^0 )
local p_retain_collapse=Cs ((normalline+doubleempty )^0 )
local p_retain_noempty=Cs ((normalline+singleempty )^0 )
local striplinepatterns={
["prune"]=p_prune_normal,
["prune and collapse"]=p_prune_collapse,
["prune and no empty"]=p_prune_noempty,
["prune and to space"]=p_prune_intospace,
["retain"]=p_retain_normal,
["retain and collapse"]=p_retain_collapse,
["retain and no empty"]=p_retain_noempty,
["collapse"]=patterns.collapser,
}
setmetatable(striplinepatterns,{ __index=function(t,k) return p_prune_collapse end })
strings.striplinepatterns=striplinepatterns
function strings.striplines(str,how)
return str and lpegmatch(striplinepatterns[how],str) or str
end
function strings.collapse(str)
return str and lpegmatch(p_prune_intospace,str) or str
end
strings.striplong=strings.striplines
function strings.nice(str)
str=gsub(str,"[:%-+_]+"," ")
return str
end
local n=0
local sequenced=table.sequenced
function string.autodouble(s,sep)
if s==nil then
return '""'
end
local t=type(s)
if t=="number" then
return tostring(s)
end
if t=="table" then
return ('"'..sequenced(s,sep or ",")..'"')
end
return ('"'..tostring(s)..'"')
end
function string.autosingle(s,sep)
if s==nil then
return "''"
end
local t=type(s)
if t=="number" then
return tostring(s)
end
if t=="table" then
return ("'"..sequenced(s,sep or ",").."'")
end
return ("'"..tostring(s).."'")
end
local tracedchars={ [0]=
"[null]","[soh]","[stx]","[etx]","[eot]","[enq]","[ack]","[bel]",
"[bs]","[ht]","[lf]","[vt]","[ff]","[cr]","[so]","[si]",
"[dle]","[dc1]","[dc2]","[dc3]","[dc4]","[nak]","[syn]","[etb]",
"[can]","[em]","[sub]","[esc]","[fs]","[gs]","[rs]","[us]",
"[space]",
}
string.tracedchars=tracedchars
strings.tracers=tracedchars
function string.tracedchar(b)
if type(b)=="number" then
return tracedchars[b] or (utfchar(b).." (U+"..format("%05X",b)..")")
else
local c=utfbyte(b)
return tracedchars[c] or (b.." (U+"..(c and format("%05X",c) or "?????")..")")
end
end
function number.signed(i)
if i>0 then
return "+",i
else
return "-",-i
end
end
local two=digit*digit
local three=two*digit
local prefix=(Carg(1)*three)^1
local splitter=Cs (
(((1-(three^1*period))^1+C(three))*prefix+C((1-period)^1))*(anything/""*Carg(2))*C(2)
)
local splitter3=Cs (
three*prefix*endofstring+two*prefix*endofstring+digit*prefix*endofstring+three+two+digit
)
patterns.formattednumber=splitter
function number.formatted(n,sep1,sep2)
if sep1==false then
if type(n)=="number" then
n=tostring(n)
end
return lpegmatch(splitter3,n,1,sep2 or ".")
else
if type(n)=="number" then
n=format("%0.2f",n)
end
if sep1==true then
return lpegmatch(splitter,n,1,".",",")
elseif sep1=="." then
return lpegmatch(splitter,n,1,sep1,sep2 or ",")
elseif sep1=="," then
return lpegmatch(splitter,n,1,sep1,sep2 or ".")
else
return lpegmatch(splitter,n,1,sep1 or ",",sep2 or ".")
end
end
end
local p=Cs(
P("-")^0*(P("0")^1/"")^0*(1-period)^0*(period*P("0")^1*endofstring/""+period^0)*P(1-P("0")^1*endofstring)^0
)
function number.compactfloat(n,fmt)
if n==0 then
return "0"
elseif n==1 then
return "1"
end
n=lpegmatch(p,format(fmt or "%0.3f",n))
if n=="." or n=="" or n=="-" then
return "0"
end
return n
end
local zero=P("0")^1/""
local plus=P("+")/""
local minus=P("-")
local separator=period
local trailing=zero^1*#S("eE")
local exponent=(S("eE")*(plus+Cs((minus*zero^0*endofstring)/"")+minus)*zero^0*(endofstring*Cc("0")+anything^1))
local pattern_a=Cs(minus^0*digit^1*(separator/""*trailing+separator*(trailing+digit)^0)*exponent)
local pattern_b=Cs((exponent+anything)^0)
function number.sparseexponent(f,n)
if not n then
n=f
f="%e"
end
local tn=type(n)
if tn=="string" then
local m=tonumber(n)
if m then
return lpegmatch((f=="%e" or f=="%E") and pattern_a or pattern_b,format(f,m))
end
elseif tn=="number" then
return lpegmatch((f=="%e" or f=="%E") and pattern_a or pattern_b,format(f,n))
end
return tostring(n)
end
local hf={}
local hs={}
setmetatable(hf,{ __index=function(t,k)
local v="%."..k.."f"
t[k]=v
return v
end } )
setmetatable(hs,{ __index=function(t,k)
local v="%"..k.."s"
t[k]=v
return v
end } )
function number.formattedfloat(n,b,a)
local s=format(hf[a],n)
local l=(b or 0)+(a or 0)+1
if #s<l then
return format(hs[l],s)
else
return s
end
end
local template=[[
%s
%s
return function(%s) return %s end
]]
local preamble=""
local environment={
global=global or _G,
lpeg=lpeg,
type=type,
tostring=tostring,
tonumber=tonumber,
format=string.format,
concat=table.concat,
signed=number.signed,
points=number.points,
basepoints=number.basepoints,
utfchar=utf.char,
utfbyte=utf.byte,
lpegmatch=lpeg.match,
nspaces=string.nspaces,
utfpadding=string.utfpadding,
tracedchar=string.tracedchar,
autosingle=string.autosingle,
autodouble=string.autodouble,
sequenced=table.sequenced,
formattednumber=number.formatted,
sparseexponent=number.sparseexponent,
formattedfloat=number.formattedfloat,
stripzero=lpeg.patterns.stripzero,
stripzeros=lpeg.patterns.stripzeros,
FORMAT=string.f9,
}
local arguments={ "a1" }
setmetatable(arguments,{ __index=function(t,k)
local v=t[k-1]..",a"..k
t[k]=v
return v
end
})
local prefix_any=C((sign+space+period+digit)^0)
local prefix_sub=(C((sign+digit)^0)+Cc(0))*period*(C((sign+digit)^0)+Cc(0))
local prefix_tab=P("{")*C((1-P("}"))^0)*P("}")+C((1-R("az","AZ","09","%%"))^0)
local format_s=function(f)
n=n+1
if f and f~="" then
return format("format('%%%ss',a%s)",f,n)
else
return format("(a%s or '')",n)
end
end
local format_S=function(f)
n=n+1
if f and f~="" then
return format("format('%%%ss',tostring(a%s))",f,n)
else
return format("tostring(a%s)",n)
end
end
local format_right=function(f)
n=n+1
f=tonumber(f)
if not f or f==0 then
return format("(a%s or '')",n)
elseif f>0 then
return format("utfpadding(a%s,%i)..a%s",n,f,n)
else
return format("a%s..utfpadding(a%s,%i)",n,n,f)
end
end
local format_left=function(f)
n=n+1
f=tonumber(f)
if not f or f==0 then
return format("(a%s or '')",n)
end
if f<0 then
return format("utfpadding(a%s,%i)..a%s",n,-f,n)
else
return format("a%s..utfpadding(a%s,%i)",n,n,-f)
end
end
local format_q=function()
n=n+1
return format("(a%s ~= nil and format('%%q',tostring(a%s)) or '')",n,n)
end
local format_Q=function()
n=n+1
return format("format('%%q',tostring(a%s))",n)
end
local format_i=function(f)
n=n+1
if f and f~="" then
return format("format('%%%si',a%s)",f,n)
else
return format("format('%%i',a%s)",n)
end
end
local format_d=format_i
local format_I=function(f)
n=n+1
return format("format('%%s%%%si',signed(a%s))",f,n)
end
local format_f=function(f)
n=n+1
return format("format('%%%sf',a%s)",f,n)
end
local format_F=function(f)
n=n+1
if not f or f=="" then
return format("(((a%s > -0.0000000005 and a%s < 0.0000000005) and '0') or format((a%s %% 1 == 0) and '%%i' or '%%.9f',a%s))",n,n,n,n)
else
return format("format((a%s %% 1 == 0) and '%%i' or '%%%sf',a%s)",n,f,n)
end
end
local format_k=function(b,a)
n=n+1
return format("formattedfloat(a%s,%s,%s)",n,b or 0,a or 0)
end
local format_g=function(f)
n=n+1
return format("format('%%%sg',a%s)",f,n)
end
local format_G=function(f)
n=n+1
return format("format('%%%sG',a%s)",f,n)
end
local format_e=function(f)
n=n+1
return format("format('%%%se',a%s)",f,n)
end
local format_E=function(f)
n=n+1
return format("format('%%%sE',a%s)",f,n)
end
local format_j=function(f)
n=n+1
return format("sparseexponent('%%%se',a%s)",f,n)
end
local format_J=function(f)
n=n+1
return format("sparseexponent('%%%sE',a%s)",f,n)
end
local format_x=function(f)
n=n+1
return format("format('%%%sx',a%s)",f,n)
end
local format_X=function(f)
n=n+1
return format("format('%%%sX',a%s)",f,n)
end
local format_o=function(f)
n=n+1
return format("format('%%%so',a%s)",f,n)
end
local format_c=function()
n=n+1
return format("utfchar(a%s)",n)
end
local format_C=function()
n=n+1
return format("tracedchar(a%s)",n)
end
local format_r=function(f)
n=n+1
return format("format('%%%s.0f',a%s)",f,n)
end
local format_h=function(f)
n=n+1
if f=="-" then
f=sub(f,2)
return format("format('%%%sx',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
else
return format("format('0x%%%sx',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
end
end
local format_H=function(f)
n=n+1
if f=="-" then
f=sub(f,2)
return format("format('%%%sX',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
else
return format("format('0x%%%sX',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
end
end
local format_u=function(f)
n=n+1
if f=="-" then
f=sub(f,2)
return format("format('%%%sx',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
else
return format("format('u+%%%sx',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
end
end
local format_U=function(f)
n=n+1
if f=="-" then
f=sub(f,2)
return format("format('%%%sX',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
else
return format("format('U+%%%sX',type(a%s) == 'number' and a%s or utfbyte(a%s))",f=="" and "05" or f,n,n,n)
end
end
local format_p=function()
n=n+1
return format("points(a%s)",n)
end
local format_b=function()
n=n+1
return format("basepoints(a%s)",n)
end
local format_t=function(f)
n=n+1
if f and f~="" then
return format("concat(a%s,%q)",n,f)
else
return format("concat(a%s)",n)
end
end
local format_T=function(f)
n=n+1
if f and f~="" then
return format("sequenced(a%s,%q)",n,f)
else
return format("sequenced(a%s)",n)
end
end
local format_l=function()
n=n+1
return format("(a%s and 'true' or 'false')",n)
end
local format_L=function()
n=n+1
return format("(a%s and 'TRUE' or 'FALSE')",n)
end
local format_n=function()
n=n+1
return format("((a%s %% 1 == 0) and format('%%i',a%s) or tostring(a%s))",n,n,n)
end
local format_N=function(f)
n=n+1
if not f or f=="" then
f=".9"
end
return format("(((a%s %% 1 == 0) and format('%%i',a%s)) or lpegmatch(stripzero,format('%%%sf',a%s)))",n,n,f,n)
end
local format_a=function(f)
n=n+1
if f and f~="" then
return format("autosingle(a%s,%q)",n,f)
else
return format("autosingle(a%s)",n)
end
end
local format_A=function(f)
n=n+1
if f and f~="" then
return format("autodouble(a%s,%q)",n,f)
else
return format("autodouble(a%s)",n)
end
end
local format_w=function(f)
n=n+1
f=tonumber(f)
if f then
return format("nspaces[%s+a%s]",f,n)
else
return format("nspaces[a%s]",n)
end
end
local format_W=function(f)
return format("nspaces[%s]",tonumber(f) or 0)
end
local format_m=function(f)
n=n+1
if not f or f=="" then
f=","
end
if f=="0" then
return format([[formattednumber(a%s,false)]],n)
else
return format([[formattednumber(a%s,%q,".")]],n,f)
end
end
local format_M=function(f)
n=n+1
if not f or f=="" then
f="."
end
if f=="0" then
return format([[formattednumber(a%s,false)]],n)
else
return format([[formattednumber(a%s,%q,",")]],n,f)
end
end
local format_z=function(f)
n=n+(tonumber(f) or 1)
return "''"
end
local format_rest=function(s)
return format("%q",s)
end
local format_extension=function(extensions,f,name)
local extension=extensions[name] or "tostring(%s)"
local f=tonumber(f) or 1
local w=find(extension,"%.%.%.")
if w then
if f==0 then
extension=gsub(extension,"%.%.%.","")
return extension
elseif f==1 then
extension=gsub(extension,"%.%.%.","%%s")
n=n+1
local a="a"..n
return format(extension,a,a)
elseif f<0 then
local a="a"..(n+f+1)
return format(extension,a,a)
else
extension=gsub(extension,"%.%.%.",rep("%%s,",f-1).."%%s")
local t={}
for i=1,f do
n=n+1
t[i]="a"..n
end
return format(extension,unpack(t))
end
else
extension=gsub(extension,"%%s",function()
n=n+1
return "a"..n
end)
return extension
end
end
local builder=Cs { "start",
start=(
(
P("%")/""*(
V("!")
+V("s")+V("q")+V("i")+V("d")+V("f")+V("F")+V("g")+V("G")+V("e")+V("E")+V("x")+V("X")+V("o")
+V("c")+V("C")+V("S")
+V("Q")
+V("n")
+V("N")
+V("k")
+V("r")+V("h")+V("H")+V("u")+V("U")+V("p")+V("b")+V("t")+V("T")+V("l")+V("L")+V("I")+V("w")
+V("W")
+V("a")
+V("A")
+V("j")+V("J")
+V("m")+V("M")
+V("z")
+V(">")
+V("<")
)+V("*")
)*(endofstring+Carg(1))
)^0,
["s"]=(prefix_any*P("s"))/format_s,
["q"]=(prefix_any*P("q"))/format_q,
["i"]=(prefix_any*P("i"))/format_i,
["d"]=(prefix_any*P("d"))/format_d,
["f"]=(prefix_any*P("f"))/format_f,
["F"]=(prefix_any*P("F"))/format_F,
["g"]=(prefix_any*P("g"))/format_g,
["G"]=(prefix_any*P("G"))/format_G,
["e"]=(prefix_any*P("e"))/format_e,
["E"]=(prefix_any*P("E"))/format_E,
["x"]=(prefix_any*P("x"))/format_x,
["X"]=(prefix_any*P("X"))/format_X,
["o"]=(prefix_any*P("o"))/format_o,
["S"]=(prefix_any*P("S"))/format_S,
["Q"]=(prefix_any*P("Q"))/format_Q,
["n"]=(prefix_any*P("n"))/format_n,
["N"]=(prefix_any*P("N"))/format_N,
["k"]=(prefix_sub*P("k"))/format_k,
["c"]=(prefix_any*P("c"))/format_c,
["C"]=(prefix_any*P("C"))/format_C,
["r"]=(prefix_any*P("r"))/format_r,
["h"]=(prefix_any*P("h"))/format_h,
["H"]=(prefix_any*P("H"))/format_H,
["u"]=(prefix_any*P("u"))/format_u,
["U"]=(prefix_any*P("U"))/format_U,
["p"]=(prefix_any*P("p"))/format_p,
["b"]=(prefix_any*P("b"))/format_b,
["t"]=(prefix_tab*P("t"))/format_t,
["T"]=(prefix_tab*P("T"))/format_T,
["l"]=(prefix_any*P("l"))/format_l,
["L"]=(prefix_any*P("L"))/format_L,
["I"]=(prefix_any*P("I"))/format_I,
["w"]=(prefix_any*P("w"))/format_w,
["W"]=(prefix_any*P("W"))/format_W,
["j"]=(prefix_any*P("j"))/format_j,
["J"]=(prefix_any*P("J"))/format_J,
["m"]=(prefix_any*P("m"))/format_m,
["M"]=(prefix_any*P("M"))/format_M,
["z"]=(prefix_any*P("z"))/format_z,
["a"]=(prefix_any*P("a"))/format_a,
["A"]=(prefix_any*P("A"))/format_A,
["<"]=(prefix_any*P("<"))/format_left,
[">"]=(prefix_any*P(">"))/format_right,
["*"]=Cs(((1-P("%"))^1+P("%%")/"%%")^1)/format_rest,
["?"]=Cs(((1-P("%"))^1 )^1)/format_rest,
["!"]=Carg(2)*prefix_any*P("!")*C((1-P("!"))^1)*P("!")/format_extension,
}
local xx=setmetatable({},{ __index=function(t,k) local v=format("%02x",k) t[k]=v return v end })
local XX=setmetatable({},{ __index=function(t,k) local v=format("%02X",k) t[k]=v return v end })
local preset={
["%02x"]=function(n) return xx[n] end,
["%02X"]=function(n) return XX[n] end,
}
local direct=P("%")*(sign+space+period+digit)^0*S("sqidfgGeExXo")*endofstring/[[local format = string.format return function(str) return format("%0",str) end]]
local function make(t,str)
local f=preset[str]
if f then
return f
end
local p=lpegmatch(direct,str)
if p then
f=loadstripped(p)()
else
n=0
p=lpegmatch(builder,str,1,t._connector_,t._extensions_)
if n>0 then
p=format(template,preamble,t._preamble_,arguments[n],p)
f=loadstripped(p,t._environment_)()
else
f=function() return str end
end
end
t[str]=f
return f
end
local function use(t,fmt,...)
return t[fmt](...)
end
strings.formatters={}
function strings.formatters.new(noconcat)
local e={}
for k,v in next,environment do
e[k]=v
end
local t={
_type_="formatter",
_connector_=noconcat and "," or "..",
_extensions_={},
_preamble_="",
_environment_=e,
}
setmetatable(t,{ __index=make,__call=use })
return t
end
local formatters=strings.formatters.new()
string.formatters=formatters
string.formatter=function(str,...) return formatters[str](...) end
local function add(t,name,template,preamble)
if type(t)=="table" and t._type_=="formatter" then
t._extensions_[name]=template or "%s"
if type(preamble)=="string" then
t._preamble_=preamble.."\n"..t._preamble_
elseif type(preamble)=="table" then
for k,v in next,preamble do
t._environment_[k]=v
end
end
end
end
strings.formatters.add=add
patterns.xmlescape=Cs((P("<")/"<"+P(">")/">"+P("&")/"&"+P('"')/"""+anything)^0)
patterns.texescape=Cs((C(S("#$%\\{}"))/"\\%1"+anything)^0)
patterns.luaescape=Cs(((1-S('"\n'))^1+P('"')/'\\"'+P('\n')/'\\n"')^0)
patterns.luaquoted=Cs(Cc('"')*((1-S('"\n'))^1+P('"')/'\\"'+P('\n')/'\\n"')^0*Cc('"'))
add(formatters,"xml",[[lpegmatch(xmlescape,%s)]],{ xmlescape=lpeg.patterns.xmlescape })
add(formatters,"tex",[[lpegmatch(texescape,%s)]],{ texescape=lpeg.patterns.texescape })
add(formatters,"lua",[[lpegmatch(luaescape,%s)]],{ luaescape=lpeg.patterns.luaescape })
local dquote=patterns.dquote
local equote=patterns.escaped+dquote/'\\"'+1
local cquote=Cc('"')
local pattern=Cs(dquote*(equote-P(-2))^0*dquote)
+Cs(cquote*(equote-space)^0*space*equote^0*cquote)
function string.optionalquoted(str)
return lpegmatch(pattern,str) or str
end
local pattern=Cs((newline/(os.newline or "\r")+1)^0)
function string.replacenewlines(str)
return lpegmatch(pattern,str)
end
function strings.newcollector()
local result,r={},0
return
function(fmt,str,...)
r=r+1
result[r]=str==nil and fmt or formatters[fmt](str,...)
end,
function(connector)
if result then
local str=concat(result,connector)
result,r={},0
return str
end
end
end
local f_16_16=formatters["%0.5N"]
function number.to16dot16(n)
return f_16_16(n/65536.0)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-tab"] = package.loaded["util-tab"] or true
-- original size: 28866, stripped down to: 16134
if not modules then modules={} end modules ['util-tab']={
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"
}
utilities=utilities or {}
utilities.tables=utilities.tables or {}
local tables=utilities.tables
local format,gmatch,gsub,sub=string.format,string.gmatch,string.gsub,string.sub
local concat,insert,remove,sort=table.concat,table.insert,table.remove,table.sort
local setmetatable,getmetatable,tonumber,tostring,rawget=setmetatable,getmetatable,tonumber,tostring,rawget
local type,next,rawset,tonumber,tostring,load,select=type,next,rawset,tonumber,tostring,load,select
local lpegmatch,P,Cs,Cc=lpeg.match,lpeg.P,lpeg.Cs,lpeg.Cc
local sortedkeys,sortedpairs=table.sortedkeys,table.sortedpairs
local formatters=string.formatters
local utftoeight=utf.toeight
local splitter=lpeg.tsplitat(".")
function utilities.tables.definetable(target,nofirst,nolast)
local composed=nil
local t={}
local snippets=lpegmatch(splitter,target)
for i=1,#snippets-(nolast and 1 or 0) do
local name=snippets[i]
if composed then
composed=composed.."."..name
t[#t+1]=formatters["if not %s then %s = { } end"](composed,composed)
else
composed=name
if not nofirst then
t[#t+1]=formatters["%s = %s or { }"](composed,composed)
end
end
end
if composed then
if nolast then
composed=composed.."."..snippets[#snippets]
end
return concat(t,"\n"),composed
else
return "",target
end
end
function tables.definedtable(...)
local t=_G
for i=1,select("#",...) do
local li=select(i,...)
local tl=t[li]
if not tl then
tl={}
t[li]=tl
end
t=tl
end
return t
end
function tables.accesstable(target,root)
local t=root or _G
for name in gmatch(target,"([^%.]+)") do
t=t[name]
if not t then
return
end
end
return t
end
function tables.migratetable(target,v,root)
local t=root or _G
local names=lpegmatch(splitter,target)
for i=1,#names-1 do
local name=names[i]
t[name]=t[name] or {}
t=t[name]
if not t then
return
end
end
t[names[#names]]=v
end
function tables.removevalue(t,value)
if value then
for i=1,#t do
if t[i]==value then
remove(t,i)
end
end
end
end
function tables.replacevalue(t,oldvalue,newvalue)
if oldvalue and newvalue then
for i=1,#t do
if t[i]==oldvalue then
t[i]=newvalue
end
end
end
end
function tables.insertbeforevalue(t,value,extra)
for i=1,#t do
if t[i]==extra then
remove(t,i)
end
end
for i=1,#t do
if t[i]==value then
insert(t,i,extra)
return
end
end
insert(t,1,extra)
end
function tables.insertaftervalue(t,value,extra)
for i=1,#t do
if t[i]==extra then
remove(t,i)
end
end
for i=1,#t do
if t[i]==value then
insert(t,i+1,extra)
return
end
end
insert(t,#t+1,extra)
end
local escape=Cs(Cc('"')*((P('"')/'""'+P(1))^0)*Cc('"'))
function table.tocsv(t,specification)
if t and #t>0 then
local result={}
local r={}
specification=specification or {}
local fields=specification.fields
if type(fields)~="string" then
fields=sortedkeys(t[1])
end
local separator=specification.separator or ","
local noffields=#fields
if specification.preamble==true then
for f=1,noffields do
r[f]=lpegmatch(escape,tostring(fields[f]))
end
result[1]=concat(r,separator)
end
for i=1,#t do
local ti=t[i]
for f=1,noffields do
local field=ti[fields[f]]
if type(field)=="string" then
r[f]=lpegmatch(escape,field)
else
r[f]=tostring(field)
end
end
result[i+1]=concat(r,separator)
end
return concat(result,"\n")
else
return ""
end
end
local nspaces=utilities.strings.newrepeater(" ")
local function toxml(t,d,result,step)
local r=#result
for k,v in sortedpairs(t) do
local s=nspaces[d]
local tk=type(k)
local tv=type(v)
if tv=="table" then
if tk=="number" then
r=r+1 result[r]=formatters["%s<entry n='%s'>"](s,k)
toxml(v,d+step,result,step)
r=r+1 result[r]=formatters["%s</entry>"](s,k)
else
r=r+1 result[r]=formatters["%s<%s>"](s,k)
toxml(v,d+step,result,step)
r=r+1 result[r]=formatters["%s</%s>"](s,k)
end
elseif tv=="string" then
if tk=="number" then
r=r+1 result[r]=formatters["%s<entry n='%s'>%!xml!</entry>"](s,k,v,k)
else
r=r+1 result[r]=formatters["%s<%s>%!xml!</%s>"](s,k,v,k)
end
elseif tk=="number" then
r=r+1 result[r]=formatters["%s<entry n='%s'>%S</entry>"](s,k,v,k)
else
r=r+1 result[r]=formatters["%s<%s>%S</%s>"](s,k,v,k)
end
end
end
function table.toxml(t,specification)
specification=specification or {}
local name=specification.name
local noroot=name==false
local result=(specification.nobanner or noroot) and {} or { "<?xml version='1.0' standalone='yes' ?>" }
local indent=specification.indent or 0
local spaces=specification.spaces or 1
if noroot then
toxml(t,indent,result,spaces)
else
toxml({ [name or "data"]=t },indent,result,spaces)
end
return concat(result,"\n")
end
function tables.encapsulate(core,capsule,protect)
if type(capsule)~="table" then
protect=true
capsule={}
end
for key,value in next,core do
if capsule[key] then
print(formatters["\ninvalid %s %a in %a"]("inheritance",key,core))
os.exit()
else
capsule[key]=value
end
end
if protect then
for key,value in next,core do
core[key]=nil
end
setmetatable(core,{
__index=capsule,
__newindex=function(t,key,value)
if capsule[key] then
print(formatters["\ninvalid %s %a' in %a"]("overload",key,core))
os.exit()
else
rawset(t,key,value)
end
end
} )
end
end
local f_hashed_string=formatters["[%q]=%q,"]
local f_hashed_number=formatters["[%q]=%s,"]
local f_hashed_boolean=formatters["[%q]=%l,"]
local f_hashed_table=formatters["[%q]="]
local f_indexed_string=formatters["[%s]=%q,"]
local f_indexed_number=formatters["[%s]=%s,"]
local f_indexed_boolean=formatters["[%s]=%l,"]
local f_indexed_table=formatters["[%s]="]
local f_ordered_string=formatters["%q,"]
local f_ordered_number=formatters["%s,"]
local f_ordered_boolean=formatters["%l,"]
function table.fastserialize(t,prefix)
local r={ type(prefix)=="string" and prefix or "return" }
local m=1
local function fastserialize(t,outer)
local n=#t
m=m+1
r[m]="{"
if n>0 then
for i=0,n do
local v=t[i]
local tv=type(v)
if tv=="string" then
m=m+1 r[m]=f_ordered_string(v)
elseif tv=="number" then
m=m+1 r[m]=f_ordered_number(v)
elseif tv=="table" then
fastserialize(v)
elseif tv=="boolean" then
m=m+1 r[m]=f_ordered_boolean(v)
end
end
end
for k,v in next,t do
local tk=type(k)
if tk=="number" then
if k>n or k<0 then
local tv=type(v)
if tv=="string" then
m=m+1 r[m]=f_indexed_string(k,v)
elseif tv=="number" then
m=m+1 r[m]=f_indexed_number(k,v)
elseif tv=="table" then
m=m+1 r[m]=f_indexed_table(k)
fastserialize(v)
elseif tv=="boolean" then
m=m+1 r[m]=f_indexed_boolean(k,v)
end
end
else
local tv=type(v)
if tv=="string" then
m=m+1 r[m]=f_hashed_string(k,v)
elseif tv=="number" then
m=m+1 r[m]=f_hashed_number(k,v)
elseif tv=="table" then
m=m+1 r[m]=f_hashed_table(k)
fastserialize(v)
elseif tv=="boolean" then
m=m+1 r[m]=f_hashed_boolean(k,v)
end
end
end
m=m+1
if outer then
r[m]="}"
else
r[m]="},"
end
return r
end
return concat(fastserialize(t,true))
end
function table.deserialize(str)
if not str or str=="" then
return
end
local code=load(str)
if not code then
return
end
code=code()
if not code then
return
end
return code
end
function table.load(filename,loader)
if filename then
local t=(loader or io.loaddata)(filename)
if t and t~="" then
local t=utftoeight(t)
t=load(t)
if type(t)=="function" then
t=t()
if type(t)=="table" then
return t
end
end
end
end
end
function table.save(filename,t,n,...)
io.savedata(filename,table.serialize(t,n==nil and true or n,...))
end
local f_key_value=formatters["%s=%q"]
local f_add_table=formatters[" {%t},\n"]
local f_return_table=formatters["return {\n%t}"]
local function slowdrop(t)
local r={}
local l={}
for i=1,#t do
local ti=t[i]
local j=0
for k,v in next,ti do
j=j+1
l[j]=f_key_value(k,v)
end
r[i]=f_add_table(l)
end
return f_return_table(r)
end
local function fastdrop(t)
local r={ "return {\n" }
local m=1
for i=1,#t do
local ti=t[i]
m=m+1 r[m]=" {"
for k,v in next,ti do
m=m+1 r[m]=f_key_value(k,v)
end
m=m+1 r[m]="},\n"
end
m=m+1
r[m]="}"
return concat(r)
end
function table.drop(t,slow)
if #t==0 then
return "return { }"
elseif slow==true then
return slowdrop(t)
else
return fastdrop(t)
end
end
local selfmapper={ __index=function(t,k) t[k]=k return k end }
function table.twowaymapper(t)
if not t then
t={}
else
local zero=rawget(t,0)
for i=zero and 0 or 1,#t do
local ti=t[i]
if ti then
local i=tostring(i)
t[i]=ti
t[ti]=i
end
end
end
setmetatable(t,selfmapper)
return t
end
local f_start_key_idx=formatters["%w{"]
local f_start_key_num=formatters["%w[%s]={"]
local f_start_key_str=formatters["%w[%q]={"]
local f_start_key_boo=formatters["%w[%l]={"]
local f_start_key_nop=formatters["%w{"]
local f_stop=formatters["%w},"]
local f_key_num_value_num=formatters["%w[%s]=%s,"]
local f_key_str_value_num=formatters["%w[%q]=%s,"]
local f_key_boo_value_num=formatters["%w[%l]=%s,"]
local f_key_num_value_str=formatters["%w[%s]=%q,"]
local f_key_str_value_str=formatters["%w[%q]=%q,"]
local f_key_boo_value_str=formatters["%w[%l]=%q,"]
local f_key_num_value_boo=formatters["%w[%s]=%l,"]
local f_key_str_value_boo=formatters["%w[%q]=%l,"]
local f_key_boo_value_boo=formatters["%w[%l]=%l,"]
local f_key_num_value_not=formatters["%w[%s]={},"]
local f_key_str_value_not=formatters["%w[%q]={},"]
local f_key_boo_value_not=formatters["%w[%l]={},"]
local f_key_num_value_seq=formatters["%w[%s]={ %, t },"]
local f_key_str_value_seq=formatters["%w[%q]={ %, t },"]
local f_key_boo_value_seq=formatters["%w[%l]={ %, t },"]
local f_val_num=formatters["%w%s,"]
local f_val_str=formatters["%w%q,"]
local f_val_boo=formatters["%w%l,"]
local f_val_not=formatters["%w{},"]
local f_val_seq=formatters["%w{ %, t },"]
local f_fin_seq=formatters[" %, t }"]
local f_table_return=formatters["return {"]
local f_table_name=formatters["%s={"]
local f_table_direct=formatters["{"]
local f_table_entry=formatters["[%q]={"]
local f_table_finish=formatters["}"]
local spaces=utilities.strings.newrepeater(" ")
local original_serialize=table.serialize
local is_simple_table=table.is_simple_table
local function serialize(root,name,specification)
if type(specification)=="table" then
return original_serialize(root,name,specification)
end
local t
local n=1
local unknown=false
local function do_serialize(root,name,depth,level,indexed)
if level>0 then
n=n+1
if indexed then
t[n]=f_start_key_idx(depth)
else
local tn=type(name)
if tn=="number" then
t[n]=f_start_key_num(depth,name)
elseif tn=="string" then
t[n]=f_start_key_str(depth,name)
elseif tn=="boolean" then
t[n]=f_start_key_boo(depth,name)
else
t[n]=f_start_key_nop(depth)
end
end
depth=depth+1
end
if root and next(root)~=nil then
local first=nil
local last=#root
if last>0 then
for k=1,last do
if rawget(root,k)==nil then
last=k-1
break
end
end
if last>0 then
first=1
end
end
local sk=sortedkeys(root)
for i=1,#sk do
local k=sk[i]
local v=root[k]
local tv=type(v)
local tk=type(k)
if first and tk=="number" and k<=last and k>=first then
if tv=="number" then
n=n+1 t[n]=f_val_num(depth,v)
elseif tv=="string" then
n=n+1 t[n]=f_val_str(depth,v)
elseif tv=="table" then
if next(v)==nil then
n=n+1 t[n]=f_val_not(depth)
else
local st=is_simple_table(v)
if st then
n=n+1 t[n]=f_val_seq(depth,st)
else
do_serialize(v,k,depth,level+1,true)
end
end
elseif tv=="boolean" then
n=n+1 t[n]=f_val_boo(depth,v)
elseif unknown then
n=n+1 t[n]=f_val_str(depth,tostring(v))
end
elseif tv=="number" then
if tk=="number" then
n=n+1 t[n]=f_key_num_value_num(depth,k,v)
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_num(depth,k,v)
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_num(depth,k,v)
elseif unknown then
n=n+1 t[n]=f_key_str_value_num(depth,tostring(k),v)
end
elseif tv=="string" then
if tk=="number" then
n=n+1 t[n]=f_key_num_value_str(depth,k,v)
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_str(depth,k,v)
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_str(depth,k,v)
elseif unknown then
n=n+1 t[n]=f_key_str_value_str(depth,tostring(k),v)
end
elseif tv=="table" then
if next(v)==nil then
if tk=="number" then
n=n+1 t[n]=f_key_num_value_not(depth,k)
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_not(depth,k)
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_not(depth,k)
elseif unknown then
n=n+1 t[n]=f_key_str_value_not(depth,tostring(k))
end
else
local st=is_simple_table(v)
if not st then
do_serialize(v,k,depth,level+1)
elseif tk=="number" then
n=n+1 t[n]=f_key_num_value_seq(depth,k,st)
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_seq(depth,k,st)
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_seq(depth,k,st)
elseif unknown then
n=n+1 t[n]=f_key_str_value_seq(depth,tostring(k),st)
end
end
elseif tv=="boolean" then
if tk=="number" then
n=n+1 t[n]=f_key_num_value_boo(depth,k,v)
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_boo(depth,k,v)
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_boo(depth,k,v)
elseif unknown then
n=n+1 t[n]=f_key_str_value_boo(depth,tostring(k),v)
end
else
if tk=="number" then
n=n+1 t[n]=f_key_num_value_str(depth,k,tostring(v))
elseif tk=="string" then
n=n+1 t[n]=f_key_str_value_str(depth,k,tostring(v))
elseif tk=="boolean" then
n=n+1 t[n]=f_key_boo_value_str(depth,k,tostring(v))
elseif unknown then
n=n+1 t[n]=f_key_str_value_str(depth,tostring(k),tostring(v))
end
end
end
end
if level>0 then
n=n+1 t[n]=f_stop(depth-1)
end
end
local tname=type(name)
if tname=="string" then
if name=="return" then
t={ f_table_return() }
else
t={ f_table_name(name) }
end
elseif tname=="number" then
t={ f_table_entry(name) }
elseif tname=="boolean" then
if name then
t={ f_table_return() }
else
t={ f_table_direct() }
end
else
t={ f_table_name("t") }
end
if root then
if getmetatable(root) then
local dummy=root._w_h_a_t_e_v_e_r_
root._w_h_a_t_e_v_e_r_=nil
end
if next(root)~=nil then
local st=is_simple_table(root)
if st then
return t[1]..f_fin_seq(st)
else
do_serialize(root,name,1,0)
end
end
end
n=n+1
t[n]=f_table_finish()
return concat(t,"\n")
end
table.serialize=serialize
if setinspector then
setinspector("table",function(v)
if type(v)=="table" then
print(serialize(v,"table",{ metacheck=false }))
return true
end
end)
end
local mt={
__newindex=function(t,k,v)
local n=t.last+1
t.last=n
t.list[n]=k
t.hash[k]=v
end,
__index=function(t,k)
return t.hash[k]
end,
__len=function(t)
return t.last
end,
}
function table.orderedhash()
return setmetatable({ list={},hash={},last=0 },mt)
end
function table.ordered(t)
local n=t.last
if n>0 then
local l=t.list
local i=1
local h=t.hash
local f=function()
if i<=n then
local k=i
local v=h[l[k]]
i=i+1
return k,v
end
end
return f,1,h[l[1]]
else
return function() end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-fil"] = package.loaded["util-fil"] or true
-- original size: 11530, stripped down to: 9007
if not modules then modules={} end modules ['util-fil']={
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"
}
local tonumber=tonumber
local byte=string.byte
local char=string.char
utilities=utilities or {}
local files={}
utilities.files=files
local zerobased={}
function files.open(filename,zb)
local f=io.open(filename,"rb")
if f then
zerobased[f]=zb or false
end
return f
end
function files.close(f)
zerobased[f]=nil
f:close()
end
function files.size(f)
local current=f:seek()
local size=f:seek("end")
f:seek("set",current)
return size
end
files.getsize=files.size
function files.setposition(f,n)
if zerobased[f] then
f:seek("set",n)
else
f:seek("set",n-1)
end
end
function files.getposition(f)
if zerobased[f] then
return f:seek()
else
return f:seek()+1
end
end
function files.look(f,n,chars)
local p=f:seek()
local s=f:read(n)
f:seek("set",p)
if chars then
return s
else
return byte(s,1,#s)
end
end
function files.skip(f,n)
if n==1 then
f:read(n)
else
f:seek("set",f:seek()+n)
end
end
function files.readbyte(f)
return byte(f:read(1))
end
function files.readbytes(f,n)
return byte(f:read(n),1,n)
end
function files.readbytetable(f,n)
local s=f:read(n or 1)
return { byte(s,1,#s) }
end
function files.readchar(f)
return f:read(1)
end
function files.readstring(f,n)
return f:read(n or 1)
end
function files.readinteger1(f)
local n=byte(f:read(1))
if n>=0x80 then
return n-0x100
else
return n
end
end
files.readcardinal1=files.readbyte
files.readcardinal=files.readcardinal1
files.readinteger=files.readinteger1
files.readsignedbyte=files.readinteger1
function files.readcardinal2(f)
local a,b=byte(f:read(2),1,2)
return 0x100*a+b
end
function files.readcardinal2le(f)
local b,a=byte(f:read(2),1,2)
return 0x100*a+b
end
function files.readinteger2(f)
local a,b=byte(f:read(2),1,2)
if a>=0x80 then
return 0x100*a+b-0x10000
else
return 0x100*a+b
end
end
function files.readinteger2le(f)
local b,a=byte(f:read(2),1,2)
if a>=0x80 then
return 0x100*a+b-0x10000
else
return 0x100*a+b
end
end
function files.readcardinal3(f)
local a,b,c=byte(f:read(3),1,3)
return 0x10000*a+0x100*b+c
end
function files.readcardinal3le(f)
local c,b,a=byte(f:read(3),1,3)
return 0x10000*a+0x100*b+c
end
function files.readinteger3(f)
local a,b,c=byte(f:read(3),1,3)
if a>=0x80 then
return 0x10000*a+0x100*b+c-0x1000000
else
return 0x10000*a+0x100*b+c
end
end
function files.readinteger3le(f)
local c,b,a=byte(f:read(3),1,3)
if a>=0x80 then
return 0x10000*a+0x100*b+c-0x1000000
else
return 0x10000*a+0x100*b+c
end
end
function files.readcardinal4(f)
local a,b,c,d=byte(f:read(4),1,4)
return 0x1000000*a+0x10000*b+0x100*c+d
end
function files.readcardinal4le(f)
local d,c,b,a=byte(f:read(4),1,4)
return 0x1000000*a+0x10000*b+0x100*c+d
end
function files.readinteger4(f)
local a,b,c,d=byte(f:read(4),1,4)
if a>=0x80 then
return 0x1000000*a+0x10000*b+0x100*c+d-0x100000000
else
return 0x1000000*a+0x10000*b+0x100*c+d
end
end
function files.readinteger4le(f)
local d,c,b,a=byte(f:read(4),1,4)
if a>=0x80 then
return 0x1000000*a+0x10000*b+0x100*c+d-0x100000000
else
return 0x1000000*a+0x10000*b+0x100*c+d
end
end
function files.readfixed2(f)
local a,b=byte(f:read(2),1,2)
if a>=0x80 then
tonumber((a-0x100).."."..b)
else
tonumber((a ).."."..b)
end
end
function files.readfixed4(f)
local a,b,c,d=byte(f:read(4),1,4)
if a>=0x80 then
tonumber((0x100*a+b-0x10000).."."..(0x100*c+d))
else
tonumber((0x100*a+b ).."."..(0x100*c+d))
end
end
if bit32 then
local extract=bit32.extract
local band=bit32.band
function files.read2dot14(f)
local a,b=byte(f:read(2),1,2)
if a>=0x80 then
local n=-(0x100*a+b)
return-(extract(n,14,2)+(band(n,0x3FFF)/16384.0))
else
local n=0x100*a+b
return (extract(n,14,2)+(band(n,0x3FFF)/16384.0))
end
end
end
function files.skipshort(f,n)
f:read(2*(n or 1))
end
function files.skiplong(f,n)
f:read(4*(n or 1))
end
if bit32 then
local rshift=bit32.rshift
function files.writecardinal2(f,n)
local a=char(n%256)
n=rshift(n,8)
local b=char(n%256)
f:write(b,a)
end
function files.writecardinal4(f,n)
local a=char(n%256)
n=rshift(n,8)
local b=char(n%256)
n=rshift(n,8)
local c=char(n%256)
n=rshift(n,8)
local d=char(n%256)
f:write(d,c,b,a)
end
function files.writecardinal2le(f,n)
local a=char(n%256)
n=rshift(n,8)
local b=char(n%256)
f:write(a,b)
end
function files.writecardinal4le(f,n)
local a=char(n%256)
n=rshift(n,8)
local b=char(n%256)
n=rshift(n,8)
local c=char(n%256)
n=rshift(n,8)
local d=char(n%256)
f:write(a,b,c,d)
end
else
local floor=math.floor
function files.writecardinal2(f,n)
local a=char(n%256)
n=floor(n/256)
local b=char(n%256)
f:write(b,a)
end
function files.writecardinal4(f,n)
local a=char(n%256)
n=floor(n/256)
local b=char(n%256)
n=floor(n/256)
local c=char(n%256)
n=floor(n/256)
local d=char(n%256)
f:write(d,c,b,a)
end
function files.writecardinal2le(f,n)
local a=char(n%256)
n=floor(n/256)
local b=char(n%256)
f:write(a,b)
end
function files.writecardinal4le(f,n)
local a=char(n%256)
n=floor(n/256)
local b=char(n%256)
n=floor(n/256)
local c=char(n%256)
n=floor(n/256)
local d=char(n%256)
f:write(a,b,c,d)
end
end
function files.writestring(f,s)
f:write(char(byte(s,1,#s)))
end
function files.writebyte(f,b)
f:write(char(b))
end
if fio and fio.readcardinal1 then
files.readcardinal1=fio.readcardinal1
files.readcardinal2=fio.readcardinal2
files.readcardinal3=fio.readcardinal3
files.readcardinal4=fio.readcardinal4
files.readcardinal1le=fio.readcardinal1le or files.readcardinal1le
files.readcardinal2le=fio.readcardinal2le or files.readcardinal2le
files.readcardinal3le=fio.readcardinal3le or files.readcardinal3le
files.readcardinal4le=fio.readcardinal4le or files.readcardinal4le
files.readinteger1=fio.readinteger1
files.readinteger2=fio.readinteger2
files.readinteger3=fio.readinteger3
files.readinteger4=fio.readinteger4
files.readinteger1le=fio.readinteger1le or files.readinteger1le
files.readinteger2le=fio.readinteger2le or files.readinteger2le
files.readinteger3le=fio.readinteger3le or files.readinteger3le
files.readinteger4le=fio.readinteger4le or files.readinteger4le
files.readfixed2=fio.readfixed2
files.readfixed4=fio.readfixed4
files.read2dot14=fio.read2dot14
files.setposition=fio.setposition
files.getposition=fio.getposition
files.readbyte=files.readcardinal1
files.readsignedbyte=files.readinteger1
files.readcardinal=files.readcardinal1
files.readinteger=files.readinteger1
local skipposition=fio.skipposition
files.skipposition=skipposition
files.readbytes=fio.readbytes
files.readbytetable=fio.readbytetable
function files.skipshort(f,n)
skipposition(f,2*(n or 1))
end
function files.skiplong(f,n)
skipposition(f,4*(n or 1))
end
end
if fio and fio.writecardinal1 then
files.writecardinal1=fio.writecardinal1
files.writecardinal2=fio.writecardinal2
files.writecardinal3=fio.writecardinal3
files.writecardinal4=fio.writecardinal4
files.writecardinal1le=fio.writecardinal1le
files.writecardinal2le=fio.writecardinal2le
files.writecardinal3le=fio.writecardinal3le
files.writecardinal4le=fio.writecardinal4le
files.writeinteger1=fio.writeinteger1 or fio.writecardinal1
files.writeinteger2=fio.writeinteger2 or fio.writecardinal2
files.writeinteger3=fio.writeinteger3 or fio.writecardinal3
files.writeinteger4=fio.writeinteger4 or fio.writecardinal4
files.writeinteger1le=files.writeinteger1le or fio.writecardinal1le
files.writeinteger2le=files.writeinteger2le or fio.writecardinal2le
files.writeinteger3le=files.writeinteger3le or fio.writecardinal3le
files.writeinteger4le=files.writeinteger4le or fio.writecardinal4le
end
if fio and fio.readcardinaltable then
files.readcardinaltable=fio.readcardinaltable
files.readintegertable=fio.readintegertable
else
local readcardinal1=files.readcardinal1
local readcardinal2=files.readcardinal2
local readcardinal3=files.readcardinal3
local readcardinal4=files.readcardinal4
function files.readcardinaltable(f,n,b)
local t={}
if b==1 then for i=1,n do t[i]=readcardinal1(f) end
elseif b==2 then for i=1,n do t[i]=readcardinal2(f) end
elseif b==3 then for i=1,n do t[i]=readcardinal3(f) end
elseif b==4 then for i=1,n do t[i]=readcardinal4(f) end end
return t
end
local readinteger1=files.readinteger1
local readinteger2=files.readinteger2
local readinteger3=files.readinteger3
local readinteger4=files.readinteger4
function files.readintegertable(f,n,b)
local t={}
if b==1 then for i=1,n do t[i]=readinteger1(f) end
elseif b==2 then for i=1,n do t[i]=readinteger2(f) end
elseif b==3 then for i=1,n do t[i]=readinteger3(f) end
elseif b==4 then for i=1,n do t[i]=readinteger4(f) end end
return t
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-sac"] = package.loaded["util-sac"] or true
-- original size: 11332, stripped down to: 8420
if not modules then modules={} end modules ['util-sac']={
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"
}
local byte,sub=string.byte,string.sub
local tonumber=tonumber
utilities=utilities or {}
local streams={}
utilities.streams=streams
function streams.open(filename,zerobased)
local f=filename and io.loaddata(filename)
if f then
return { f,1,#f,zerobased or false }
end
end
function streams.openstring(f,zerobased)
if f then
return { f,1,#f,zerobased or false }
end
end
function streams.getstring(f)
if f then
return f[1]
end
end
function streams.close()
end
function streams.size(f)
return f and f[3] or 0
end
function streams.setposition(f,i)
if f[4] then
if i<=0 then
f[2]=1
else
f[2]=i+1
end
else
if i<=1 then
f[2]=1
else
f[2]=i
end
end
end
function streams.getposition(f)
if f[4] then
return f[2]-1
else
return f[2]
end
end
function streams.look(f,n,chars)
local b=f[2]
local e=b+n-1
if chars then
return sub(f[1],b,e)
else
return byte(f[1],b,e)
end
end
function streams.skip(f,n)
f[2]=f[2]+n
end
function streams.readbyte(f)
local i=f[2]
f[2]=i+1
return byte(f[1],i)
end
function streams.readbytes(f,n)
local i=f[2]
local j=i+n
f[2]=j
return byte(f[1],i,j-1)
end
function streams.readbytetable(f,n)
local i=f[2]
local j=i+n
f[2]=j
return { byte(f[1],i,j-1) }
end
function streams.skipbytes(f,n)
f[2]=f[2]+n
end
function streams.readchar(f)
local i=f[2]
f[2]=i+1
return sub(f[1],i,i)
end
function streams.readstring(f,n)
local i=f[2]
local j=i+n
f[2]=j
return sub(f[1],i,j-1)
end
function streams.readinteger1(f)
local i=f[2]
f[2]=i+1
local n=byte(f[1],i)
if n>=0x80 then
return n-0x100
else
return n
end
end
streams.readcardinal1=streams.readbyte
streams.readcardinal=streams.readcardinal1
streams.readinteger=streams.readinteger1
function streams.readcardinal2(f)
local i=f[2]
local j=i+1
f[2]=j+1
local a,b=byte(f[1],i,j)
return 0x100*a+b
end
function streams.readcardinal2le(f)
local i=f[2]
local j=i+1
f[2]=j+1
local b,a=byte(f[1],i,j)
return 0x100*a+b
end
function streams.readinteger2(f)
local i=f[2]
local j=i+1
f[2]=j+1
local a,b=byte(f[1],i,j)
if a>=0x80 then
return 0x100*a+b-0x10000
else
return 0x100*a+b
end
end
function streams.readinteger2le(f)
local i=f[2]
local j=i+1
f[2]=j+1
local b,a=byte(f[1],i,j)
if a>=0x80 then
return 0x100*a+b-0x10000
else
return 0x100*a+b
end
end
function streams.readcardinal3(f)
local i=f[2]
local j=i+2
f[2]=j+1
local a,b,c=byte(f[1],i,j)
return 0x10000*a+0x100*b+c
end
function streams.readcardinal3le(f)
local i=f[2]
local j=i+2
f[2]=j+1
local c,b,a=byte(f[1],i,j)
return 0x10000*a+0x100*b+c
end
function streams.readinteger3(f)
local i=f[2]
local j=i+3
f[2]=j+1
local a,b,c=byte(f[1],i,j)
if a>=0x80 then
return 0x10000*a+0x100*b+c-0x1000000
else
return 0x10000*a+0x100*b+c
end
end
function streams.readinteger3le(f)
local i=f[2]
local j=i+3
f[2]=j+1
local c,b,a=byte(f[1],i,j)
if a>=0x80 then
return 0x10000*a+0x100*b+c-0x1000000
else
return 0x10000*a+0x100*b+c
end
end
function streams.readcardinal4(f)
local i=f[2]
local j=i+3
f[2]=j+1
local a,b,c,d=byte(f[1],i,j)
return 0x1000000*a+0x10000*b+0x100*c+d
end
function streams.readcardinal4le(f)
local i=f[2]
local j=i+3
f[2]=j+1
local d,c,b,a=byte(f[1],i,j)
return 0x1000000*a+0x10000*b+0x100*c+d
end
function streams.readinteger4(f)
local i=f[2]
local j=i+3
f[2]=j+1
local a,b,c,d=byte(f[1],i,j)
if a>=0x80 then
return 0x1000000*a+0x10000*b+0x100*c+d-0x100000000
else
return 0x1000000*a+0x10000*b+0x100*c+d
end
end
function streams.readinteger4le(f)
local i=f[2]
local j=i+3
f[2]=j+1
local d,c,b,a=byte(f[1],i,j)
if a>=0x80 then
return 0x1000000*a+0x10000*b+0x100*c+d-0x100000000
else
return 0x1000000*a+0x10000*b+0x100*c+d
end
end
function streams.readfixed2(f)
local i=f[2]
local j=i+1
f[2]=j+1
local a,b=byte(f[1],i,j)
if a>=0x80 then
tonumber((a-0x100).."."..b)
else
tonumber((a ).."."..b)
end
end
function streams.readfixed4(f)
local i=f[2]
local j=i+3
f[2]=j+1
local a,b,c,d=byte(f[1],i,j)
if a>=0x80 then
tonumber((0x100*a+b-0x10000).."."..(0x100*c+d))
else
tonumber((0x100*a+b ).."."..(0x100*c+d))
end
end
if bit32 then
local extract=bit32.extract
local band=bit32.band
function streams.read2dot14(f)
local i=f[2]
local j=i+1
f[2]=j+1
local a,b=byte(f[1],i,j)
if a>=0x80 then
local n=-(0x100*a+b)
return-(extract(n,14,2)+(band(n,0x3FFF)/16384.0))
else
local n=0x100*a+b
return (extract(n,14,2)+(band(n,0x3FFF)/16384.0))
end
end
end
function streams.skipshort(f,n)
f[2]=f[2]+2*(n or 1)
end
function streams.skiplong(f,n)
f[2]=f[2]+4*(n or 1)
end
if sio and sio.readcardinal2 then
local readcardinal1=sio.readcardinal1
local readcardinal2=sio.readcardinal2
local readcardinal3=sio.readcardinal3
local readcardinal4=sio.readcardinal4
local readinteger1=sio.readinteger1
local readinteger2=sio.readinteger2
local readinteger3=sio.readinteger3
local readinteger4=sio.readinteger4
local readfixed2=sio.readfixed2
local readfixed4=sio.readfixed4
local read2dot14=sio.read2dot14
local readbytes=sio.readbytes
local readbytetable=sio.readbytetable
function streams.readcardinal1(f)
local i=f[2]
f[2]=i+1
return readcardinal1(f[1],i)
end
function streams.readcardinal2(f)
local i=f[2]
f[2]=i+2
return readcardinal2(f[1],i)
end
function streams.readcardinal3(f)
local i=f[2]
f[2]=i+3
return readcardinal3(f[1],i)
end
function streams.readcardinal4(f)
local i=f[2]
f[2]=i+4
return readcardinal4(f[1],i)
end
function streams.readinteger1(f)
local i=f[2]
f[2]=i+1
return readinteger1(f[1],i)
end
function streams.readinteger2(f)
local i=f[2]
f[2]=i+2
return readinteger2(f[1],i)
end
function streams.readinteger3(f)
local i=f[2]
f[2]=i+3
return readinteger3(f[1],i)
end
function streams.readinteger4(f)
local i=f[2]
f[2]=i+4
return readinteger4(f[1],i)
end
function streams.read2dot4(f)
local i=f[2]
f[2]=i+2
return read2dot4(f[1],i)
end
function streams.readbytes(f,n)
local i=f[2]
local s=f[3]
local p=i+n
if p>s then
f[2]=s+1
else
f[2]=p
end
return readbytes(f[1],i,n)
end
function streams.readbytetable(f,n)
local i=f[2]
local s=f[3]
local p=i+n
if p>s then
f[2]=s+1
else
f[2]=p
end
return readbytetable(f[1],i,n)
end
streams.readbyte=streams.readcardinal1
streams.readsignedbyte=streams.readinteger1
streams.readcardinal=streams.readcardinal1
streams.readinteger=streams.readinteger1
end
if sio and sio.readcardinaltable then
local readcardinaltable=sio.readcardinaltable
local readintegertable=sio.readintegertable
function utilities.streams.readcardinaltable(f,n,b)
local i=f[2]
local s=f[3]
local p=i+n*b
if p>s then
f[2]=s+1
else
f[2]=p
end
return readcardinaltable(f[1],i,n,b)
end
function utilities.streams.readintegertable(f,n,b)
local i=f[2]
local s=f[3]
local p=i+n*b
if p>s then
f[2]=s+1
else
f[2]=p
end
return readintegertable(f[1],i,n,b)
end
else
local readcardinal1=streams.readcardinal1
local readcardinal2=streams.readcardinal2
local readcardinal3=streams.readcardinal3
local readcardinal4=streams.readcardinal4
function streams.readcardinaltable(f,n,b)
local i=f[2]
local s=f[3]
local p=i+n*b
if p>s then
f[2]=s+1
else
f[2]=p
end
local t={}
if b==1 then for i=1,n do t[i]=readcardinal1(f[1],i) end
elseif b==2 then for i=1,n do t[i]=readcardinal2(f[1],i) end
elseif b==3 then for i=1,n do t[i]=readcardinal3(f[1],i) end
elseif b==4 then for i=1,n do t[i]=readcardinal4(f[1],i) end end
return t
end
local readinteger1=streams.readinteger1
local readinteger2=streams.readinteger2
local readinteger3=streams.readinteger3
local readinteger4=streams.readinteger4
function streams.readintegertable(f,n,b)
local i=f[2]
local s=f[3]
local p=i+n*b
if p>s then
f[2]=s+1
else
f[2]=p
end
local t={}
if b==1 then for i=1,n do t[i]=readinteger1(f[1],i) end
elseif b==2 then for i=1,n do t[i]=readinteger2(f[1],i) end
elseif b==3 then for i=1,n do t[i]=readinteger3(f[1],i) end
elseif b==4 then for i=1,n do t[i]=readinteger4(f[1],i) end end
return t
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-sto"] = package.loaded["util-sto"] or true
-- original size: 6661, stripped down to: 3074
if not modules then modules={} end modules ['util-sto']={
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"
}
local setmetatable,getmetatable,rawset,type=setmetatable,getmetatable,rawset,type
utilities=utilities or {}
utilities.storage=utilities.storage or {}
local storage=utilities.storage
function storage.mark(t)
if not t then
print("\nfatal error: storage cannot be marked\n")
os.exit()
return
end
local m=getmetatable(t)
if not m then
m={}
setmetatable(t,m)
end
m.__storage__=true
return t
end
function storage.allocate(t)
t=t or {}
local m=getmetatable(t)
if not m then
m={}
setmetatable(t,m)
end
m.__storage__=true
return t
end
function storage.marked(t)
local m=getmetatable(t)
return m and m.__storage__
end
function storage.checked(t)
if not t then
report("\nfatal error: storage has not been allocated\n")
os.exit()
return
end
return t
end
function storage.setinitializer(data,initialize)
local m=getmetatable(data) or {}
m.__index=function(data,k)
m.__index=nil
initialize()
return data[k]
end
setmetatable(data,m)
end
local keyisvalue={ __index=function(t,k)
t[k]=k
return k
end }
function storage.sparse(t)
t=t or {}
setmetatable(t,keyisvalue)
return t
end
local function f_empty () return "" end
local function f_self (t,k) t[k]=k return k end
local function f_table (t,k) local v={} t[k]=v return v end
local function f_number(t,k) t[k]=0 return 0 end
local function f_ignore() end
local f_index={
["empty"]=f_empty,
["self"]=f_self,
["table"]=f_table,
["number"]=f_number,
}
function table.setmetatableindex(t,f)
if type(t)~="table" then
f,t=t,{}
end
local m=getmetatable(t)
local i=f_index[f] or f
if m then
m.__index=i
else
setmetatable(t,{ __index=i })
end
return t
end
local f_index={
["ignore"]=f_ignore,
}
function table.setmetatablenewindex(t,f)
if type(t)~="table" then
f,t=t,{}
end
local m=getmetatable(t)
local i=f_index[f] or f
if m then
m.__newindex=i
else
setmetatable(t,{ __newindex=i })
end
return t
end
function table.setmetatablecall(t,f)
if type(t)~="table" then
f,t=t,{}
end
local m=getmetatable(t)
if m then
m.__call=f
else
setmetatable(t,{ __call=f })
end
return t
end
function table.setmetatableindices(t,f,n,c)
if type(t)~="table" then
f,t=t,{}
end
local m=getmetatable(t)
local i=f_index[f] or f
if m then
m.__index=i
m.__newindex=n
m.__call=c
else
setmetatable(t,{
__index=i,
__newindex=n,
__call=c,
})
end
return t
end
function table.setmetatablekey(t,key,value)
local m=getmetatable(t)
if not m then
m={}
setmetatable(t,m)
end
m[key]=value
return t
end
function table.getmetatablekey(t,key,value)
local m=getmetatable(t)
return m and m[key]
end
function table.makeweak(t)
if not t then
t={}
end
local m=getmetatable(t)
if m then
m.__mode="v"
else
setmetatable(t,{ __mode="v" })
end
return t
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-prs"] = package.loaded["util-prs"] or true
-- original size: 24132, stripped down to: 16210
if not modules then modules={} end modules ['util-prs']={
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"
}
local lpeg,table,string=lpeg,table,string
local P,R,V,S,C,Ct,Cs,Carg,Cc,Cg,Cf,Cp=lpeg.P,lpeg.R,lpeg.V,lpeg.S,lpeg.C,lpeg.Ct,lpeg.Cs,lpeg.Carg,lpeg.Cc,lpeg.Cg,lpeg.Cf,lpeg.Cp
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local concat,gmatch,find=table.concat,string.gmatch,string.find
local tostring,type,next,rawset=tostring,type,next,rawset
local mod,div=math.mod,math.div
utilities=utilities or {}
local parsers=utilities.parsers or {}
utilities.parsers=parsers
local patterns=parsers.patterns or {}
parsers.patterns=patterns
local setmetatableindex=table.setmetatableindex
local sortedhash=table.sortedhash
local sortedkeys=table.sortedkeys
local tohash=table.tohash
local hashes={}
parsers.hashes=hashes
local digit=R("09")
local space=P(' ')
local equal=P("=")
local colon=P(":")
local comma=P(",")
local lbrace=P("{")
local rbrace=P("}")
local lparent=P("(")
local rparent=P(")")
local lbracket=P("[")
local rbracket=P("]")
local period=S(".")
local punctuation=S(".,:;")
local spacer=lpegpatterns.spacer
local whitespace=lpegpatterns.whitespace
local newline=lpegpatterns.newline
local anything=lpegpatterns.anything
local endofstring=lpegpatterns.endofstring
local nobrace=1-(lbrace+rbrace )
local noparent=1-(lparent+rparent)
local nobracket=1-(lbracket+rbracket)
local escape,left,right=P("\\"),P('{'),P('}')
lpegpatterns.balanced=P {
[1]=((escape*(left+right))+(1-(left+right))+V(2))^0,
[2]=left*V(1)*right
}
local nestedbraces=P { lbrace*(nobrace+V(1))^0*rbrace }
local nestedparents=P { lparent*(noparent+V(1))^0*rparent }
local nestedbrackets=P { lbracket*(nobracket+V(1))^0*rbracket }
local spaces=space^0
local argument=Cs((lbrace/"")*((nobrace+nestedbraces)^0)*(rbrace/""))
local content=(1-endofstring)^0
lpegpatterns.nestedbraces=nestedbraces
lpegpatterns.nestedparents=nestedparents
lpegpatterns.nested=nestedbraces
lpegpatterns.argument=argument
lpegpatterns.content=content
local value=lbrace*C((nobrace+nestedbraces)^0)*rbrace+C((nestedbraces+(1-comma))^0)
local key=C((1-equal-comma)^1)
local pattern_a=(space+comma)^0*(key*equal*value+key*C(""))
local pattern_c=(space+comma)^0*(key*equal*value)
local pattern_d=(space+comma)^0*(key*(equal+colon)*value+key*C(""))
local key=C((1-space-equal-comma)^1)
local pattern_b=spaces*comma^0*spaces*(key*((spaces*equal*spaces*value)+C("")))
local hash={}
local function set(key,value)
hash[key]=value
end
local pattern_a_s=(pattern_a/set)^1
local pattern_b_s=(pattern_b/set)^1
local pattern_c_s=(pattern_c/set)^1
local pattern_d_s=(pattern_d/set)^1
patterns.settings_to_hash_a=pattern_a_s
patterns.settings_to_hash_b=pattern_b_s
patterns.settings_to_hash_c=pattern_c_s
patterns.settings_to_hash_d=pattern_d_s
function parsers.make_settings_to_hash_pattern(set,how)
if how=="strict" then
return (pattern_c/set)^1
elseif how=="tolerant" then
return (pattern_b/set)^1
else
return (pattern_a/set)^1
end
end
function parsers.settings_to_hash(str,existing)
if not str or str=="" then
return {}
elseif type(str)=="table" then
if existing then
for k,v in next,str do
existing[k]=v
end
return exiting
else
return str
end
else
hash=existing or {}
lpegmatch(pattern_a_s,str)
return hash
end
end
function parsers.settings_to_hash_colon_too(str)
if not str or str=="" then
return {}
elseif type(str)=="table" then
return str
else
hash={}
lpegmatch(pattern_d_s,str)
return hash
end
end
function parsers.settings_to_hash_tolerant(str,existing)
if not str or str=="" then
return {}
elseif type(str)=="table" then
if existing then
for k,v in next,str do
existing[k]=v
end
return exiting
else
return str
end
else
hash=existing or {}
lpegmatch(pattern_b_s,str)
return hash
end
end
function parsers.settings_to_hash_strict(str,existing)
if not str or str=="" then
return nil
elseif type(str)=="table" then
if existing then
for k,v in next,str do
existing[k]=v
end
return exiting
else
return str
end
elseif str and str~="" then
hash=existing or {}
lpegmatch(pattern_c_s,str)
return next(hash) and hash
end
end
local separator=comma*space^0
local value=lbrace*C((nobrace+nestedbraces)^0)*rbrace+C((nestedbraces+(1-comma))^0)
local pattern=spaces*Ct(value*(separator*value)^0)
patterns.settings_to_array=pattern
function parsers.settings_to_array(str,strict)
if not str or str=="" then
return {}
elseif type(str)=="table" then
return str
elseif strict then
if find(str,"{",1,true) then
return lpegmatch(pattern,str)
else
return { str }
end
elseif find(str,",",1,true) then
return lpegmatch(pattern,str)
else
return { str }
end
end
function parsers.settings_to_numbers(str)
if not str or str=="" then
return {}
end
if type(str)=="table" then
elseif find(str,",",1,true) then
str=lpegmatch(pattern,str)
else
return { tonumber(str) }
end
for i=1,#str do
str[i]=tonumber(str[i])
end
return str
end
local value=lbrace*C((nobrace+nestedbraces)^0)*rbrace+C((nestedbraces+nestedbrackets+nestedparents+(1-comma))^0)
local pattern=spaces*Ct(value*(separator*value)^0)
function parsers.settings_to_array_obey_fences(str)
return lpegmatch(pattern,str)
end
local cache_a={}
local cache_b={}
function parsers.groupedsplitat(symbol,withaction)
if not symbol then
symbol=","
end
local pattern=(withaction and cache_b or cache_a)[symbol]
if not pattern then
local symbols=S(symbol)
local separator=space^0*symbols*space^0
local value=lbrace*C((nobrace+nestedbraces)^0)*rbrace+C((nestedbraces+(1-(space^0*(symbols+P(-1)))))^0)
if withaction then
local withvalue=Carg(1)*value/function(f,s) return f(s) end
pattern=spaces*withvalue*(separator*withvalue)^0
cache_b[symbol]=pattern
else
pattern=spaces*Ct(value*(separator*value)^0)
cache_a[symbol]=pattern
end
end
return pattern
end
local pattern_a=parsers.groupedsplitat(",",false)
local pattern_b=parsers.groupedsplitat(",",true)
function parsers.stripped_settings_to_array(str)
if not str or str=="" then
return {}
else
return lpegmatch(pattern_a,str)
end
end
function parsers.process_stripped_settings(str,action)
if not str or str=="" then
return {}
else
return lpegmatch(pattern_b,str,1,action)
end
end
local function set(t,v)
t[#t+1]=v
end
local value=P(Carg(1)*value)/set
local pattern=value*(separator*value)^0*Carg(1)
function parsers.add_settings_to_array(t,str)
return lpegmatch(pattern,str,nil,t)
end
function parsers.hash_to_string(h,separator,yes,no,strict,omit)
if h then
local t={}
local tn=0
local s=sortedkeys(h)
omit=omit and tohash(omit)
for i=1,#s do
local key=s[i]
if not omit or not omit[key] then
local value=h[key]
if type(value)=="boolean" then
if yes and no then
if value then
tn=tn+1
t[tn]=key..'='..yes
elseif not strict then
tn=tn+1
t[tn]=key..'='..no
end
elseif value or not strict then
tn=tn+1
t[tn]=key..'='..tostring(value)
end
else
tn=tn+1
t[tn]=key..'='..value
end
end
end
return concat(t,separator or ",")
else
return ""
end
end
function parsers.array_to_string(a,separator)
if a then
return concat(a,separator or ",")
else
return ""
end
end
local pattern=Cf(Ct("")*Cg(C((1-S(", "))^1)*S(", ")^0*Cc(true))^1,rawset)
function parsers.settings_to_set(str)
return str and lpegmatch(pattern,str) or {}
end
hashes.settings_to_set=table.setmetatableindex(function(t,k)
local v=k and lpegmatch(pattern,k) or {}
t[k]=v
return v
end)
getmetatable(hashes.settings_to_set).__mode="kv"
function parsers.simple_hash_to_string(h,separator)
local t={}
local tn=0
for k,v in sortedhash(h) do
if v then
tn=tn+1
t[tn]=k
end
end
return concat(t,separator or ",")
end
local str=Cs(lpegpatterns.unquoted)+C((1-whitespace-equal)^1)
local setting=Cf(Carg(1)*(whitespace^0*Cg(str*whitespace^0*(equal*whitespace^0*str+Cc(""))))^1,rawset)
local splitter=setting^1
function parsers.options_to_hash(str,target)
return str and lpegmatch(splitter,str,1,target or {}) or {}
end
local splitter=lpeg.tsplitat(" ")
function parsers.options_to_array(str)
return str and lpegmatch(splitter,str) or {}
end
local value=P(lbrace*C((nobrace+nestedbraces)^0)*rbrace)+C(digit^1*lparent*(noparent+nestedparents)^1*rparent)+C((nestedbraces+(1-comma))^1)
local pattern_a=spaces*Ct(value*(separator*value)^0)
local function repeater(n,str)
if not n then
return str
else
local s=lpegmatch(pattern_a,str)
if n==1 then
return unpack(s)
else
local t={}
local tn=0
for i=1,n do
for j=1,#s do
tn=tn+1
t[tn]=s[j]
end
end
return unpack(t)
end
end
end
local value=P(lbrace*C((nobrace+nestedbraces)^0)*rbrace)+(C(digit^1)/tonumber*lparent*Cs((noparent+nestedparents)^1)*rparent)/repeater+C((nestedbraces+(1-comma))^1)
local pattern_b=spaces*Ct(value*(separator*value)^0)
function parsers.settings_to_array_with_repeat(str,expand)
if expand then
return lpegmatch(pattern_b,str) or {}
else
return lpegmatch(pattern_a,str) or {}
end
end
local value=lbrace*C((nobrace+nestedbraces)^0)*rbrace
local pattern=Ct((space+value)^0)
function parsers.arguments_to_table(str)
return lpegmatch(pattern,str)
end
function parsers.getparameters(self,class,parentclass,settings)
local sc=self[class]
if not sc then
sc={}
self[class]=sc
if parentclass then
local sp=self[parentclass]
if not sp then
sp={}
self[parentclass]=sp
end
setmetatableindex(sc,sp)
end
end
parsers.settings_to_hash(settings,sc)
end
function parsers.listitem(str)
return gmatch(str,"[^, ]+")
end
local pattern=Cs { "start",
start=V("one")+V("two")+V("three"),
rest=(Cc(",")*V("thousand"))^0*(P(".")+endofstring)*anything^0,
thousand=digit*digit*digit,
one=digit*V("rest"),
two=digit*digit*V("rest"),
three=V("thousand")*V("rest"),
}
lpegpatterns.splitthousands=pattern
function parsers.splitthousands(str)
return lpegmatch(pattern,str) or str
end
local optionalwhitespace=whitespace^0
lpegpatterns.words=Ct((Cs((1-punctuation-whitespace)^1)+anything)^1)
lpegpatterns.sentences=Ct((optionalwhitespace*Cs((1-period)^0*period))^1)
lpegpatterns.paragraphs=Ct((optionalwhitespace*Cs((whitespace^1*endofstring/""+1-(spacer^0*newline*newline))^1))^1)
local dquote=P('"')
local equal=P('=')
local escape=P('\\')
local separator=S(' ,')
local key=C((1-equal)^1)
local value=dquote*C((1-dquote-escape*dquote)^0)*dquote
local pattern=Cf(Ct("")*(Cg(key*equal*value)*separator^0)^1,rawset)^0*P(-1)
function parsers.keq_to_hash(str)
if str and str~="" then
return lpegmatch(pattern,str)
else
return {}
end
end
local defaultspecification={ separator=",",quote='"' }
function parsers.csvsplitter(specification)
specification=specification and setmetatableindex(specification,defaultspecification) or defaultspecification
local separator=specification.separator
local quotechar=specification.quote
local separator=S(separator~="" and separator or ",")
local whatever=C((1-separator-newline)^0)
if quotechar and quotechar~="" then
local quotedata=nil
for chr in gmatch(quotechar,".") do
local quotechar=P(chr)
local quoteword=quotechar*C((1-quotechar)^0)*quotechar
if quotedata then
quotedata=quotedata+quoteword
else
quotedata=quoteword
end
end
whatever=quotedata+whatever
end
local parser=Ct((Ct(whatever*(separator*whatever)^0)*S("\n\r")^1)^0 )
return function(data)
return lpegmatch(parser,data)
end
end
function parsers.rfc4180splitter(specification)
specification=specification and setmetatableindex(specification,defaultspecification) or defaultspecification
local separator=specification.separator
local quotechar=P(specification.quote)
local dquotechar=quotechar*quotechar
/specification.quote
local separator=S(separator~="" and separator or ",")
local escaped=quotechar*Cs((dquotechar+(1-quotechar))^0)*quotechar
local non_escaped=C((1-quotechar-newline-separator)^1)
local field=escaped+non_escaped+Cc("")
local record=Ct(field*(separator*field)^1)
local headerline=record*Cp()
local morerecords=(newline^(specification.strict and -1 or 1)*record)^0
local headeryes=Ct(morerecords)
local headernop=Ct(record*morerecords)
return function(data,getheader)
if getheader then
local header,position=lpegmatch(headerline,data)
local data=lpegmatch(headeryes,data,position)
return data,header
else
return lpegmatch(headernop,data)
end
end
end
local function ranger(first,last,n,action)
if not first then
elseif last==true then
for i=first,n or first do
action(i)
end
elseif last then
for i=first,last do
action(i)
end
else
action(first)
end
end
local cardinal=lpegpatterns.cardinal/tonumber
local spacers=lpegpatterns.spacer^0
local endofstring=lpegpatterns.endofstring
local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1
local stepper=spacers*(cardinal*(spacers*S(":-")*spacers*(cardinal+(P("*")+endofstring)*Cc(true) )+Cc(false) )*Carg(1)*Carg(2)/ranger*S(", ")^0 )^1*endofstring
function parsers.stepper(str,n,action)
if type(n)=="function" then
lpegmatch(stepper,str,1,false,n or print)
else
lpegmatch(stepper,str,1,n,action or print)
end
end
local pattern_math=Cs((P("%")/"\\percent "+P("^")*Cc("{")*lpegpatterns.integer*Cc("}")+anything)^0)
local pattern_text=Cs((P("%")/"\\percent "+(P("^")/"\\high")*Cc("{")*lpegpatterns.integer*Cc("}")+anything)^0)
patterns.unittotex=pattern
function parsers.unittotex(str,textmode)
return lpegmatch(textmode and pattern_text or pattern_math,str)
end
local pattern=Cs((P("^")/"<sup>"*lpegpatterns.integer*Cc("</sup>")+anything)^0)
function parsers.unittoxml(str)
return lpegmatch(pattern,str)
end
local cache={}
local spaces=lpegpatterns.space^0
local dummy=function() end
setmetatableindex(cache,function(t,k)
local separator=P(k)
local value=(1-separator)^0
local pattern=spaces*C(value)*separator^0*Cp()
t[k]=pattern
return pattern
end)
local commalistiterator=cache[","]
function parsers.iterator(str,separator)
local n=#str
if n==0 then
return dummy
else
local pattern=separator and cache[separator] or commalistiterator
local p=1
return function()
if p<=n then
local s,e=lpegmatch(pattern,str,p)
if e then
p=e
return s
end
end
end
end
end
local function initialize(t,name)
local source=t[name]
if source then
local result={}
for k,v in next,t[name] do
result[k]=v
end
return result
else
return {}
end
end
local function fetch(t,name)
return t[name] or {}
end
local function process(result,more)
for k,v in next,more do
result[k]=v
end
return result
end
local name=C((1-S(", "))^1)
local parser=(Carg(1)*name/initialize)*(S(", ")^1*(Carg(1)*name/fetch))^0
local merge=Cf(parser,process)
function parsers.mergehashes(hash,list)
return lpegmatch(merge,list,1,hash)
end
function parsers.runtime(time)
if not time then
time=os.runtime()
end
local days=div(time,24*60*60)
time=mod(time,24*60*60)
local hours=div(time,60*60)
time=mod(time,60*60)
local minutes=div(time,60)
local seconds=mod(time,60)
return days,hours,minutes,seconds
end
local spacing=whitespace^0
local apply=P("->")
local method=C((1-apply)^1)
local token=lbrace*C((1-rbrace)^1)*rbrace+C(anything^1)
local pattern=spacing*(method*spacing*apply+Carg(1))*spacing*token
function parsers.splitmethod(str,default)
if str then
return lpegmatch(pattern,str,1,default or false)
else
return default or false,""
end
end
local p_year=lpegpatterns.digit^4/tonumber
local pattern=Cf(Ct("")*(
(Cg(Cc("year")*p_year)*S("-/")*Cg(Cc("month")*cardinal)*S("-/")*Cg(Cc("day")*cardinal)
)+(Cg(Cc("day")*cardinal)*S("-/")*Cg(Cc("month")*cardinal)*S("-/")*Cg(Cc("year")*p_year)
)
)*P(" ")*Cg(Cc("hour")*cardinal)*P(":")*Cg(Cc("min")*cardinal)*(P(":")*Cg(Cc("sec")*cardinal))^-1
,rawset)
lpegpatterns.splittime=pattern
function parsers.totime(str)
return lpegmatch(pattern,str)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-fmt"] = package.loaded["util-fmt"] or true
-- original size: 2541, stripped down to: 1624
if not modules then modules={} end modules ['util-fmt']={
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"
}
utilities=utilities or {}
utilities.formatters=utilities.formatters or {}
local formatters=utilities.formatters
local concat,format=table.concat,string.format
local tostring,type=tostring,type
local strip=string.strip
local lpegmatch=lpeg.match
local stripper=lpeg.patterns.stripzeros
function formatters.stripzeros(str)
return lpegmatch(stripper,str)
end
function formatters.formatcolumns(result,between)
if result and #result>0 then
between=between or " "
local widths,numbers={},{}
local first=result[1]
local n=#first
for i=1,n do
widths[i]=0
end
for i=1,#result do
local r=result[i]
for j=1,n do
local rj=r[j]
local tj=type(rj)
if tj=="number" then
numbers[j]=true
rj=tostring(rj)
elseif tj~="string" then
rj=tostring(rj)
r[j]=rj
end
local w=#rj
if w>widths[j] then
widths[j]=w
end
end
end
for i=1,n do
local w=widths[i]
if numbers[i] then
if w>80 then
widths[i]="%s"..between
else
widths[i]="%0"..w.."i"..between
end
else
if w>80 then
widths[i]="%s"..between
elseif w>0 then
widths[i]="%-"..w.."s"..between
else
widths[i]="%s"
end
end
end
local template=strip(concat(widths))
for i=1,#result do
local str=format(template,unpack(result[i]))
result[i]=strip(str)
end
end
return result
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-reset"] = package.loaded["util-soc-imp-reset"] or true
-- original size: 374, stripped down to: 282
local loaded=package.loaded
loaded["socket"]=nil
loaded["copas"]=nil
loaded["ltn12"]=nil
loaded["mbox"]=nil
loaded["mime"]=nil
loaded["socket.url"]=nil
loaded["socket.headers"]=nil
loaded["socket.tp"]=nil
loaded["socket.http"]=nil
loaded["socket.ftp"]=nil
loaded["socket.smtp"]=nil
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-socket"] = package.loaded["util-soc-imp-socket"] or true
-- original size: 4905, stripped down to: 3562
local type,tostring,setmetatable=type,tostring,setmetatable
local min=math.min
local format=string.format
local socket=socket or package.loaded.socket or require("socket.core")
local connect=socket.connect
local tcp4=socket.tcp4
local tcp6=socket.tcp6
local getaddrinfo=socket.dns.getaddrinfo
local defaulthost="0.0.0.0"
local function report(fmt,first,...)
if logs then
report=logs and logs.reporter("socket")
report(fmt,first,...)
elseif fmt then
fmt="socket: "..fmt
if first then
print(format(fmt,first,...))
else
print(fmt)
end
end
end
socket.report=report
function socket.connect4(address,port,laddress,lport)
return connect(address,port,laddress,lport,"inet")
end
function socket.connect6(address,port,laddress,lport)
return connect(address,port,laddress,lport,"inet6")
end
function socket.bind(host,port,backlog)
if host=="*" or host=="" then
host=defaulthost
end
local addrinfo,err=getaddrinfo(host)
if not addrinfo then
return nil,err
end
for i=1,#addrinfo do
local alt=addrinfo[i]
local sock,err=(alt.family=="inet" and tcp4 or tcp6)()
if not sock then
return nil,err or "unknown error"
end
sock:setoption("reuseaddr",true)
local res,err=sock:bind(alt.addr,port)
if res then
res,err=sock:listen(backlog)
if res then
return sock
else
sock:close()
end
else
sock:close()
end
end
return nil,"invalid address"
end
socket.try=socket.newtry()
function socket.choose(list)
return function(name,opt1,opt2)
if type(name)~="string" then
name,opt1,opt2="default",name,opt1
end
local f=list[name or "nil"]
if f then
return f(opt1,opt2)
else
report("error: unknown key '%s'",tostring(name))
end
end
end
local sourcet={}
local sinkt={}
socket.sourcet=sourcet
socket.sinkt=sinkt
socket.BLOCKSIZE=2048
sinkt["close-when-done"]=function(sock)
return setmetatable (
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},
{
__call=function(self,chunk,err)
if chunk then
return sock:send(chunk)
else
sock:close()
return 1
end
end
}
)
end
sinkt["keep-open"]=function(sock)
return setmetatable (
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},{
__call=function(self,chunk,err)
if chunk then
return sock:send(chunk)
else
return 1
end
end
}
)
end
sinkt["default"]=sinkt["keep-open"]
socket.sink=socket.choose(sinkt)
sourcet["by-length"]=function(sock,length)
local blocksize=socket.BLOCKSIZE
return setmetatable (
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},
{
__call=function()
if length<=0 then
return nil
end
local chunk,err=sock:receive(min(blocksize,length))
if err then
return nil,err
end
length=length-#chunk
return chunk
end
}
)
end
sourcet["until-closed"]=function(sock)
local blocksize=socket.BLOCKSIZE
local done=false
return setmetatable (
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},{
__call=function()
if done then
return nil
end
local chunk,status,partial=sock:receive(blocksize)
if not status then
return chunk
elseif status=="closed" then
sock:close()
done=true
return partial
else
return nil,status
end
end
}
)
end
sourcet["default"]=sourcet["until-closed"]
socket.source=socket.choose(sourcet)
_G.socket=socket
package.loaded["socket"]=socket
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-copas"] = package.loaded["util-soc-imp-copas"] or true
-- original size: 25844, stripped down to: 14821
local socket=socket or require("socket")
local ssl=ssl or nil
local WATCH_DOG_TIMEOUT=120
local UDP_DATAGRAM_MAX=8192
local type,next,pcall,getmetatable,tostring=type,next,pcall,getmetatable,tostring
local min,max,random=math.min,math.max,math.random
local find=string.find
local insert,remove=table.insert,table.remove
local gettime=socket.gettime
local selectsocket=socket.select
local createcoroutine=coroutine.create
local resumecoroutine=coroutine.resume
local yieldcoroutine=coroutine.yield
local runningcoroutine=coroutine.running
local function report(fmt,first,...)
if logs then
report=logs and logs.reporter("copas")
report(fmt,first,...)
elseif fmt then
fmt="copas: "..fmt
if first then
print(format(fmt,first,...))
else
print(fmt)
end
end
end
local copas={
_COPYRIGHT="Copyright (C) 2005-2016 Kepler Project",
_DESCRIPTION="Coroutine Oriented Portable Asynchronous Services",
_VERSION="Copas 2.0.1",
autoclose=true,
running=false,
report=report,
}
local function statushandler(status,...)
if status then
return...
end
local err=(...)
if type(err)=="table" then
err=err[1]
end
report("error: %s",tostring(err))
return nil,err
end
function socket.protect(func)
return function(...)
return statushandler(pcall(func,...))
end
end
function socket.newtry(finalizer)
return function (...)
local status=(...)
if not status then
local detail=select(2,...)
pcall(finalizer,detail)
report("error: %s",tostring(detail))
return
end
return...
end
end
local function newset()
local reverse={}
local set={}
local queue={}
setmetatable(set,{
__index={
insert=function(set,value)
if not reverse[value] then
local n=#set+1
set[n]=value
reverse[value]=n
end
end,
remove=function(set,value)
local index=reverse[value]
if index then
reverse[value]=nil
local n=#set
local top=set[n]
set[n]=nil
if top~=value then
reverse[top]=index
set[index]=top
end
end
end,
push=function (set,key,itm)
local entry=queue[key]
if entry==nil then
queue[key]={ itm }
else
entry[#entry+1]=itm
end
end,
pop=function (set,key)
local top=queue[key]
if top~=nil then
local ret=remove(top,1)
if top[1]==nil then
queue[key]=nil
end
return ret
end
end
}
} )
return set
end
local _sleeping={
times={},
cos={},
lethargy={},
insert=function()
end,
remove=function()
end,
push=function(self,sleeptime,co)
if not co then
return
end
if sleeptime<0 then
self.lethargy[co]=true
return
else
sleeptime=gettime()+sleeptime
end
local t=self.times
local c=self.cos
local i=1
local n=#t
while i<=n and t[i]<=sleeptime do
i=i+1
end
insert(t,i,sleeptime)
insert(c,i,co)
end,
getnext=
function(self)
local t=self.times
local delay=t[1] and t[1]-gettime() or nil
return delay and max(delay,0) or nil
end,
pop=
function(self,time)
local t=self.times
local c=self.cos
if #t==0 or time<t[1] then
return
end
local co=c[1]
remove(t,1)
remove(c,1)
return co
end,
wakeup=function(self,co)
local let=self.lethargy
if let[co] then
self:push(0,co)
let[co]=nil
else
local c=self.cos
local t=self.times
for i=1,#c do
if c[i]==co then
remove(c,i)
remove(t,i)
self:push(0,co)
return
end
end
end
end
}
local _servers=newset()
local _reading=newset()
local _writing=newset()
local _reading_log={}
local _writing_log={}
local _is_timeout={
timeout=true,
wantread=true,
wantwrite=true,
}
local function isTCP(socket)
return not find(tostring(socket),"^udp")
end
local function copasreceive(client,pattern,part)
if not pattern or pattern=="" then
pattern="*l"
end
local current_log=_reading_log
local s,err
repeat
s,err,part=client:receive(pattern,part)
if s or (not _is_timeout[err]) then
current_log[client]=nil
return s,err,part
end
if err=="wantwrite" then
current_log=_writing_log
current_log[client]=gettime()
yieldcoroutine(client,_writing)
else
current_log=_reading_log
current_log[client]=gettime()
yieldcoroutine(client,_reading)
end
until false
end
local function copasreceivefrom(client,size)
local s,err,port
if not size or size==0 then
size=UDP_DATAGRAM_MAX
end
repeat
s,err,port=client:receivefrom(size)
if s or err~="timeout" then
_reading_log[client]=nil
return s,err,port
end
_reading_log[client]=gettime()
yieldcoroutine(client,_reading)
until false
end
local function copasreceivepartial(client,pattern,part)
if not pattern or pattern=="" then
pattern="*l"
end
local logger=_reading_log
local queue=_reading
local s,err
repeat
s,err,part=client:receive(pattern,part)
if s or (type(pattern)=="number" and part~="" and part) or not _is_timeout[err] then
logger[client]=nil
return s,err,part
end
if err=="wantwrite" then
logger=_writing_log
queue=_writing
else
logger=_reading_log
queue=_reading
end
logger[client]=gettime()
yieldcoroutine(client,queue)
until false
end
local function copassend(client,data,from,to)
if not from then
from=1
end
local lastIndex=from-1
local logger=_writing_log
local queue=_writing
local s,err
repeat
s,err,lastIndex=client:send(data,lastIndex+1,to)
if random(100)>90 then
logger[client]=gettime()
yieldcoroutine(client,queue)
end
if s or not _is_timeout[err] then
logger[client]=nil
return s,err,lastIndex
end
if err=="wantread" then
logger=_reading_log
queue=_reading
else
logger=_writing_log
queue=_writing
end
logger[client]=gettime()
yieldcoroutine(client,queue)
until false
end
local function copassendto(client,data,ip,port)
repeat
local s,err=client:sendto(data,ip,port)
if random(100)>90 then
_writing_log[client]=gettime()
yieldcoroutine(client,_writing)
end
if s or err~="timeout" then
_writing_log[client]=nil
return s,err
end
_writing_log[client]=gettime()
yieldcoroutine(client,_writing)
until false
end
local function copasconnect(skt,host,port)
skt:settimeout(0)
local ret,err,tried_more_than_once
repeat
ret,err=skt:connect (host,port)
if ret or (err~="timeout" and err~="Operation already in progress") then
if not ret and err=="already connected" and tried_more_than_once then
ret=1
err=nil
end
_writing_log[skt]=nil
return ret,err
end
tried_more_than_once=tried_more_than_once or true
_writing_log[skt]=gettime()
yieldcoroutine(skt,_writing)
until false
end
local function copasdohandshake(skt,sslt)
if not ssl then
ssl=require("ssl")
end
if not ssl then
report("error: no ssl library")
return
end
local nskt,err=ssl.wrap(skt,sslt)
if not nskt then
report("error: %s",tostring(err))
return
end
nskt:settimeout(0)
local queue
repeat
local success,err=nskt:dohandshake()
if success then
return nskt
elseif err=="wantwrite" then
queue=_writing
elseif err=="wantread" then
queue=_reading
else
report("error: %s",tostring(err))
return
end
yieldcoroutine(nskt,queue)
until false
end
local function copasflush(client)
end
copas.connect=copassconnect
copas.send=copassend
copas.sendto=copassendto
copas.receive=copasreceive
copas.receivefrom=copasreceivefrom
copas.copasreceivepartial=copasreceivepartial
copas.copasreceivePartial=copasreceivepartial
copas.dohandshake=copasdohandshake
copas.flush=copasflush
local function _skt_mt_tostring(self)
return tostring(self.socket).." (copas wrapped)"
end
local _skt_mt_tcp_index={
send=function(self,data,from,to)
return copassend (self.socket,data,from,to)
end,
receive=function (self,pattern,prefix)
if self.timeout==0 then
return copasreceivePartial(self.socket,pattern,prefix)
else
return copasreceive(self.socket,pattern,prefix)
end
end,
flush=function (self)
return copasflush(self.socket)
end,
settimeout=function (self,time)
self.timeout=time
return true
end,
connect=function(self,...)
local res,err=copasconnect(self.socket,...)
if res and self.ssl_params then
res,err=self:dohandshake()
end
return res,err
end,
close=function(self,...)
return self.socket:close(...)
end,
bind=function(self,...)
return self.socket:bind(...)
end,
getsockname=function(self,...)
return self.socket:getsockname(...)
end,
getstats=function(self,...)
return self.socket:getstats(...)
end,
setstats=function(self,...)
return self.socket:setstats(...)
end,
listen=function(self,...)
return self.socket:listen(...)
end,
accept=function(self,...)
return self.socket:accept(...)
end,
setoption=function(self,...)
return self.socket:setoption(...)
end,
getpeername=function(self,...)
return self.socket:getpeername(...)
end,
shutdown=function(self,...)
return self.socket:shutdown(...)
end,
dohandshake=function(self,sslt)
self.ssl_params=sslt or self.ssl_params
local nskt,err=copasdohandshake(self.socket,self.ssl_params)
if not nskt then
return nskt,err
end
self.socket=nskt
return self
end,
}
local _skt_mt_tcp={
__tostring=_skt_mt_tostring,
__index=_skt_mt_tcp_index,
}
local _skt_mt_udp_index={
sendto=function (self,...)
return copassendto(self.socket,...)
end,
receive=function (self,size)
return copasreceive(self.socket,size or UDP_DATAGRAM_MAX)
end,
receivefrom=function (self,size)
return copasreceivefrom(self.socket,size or UDP_DATAGRAM_MAX)
end,
setpeername=function(self,...)
return self.socket:getpeername(...)
end,
setsockname=function(self,...)
return self.socket:setsockname(...)
end,
close=function(self,...)
return true
end
}
local _skt_mt_udp={
__tostring=_skt_mt_tostring,
__index=_skt_mt_udp_index,
}
for k,v in next,_skt_mt_tcp_index do
if not _skt_mt_udp_index[k] then
_skt_mt_udp_index[k]=v
end
end
local function wrap(skt,sslt)
if getmetatable(skt)==_skt_mt_tcp or getmetatable(skt)==_skt_mt_udp then
return skt
end
skt:settimeout(0)
if isTCP(skt) then
return setmetatable ({ socket=skt,ssl_params=sslt },_skt_mt_tcp)
else
return setmetatable ({ socket=skt },_skt_mt_udp)
end
end
copas.wrap=wrap
function copas.handler(handler,sslparams)
return function (skt,...)
skt=wrap(skt)
if sslparams then
skt:dohandshake(sslparams)
end
return handler(skt,...)
end
end
local _errhandlers={}
function copas.setErrorHandler(err)
local co=runningcoroutine()
if co then
_errhandlers[co]=err
end
end
local function _deferror (msg,co,skt)
report("%s (%s) (%s)",msg,tostring(co),tostring(skt))
end
local function _doTick (co,skt,...)
if not co then
return
end
local ok,res,new_q=resumecoroutine(co,skt,...)
if ok and res and new_q then
new_q:insert(res)
new_q:push(res,co)
else
if not ok then
pcall(_errhandlers[co] or _deferror,res,co,skt)
end
if skt and copas.autoclose and isTCP(skt) then
skt:close()
end
_errhandlers[co]=nil
end
end
local function _accept(input,handler)
local client=input:accept()
if client then
client:settimeout(0)
local co=createcoroutine(handler)
_doTick (co,client)
end
return client
end
local function _tickRead(skt)
_doTick(_reading:pop(skt),skt)
end
local function _tickWrite(skt)
_doTick(_writing:pop(skt),skt)
end
local function addTCPserver(server,handler,timeout)
server:settimeout(timeout or 0)
_servers[server]=handler
_reading:insert(server)
end
local function addUDPserver(server,handler,timeout)
server:settimeout(timeout or 0)
local co=createcoroutine(handler)
_reading:insert(server)
_doTick(co,server)
end
function copas.addserver(server,handler,timeout)
if isTCP(server) then
addTCPserver(server,handler,timeout)
else
addUDPserver(server,handler,timeout)
end
end
function copas.removeserver(server,keep_open)
local s=server
local mt=getmetatable(server)
if mt==_skt_mt_tcp or mt==_skt_mt_udp then
s=server.socket
end
_servers[s]=nil
_reading:remove(s)
if keep_open then
return true
end
return server:close()
end
function copas.addthread(handler,...)
local thread=createcoroutine(function(_,...) return handler(...) end)
_doTick(thread,nil,...)
return thread
end
local _tasks={}
local function addtaskRead(task)
task.def_tick=_tickRead
_tasks[task]=true
end
local function addtaskWrite(task)
task.def_tick=_tickWrite
_tasks[task]=true
end
local function tasks()
return next,_tasks
end
local _readable_t={
events=function(self)
local i=0
return function ()
i=i+1
return self._evs[i]
end
end,
tick=function(self,input)
local handler=_servers[input]
if handler then
input=_accept(input,handler)
else
_reading:remove(input)
self.def_tick(input)
end
end
}
addtaskRead(_readable_t)
local _writable_t={
events=function(self)
local i=0
return function()
i=i+1
return self._evs[i]
end
end,
tick=function(self,output)
_writing:remove(output)
self.def_tick(output)
end
}
addtaskWrite(_writable_t)
local _sleeping_t={
tick=function(self,time,...)
_doTick(_sleeping:pop(time),...)
end
}
function copas.sleep(sleeptime)
yieldcoroutine((sleeptime or 0),_sleeping)
end
function copas.wakeup(co)
_sleeping:wakeup(co)
end
local last_cleansing=0
local function _select(timeout)
local now=gettime()
local r_evs,w_evs,err=selectsocket(_reading,_writing,timeout)
_readable_t._evs=r_evs
_writable_t._evs=w_evs
if (last_cleansing-now)>WATCH_DOG_TIMEOUT then
last_cleansing=now
for skt,time in next,_reading_log do
if not r_evs[skt] and (time-now)>WATCH_DOG_TIMEOUT then
local n=#r_evs+1
_reading_log[skt]=nil
r_evs[n]=skt
r_evs[skt]=n
end
end
for skt,time in next,_writing_log do
if not w_evs[skt] and (time-now)>WATCH_DOG_TIMEOUT then
local n=#w_evs+1
_writing_log[skt]=nil
w_evs[n]=skt
w_evs[skt]=n
end
end
end
if err=="timeout" and #r_evs+#w_evs>0 then
return nil
else
return err
end
end
local function copasfinished()
return not (next(_reading) or next(_writing) or _sleeping:getnext())
end
local function copasstep(timeout)
_sleeping_t:tick(gettime())
local nextwait=_sleeping:getnext()
if nextwait then
timeout=timeout and min(nextwait,timeout) or nextwait
elseif copasfinished() then
return false
end
local err=_select(timeout)
if err then
if err=="timeout" then
return false
end
return nil,err
end
for task in tasks() do
for event in task:events() do
task:tick(event)
end
end
return true
end
copas.finished=copasfinished
copas.step=copasstep
function copas.loop(timeout)
copas.running=true
while not copasfinished() do
copasstep(timeout)
end
copas.running=false
end
package.loaded["copas"]=copas
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-ltn12"] = package.loaded["util-soc-imp-ltn12"] or true
-- original size: 8709, stripped down to: 5411
local select,unpack=select,unpack
local insert,remove=table.insert,table.remove
local sub=string.sub
local function report(fmt,first,...)
if logs then
report=logs and logs.reporter("ltn12")
report(fmt,first,...)
elseif fmt then
fmt="ltn12: "..fmt
if first then
print(format(fmt,first,...))
else
print(fmt)
end
end
end
local filter={}
local source={}
local sink={}
local pump={}
local ltn12={
_VERSION="LTN12 1.0.3",
BLOCKSIZE=2048,
filter=filter,
source=source,
sink=sink,
pump=pump,
report=report,
}
function filter.cycle(low,ctx,extra)
if low then
return function(chunk)
return (low(ctx,chunk,extra))
end
end
end
function filter.chain(...)
local arg={... }
local n=select('#',...)
local top=1
local index=1
local retry=""
return function(chunk)
retry=chunk and retry
while true do
local action=arg[index]
if index==top then
chunk=action(chunk)
if chunk=="" or top==n then
return chunk
elseif chunk then
index=index+1
else
top=top+1
index=top
end
else
chunk=action(chunk or "")
if chunk=="" then
index=index-1
chunk=retry
elseif chunk then
if index==n then
return chunk
else
index=index+1
end
else
report("error: filter returned inappropriate 'nil'")
return
end
end
end
end
end
local function empty()
return nil
end
function source.empty()
return empty
end
local function sourceerror(err)
return function()
return nil,err
end
end
source.error=sourceerror
function source.file(handle,io_err)
if handle then
local blocksize=ltn12.BLOCKSIZE
return function()
local chunk=handle:read(blocksize)
if not chunk then
handle:close()
end
return chunk
end
else
return sourceerror(io_err or "unable to open file")
end
end
function source.simplify(src)
return function()
local chunk,err_or_new=src()
if err_or_new then
src=err_or_new
end
if chunk then
return chunk
else
return nil,err_or_new
end
end
end
function source.string(s)
if s then
local blocksize=ltn12.BLOCKSIZE
local i=1
return function()
local nexti=i+blocksize
local chunk=sub(s,i,nexti-1)
i=nexti
if chunk~="" then
return chunk
else
return nil
end
end
else return source.empty() end
end
function source.rewind(src)
local t={}
return function(chunk)
if chunk then
insert(t,chunk)
else
chunk=remove(t)
if chunk then
return chunk
else
return src()
end
end
end
end
function source.chain(src,f,...)
if... then
f=filter.chain(f,...)
end
local last_in=""
local last_out=""
local state="feeding"
local err
return function()
if not last_out then
report("error: source is empty")
return
end
while true do
if state=="feeding" then
last_in,err=src()
if err then
return nil,err
end
last_out=f(last_in)
if not last_out then
if last_in then
report("error: filter returned inappropriate 'nil'")
end
return nil
elseif last_out~="" then
state="eating"
if last_in then
last_in=""
end
return last_out
end
else
last_out=f(last_in)
if last_out=="" then
if last_in=="" then
state="feeding"
else
report("error: filter returned nothing")
return
end
elseif not last_out then
if last_in then
report("filter returned inappropriate 'nil'")
end
return nil
else
return last_out
end
end
end
end
end
function source.cat(...)
local arg={... }
local src=remove(arg,1)
return function()
while src do
local chunk,err=src()
if chunk then
return chunk
end
if err then
return nil,err
end
src=remove(arg,1)
end
end
end
function sink.table(t)
if not t then
t={}
end
local f=function(chunk,err)
if chunk then
insert(t,chunk)
end
return 1
end
return f,t
end
function sink.simplify(snk)
return function(chunk,err)
local ret,err_or_new=snk(chunk,err)
if not ret then
return nil,err_or_new
end
if err_or_new then
snk=err_or_new
end
return 1
end
end
local function null()
return 1
end
function sink.null()
return null
end
local function sinkerror(err)
return function()
return nil,err
end
end
sink.error=sinkerror
function sink.file(handle,io_err)
if handle then
return function(chunk,err)
if not chunk then
handle:close()
return 1
else
return handle:write(chunk)
end
end
else
return sinkerror(io_err or "unable to open file")
end
end
function sink.chain(f,snk,...)
if... then
local args={ f,snk,... }
snk=remove(args,#args)
f=filter.chain(unpack(args))
end
return function(chunk,err)
if chunk~="" then
local filtered=f(chunk)
local done=chunk and ""
while true do
local ret,snkerr=snk(filtered,err)
if not ret then
return nil,snkerr
end
if filtered==done then
return 1
end
filtered=f(done)
end
else
return 1
end
end
end
function pump.step(src,snk)
local chunk,src_err=src()
local ret,snk_err=snk(chunk,src_err)
if chunk and ret then
return 1
else
return nil,src_err or snk_err
end
end
function pump.all(src,snk,step)
if not step then
step=pump.step
end
while true do
local ret,err=step(src,snk)
if not ret then
if err then
return nil,err
else
return 1
end
end
end
end
package.loaded["ltn12"]=ltn12
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-mime"] = package.loaded["util-soc-imp-mime"] or true
-- original size: 2373, stripped down to: 1931
local type,tostring=type,tostring
local mime=mime or package.loaded.mime or require("mime.core")
local ltn12=ltn12 or package.loaded.ltn12 or require("ltn12")
local filtercycle=ltn12.filter.cycle
local function report(fmt,first,...)
if logs then
report=logs and logs.reporter("mime")
report(fmt,first,...)
elseif fmt then
fmt="mime: "..fmt
if first then
print(format(fmt,first,...))
else
print(fmt)
end
end
end
mime.report=report
local encodet={}
local decodet={}
local wrapt={}
mime.encodet=encodet
mime.decodet=decodet
mime.wrapt=wrapt
local mime_b64=mime.b64
local mime_qp=mime.qp
local mime_unb64=mime.unb64
local mime_unqp=mime.unqp
local mime_wrp=mime.wrp
local mime_qpwrp=mime.qpwrp
local mime_eol=mime_eol
local mime_dot=mime_dot
encodet['base64']=function()
return filtercycle(mime_b64,"")
end
encodet['quoted-printable']=function(mode)
return filtercycle(mime_qp,"",mode=="binary" and "=0D=0A" or "\r\n")
end
decodet['base64']=function()
return filtercycle(mime_unb64,"")
end
decodet['quoted-printable']=function()
return filtercycle(mime_unqp,"")
end
local wraptext=function(length)
if not length then
length=76
end
return filtercycle(mime_wrp,length,length)
end
local wrapquoted=function()
return filtercycle(mime_qpwrp,76,76)
end
wrapt['text']=wraptext
wrapt['base64']=wraptext
wrapt['default']=wraptext
wrapt['quoted-printable']=wrapquoted
function mime.normalize(marker)
return filtercycle(mime_eol,0,marker)
end
function mime.stuff()
return filtercycle(mime_dot,2)
end
local function choose(list)
return function(name,opt1,opt2)
if type(name)~="string" then
name,opt1,opt2="default",name,opt1
end
local filter=list[name or "nil"]
if filter then
return filter(opt1,opt2)
else
report("error: unknown key '%s'",tostring(name))
end
end
end
mime.encode=choose(encodet)
mime.decode=choose(decodet)
mime.wrap=choose(wrapt)
package.loaded["mime"]=mime
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-url"] = package.loaded["util-soc-imp-url"] or true
-- original size: 6863, stripped down to: 5269
local tonumber,tostring,type=tonumber,tostring,type
local gsub,sub,match,find,format,byte,char=string.gsub,string.sub,string.match,string.find,string.format,string.byte,string.char
local insert=table.insert
local socket=socket or require("socket")
local url={
_VERSION="URL 1.0.3",
}
socket.url=url
function url.escape(s)
return (gsub(s,"([^A-Za-z0-9_])",function(c)
return format("%%%02x",byte(c))
end))
end
local function make_set(t)
local s={}
for i=1,#t do
s[t[i]]=true
end
return s
end
local segment_set=make_set {
"-","_",".","!","~","*","'","(",
")",":","@","&","=","+","$",",",
}
local function protect_segment(s)
return gsub(s,"([^A-Za-z0-9_])",function(c)
if segment_set[c] then
return c
else
return format("%%%02X",byte(c))
end
end)
end
function url.unescape(s)
return (gsub(s,"%%(%x%x)",function(hex)
return char(tonumber(hex,16))
end))
end
local function absolute_path(base_path,relative_path)
if find(relative_path,"^/") then
return relative_path
end
local path=gsub(base_path,"[^/]*$","")
path=path..relative_path
path=gsub(path,"([^/]*%./)",function (s)
if s~="./" then
return s
else
return ""
end
end)
path=gsub(path,"/%.$","/")
local reduced
while reduced~=path do
reduced=path
path=gsub(reduced,"([^/]*/%.%./)",function (s)
if s~="../../" then
return ""
else
return s
end
end)
end
path=gsub(reduced,"([^/]*/%.%.)$",function (s)
if s~="../.." then
return ""
else
return s
end
end)
return path
end
function url.parse(url,default)
local parsed={}
for k,v in next,default or parsed do
parsed[k]=v
end
if not url or url=="" then
return nil,"invalid url"
end
url=gsub(url,"#(.*)$",function(f)
parsed.fragment=f
return ""
end)
url=gsub(url,"^([%w][%w%+%-%.]*)%:",function(s)
parsed.scheme=s
return ""
end)
url=gsub(url,"^//([^/]*)",function(n)
parsed.authority=n
return ""
end)
url=gsub(url,"%?(.*)",function(q)
parsed.query=q
return ""
end)
url=gsub(url,"%;(.*)",function(p)
parsed.params=p
return ""
end)
if url~="" then
parsed.path=url
end
local authority=parsed.authority
if not authority then
return parsed
end
authority=gsub(authority,"^([^@]*)@",function(u)
parsed.userinfo=u
return ""
end)
authority=gsub(authority,":([^:%]]*)$",function(p)
parsed.port=p
return ""
end)
if authority~="" then
parsed.host=match(authority,"^%[(.+)%]$") or authority
end
local userinfo=parsed.userinfo
if not userinfo then
return parsed
end
userinfo=gsub(userinfo,":([^:]*)$",function(p)
parsed.password=p
return ""
end)
parsed.user=userinfo
return parsed
end
function url.build(parsed)
local url=parsed.path or ""
if parsed.params then
url=url..";"..parsed.params
end
if parsed.query then
url=url.."?"..parsed.query
end
local authority=parsed.authority
if parsed.host then
authority=parsed.host
if find(authority,":") then
authority="["..authority.."]"
end
if parsed.port then
authority=authority..":"..tostring(parsed.port)
end
local userinfo=parsed.userinfo
if parsed.user then
userinfo=parsed.user
if parsed.password then
userinfo=userinfo..":"..parsed.password
end
end
if userinfo then authority=userinfo.."@"..authority end
end
if authority then
url="//"..authority..url
end
if parsed.scheme then
url=parsed.scheme..":"..url
end
if parsed.fragment then
url=url.."#"..parsed.fragment
end
return url
end
function url.absolute(base_url,relative_url)
local base_parsed
if type(base_url)=="table" then
base_parsed=base_url
base_url=url.build(base_parsed)
else
base_parsed=url.parse(base_url)
end
local relative_parsed=url.parse(relative_url)
if not base_parsed then
return relative_url
elseif not relative_parsed then
return base_url
elseif relative_parsed.scheme then
return relative_url
else
relative_parsed.scheme=base_parsed.scheme
if not relative_parsed.authority then
relative_parsed.authority=base_parsed.authority
if not relative_parsed.path then
relative_parsed.path=base_parsed.path
if not relative_parsed.params then
relative_parsed.params=base_parsed.params
if not relative_parsed.query then
relative_parsed.query=base_parsed.query
end
end
else
relative_parsed.path=absolute_path(base_parsed.path or "",relative_parsed.path)
end
end
return url.build(relative_parsed)
end
end
function url.parse_path(path)
local parsed={}
path=path or ""
gsub(path,"([^/]+)",function (s)
insert(parsed,s)
end)
for i=1,#parsed do
parsed[i]=url.unescape(parsed[i])
end
if sub(path,1,1)=="/" then
parsed.is_absolute=1
end
if sub(path,-1,-1)=="/" then
parsed.is_directory=1
end
return parsed
end
function url.build_path(parsed,unsafe)
local path=""
local n=#parsed
if unsafe then
for i=1,n-1 do
path=path..parsed[i].."/"
end
if n>0 then
path=path..parsed[n]
if parsed.is_directory then
path=path.."/"
end
end
else
for i=1,n-1 do
path=path..protect_segment(parsed[i]).."/"
end
if n>0 then
path=path..protect_segment(parsed[n])
if parsed.is_directory then
path=path.."/"
end
end
end
if parsed.is_absolute then
path="/"..path
end
return path
end
package.loaded["socket.url"]=url
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-headers"] = package.loaded["util-soc-imp-headers"] or true
-- original size: 5721, stripped down to: 3754
local next=next
local lower=string.lower
local concat=table.concat
local socket=socket or require("socket")
local headers={}
socket.headers=headers
local canonic={
["accept"]="Accept",
["accept-charset"]="Accept-Charset",
["accept-encoding"]="Accept-Encoding",
["accept-language"]="Accept-Language",
["accept-ranges"]="Accept-Ranges",
["action"]="Action",
["alternate-recipient"]="Alternate-Recipient",
["age"]="Age",
["allow"]="Allow",
["arrival-date"]="Arrival-Date",
["authorization"]="Authorization",
["bcc"]="Bcc",
["cache-control"]="Cache-Control",
["cc"]="Cc",
["comments"]="Comments",
["connection"]="Connection",
["content-description"]="Content-Description",
["content-disposition"]="Content-Disposition",
["content-encoding"]="Content-Encoding",
["content-id"]="Content-ID",
["content-language"]="Content-Language",
["content-length"]="Content-Length",
["content-location"]="Content-Location",
["content-md5"]="Content-MD5",
["content-range"]="Content-Range",
["content-transfer-encoding"]="Content-Transfer-Encoding",
["content-type"]="Content-Type",
["cookie"]="Cookie",
["date"]="Date",
["diagnostic-code"]="Diagnostic-Code",
["dsn-gateway"]="DSN-Gateway",
["etag"]="ETag",
["expect"]="Expect",
["expires"]="Expires",
["final-log-id"]="Final-Log-ID",
["final-recipient"]="Final-Recipient",
["from"]="From",
["host"]="Host",
["if-match"]="If-Match",
["if-modified-since"]="If-Modified-Since",
["if-none-match"]="If-None-Match",
["if-range"]="If-Range",
["if-unmodified-since"]="If-Unmodified-Since",
["in-reply-to"]="In-Reply-To",
["keywords"]="Keywords",
["last-attempt-date"]="Last-Attempt-Date",
["last-modified"]="Last-Modified",
["location"]="Location",
["max-forwards"]="Max-Forwards",
["message-id"]="Message-ID",
["mime-version"]="MIME-Version",
["original-envelope-id"]="Original-Envelope-ID",
["original-recipient"]="Original-Recipient",
["pragma"]="Pragma",
["proxy-authenticate"]="Proxy-Authenticate",
["proxy-authorization"]="Proxy-Authorization",
["range"]="Range",
["received"]="Received",
["received-from-mta"]="Received-From-MTA",
["references"]="References",
["referer"]="Referer",
["remote-mta"]="Remote-MTA",
["reply-to"]="Reply-To",
["reporting-mta"]="Reporting-MTA",
["resent-bcc"]="Resent-Bcc",
["resent-cc"]="Resent-Cc",
["resent-date"]="Resent-Date",
["resent-from"]="Resent-From",
["resent-message-id"]="Resent-Message-ID",
["resent-reply-to"]="Resent-Reply-To",
["resent-sender"]="Resent-Sender",
["resent-to"]="Resent-To",
["retry-after"]="Retry-After",
["return-path"]="Return-Path",
["sender"]="Sender",
["server"]="Server",
["smtp-remote-recipient"]="SMTP-Remote-Recipient",
["status"]="Status",
["subject"]="Subject",
["te"]="TE",
["to"]="To",
["trailer"]="Trailer",
["transfer-encoding"]="Transfer-Encoding",
["upgrade"]="Upgrade",
["user-agent"]="User-Agent",
["vary"]="Vary",
["via"]="Via",
["warning"]="Warning",
["will-retry-until"]="Will-Retry-Until",
["www-authenticate"]="WWW-Authenticate",
["x-mailer"]="X-Mailer",
}
headers.canonic=setmetatable(canonic,{
__index=function(t,k)
socket.report("invalid header: %s",k)
t[k]=k
return k
end
})
function headers.normalize(headers)
if not headers then
return {}
end
local normalized={}
for k,v in next,headers do
normalized[#normalized+1]=canonic[k]..": "..v
end
normalized[#normalized+1]=""
normalized[#normalized+1]=""
return concat(normalized,"\r\n")
end
function headers.lower(lowered,headers)
if not lowered then
return {}
end
if not headers then
lowered,headers={},lowered
end
for k,v in next,headers do
lowered[lower(k)]=v
end
return lowered
end
socket.headers=headers
package.loaded["socket.headers"]=headers
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-tp"] = package.loaded["util-soc-imp-tp"] or true
-- original size: 3116, stripped down to: 2533
local setmetatable,next,type,tonumber=setmetatable,next,type,tonumber
local find,upper=string.find,string.upper
local socket=socket or require("socket")
local ltn12=ltn12 or require("ltn12")
local skipsocket=socket.skip
local sinksocket=socket.sink
local tcpsocket=socket.tcp
local ltn12pump=ltn12.pump
local pumpall=ltn12pump.all
local pumpstep=ltn12pump.step
local tp={
TIMEOUT=60,
}
socket.tp=tp
local function get_reply(c)
local line,err=c:receive()
local reply=line
if err then return
nil,err
end
local code,sep=skipsocket(2,find(line,"^(%d%d%d)(.?)"))
if not code then
return nil,"invalid server reply"
end
if sep=="-" then
local current
repeat
line,err=c:receive()
if err then
return nil,err
end
current,sep=skipsocket(2,find(line,"^(%d%d%d)(.?)"))
reply=reply.."\n"..line
until code==current and sep==" "
end
return code,reply
end
local methods={}
local mt={ __index=methods }
function methods.getpeername(self)
return self.c:getpeername()
end
function methods.getsockname(self)
return self.c:getpeername()
end
function methods.check(self,ok)
local code,reply=get_reply(self.c)
if not code then
return nil,reply
end
local c=tonumber(code)
local t=type(ok)
if t=="function" then
return ok(c,reply)
elseif t=="table" then
for i=1,#ok do
if find(code,ok[i]) then
return c,reply
end
end
return nil,reply
elseif find(code,ok) then
return c,reply
else
return nil,reply
end
end
function methods.command(self,cmd,arg)
cmd=upper(cmd)
if arg then
cmd=cmd.." "..arg.."\r\n"
else
cmd=cmd.."\r\n"
end
return self.c:send(cmd)
end
function methods.sink(self,snk,pat)
local chunk,err=self.c:receive(pat)
return snk(chunk,err)
end
function methods.send(self,data)
return self.c:send(data)
end
function methods.receive(self,pat)
return self.c:receive(pat)
end
function methods.getfd(self)
return self.c:getfd()
end
function methods.dirty(self)
return self.c:dirty()
end
function methods.getcontrol(self)
return self.c
end
function methods.source(self,source,step)
local sink=sinksocket("keep-open",self.c)
local ret,err=pumpall(source,sink,step or pumpstep)
return ret,err
end
function methods.close(self)
self.c:close()
return 1
end
function tp.connect(host,port,timeout,create)
local c,e=(create or tcpsocket)()
if not c then
return nil,e
end
c:settimeout(timeout or tp.TIMEOUT)
local r,e=c:connect(host,port)
if not r then
c:close()
return nil,e
end
return setmetatable({ c=c },mt)
end
package.loaded["socket.tp"]=tp
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-http"] = package.loaded["util-soc-imp-http"] or true
-- original size: 12577, stripped down to: 9577
local tostring,tonumber,setmetatable,next,type=tostring,tonumber,setmetatable,next,type
local find,lower,format,gsub,match=string.find,string.lower,string.format,string.gsub,string.match
local concat=table.concat
local socket=socket or require("socket")
local url=socket.url or require("socket.url")
local ltn12=ltn12 or require("ltn12")
local mime=mime or require("mime")
local headers=socket.headers or require("socket.headers")
local normalizeheaders=headers.normalize
local parseurl=url.parse
local buildurl=url.build
local absoluteurl=url.absolute
local unescapeurl=url.unescape
local skipsocket=socket.skip
local sinksocket=socket.sink
local sourcesocket=socket.source
local trysocket=socket.try
local tcpsocket=socket.tcp
local newtrysocket=socket.newtry
local protectsocket=socket.protect
local emptysource=ltn12.source.empty
local stringsource=ltn12.source.string
local rewindsource=ltn12.source.rewind
local pumpstep=ltn12.pump.step
local pumpall=ltn12.pump.all
local sinknull=ltn12.sink.null
local sinktable=ltn12.sink.table
local lowerheaders=headers.lower
local mimeb64=mime.b64
local http={
TIMEOUT=60,
USERAGENT=socket._VERSION,
}
socket.http=http
local PORT=80
local SCHEMES={
http=true,
}
local function receiveheaders(sock,headers)
if not headers then
headers={}
end
local line,err=sock:receive()
if err then
return nil,err
end
while line~="" do
local name,value=skipsocket(2,find(line,"^(.-):%s*(.*)"))
if not (name and value) then
return nil,"malformed reponse headers"
end
name=lower(name)
line,err=sock:receive()
if err then
return nil,err
end
while find(line,"^%s") do
value=value..line
line=sock:receive()
if err then
return nil,err
end
end
local found=headers[name]
if found then
value=found..", "..value
end
headers[name]=value
end
return headers
end
socket.sourcet["http-chunked"]=function(sock,headers)
return setmetatable (
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},{
__call=function()
local line,err=sock:receive()
if err then
return nil,err
end
local size=tonumber(gsub(line,";.*",""),16)
if not size then
return nil,"invalid chunk size"
end
if size>0 then
local chunk,err,part=sock:receive(size)
if chunk then
sock:receive()
end
return chunk,err
else
headers,err=receiveheaders(sock,headers)
if not headers then
return nil,err
end
end
end
}
)
end
socket.sinkt["http-chunked"]=function(sock)
return setmetatable(
{
getfd=function() return sock:getfd() end,
dirty=function() return sock:dirty() end,
},
{
__call=function(self,chunk,err)
if not chunk then
chunk=""
end
return sock:send(format("%X\r\n%s\r\n",#chunk,chunk))
end
})
end
local methods={}
local mt={ __index=methods }
local function openhttp(host,port,create)
local c=trysocket((create or tcpsocket)())
local h=setmetatable({ c=c },mt)
local try=newtrysocket(function() h:close() end)
h.try=try
try(c:settimeout(http.TIMEOUT))
try(c:connect(host,port or PORT))
return h
end
http.open=openhttp
function methods.sendrequestline(self,method,uri)
local requestline=format("%s %s HTTP/1.1\r\n",method or "GET",uri)
return self.try(self.c:send(requestline))
end
function methods.sendheaders(self,headers)
self.try(self.c:send(normalizeheaders(headers)))
return 1
end
function methods.sendbody(self,headers,source,step)
if not source then
source=emptysource()
end
if not step then
step=pumpstep
end
local mode="http-chunked"
if headers["content-length"] then
mode="keep-open"
end
return self.try(pumpall(source,sinksocket(mode,self.c),step))
end
function methods.receivestatusline(self)
local try=self.try
local status=try(self.c:receive(5))
if status~="HTTP/" then
return nil,status
end
status=try(self.c:receive("*l",status))
local code=skipsocket(2,find(status,"HTTP/%d*%.%d* (%d%d%d)"))
return try(tonumber(code),status)
end
function methods.receiveheaders(self)
return self.try(receiveheaders(self.c))
end
function methods.receivebody(self,headers,sink,step)
if not sink then
sink=sinknull()
end
if not step then
step=pumpstep
end
local length=tonumber(headers["content-length"])
local encoding=headers["transfer-encoding"]
local mode="default"
if encoding and encoding~="identity" then
mode="http-chunked"
elseif length then
mode="by-length"
end
return self.try(pumpall(sourcesocket(mode,self.c,length),sink,step))
end
function methods.receive09body(self,status,sink,step)
local source=rewindsource(sourcesocket("until-closed",self.c))
source(status)
return self.try(pumpall(source,sink,step))
end
function methods.close(self)
return self.c:close()
end
local function adjusturi(request)
if not request.proxy and not http.PROXY then
request={
path=trysocket(request.path,"invalid path 'nil'"),
params=request.params,
query=request.query,
fragment=request.fragment,
}
end
return buildurl(request)
end
local function adjustheaders(request)
local headers={
["user-agent"]=http.USERAGENT,
["host"]=gsub(request.authority,"^.-@",""),
["connection"]="close, TE",
["te"]="trailers"
}
local username=request.user
local password=request.password
if username and password then
headers["authorization"]="Basic "..(mimeb64(username..":"..unescapeurl(password)))
end
local proxy=request.proxy or http.PROXY
if proxy then
proxy=parseurl(proxy)
local username=proxy.user
local password=proxy.password
if username and password then
headers["proxy-authorization"]="Basic "..(mimeb64(username..":"..password))
end
end
local requestheaders=request.headers
if requestheaders then
headers=lowerheaders(headers,requestheaders)
end
return headers
end
local default={
host="",
port=PORT,
path="/",
scheme="http"
}
local function adjustrequest(originalrequest)
local url=originalrequest.url
local request=url and parseurl(url,default) or {}
for k,v in next,originalrequest do
request[k]=v
end
local host=request.host
local port=request.port
local uri=request.uri
if not host or host=="" then
trysocket(nil,"invalid host '"..tostring(host).."'")
end
if port=="" then
request.port=PORT
end
if not uri or uri=="" then
request.uri=adjusturi(request)
end
request.headers=adjustheaders(request)
local proxy=request.proxy or http.PROXY
if proxy then
proxy=parseurl(proxy)
request.host=proxy.host
request.port=proxy.port or 3128
end
return request
end
local maxredericts=4
local validredirects={ [301]=true,[302]=true,[303]=true,[307]=true }
local validmethods={ [false]=true,GET=true,HEAD=true }
local function shouldredirect(request,code,headers)
local location=headers.location
if not location then
return false
end
location=gsub(location,"%s","")
if location=="" then
return false
end
local scheme=match(location,"^([%w][%w%+%-%.]*)%:")
if scheme and not SCHEMES[scheme] then
return false
end
local method=request.method
local redirect=request.redirect
local redirects=request.nredirects or 0
return redirect and validredirects[code] and validmethods[method] and redirects<=maxredericts
end
local function shouldreceivebody(request,code)
if request.method=="HEAD" then
return nil
end
if code==204 or code==304 then
return nil
end
if code>=100 and code<200 then
return nil
end
return 1
end
local tredirect,trequest,srequest
tredirect=function(request,location)
local result,code,headers,status=trequest {
url=absoluteurl(request.url,location),
source=request.source,
sink=request.sink,
headers=request.headers,
proxy=request.proxy,
nredirects=(request.nredirects or 0)+1,
create=request.create,
}
if not headers then
headers={}
end
if not headers.location then
headers.location=location
end
return result,code,headers,status
end
trequest=function(originalrequest)
local request=adjustrequest(originalrequest)
local connection=openhttp(request.host,request.port,request.create)
local headers=request.headers
connection:sendrequestline(request.method,request.uri)
connection:sendheaders(headers)
if request.source then
connection:sendbody(headers,request.source,request.step)
end
local code,status=connection:receivestatusline()
if not code then
connection:receive09body(status,request.sink,request.step)
return 1,200
end
while code==100 do
headers=connection:receiveheaders()
code,status=connection:receivestatusline()
end
headers=connection:receiveheaders()
if shouldredirect(request,code,headers) and not request.source then
connection:close()
return tredirect(originalrequest,headers.location)
end
if shouldreceivebody(request,code) then
connection:receivebody(headers,request.sink,request.step)
end
connection:close()
return 1,code,headers,status
end
local function genericform(url,body)
local buffer={}
local request={
url=url,
sink=sinktable(buffer),
target=buffer,
}
if body then
request.source=stringsource(body)
request.method="POST"
request.headers={
["content-length"]=#body,
["content-type"]="application/x-www-form-urlencoded"
}
end
return request
end
http.genericform=genericform
srequest=function(url,body)
local request=genericform(url,body)
local _,code,headers,status=trequest(request)
return concat(request.target),code,headers,status
end
http.request=protectsocket(function(request,body)
if type(request)=="string" then
return srequest(request,body)
else
return trequest(request)
end
end)
package.loaded["socket.http"]=http
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-ftp"] = package.loaded["util-soc-imp-ftp"] or true
-- original size: 10357, stripped down to: 8548
local setmetatable,type,next=setmetatable,type,next
local find,format,gsub,match=string.find,string.format,string.gsub,string.match
local concat=table.concat
local mod=math.mod
local socket=socket or require("socket")
local url=socket.url or require("socket.url")
local tp=socket.tp or require("socket.tp")
local ltn12=ltn12 or require("ltn12")
local tcpsocket=socket.tcp
local trysocket=socket.try
local skipsocket=socket.skip
local sinksocket=socket.sink
local selectsocket=socket.select
local bindsocket=socket.bind
local newtrysocket=socket.newtry
local sourcesocket=socket.source
local protectsocket=socket.protect
local parseurl=url.parse
local unescapeurl=url.unescape
local pumpall=ltn12.pump.all
local pumpstep=ltn12.pump.step
local sourcestring=ltn12.source.string
local sinktable=ltn12.sink.table
local ftp={
TIMEOUT=60,
USER="ftp",
PASSWORD="anonymous@anonymous.org",
}
socket.ftp=ftp
local PORT=21
local methods={}
local mt={ __index=methods }
function ftp.open(server,port,create)
local tp=trysocket(tp.connect(server,port or PORT,ftp.TIMEOUT,create))
local f=setmetatable({ tp=tp },metat)
f.try=newtrysocket(function() f:close() end)
return f
end
function methods.portconnect(self)
local try=self.try
local server=self.server
try(server:settimeout(ftp.TIMEOUT))
self.data=try(server:accept())
try(self.data:settimeout(ftp.TIMEOUT))
end
function methods.pasvconnect(self)
local try=self.try
self.data=try(tcpsocket())
self(self.data:settimeout(ftp.TIMEOUT))
self(self.data:connect(self.pasvt.address,self.pasvt.port))
end
function methods.login(self,user,password)
local try=self.try
local tp=self.tp
try(tp:command("user",user or ftp.USER))
local code,reply=try(tp:check{"2..",331})
if code==331 then
try(tp:command("pass",password or ftp.PASSWORD))
try(tp:check("2.."))
end
return 1
end
function methods.pasv(self)
local try=self.try
local tp=self.tp
try(tp:command("pasv"))
local code,reply=try(self.tp:check("2.."))
local pattern="(%d+)%D(%d+)%D(%d+)%D(%d+)%D(%d+)%D(%d+)"
local a,b,c,d,p1,p2=skipsocket(2,find(reply,pattern))
try(a and b and c and d and p1 and p2,reply)
local address=format("%d.%d.%d.%d",a,b,c,d)
local port=p1*256+p2
local server=self.server
self.pasvt={
address=address,
port=port,
}
if server then
server:close()
self.server=nil
end
return address,port
end
function methods.epsv(self)
local try=self.try
local tp=self.tp
try(tp:command("epsv"))
local code,reply=try(tp:check("229"))
local pattern="%((.)(.-)%1(.-)%1(.-)%1%)"
local d,prt,address,port=match(reply,pattern)
try(port,"invalid epsv response")
local address=tp:getpeername()
local server=self.server
self.pasvt={
address=address,
port=port,
}
if self.server then
server:close()
self.server=nil
end
return address,port
end
function methods.port(self,address,port)
local try=self.try
local tp=self.tp
self.pasvt=nil
if not address then
address,port=try(tp:getsockname())
self.server=try(bindsocket(address,0))
address,port=try(self.server:getsockname())
try(self.server:settimeout(ftp.TIMEOUT))
end
local pl=mod(port,256)
local ph=(port-pl)/256
local arg=gsub(format("%s,%d,%d",address,ph,pl),"%.",",")
try(tp:command("port",arg))
try(tp:check("2.."))
return 1
end
function methods.eprt(self,family,address,port)
local try=self.try
local tp=self.tp
self.pasvt=nil
if not address then
address,port=try(tp:getsockname())
self.server=try(bindsocket(address,0))
address,port=try(self.server:getsockname())
try(self.server:settimeout(ftp.TIMEOUT))
end
local arg=format("|%s|%s|%d|",family,address,port)
try(tp:command("eprt",arg))
try(tp:check("2.."))
return 1
end
function methods.send(self,sendt)
local try=self.try
local tp=self.tp
try(self.pasvt or self.server,"need port or pasv first")
if self.pasvt then
self:pasvconnect()
end
local argument=sendt.argument or unescapeurl(gsub(sendt.path or "","^[/\\]",""))
if argument=="" then
argument=nil
end
local command=sendt.command or "stor"
try(tp:command(command,argument))
local code,reply=try(tp:check{"2..","1.."})
if not self.pasvt then
self:portconnect()
end
local step=sendt.step or pumpstep
local readt={ tp }
local checkstep=function(src,snk)
local readyt=selectsocket(readt,nil,0)
if readyt[tp] then
code=try(tp:check("2.."))
end
return step(src,snk)
end
local sink=sinksocket("close-when-done",self.data)
try(pumpall(sendt.source,sink,checkstep))
if find(code,"1..") then
try(tp:check("2.."))
end
self.data:close()
local sent=skipsocket(1,self.data:getstats())
self.data=nil
return sent
end
function methods.receive(self,recvt)
local try=self.try
local tp=self.tp
try(self.pasvt or self.server,"need port or pasv first")
if self.pasvt then self:pasvconnect() end
local argument=recvt.argument or unescapeurl(gsub(recvt.path or "","^[/\\]",""))
if argument=="" then
argument=nil
end
local command=recvt.command or "retr"
try(tp:command(command,argument))
local code,reply=try(tp:check{"1..","2.."})
if code>=200 and code<=299 then
recvt.sink(reply)
return 1
end
if not self.pasvt then
self:portconnect()
end
local source=sourcesocket("until-closed",self.data)
local step=recvt.step or pumpstep
try(pumpall(source,recvt.sink,step))
if find(code,"1..") then
try(tp:check("2.."))
end
self.data:close()
self.data=nil
return 1
end
function methods.cwd(self,dir)
local try=self.try
local tp=self.tp
try(tp:command("cwd",dir))
try(tp:check(250))
return 1
end
function methods.type(self,typ)
local try=self.try
local tp=self.tp
try(tp:command("type",typ))
try(tp:check(200))
return 1
end
function methods.greet(self)
local try=self.try
local tp=self.tp
local code=try(tp:check{"1..","2.."})
if find(code,"1..") then
try(tp:check("2.."))
end
return 1
end
function methods.quit(self)
local try=self.try
try(self.tp:command("quit"))
try(self.tp:check("2.."))
return 1
end
function methods.close(self)
local data=self.data
if data then
data:close()
end
local server=self.server
if server then
server:close()
end
local tp=self.tp
if tp then
tp:close()
end
end
local function override(t)
if t.url then
local u=parseurl(t.url)
for k,v in next,t do
u[k]=v
end
return u
else
return t
end
end
local function tput(putt)
putt=override(putt)
local host=putt.host
trysocket(host,"missing hostname")
local f=ftp.open(host,putt.port,putt.create)
f:greet()
f:login(putt.user,putt.password)
local typ=putt.type
if typ then
f:type(typ)
end
f:epsv()
local sent=f:send(putt)
f:quit()
f:close()
return sent
end
local default={
path="/",
scheme="ftp",
}
local function genericform(u)
local t=trysocket(parseurl(u,default))
trysocket(t.scheme=="ftp","wrong scheme '"..t.scheme.."'")
trysocket(t.host,"missing hostname")
local pat="^type=(.)$"
if t.params then
local typ=skipsocket(2,find(t.params,pat))
t.type=typ
trysocket(typ=="a" or typ=="i","invalid type '"..typ.."'")
end
return t
end
ftp.genericform=genericform
local function sput(u,body)
local putt=genericform(u)
putt.source=sourcestring(body)
return tput(putt)
end
ftp.put=protectsocket(function(putt,body)
if type(putt)=="string" then
return sput(putt,body)
else
return tput(putt)
end
end)
local function tget(gett)
gett=override(gett)
local host=gett.host
trysocket(host,"missing hostname")
local f=ftp.open(host,gett.port,gett.create)
f:greet()
f:login(gett.user,gett.password)
if gett.type then
f:type(gett.type)
end
f:epsv()
f:receive(gett)
f:quit()
return f:close()
end
local function sget(u)
local gett=genericform(u)
local t={}
gett.sink=sinktable(t)
tget(gett)
return concat(t)
end
ftp.command=protectsocket(function(cmdt)
cmdt=override(cmdt)
local command=cmdt.command
local argument=cmdt.argument
local check=cmdt.check
local host=cmdt.host
trysocket(host,"missing hostname")
trysocket(command,"missing command")
local f=ftp.open(host,cmdt.port,cmdt.create)
local try=f.try
local tp=f.tp
f:greet()
f:login(cmdt.user,cmdt.password)
if type(command)=="table" then
local argument=argument or {}
for i=1,#command do
local cmd=command[i]
try(tp:command(cmd,argument[i]))
if check and check[i] then
try(tp:check(check[i]))
end
end
else
try(tp:command(command,argument))
if check then
try(tp:check(check))
end
end
f:quit()
return f:close()
end)
ftp.get=protectsocket(function(gett)
if type(gett)=="string" then
return sget(gett)
else
return tget(gett)
end
end)
package.loaded["socket.ftp"]=ftp
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-soc-imp-smtp"] = package.loaded["util-soc-imp-smtp"] or true
-- original size: 7018, stripped down to: 5883
local type,setmetatable,next=type,setmetatable,next
local find,lower,format=string.find,string.lower,string.format
local osdate,osgetenv=os.date,os.getenv
local random=math.random
local socket=socket or require("socket")
local headers=socket.headers or require("socket.headers")
local ltn12=ltn12 or require("ltn12")
local tp=socket.tp or require("socket.tp")
local mime=mime or require("mime")
local mimeb64=mime.b64
local mimestuff=mime.stuff
local skipsocket=socket.skip
local trysocket=socket.try
local newtrysocket=socket.newtry
local protectsocket=socket.protect
local normalizeheaders=headers.normalize
local lowerheaders=headers.lower
local createcoroutine=coroutine.create
local resumecoroutine=coroutine.resume
local yieldcoroutine=coroutine.resume
local smtp={
TIMEOUT=60,
SERVER="localhost",
PORT=25,
DOMAIN=osgetenv("SERVER_NAME") or "localhost",
ZONE="-0000",
}
socket.smtp=smtp
local methods={}
local mt={ __index=methods }
function methods.greet(self,domain)
local try=self.try
local tp=self.tp
try(tp:check("2.."))
try(tp:command("EHLO",domain or _M.DOMAIN))
return skipsocket(1,try(tp:check("2..")))
end
function methods.mail(self,from)
local try=self.try
local tp=self.tp
try(tp:command("MAIL","FROM:"..from))
return try(tp:check("2.."))
end
function methods.rcpt(self,to)
local try=self.try
local tp=self.tp
try(tp:command("RCPT","TO:"..to))
return try(tp:check("2.."))
end
function methods.data(self,src,step)
local try=self.try
local tp=self.tp
try(tp:command("DATA"))
try(tp:check("3.."))
try(tp:source(src,step))
try(tp:send("\r\n.\r\n"))
return try(tp:check("2.."))
end
function methods.quit(self)
local try=self.try
local tp=self.tp
try(tp:command("QUIT"))
return try(tp:check("2.."))
end
function methods.close(self)
return self.tp:close()
end
function methods.login(self,user,password)
local try=self.try
local tp=self.tp
try(tp:command("AUTH","LOGIN"))
try(tp:check("3.."))
try(tp:send(mimeb64(user).."\r\n"))
try(tp:check("3.."))
try(tp:send(mimeb64(password).."\r\n"))
return try(tp:check("2.."))
end
function methods.plain(self,user,password)
local try=self.try
local tp=self.tp
local auth="PLAIN "..mimeb64("\0"..user.."\0"..password)
try(tp:command("AUTH",auth))
return try(tp:check("2.."))
end
function methods.auth(self,user,password,ext)
if not user or not password then
return 1
end
local try=self.try
if find(ext,"AUTH[^\n]+LOGIN") then
return self:login(user,password)
elseif find(ext,"AUTH[^\n]+PLAIN") then
return self:plain(user,password)
else
try(nil,"authentication not supported")
end
end
function methods.send(self,mail)
self:mail(mail.from)
local receipt=mail.rcpt
if type(receipt)=="table" then
for i=1,#receipt do
self:rcpt(receipt[i])
end
elseif receipt then
self:rcpt(receipt)
end
self:data(ltn12.source.chain(mail.source,mimestuff()),mail.step)
end
local function opensmtp(self,server,port,create)
if not server or server=="" then
server=smtp.SERVER
end
if not port or port=="" then
port=smtp.PORT
end
local s={
tp=trysocket(tp.connect(server,port,smtp.TIMEOUT,create)),
try=newtrysocket(function()
s:close()
end),
}
setmetatable(s,mt)
return s
end
smtp.open=opensmtp
local nofboundaries=0
local function newboundary()
nofboundaries=nofboundaries+1
return format('%s%05d==%05u',osdate('%d%m%Y%H%M%S'),random(0,99999),nofboundaries)
end
local send_message
local function send_headers(headers)
yieldcoroutine(normalizeheaders(headers))
end
local function send_multipart(message)
local boundary=newboundary()
local headers=lowerheaders(message.headers)
local body=message.body
local preamble=body.preamble
local epilogue=body.epilogue
local content=headers['content-type'] or 'multipart/mixed'
headers['content-type']=content..'; boundary="'..boundary..'"'
send_headers(headers)
if preamble then
yieldcoroutine(preamble)
yieldcoroutine("\r\n")
end
for i=1,#body do
yieldcoroutine("\r\n--"..boundary.."\r\n")
send_message(body[i])
end
yieldcoroutine("\r\n--"..boundary.."--\r\n\r\n")
if epilogue then
yieldcoroutine(epilogue)
yieldcoroutine("\r\n")
end
end
local default_content_type='text/plain; charset="UTF-8"'
local function send_source(message)
local headers=lowerheaders(message.headers)
if not headers['content-type'] then
headers['content-type']=default_content_type
end
send_headers(headers)
local getchunk=message.body
while true do
local chunk,err=getchunk()
if err then
yieldcoroutine(nil,err)
elseif chunk then
yieldcoroutine(chunk)
else
break
end
end
end
local function send_string(message)
local headers=lowerheaders(message.headers)
if not headers['content-type'] then
headers['content-type']=default_content_type
end
send_headers(headers)
yieldcoroutine(message.body)
end
function send_message(message)
local body=message.body
if type(body)=="table" then
send_multipart(message)
elseif type(body)=="function" then
send_source(message)
else
send_string(message)
end
end
local function adjust_headers(message)
local headers=lowerheaders(message.headers)
if not headers["date"] then
headers["date"]=osdate("!%a, %d %b %Y %H:%M:%S ")..(message.zone or smtp.ZONE)
end
if not headers["x-mailer"] then
headers["x-mailer"]=socket._VERSION
end
headers["mime-version"]="1.0"
return headers
end
function smtp.message(message)
message.headers=adjust_headers(message)
local action=createcoroutine(function()
send_message(message)
end)
return function()
local ret,a,b=resumecoroutine(action)
if ret then
return a,b
else
return nil,a
end
end
end
smtp.send=protectsocket(function(mail)
local snd=opensmtp(smtp,mail.server,mail.port,mail.create)
local ext=snd:greet(mail.domain)
snd:auth(mail.user,mail.password,ext)
snd:send(mail)
snd:quit()
return snd:close()
end)
package.loaded["socket.smtp"]=smtp
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["trac-set"] = package.loaded["trac-set"] or true
-- original size: 13340, stripped down to: 8826
if not modules then modules={} end modules ['trac-set']={
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"
}
local type,next,tostring,tonumber=type,next,tostring,tonumber
local concat,sortedhash=table.concat,table.sortedhash
local format,find,lower,gsub,topattern=string.format,string.find,string.lower,string.gsub,string.topattern
local is_boolean=string.is_boolean
local settings_to_hash=utilities.parsers.settings_to_hash
local allocate=utilities.storage.allocate
utilities=utilities or {}
local utilities=utilities
local setters=utilities.setters or {}
utilities.setters=setters
local data={}
local trace_initialize=false
function setters.initialize(filename,name,values)
local setter=data[name]
if setter then
frozen=true
local data=setter.data
if data then
for key,newvalue in sortedhash(values) do
local newvalue=is_boolean(newvalue,newvalue,true)
local functions=data[key]
if functions then
local oldvalue=functions.value
if functions.frozen then
if trace_initialize then
setter.report("%s: %a is %s to %a",filename,key,"frozen",oldvalue)
end
elseif #functions>0 and not oldvalue then
if trace_initialize then
setter.report("%s: %a is %s to %a",filename,key,"set",newvalue)
end
for i=1,#functions do
functions[i](newvalue)
end
functions.value=newvalue
functions.frozen=functions.frozen or frozen
else
if trace_initialize then
setter.report("%s: %a is %s as %a",filename,key,"kept",oldvalue)
end
end
else
functions={ default=newvalue,frozen=frozen }
data[key]=functions
if trace_initialize then
setter.report("%s: %a is %s to %a",filename,key,"defaulted",newvalue)
end
end
end
return true
end
end
end
local function set(t,what,newvalue)
local data=t.data
if not data.frozen then
local done=t.done
if type(what)=="string" then
what=settings_to_hash(what)
end
if type(what)~="table" then
return
end
if not done then
done={}
t.done=done
end
for w,value in sortedhash(what) do
if value=="" then
value=newvalue
elseif not value then
value=false
else
value=is_boolean(value,value,true)
end
w=topattern(w,true,true)
for name,functions in sortedhash(data) do
if done[name] then
elseif find(name,w) then
done[name]=true
for i=1,#functions do
functions[i](value)
end
functions.value=value
end
end
end
end
end
local function reset(t)
local data=t.data
if not data.frozen then
for name,functions in sortedthash(data) do
for i=1,#functions do
functions[i](false)
end
functions.value=false
end
end
end
local function enable(t,what)
set(t,what,true)
end
local function disable(t,what)
local data=t.data
if not what or what=="" then
t.done={}
reset(t)
else
set(t,what,false)
end
end
function setters.register(t,what,...)
local data=t.data
what=lower(what)
local functions=data[what]
if not functions then
functions={}
data[what]=functions
if trace_initialize then
t.report("defining %a",what)
end
end
local default=functions.default
for i=1,select("#",...) do
local fnc=select(i,...)
local typ=type(fnc)
if typ=="string" then
if trace_initialize then
t.report("coupling %a to %a",what,fnc)
end
local s=fnc
fnc=function(value) set(t,s,value) end
elseif typ~="function" then
fnc=nil
end
if fnc then
functions[#functions+1]=fnc
local value=functions.value or default
if value~=nil then
fnc(value)
functions.value=value
end
end
end
return false
end
function setters.enable(t,what)
local e=t.enable
t.enable,t.done=enable,{}
enable(t,what)
t.enable,t.done=e,{}
end
function setters.disable(t,what)
local e=t.disable
t.disable,t.done=disable,{}
disable(t,what)
t.disable,t.done=e,{}
end
function setters.reset(t)
t.done={}
reset(t)
end
function setters.list(t)
local list=table.sortedkeys(t.data)
local user,system={},{}
for l=1,#list do
local what=list[l]
if find(what,"^%*") then
system[#system+1]=what
else
user[#user+1]=what
end
end
return user,system
end
function setters.show(t)
local list=setters.list(t)
t.report()
for k=1,#list do
local name=list[k]
local functions=t.data[name]
if functions then
local value=functions.value
local default=functions.default
local modules=#functions
if default==nil then
default="unset"
elseif type(default)=="table" then
default=concat(default,"|")
else
default=tostring(default)
end
if value==nil then
value="unset"
elseif type(value)=="table" then
value=concat(value,"|")
else
value=tostring(value)
end
t.report(name)
t.report(" modules : %i",modules)
t.report(" default : %s",default)
t.report(" value : %s",value)
t.report()
end
end
end
local enable,disable,register,list,show=setters.enable,setters.disable,setters.register,setters.list,setters.show
function setters.report(setter,...)
print(format("%-15s : %s\n",setter.name,format(...)))
end
local function default(setter,name)
local d=setter.data[name]
return d and d.default
end
local function value(setter,name)
local d=setter.data[name]
return d and (d.value or d.default)
end
function setters.new(name)
local setter
setter={
data=allocate(),
name=name,
report=function(...) setters.report (setter,...) end,
enable=function(...) enable (setter,...) end,
disable=function(...) disable (setter,...) end,
reset=function(...) reset (setter,...) end,
register=function(...) register(setter,...) end,
list=function(...) list (setter,...) end,
show=function(...) show (setter,...) end,
default=function(...) return default (setter,...) end,
value=function(...) return value (setter,...) end,
}
data[name]=setter
return setter
end
trackers=setters.new("trackers")
directives=setters.new("directives")
experiments=setters.new("experiments")
local t_enable,t_disable=trackers .enable,trackers .disable
local d_enable,d_disable=directives .enable,directives .disable
local e_enable,e_disable=experiments.enable,experiments.disable
local trace_directives=false local trace_directives=false trackers.register("system.directives",function(v) trace_directives=v end)
local trace_experiments=false local trace_experiments=false trackers.register("system.experiments",function(v) trace_experiments=v end)
function directives.enable(...)
if trace_directives then
directives.report("enabling: % t",{...})
end
d_enable(...)
end
function directives.disable(...)
if trace_directives then
directives.report("disabling: % t",{...})
end
d_disable(...)
end
function experiments.enable(...)
if trace_experiments then
experiments.report("enabling: % t",{...})
end
e_enable(...)
end
function experiments.disable(...)
if trace_experiments then
experiments.report("disabling: % t",{...})
end
e_disable(...)
end
directives.register("system.nostatistics",function(v)
if statistics then
statistics.enable=not v
else
end
end)
directives.register("system.nolibraries",function(v)
if libraries then
libraries=nil
else
end
end)
if environment then
local engineflags=environment.engineflags
if engineflags then
local list=engineflags["c:trackers"] or engineflags["trackers"]
if type(list)=="string" then
setters.initialize("commandline flags","trackers",settings_to_hash(list))
end
local list=engineflags["c:directives"] or engineflags["directives"]
if type(list)=="string" then
setters.initialize("commandline flags","directives",settings_to_hash(list))
end
end
end
if texconfig then
local function set(k,v)
v=tonumber(v)
if v then
texconfig[k]=v
end
end
directives.register("luatex.expanddepth",function(v) set("expand_depth",v) end)
directives.register("luatex.hashextra",function(v) set("hash_extra",v) end)
directives.register("luatex.nestsize",function(v) set("nest_size",v) end)
directives.register("luatex.maxinopen",function(v) set("max_in_open",v) end)
directives.register("luatex.maxprintline",function(v) set("max_print_line",v) end)
directives.register("luatex.maxstrings",function(v) set("max_strings",v) end)
directives.register("luatex.paramsize",function(v) set("param_size",v) end)
directives.register("luatex.savesize",function(v) set("save_size",v) end)
directives.register("luatex.stacksize",function(v) set("stack_size",v) end)
end
local data=table.setmetatableindex("table")
updaters={
register=function(what,f)
local d=data[what]
d[#d+1]=f
end,
apply=function(what,...)
local d=data[what]
for i=1,#d do
d[i](...)
end
end,
}
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["trac-log"] = package.loaded["trac-log"] or true
-- original size: 32618, stripped down to: 20935
if not modules then modules={} end modules ['trac-log']={
version=1.001,
comment="companion to trac-log.mkiv",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local next,type,select,print=next,type,select,print
local format,gmatch,find=string.format,string.gmatch,string.find
local concat,insert,remove=table.concat,table.insert,table.remove
local topattern=string.topattern
local utfchar=utf.char
local datetime=os.date
local openfile=io.open
local runningtex=tex and (tex.jobname or tex.formatname)
local write_nl=runningtex and texio and texio.write_nl or print
local write=runningtex and texio and texio.write or io.write
local setmetatableindex=table.setmetatableindex
local formatters=string.formatters
local settings_to_hash=utilities.parsers.settings_to_hash
local sortedkeys=table.sortedkeys
local variant="default"
logs=logs or {}
local logs=logs
local moreinfo=[[
More information about ConTeXt and the tools that come with it can be found at:
]].."\n"..[[
maillist : ntg-context@ntg.nl / http://www.ntg.nl/mailman/listinfo/ntg-context
webpage : http://www.pragma-ade.nl / http://tex.aanhet.net
wiki : http://contextgarden.net
]]
formatters.add (
formatters,"unichr",
[["U+" .. format("%%05X",%s) .. " (" .. utfchar(%s) .. ")"]]
)
formatters.add (
formatters,"chruni",
[[utfchar(%s) .. " (U+" .. format("%%05X",%s) .. ")"]]
)
local function ignore() end
setmetatableindex(logs,function(t,k) t[k]=ignore;return ignore end)
local report,subreport,status,settarget,setformats,settranslations
local direct,subdirect,writer,pushtarget,poptarget,setlogfile,settimedlog,setprocessor,setformatters,newline
if runningtex and texio then
if texio.setescape then
texio.setescape(0)
end
if arg then
for k,v in next,arg do
if v=="--ansi" or v=="--c:ansi" then
variant="ansi"
break
end
end
end
local function useluawrites()
local texio_write_nl=texio.write_nl
local texio_write=texio.write
local io_write=io.write
write_nl=function(target,...)
if not io_write then
io_write=io.write
end
if target=="term and log" then
texio_write_nl("log",...)
texio_write_nl("term","")
io_write(...)
elseif target=="log" then
texio_write_nl("log",...)
elseif target=="term" then
texio_write_nl("term","")
io_write(...)
elseif type(target)=="number" then
texio_write_nl(target,...)
elseif target~="none" then
texio_write_nl("log",target,...)
texio_write_nl("term","")
io_write(target,...)
end
end
write=function(target,...)
if not io_write then
io_write=io.write
end
if target=="term and log" then
texio_write("log",...)
io_write(...)
elseif target=="log" then
texio_write("log",...)
elseif target=="term" then
io_write(...)
elseif type(target)=="number" then
texio_write(target,...)
elseif target~="none" then
texio_write("log",target,...)
io_write(target,...)
end
end
texio.write=write
texio.write_nl=write_nl
useluawrites=ignore
end
local whereto="both"
local target=nil
local targets=nil
local formats=table.setmetatableindex("self")
local translations=table.setmetatableindex("self")
local report_yes,subreport_yes,direct_yes,subdirect_yes,status_yes
local report_nop,subreport_nop,direct_nop,subdirect_nop,status_nop
local variants={
default={
formats={
report_yes=formatters["%-15s > %s\n"],
report_nop=formatters["%-15s >\n"],
direct_yes=formatters["%-15s > %s"],
direct_nop=formatters["%-15s >"],
subreport_yes=formatters["%-15s > %s > %s\n"],
subreport_nop=formatters["%-15s > %s >\n"],
subdirect_yes=formatters["%-15s > %s > %s"],
subdirect_nop=formatters["%-15s > %s >"],
status_yes=formatters["%-15s : %s\n"],
status_nop=formatters["%-15s :\n"],
},
targets={
logfile="log",
log="log",
file="log",
console="term",
terminal="term",
both="term and log",
},
},
ansi={
formats={
report_yes=formatters["[0;33m%-15s [0;1m>[0m %s\n"],
report_nop=formatters["[0;33m%-15s [0;1m>[0m\n"],
direct_yes=formatters["[0;33m%-15s [0;1m>[0m %s"],
direct_nop=formatters["[0;33m%-15s [0;1m>[0m"],
subreport_yes=formatters["[0;33m%-15s [0;1m>[0;35m %s [0;1m>[0m %s\n"],
subreport_nop=formatters["[0;33m%-15s [0;1m>[0;35m %s [0;1m>[0m\n"],
subdirect_yes=formatters["[0;33m%-15s [0;1m>[0;35m %s [0;1m>[0m %s"],
subdirect_nop=formatters["[0;33m%-15s [0;1m>[0;35m %s [0;1m>[0m"],
status_yes=formatters["[0;33m%-15s [0;1m:[0m %s\n"],
status_nop=formatters["[0;33m%-15s [0;1m:[0m\n"],
},
targets={
logfile="none",
log="none",
file="none",
console="term",
terminal="term",
both="term",
},
}
}
logs.flush=io.flush
writer=function(...)
write_nl(target,...)
end
newline=function()
write_nl(target,"\n")
end
report=function(a,b,c,...)
if c~=nil then
write_nl(target,report_yes(translations[a],formatters[formats[b]](c,...)))
elseif b then
write_nl(target,report_yes(translations[a],formats[b]))
elseif a then
write_nl(target,report_nop(translations[a]))
else
write_nl(target,"\n")
end
end
direct=function(a,b,c,...)
if c~=nil then
return direct_yes(translations[a],formatters[formats[b]](c,...))
elseif b then
return direct_yes(translations[a],formats[b])
elseif a then
return direct_nop(translations[a])
else
return ""
end
end
subreport=function(a,s,b,c,...)
if c~=nil then
write_nl(target,subreport_yes(translations[a],translations[s],formatters[formats[b]](c,...)))
elseif b then
write_nl(target,subreport_yes(translations[a],translations[s],formats[b]))
elseif a then
write_nl(target,subreport_nop(translations[a],translations[s]))
else
write_nl(target,"\n")
end
end
subdirect=function(a,s,b,c,...)
if c~=nil then
return subdirect_yes(translations[a],translations[s],formatters[formats[b]](c,...))
elseif b then
return subdirect_yes(translations[a],translations[s],formats[b])
elseif a then
return subdirect_nop(translations[a],translations[s])
else
return ""
end
end
status=function(a,b,c,...)
if c~=nil then
write_nl(target,status_yes(translations[a],formatters[formats[b]](c,...)))
elseif b then
write_nl(target,status_yes(translations[a],formats[b]))
elseif a then
write_nl(target,status_nop(translations[a]))
else
write_nl(target,"\n")
end
end
settarget=function(askedwhereto)
whereto=askedwhereto or whereto or "both"
target=targets[whereto]
if not target then
whereto="both"
target=targets[whereto]
end
if target=="term" or target=="term and log" then
logs.flush=io.flush
else
logs.flush=ignore
end
end
local stack={}
pushtarget=function(newtarget)
insert(stack,target)
settarget(newtarget)
end
poptarget=function()
if #stack>0 then
settarget(remove(stack))
end
end
setformats=function(f)
formats=f
end
settranslations=function(t)
translations=t
end
setprocessor=function(f)
local writeline=write_nl
write_nl=function(target,...)
writeline(target,f(...))
end
end
setformatters=function(specification)
local t=nil
local f=nil
local d=variants.default
if not specification then
elseif type(specification)=="table" then
t=specification.targets
f=specification.formats or specification
else
local v=variants[specification]
if v then
t=v.targets
f=v.formats
variant=specification
end
end
targets=t or d.targets
target=targets[whereto] or target
if f then
d=d.formats
else
f=d.formats
d=f
end
setmetatableindex(f,d)
report_yes=f.report_yes
report_nop=f.report_nop
subreport_yes=f.subreport_yes
subreport_nop=f.subreport_nop
direct_yes=f.direct_yes
direct_nop=f.direct_nop
subdirect_yes=f.subdirect_yes
subdirect_nop=f.subdirect_nop
status_yes=f.status_yes
status_nop=f.status_nop
if variant=="ansi" then
useluawrites()
end
settarget(whereto)
end
setformatters(variant)
setlogfile=ignore
settimedlog=ignore
else
local report_yes,subreport_yes,status_yes
local report_nop,subreport_nop,status_nop
local variants={
default={
formats={
report_yes=formatters["%-15s | %s"],
report_nop=formatters["%-15s |"],
subreport_yes=formatters["%-15s | %s | %s"],
subreport_nop=formatters["%-15s | %s |"],
status_yes=formatters["%-15s : %s\n"],
status_nop=formatters["%-15s :\n"],
},
},
ansi={
formats={
report_yes=formatters["[0;32m%-15s [0;1m|[0m %s"],
report_nop=formatters["[0;32m%-15s [0;1m|[0m"],
subreport_yes=formatters["[0;32m%-15s [0;1m|[0;31m %s [0;1m|[0m %s"],
subreport_nop=formatters["[0;32m%-15s [0;1m|[0;31m %s [0;1m|[0m"],
status_yes=formatters["[0;32m%-15s [0;1m:[0m %s\n"],
status_nop=formatters["[0;32m%-15s [0;1m:[0m\n"],
},
},
}
logs.flush=ignore
writer=function(s)
write_nl(s)
end
newline=function()
write_nl("\n")
end
report=function(a,b,c,...)
if c then
write_nl(report_yes(a,formatters[b](c,...)))
elseif b then
write_nl(report_yes(a,b))
elseif a then
write_nl(report_nop(a))
else
write_nl("")
end
end
subreport=function(a,sub,b,c,...)
if c then
write_nl(subreport_yes(a,sub,formatters[b](c,...)))
elseif b then
write_nl(subreport_yes(a,sub,b))
elseif a then
write_nl(subreport_nop(a,sub))
else
write_nl("")
end
end
status=function(a,b,c,...)
if c then
write_nl(status_yes(a,formatters[b](c,...)))
elseif b then
write_nl(status_yes(a,b))
elseif a then
write_nl(status_nop(a))
else
write_nl("\n")
end
end
direct=ignore
subdirect=ignore
settarget=ignore
pushtarget=ignore
poptarget=ignore
setformats=ignore
settranslations=ignore
setprocessor=function(f)
local writeline=write_nl
write_nl=function(s)
writeline(f(s))
end
end
setformatters=function(specification)
local f=nil
local d=variants.default
if specification then
if type(specification)=="table" then
f=specification.formats or specification
else
local v=variants[specification]
if v then
f=v.formats
end
end
end
if f then
d=d.formats
else
f=d.formats
d=f
end
setmetatableindex(f,d)
report_yes=f.report_yes
report_nop=f.report_nop
subreport_yes=f.subreport_yes
subreport_nop=f.subreport_nop
status_yes=f.status_yes
status_nop=f.status_nop
end
setformatters(variant)
setlogfile=function(name,keepopen)
if name and name~="" then
local localtime=os.localtime
local writeline=write_nl
if keepopen then
local f=io.open(name,"ab")
write_nl=function(s)
writeline(s)
f:write(localtime()," | ",s,"\n")
end
else
write_nl=function(s)
writeline(s)
local f=io.open(name,"ab")
f:write(localtime()," | ",s,"\n")
f:close()
end
end
end
setlogfile=ignore
end
settimedlog=function()
local localtime=os.localtime
local writeline=write_nl
write_nl=function(s)
writeline(localtime().." | "..s)
end
settimedlog=ignore
end
end
logs.report=report
logs.subreport=subreport
logs.status=status
logs.settarget=settarget
logs.pushtarget=pushtarget
logs.poptarget=poptarget
logs.setformats=setformats
logs.settranslations=settranslations
logs.setlogfile=setlogfile
logs.settimedlog=settimedlog
logs.setprocessor=setprocessor
logs.setformatters=setformatters
logs.direct=direct
logs.subdirect=subdirect
logs.writer=writer
logs.newline=newline
local data={}
local states=nil
local force=false
function logs.reporter(category,subcategory)
local logger=data[category]
if not logger then
local state=states==true
if not state and type(states)=="table" then
for c,_ in next,states do
if find(category,c) then
state=true
break
end
end
end
logger={
reporters={},
state=state,
}
data[category]=logger
end
local reporter=logger.reporters[subcategory or "default"]
if not reporter then
if subcategory then
reporter=function(...)
if force or not logger.state then
subreport(category,subcategory,...)
end
end
logger.reporters[subcategory]=reporter
else
local tag=category
reporter=function(...)
if force or not logger.state then
report(category,...)
end
end
logger.reporters.default=reporter
end
end
return reporter
end
logs.new=logs.reporter
local ctxreport=logs.writer
function logs.setmessenger(m)
ctxreport=m
end
function logs.messenger(category,subcategory)
if subcategory then
return function(...)
ctxreport(subdirect(category,subcategory,...))
end
else
return function(...)
ctxreport(direct(category,...))
end
end
end
local function setblocked(category,value)
if category==true or category=="all" then
category,value="*",true
elseif category==false then
category,value="*",false
elseif value==nil then
value=true
end
if category=="*" then
states=value
for k,v in next,data do
v.state=value
end
else
alllocked=false
states=settings_to_hash(category,type(states)=="table" and states or nil)
for c in next,states do
local v=data[c]
if v then
v.state=value
else
c=topattern(c,true,true)
for k,v in next,data do
if find(k,c) then
v.state=value
end
end
end
end
end
end
function logs.disable(category,value)
setblocked(category,value==nil and true or value)
end
function logs.enable(category)
setblocked(category,false)
end
function logs.categories()
return sortedkeys(data)
end
function logs.show()
local n,c,s,max=0,0,0,0
for category,v in table.sortedpairs(data) do
n=n+1
local state=v.state
local reporters=v.reporters
local nc=#category
if nc>c then
c=nc
end
for subcategory,_ in next,reporters do
local ns=#subcategory
if ns>c then
s=ns
end
local m=nc+ns
if m>max then
max=m
end
end
local subcategories=concat(sortedkeys(reporters),", ")
if state==true then
state="disabled"
elseif state==false then
state="enabled"
else
state="unknown"
end
report("logging","category %a, subcategories %a, state %a",category,subcategories,state)
end
report("logging","categories: %s, max category: %s, max subcategory: %s, max combined: %s",n,c,s,max)
end
local delayed_reporters={}
setmetatableindex(delayed_reporters,function(t,k)
local v=logs.reporter(k.name)
t[k]=v
return v
end)
function utilities.setters.report(setter,...)
delayed_reporters[setter](...)
end
directives.register("logs.blocked",function(v)
setblocked(v,true)
end)
directives.register("logs.target",function(v)
settarget(v)
end)
if tex then
local report=logs.reporter("pages")
local texgetcount=tex and tex.getcount
local real,user,sub=0,0,0
function logs.start_page_number()
real=texgetcount("realpageno")
user=texgetcount("userpageno")
sub=texgetcount("subpageno")
end
local timing=false
local lasttime=nil
trackers.register("pages.timing",function(v)
timing=""
end)
function logs.stop_page_number()
if timing then
local elapsed=statistics.currenttime(statistics)
local average,page
if not lasttime or real<2 then
average=elapsed
page=elapsed
else
average=elapsed/(real-1)
page=elapsed-lasttime
end
lasttime=elapsed
timing=formatters[", total %0.03f, page %0.03f, average %0.03f"](elapsed,page,average)
end
if real<=0 then
report("flushing page%s",timing)
elseif user<=0 then
report("flushing realpage %s%s",real,timing)
elseif sub<=0 then
report("flushing realpage %s, userpage %s%s",real,user,timing)
else
report("flushing realpage %s, userpage %s, subpage %s%s",real,user,sub,timing)
end
logs.flush()
end
end
local nesting=0
local verbose=false
local hasscheme=url.hasscheme
function logs.show_open(name)
end
function logs.show_close(name)
end
function logs.show_load(name)
end
local simple=logs.reporter("comment")
logs.simple=simple
logs.simpleline=simple
logs.setprogram=ignore
logs.extendbanner=ignore
logs.reportlines=ignore
logs.reportbanner=ignore
logs.reportline=ignore
logs.simplelines=ignore
logs.help=ignore
local Carg,C,lpegmatch=lpeg.Carg,lpeg.C,lpeg.match
local p_newline=lpeg.patterns.newline
local linewise=(
Carg(1)*C((1-p_newline)^1)/function(t,s) t.report(s) end+Carg(1)*p_newline^2/function(t) t.report() end+p_newline
)^1
local function reportlines(t,str)
if str then
lpegmatch(linewise,str,1,t)
end
end
local function reportbanner(t)
local banner=t.banner
if banner then
t.report(banner)
t.report()
end
end
local function reportversion(t)
local banner=t.banner
if banner then
t.report(banner)
end
end
local function reporthelp(t,...)
local helpinfo=t.helpinfo
if type(helpinfo)=="string" then
reportlines(t,helpinfo)
elseif type(helpinfo)=="table" then
for i=1,select("#",...) do
reportlines(t,t.helpinfo[select(i,...)])
if i<n then
t.report()
end
end
end
end
local function reportinfo(t)
t.report()
reportlines(t,t.moreinfo)
end
local function reportexport(t,method)
report(t.helpinfo)
end
local reporters={
lines=reportlines,
banner=reportbanner,
version=reportversion,
help=reporthelp,
info=reportinfo,
export=reportexport,
}
local exporters={
}
logs.reporters=reporters
logs.exporters=exporters
function logs.application(t)
t.name=t.name or "unknown"
t.banner=t.banner
t.moreinfo=moreinfo
t.report=logs.reporter(t.name)
t.help=function(...)
reporters.banner(t)
reporters.help(t,...)
reporters.info(t)
end
t.export=function(...)
reporters.export(t,...)
end
t.identify=function()
reporters.banner(t)
end
t.version=function()
reporters.version(t)
end
return t
end
local f_syslog=formatters["%s %s => %s => %s => %s\r"]
function logs.system(whereto,process,jobname,category,fmt,arg,...)
local message=f_syslog(datetime("%d/%m/%y %H:%m:%S"),process,jobname,category,arg==nil and fmt or format(fmt,arg,...))
for i=1,10 do
local f=openfile(whereto,"a")
if f then
f:write(message)
f:close()
break
else
sleep(0.1)
end
end
end
local report_system=logs.reporter("system","logs")
function logs.obsolete(old,new)
local o=loadstring("return "..new)()
if type(o)=="function" then
return function(...)
report_system("function %a is obsolete, use %a",old,new)
loadstring(old.."="..new.." return "..old)()(...)
end
elseif type(o)=="table" then
local t,m={},{}
m.__index=function(t,k)
report_system("table %a is obsolete, use %a",old,new)
m.__index,m.__newindex=o,o
return o[k]
end
m.__newindex=function(t,k,v)
report_system("table %a is obsolete, use %a",old,new)
m.__index,m.__newindex=o,o
o[k]=v
end
if libraries then
libraries.obsolete[old]=t
end
setmetatable(t,m)
return t
end
end
if utilities then
utilities.report=report_system
end
if tex and tex.error then
function logs.texerrormessage(...)
tex.error(format(...))
end
else
function logs.texerrormessage(...)
print(format(...))
end
end
io.stdout:setvbuf('no')
io.stderr:setvbuf('no')
if package.helpers.report then
package.helpers.report=logs.reporter("package loader")
end
if tex then
local finalactions={}
local fatalerrors={}
local possiblefatal={}
local loggingerrors=false
function logs.loggingerrors()
return loggingerrors
end
directives.register("logs.errors",function(v)
loggingerrors=v
if type(v)=="string" then
fatalerrors=settings_to_hash(v)
else
fatalerrors={}
end
end)
function logs.registerfinalactions(...)
insert(finalactions,...)
end
local what=nil
local report=nil
local state=nil
local target=nil
local function startlogging(t,r,w,s)
target=t
state=force
force=true
report=type(r)=="function" and r or logs.reporter(r)
what=w
pushtarget(target)
newline()
if s then
report("start %s: %s",what,s)
else
report("start %s",what)
end
if target=="logfile" then
newline()
end
return report
end
local function stoplogging()
if target=="logfile" then
newline()
end
report("stop %s",what)
if target=="logfile" then
newline()
end
poptarget()
state=oldstate
end
function logs.startfilelogging(...)
return startlogging("logfile",...)
end
logs.stopfilelogging=stoplogging
local done=false
function logs.starterrorlogging(r,w,...)
if not done then
pushtarget("terminal")
newline()
logs.report("error logging","start possible issues")
poptarget()
done=true
end
if fatalerrors[w] then
possiblefatal[w]=true
end
return startlogging("terminal",r,w,...)
end
logs.stoperrorlogging=stoplogging
function logs.finalactions()
if #finalactions>0 then
for i=1,#finalactions do
finalactions[i]()
end
if done then
pushtarget("terminal")
newline()
logs.report("error logging","stop possible issues")
poptarget()
end
return next(possiblefatal) and sortedkeys(possiblefatal) or false
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["trac-inf"] = package.loaded["trac-inf"] or true
-- original size: 8966, stripped down to: 5972
if not modules then modules={} end modules ['trac-inf']={
version=1.001,
comment="companion to trac-inf.mkiv",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local type,tonumber,select=type,tonumber,select
local format,lower,find=string.format,string.lower,string.find
local concat=table.concat
local clock=os.gettimeofday or os.clock
local setmetatableindex=table.setmetatableindex
local serialize=table.serialize
local formatters=string.formatters
statistics=statistics or {}
local statistics=statistics
statistics.enable=true
statistics.threshold=0.01
local statusinfo,n,registered,timers={},0,{},{}
setmetatableindex(timers,function(t,k)
local v={ timing=0,loadtime=0 }
t[k]=v
return v
end)
local function hastiming(instance)
return instance and timers[instance]
end
local function resettiming(instance)
timers[instance or "notimer"]={ timing=0,loadtime=0 }
end
local ticks=clock
local seconds=function(n) return n or 0 end
local function starttiming(instance,reset)
local timer=timers[instance or "notimer"]
local it=timer.timing
if reset then
it=0
timer.loadtime=0
end
if it==0 then
timer.starttime=ticks()
if not timer.loadtime then
timer.loadtime=0
end
end
timer.timing=it+1
end
local function stoptiming(instance)
local timer=timers[instance or "notimer"]
local it=timer.timing
if it>1 then
timer.timing=it-1
else
local starttime=timer.starttime
if starttime and starttime>0 then
local stoptime=ticks()
local loadtime=stoptime-starttime
timer.stoptime=stoptime
timer.loadtime=timer.loadtime+loadtime
timer.timing=0
timer.starttime=0
return loadtime
end
end
return 0
end
local function elapsed(instance)
if type(instance)=="number" then
return instance
else
local timer=timers[instance or "notimer"]
return timer and seconds(timer.loadtime) or 0
end
end
local function currenttime(instance)
if type(instance)=="number" then
return instance
else
local timer=timers[instance or "notimer"]
local it=timer.timing
if it>1 then
else
local starttime=timer.starttime
if starttime and starttime>0 then
return seconds(timer.loadtime+ticks()-starttime)
end
end
return 0
end
end
local function elapsedtime(instance)
return format("%0.3f",elapsed(instance))
end
local function elapsedindeed(instance)
return elapsed(instance)>statistics.threshold
end
local function elapsedseconds(instance,rest)
if elapsedindeed(instance) then
return format("%0.3f seconds %s",elapsed(instance),rest or "")
end
end
statistics.hastiming=hastiming
statistics.resettiming=resettiming
statistics.starttiming=starttiming
statistics.stoptiming=stoptiming
statistics.currenttime=currenttime
statistics.elapsed=elapsed
statistics.elapsedtime=elapsedtime
statistics.elapsedindeed=elapsedindeed
statistics.elapsedseconds=elapsedseconds
function statistics.register(tag,fnc)
if statistics.enable and type(fnc)=="function" then
local rt=registered[tag] or (#statusinfo+1)
statusinfo[rt]={ tag,fnc }
registered[tag]=rt
if #tag>n then n=#tag end
end
end
local report=logs.reporter("mkiv lua stats")
function statistics.show()
if statistics.enable then
local register=statistics.register
register("used platform",function()
return format("%s, type: %s, binary subtree: %s",
os.platform or "unknown",os.type or "unknown",environment.texos or "unknown")
end)
register("used engine",function()
return format("%s version %s with functionality level %s, banner: %s",
LUATEXENGINE,LUATEXVERSION,LUATEXFUNCTIONALITY,lower(status.banner))
end)
register("control sequences",function()
return format("%s of %s + %s",status.cs_count,status.hash_size,status.hash_extra)
end)
register("callbacks",statistics.callbacks)
if TEXENGINE=="luajittex" and JITSUPPORTED then
local jitstatus=jit.status
if jitstatus then
local jitstatus={ jitstatus() }
if jitstatus[1] then
register("luajit options",concat(jitstatus," ",2))
end
end
end
register("lua properties",function()
local hashchar=tonumber(status.luatex_hashchars)
local mask=lua.mask or "ascii"
return format("engine: %s %s, used memory: %s, hash chars: min(%i,40), symbol mask: %s (%s)",
jit and "luajit" or "lua",
LUAVERSION,
statistics.memused(),
hashchar and 2^hashchar or "unknown",
mask,
mask=="utf" and "τεχ" or "tex")
end)
register("runtime",statistics.runtime)
logs.newline()
for i=1,#statusinfo do
local s=statusinfo[i]
local r=s[2]()
if r then
report("%s: %s",s[1],r)
end
end
statistics.enable=false
end
end
function statistics.memused()
local round=math.round or math.floor
return format("%s MB (ctx: %s MB)",round(collectgarbage("count")/1000),round(status.luastate_bytes/1000000))
end
starttiming(statistics)
function statistics.formatruntime(runtime)
return format("%s seconds",runtime)
end
function statistics.runtime()
stoptiming(statistics)
local runtime=lua.getruntime and lua.getruntime() or elapsedtime(statistics)
return statistics.formatruntime(runtime)
end
local report=logs.reporter("system")
function statistics.timed(action,all)
starttiming("run")
action()
stoptiming("run")
local runtime=tonumber(elapsedtime("run"))
if all then
local alltime=tonumber(lua.getruntime and lua.getruntime() or elapsedtime(statistics))
if alltime and alltime>0 then
report("total runtime: %0.3f seconds of %0.3f seconds",runtime,alltime)
return
end
end
report("total runtime: %0.3f seconds",runtime)
end
function statistics.tracefunction(base,tag,...)
for i=1,select("#",...) do
local name=select(i,...)
local stat={}
local func=base[name]
setmetatableindex(stat,function(t,k) t[k]=0 return 0 end)
base[name]=function(n,k,v) stat[k]=stat[k]+1 return func(n,k,v) end
statistics.register(formatters["%s.%s"](tag,name),function() return serialize(stat,"calls") end)
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["trac-pro"] = package.loaded["trac-pro"] or true
-- original size: 5841, stripped down to: 3352
if not modules then modules={} end modules ['trac-pro']={
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"
}
local getmetatable,setmetatable,rawset,type,next=getmetatable,setmetatable,rawset,type,next
local trace_namespaces=false trackers.register("system.namespaces",function(v) trace_namespaces=v end)
local report_system=logs.reporter("system","protection")
namespaces=namespaces or {}
local namespaces=namespaces
local registered={}
local function report_index(k,name)
if trace_namespaces then
report_system("reference to %a in protected namespace %a: %s",k,name)
debugger.showtraceback(report_system)
else
report_system("reference to %a in protected namespace %a",k,name)
end
end
local function report_newindex(k,name)
if trace_namespaces then
report_system("assignment to %a in protected namespace %a: %s",k,name)
debugger.showtraceback(report_system)
else
report_system("assignment to %a in protected namespace %a",k,name)
end
end
local function register(name)
local data=name=="global" and _G or _G[name]
if not data then
return
end
registered[name]=data
local m=getmetatable(data)
if not m then
m={}
setmetatable(data,m)
end
local index,newindex={},{}
m.__saved__index=m.__index
m.__no__index=function(t,k)
if not index[k] then
index[k]=true
report_index(k,name)
end
return nil
end
m.__saved__newindex=m.__newindex
m.__no__newindex=function(t,k,v)
if not newindex[k] then
newindex[k]=true
report_newindex(k,name)
end
rawset(t,k,v)
end
m.__protection__depth=0
end
local function private(name)
local data=registered[name]
if not data then
data=_G[name]
if not data then
data={}
_G[name]=data
end
register(name)
end
return data
end
local function protect(name)
local data=registered[name]
if not data then
return
end
local m=getmetatable(data)
local pd=m.__protection__depth
if pd>0 then
m.__protection__depth=pd+1
else
m.__save_d_index,m.__saved__newindex=m.__index,m.__newindex
m.__index,m.__newindex=m.__no__index,m.__no__newindex
m.__protection__depth=1
end
end
local function unprotect(name)
local data=registered[name]
if not data then
return
end
local m=getmetatable(data)
local pd=m.__protection__depth
if pd>1 then
m.__protection__depth=pd-1
else
m.__index,m.__newindex=m.__saved__index,m.__saved__newindex
m.__protection__depth=0
end
end
local function protectall()
for name,_ in next,registered do
if name~="global" then
protect(name)
end
end
end
local function unprotectall()
for name,_ in next,registered do
if name~="global" then
unprotect(name)
end
end
end
namespaces.register=register
namespaces.private=private
namespaces.protect=protect
namespaces.unprotect=unprotect
namespaces.protectall=protectall
namespaces.unprotectall=unprotectall
namespaces.private("namespaces") registered={} register("global")
directives.register("system.protect",function(v)
if v then
protectall()
else
unprotectall()
end
end)
directives.register("system.checkglobals",function(v)
if v then
report_system("enabling global namespace guard")
protect("global")
else
report_system("disabling global namespace guard")
unprotect("global")
end
end)
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-lua"] = package.loaded["util-lua"] or true
-- original size: 6664, stripped down to: 4589
if not modules then modules={} end modules ['util-lua']={
version=1.001,
comment="companion to luat-lib.mkiv",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
comment="the strip code is written by Peter Cawley",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local rep,sub,byte,dump,format=string.rep,string.sub,string.byte,string.dump,string.format
local load,loadfile,type,collectgarbage=load,loadfile,type,collectgarbage
utilities=utilities or {}
utilities.lua=utilities.lua or {}
local luautilities=utilities.lua
local report_lua=logs.reporter("system","lua")
local report_mem=logs.reporter("system","lua memory")
local tracestripping=false
local tracememory=false
luautilities.stripcode=true
luautilities.alwaysstripcode=false
luautilities.nofstrippedchunks=0
luautilities.nofstrippedbytes=0
local strippedchunks={}
luautilities.strippedchunks=strippedchunks
luautilities.suffixes={
tma="tma",
tmc=jit and "tmb" or "tmc",
lua="lua",
luc=jit and "lub" or "luc",
lui="lui",
luv="luv",
luj="luj",
tua="tua",
tuc="tuc",
}
local function register(name)
if tracestripping then
report_lua("stripped bytecode from %a",name or "unknown")
end
strippedchunks[#strippedchunks+1]=name
luautilities.nofstrippedchunks=luautilities.nofstrippedchunks+1
end
local function stupidcompile(luafile,lucfile,strip)
local code=io.loaddata(luafile)
if code and code~="" then
code=load(code)
if code then
code=dump(code,strip and luautilities.stripcode or luautilities.alwaysstripcode)
if code and code~="" then
register(name)
io.savedata(lucfile,code)
return true,0
end
else
report_lua("fatal error %a in file %a",1,luafile)
end
else
report_lua("fatal error %a in file %a",2,luafile)
end
return false,0
end
function luautilities.loadedluacode(fullname,forcestrip,name,macros)
name=name or fullname
if macros then
macros=lua.macros
end
local code,message
if macros then
code,message=macros.loaded(fullname,true,false)
else
code,message=loadfile(fullname)
end
if code then
code()
else
report_lua("loading of file %a failed:\n\t%s",fullname,message or "no message")
code,message=loadfile(fullname)
end
if forcestrip and luautilities.stripcode then
if type(forcestrip)=="function" then
forcestrip=forcestrip(fullname)
end
if forcestrip or luautilities.alwaysstripcode then
register(name)
return load(dump(code,true)),0
else
return code,0
end
elseif luautilities.alwaysstripcode then
register(name)
return load(dump(code,true)),0
else
return code,0
end
end
function luautilities.strippedloadstring(code,name,forcestrip)
local code,message=load(code)
if not code then
report_lua("loading of file %a failed:\n\t%s",name,message or "no message")
end
if forcestrip and luautilities.stripcode or luautilities.alwaysstripcode then
register(name)
return load(dump(code,true)),0
else
return code,0
end
end
function luautilities.loadstring(code,name)
local code,message=load(code)
if not code then
report_lua("loading of file %a failed:\n\t%s",name,message or "no message")
end
return code,0
end
function luautilities.compile(luafile,lucfile,cleanup,strip,fallback)
report_lua("compiling %a into %a",luafile,lucfile)
os.remove(lucfile)
local done=stupidcompile(luafile,lucfile,strip~=false)
if done then
report_lua("dumping %a into %a stripped",luafile,lucfile)
if cleanup==true and lfs.isfile(lucfile) and lfs.isfile(luafile) then
report_lua("removing %a",luafile)
os.remove(luafile)
end
end
return done
end
function luautilities.loadstripped(...)
local l=load(...)
if l then
return load(dump(l,true))
end
end
local finalizers={}
setmetatable(finalizers,{
__gc=function(t)
for i=1,#t do
pcall(t[i])
end
end
} )
function luautilities.registerfinalizer(f)
finalizers[#finalizers+1]=f
end
function luautilities.checkmemory(previous,threshold,trace)
local current=collectgarbage("count")
if previous then
local checked=(threshold or 64)*1024
local delta=current-previous
if current-previous>checked then
collectgarbage("collect")
local afterwards=collectgarbage("count")
if trace or tracememory then
report_mem("previous %r MB, current %r MB, delta %r MB, threshold %r MB, afterwards %r MB",
previous/1024,current/1024,delta/1024,threshold,afterwards)
end
return afterwards
elseif trace or tracememory then
report_mem("previous %r MB, current %r MB, delta %r MB, threshold %r MB",
previous/1024,current/1024,delta/1024,threshold)
end
end
return current
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-deb"] = package.loaded["util-deb"] or true
-- original size: 9955, stripped down to: 6693
if not modules then modules={} end modules ['util-deb']={
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"
}
local type,next,tostring,tonumber=type,next,tostring,tonumber
local format,find,sub,gsub=string.format,string.find,string.sub,string.gsub
local insert,remove,sort=table.insert,table.remove,table.sort
local setmetatableindex=table.setmetatableindex
utilities=utilities or {}
local debugger=utilities.debugger or {}
utilities.debugger=debugger
local report=logs.reporter("debugger")
local ticks=os.gettimeofday or os.clock
local seconds=function(n) return n or 0 end
local overhead=0
local dummycalls=10*1000
local nesting=0
local names={}
local initialize=false
if not (FFISUPPORTED and ffi) then
elseif os.type=="windows" then
initialize=function()
local kernel=ffilib("kernel32","system")
if kernel then
local tonumber=ffi.number or tonumber
ffi.cdef[[
int QueryPerformanceFrequency(int64_t *lpFrequency);
int QueryPerformanceCounter(int64_t *lpPerformanceCount);
]]
local target=ffi.new("__int64[1]")
ticks=function()
if kernel.QueryPerformanceCounter(target)==1 then
return tonumber(target[0])
else
return 0
end
end
local target=ffi.new("__int64[1]")
seconds=function(ticks)
if kernel.QueryPerformanceFrequency(target)==1 then
return ticks/tonumber(target[0])
else
return 0
end
end
end
initialize=false
end
elseif os.type=="unix" then
initialize=function()
local C=ffi.C
local tonumber=ffi.number or tonumber
ffi.cdef [[
/* what a mess */
typedef int clk_id_t;
typedef enum { CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID } clk_id;
typedef struct timespec { long sec; long nsec; } ctx_timespec;
int clock_gettime(clk_id_t timerid, struct timespec *t);
]]
local target=ffi.new("ctx_timespec[?]",1)
local clock=C.CLOCK_PROCESS_CPUTIME_ID
ticks=function ()
C.clock_gettime(clock,target)
return tonumber(target[0].sec*1000000000+target[0].nsec)
end
seconds=function(ticks)
return ticks/1000000000
end
initialize=false
end
end
setmetatableindex(names,function(t,name)
local v=setmetatableindex(function(t,source)
local v=setmetatableindex(function(t,line)
local v={ total=0,count=0,nesting=0 }
t[line]=v
return v
end)
t[source]=v
return v
end)
t[name]=v
return v
end)
local getinfo=nil
local sethook=nil
local function hook(where)
local f=getinfo(2,"nSl")
if f then
local source=f.short_src
if not source then
return
end
local line=f.linedefined or 0
local name=f.name
if not name then
local what=f.what
if what=="C" then
name="<anonymous>"
else
name=f.namewhat or what or "<unknown>"
end
end
local data=names[name][source][line]
if where=="call" then
local nesting=data.nesting
if nesting==0 then
data.count=data.count+1
insert(data,ticks())
data.nesting=1
else
data.nesting=nesting+1
end
elseif where=="return" then
local nesting=data.nesting
if nesting==1 then
local t=remove(data)
if t then
data.total=data.total+ticks()-t
end
data.nesting=0
else
data.nesting=nesting-1
end
end
end
end
function debugger.showstats(printer,threshold)
local printer=printer or report
local calls=0
local functions=0
local dataset={}
local length=0
local realtime=0
local totaltime=0
local threshold=threshold or 0
for name,sources in next,names do
for source,lines in next,sources do
for line,data in next,lines do
local count=data.count
if count>threshold then
if #name>length then
length=#name
end
local total=data.total
local real=total
if real>0 then
real=total-(count*overhead/dummycalls)
if real<0 then
real=0
end
realtime=realtime+real
end
totaltime=totaltime+total
if line<0 then
line=0
end
dataset[#dataset+1]={ real,total,count,name,source,line }
end
end
end
end
sort(dataset,function(a,b)
if a[1]==b[1] then
if a[2]==b[2] then
if a[3]==b[3] then
if a[4]==b[4] then
if a[5]==b[5] then
return a[6]<b[6]
else
return a[5]<b[5]
end
else
return a[4]<b[4]
end
else
return b[3]<a[3]
end
else
return b[2]<a[2]
end
else
return b[1]<a[1]
end
end)
if length>50 then
length=50
end
local fmt=string.formatters["%4.9k s %3.3k %% %4.9k s %3.3k %% %8i # %-"..length.."s %4i %s"]
for i=1,#dataset do
local data=dataset[i]
local real=data[1]
local total=data[2]
local count=data[3]
local name=data[4]
local source=data[5]
local line=data[6]
calls=calls+count
functions=functions+1
name=gsub(name,"%s+"," ")
if #name>length then
name=sub(name,1,length)
end
printer(fmt(seconds(total),100*total/totaltime,seconds(real),100*real/realtime,count,name,line,source))
end
printer("")
printer(format("functions : %i",functions))
printer(format("calls : %i",calls))
printer(format("overhead : %f",seconds(overhead/1000)))
end
local function getdebug()
if sethook and getinfo then
return
end
if not debug then
local okay
okay,debug=pcall(require,"debug")
end
if type(debug)~="table" then
return
end
getinfo=debug.getinfo
sethook=debug.sethook
if type(getinfo)~="function" then
getinfo=nil
end
if type(sethook)~="function" then
sethook=nil
end
end
function debugger.savestats(filename,threshold)
local f=io.open(filename,'w')
if f then
debugger.showstats(function(str) f:write(str,"\n") end,threshold)
f:close()
end
end
function debugger.enable()
getdebug()
if sethook and getinfo and nesting==0 then
running=true
if initialize then
initialize()
end
sethook(hook,"cr")
local function dummy() end
local t=ticks()
for i=1,dummycalls do
dummy()
end
overhead=ticks()-t
end
if nesting>0 then
nesting=nesting+1
end
end
function debugger.disable()
if nesting>0 then
nesting=nesting-1
end
if sethook and getinfo and nesting==0 then
sethook()
end
end
local function showtraceback(rep)
getdebug()
if getinfo then
local level=2
local reporter=rep or report
while true do
local info=getinfo(level,"Sl")
if not info then
break
elseif info.what=="C" then
reporter("%2i : %s",level-1,"C function")
else
reporter("%2i : %s : %s",level-1,info.short_src,info.currentline)
end
level=level+1
end
end
end
debugger.showtraceback=showtraceback
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-tpl"] = package.loaded["util-tpl"] or true
-- original size: 7112, stripped down to: 3887
if not modules then modules={} end modules ['util-tpl']={
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"
}
utilities.templates=utilities.templates or {}
local templates=utilities.templates
local trace_template=false trackers.register("templates.trace",function(v) trace_template=v end)
local report_template=logs.reporter("template")
local tostring,next=tostring,next
local format,sub,byte=string.format,string.sub,string.byte
local P,C,R,Cs,Cc,Carg,lpegmatch,lpegpatterns=lpeg.P,lpeg.C,lpeg.R,lpeg.Cs,lpeg.Cc,lpeg.Carg,lpeg.match,lpeg.patterns
local replacer
local function replacekey(k,t,how,recursive)
local v=t[k]
if not v then
if trace_template then
report_template("unknown key %a",k)
end
return ""
else
v=tostring(v)
if trace_template then
report_template("setting key %a to value %a",k,v)
end
if recursive then
return lpegmatch(replacer,v,1,t,how,recursive)
else
return v
end
end
end
local sqlescape=lpeg.replacer {
{ "'","''" },
{ "\\","\\\\" },
{ "\r\n","\\n" },
{ "\r","\\n" },
}
local sqlquoted=Cs(Cc("'")*sqlescape*Cc("'"))
lpegpatterns.sqlescape=sqlescape
lpegpatterns.sqlquoted=sqlquoted
local luaescape=lpegpatterns.luaescape
local escapers={
lua=function(s)
return lpegmatch(luaescape,s)
end,
sql=function(s)
return lpegmatch(sqlescape,s)
end,
}
local quotedescapers={
lua=function(s)
return format("%q",s)
end,
sql=function(s)
return lpegmatch(sqlquoted,s)
end,
}
local luaescaper=escapers.lua
local quotedluaescaper=quotedescapers.lua
local function replacekeyunquoted(s,t,how,recurse)
if how==false then
return replacekey(s,t,how,recurse)
else
local escaper=how and escapers[how] or luaescaper
return escaper(replacekey(s,t,how,recurse))
end
end
local function replacekeyquoted(s,t,how,recurse)
if how==false then
return replacekey(s,t,how,recurse)
else
local escaper=how and quotedescapers[how] or quotedluaescaper
return escaper(replacekey(s,t,how,recurse))
end
end
local function replaceoptional(l,m,r,t,how,recurse)
local v=t[l]
return v and v~="" and lpegmatch(replacer,r,1,t,how or "lua",recurse or false) or ""
end
local single=P("%")
local double=P("%%")
local lquoted=P("%[")
local rquoted=P("]%")
local lquotedq=P("%(")
local rquotedq=P(")%")
local escape=double/'%%'
local nosingle=single/''
local nodouble=double/''
local nolquoted=lquoted/''
local norquoted=rquoted/''
local nolquotedq=lquotedq/''
local norquotedq=rquotedq/''
local noloptional=P("%?")/''
local noroptional=P("?%")/''
local nomoptional=P(":")/''
local args=Carg(1)*Carg(2)*Carg(3)
local key=nosingle*((C((1-nosingle )^1)*args)/replacekey )*nosingle
local quoted=nolquotedq*((C((1-norquotedq )^1)*args)/replacekeyquoted )*norquotedq
local unquoted=nolquoted*((C((1-norquoted )^1)*args)/replacekeyunquoted)*norquoted
local optional=noloptional*((C((1-nomoptional)^1)*nomoptional*C((1-noroptional)^1)*args)/replaceoptional)*noroptional
local any=P(1)
replacer=Cs((unquoted+quoted+escape+optional+key+any)^0)
local function replace(str,mapping,how,recurse)
if mapping and str then
return lpegmatch(replacer,str,1,mapping,how or "lua",recurse or false) or str
else
return str
end
end
templates.replace=replace
function templates.replacer(str,how,recurse)
return function(mapping)
return lpegmatch(replacer,str,1,mapping,how or "lua",recurse or false) or str
end
end
function templates.load(filename,mapping,how,recurse)
local data=io.loaddata(filename) or ""
if mapping and next(mapping) then
return replace(data,mapping,how,recurse)
else
return data
end
end
function templates.resolve(t,mapping,how,recurse)
if not mapping then
mapping=t
end
for k,v in next,t do
t[k]=replace(v,mapping,how,recurse)
end
return t
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-sbx"] = package.loaded["util-sbx"] or true
-- original size: 20393, stripped down to: 13121
if not modules then modules={} end modules ['util-sbx']={
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"
}
if not sandbox then require("l-sandbox") end
local next,type=next,type
local replace=utilities.templates.replace
local collapsepath=file.collapsepath
local expandname=dir.expandname
local sortedhash=table.sortedhash
local lpegmatch=lpeg.match
local platform=os.type
local P,S,C=lpeg.P,lpeg.S,lpeg.C
local gsub=string.gsub
local lower=string.lower
local find=string.find
local concat=string.concat
local unquoted=string.unquoted
local optionalquoted=string.optionalquoted
local basename=file.basename
local nameonly=file.nameonly
local sandbox=sandbox
local validroots={}
local validrunners={}
local validbinaries=true
local validlibraries=true
local validators={}
local finalized=nil
local trace=false
local p_validroot=nil
local p_split=lpeg.firstofsplit(" ")
local report=logs.reporter("sandbox")
trackers.register("sandbox",function(v) trace=v end)
sandbox.setreporter(report)
sandbox.finalizer {
category="files",
action=function()
finalized=true
end
}
local function registerroot(root,what)
if finalized then
report("roots are already finalized")
else
if type(root)=="table" then
root,what=root[1],root[2]
end
if type(root)=="string" and root~="" then
root=collapsepath(expandname(root))
if what=="r" or what=="ro" or what=="readable" then
what="read"
elseif what=="w" or what=="wo" or what=="writable" then
what="write"
end
validroots[root]=what=="write" or false
end
end
end
sandbox.finalizer {
category="files",
action=function()
if p_validroot then
report("roots are already initialized")
else
sandbox.registerroot(".","write")
for name in sortedhash(validroots) do
if p_validroot then
p_validroot=P(name)+p_validroot
else
p_validroot=P(name)
end
end
p_validroot=p_validroot/validroots
end
end
}
local function registerbinary(name)
if finalized then
report("binaries are already finalized")
elseif type(name)=="string" and name~="" then
if not validbinaries then
return
end
if validbinaries==true then
validbinaries={ [name]=true }
else
validbinaries[name]=true
end
elseif name==true then
validbinaries={}
end
end
local function registerlibrary(name)
if finalized then
report("libraries are already finalized")
elseif type(name)=="string" and name~="" then
if not validlibraries then
return
end
if validlibraries==true then
validlibraries={ [nameonly(name)]=true }
else
validlibraries[nameonly(name)]=true
end
elseif name==true then
validlibraries={}
end
end
local p_write=S("wa") p_write=(1-p_write)^0*p_write
local p_path=S("\\/~$%:") p_path=(1-p_path )^0*p_path
local function normalized(name)
if platform=="windows" then
name=gsub(name,"/","\\")
end
return name
end
function sandbox.possiblepath(name)
return lpegmatch(p_path,name) and true or false
end
local filenamelogger=false
function sandbox.setfilenamelogger(l)
filenamelogger=type(l)=="function" and l or false
end
local function validfilename(name,what)
if p_validroot and type(name)=="string" and lpegmatch(p_path,name) then
local asked=collapsepath(expandname(name))
local okay=lpegmatch(p_validroot,asked)
if okay==true then
if filenamelogger then
filenamelogger(name,"w",asked,true)
end
return name
elseif okay==false then
if not what then
if filenamelogger then
filenamelogger(name,"r",asked,true)
end
return name
elseif lpegmatch(p_write,what) then
if filenamelogger then
filenamelogger(name,"w",asked,false)
end
return
else
if filenamelogger then
filenamelogger(name,"r",asked,true)
end
return name
end
elseif filenamelogger then
filenamelogger(name,"*",name,false)
end
else
return name
end
end
local function readable(name,finalized)
return validfilename(name,"r")
end
local function normalizedreadable(name,finalized)
local valid=validfilename(name,"r")
if valid then
return normalized(valid)
end
end
local function writeable(name,finalized)
return validfilename(name,"w")
end
local function normalizedwriteable(name,finalized)
local valid=validfilename(name,"w")
if valid then
return normalized(valid)
end
end
validators.readable=readable
validators.writeable=normalizedwriteable
validators.normalizedreadable=normalizedreadable
validators.normalizedwriteable=writeable
validators.filename=readable
table.setmetatableindex(validators,function(t,k)
if k then
t[k]=readable
end
return readable
end)
function validators.string(s,finalized)
if finalized and suspicious(s) then
return ""
else
return s
end
end
function validators.cache(s)
if finalized then
return basename(s)
else
return s
end
end
function validators.url(s)
if finalized and find("^file:") then
return ""
else
return s
end
end
local function filehandlerone(action,one,...)
local checkedone=validfilename(one)
if checkedone then
return action(one,...)
else
end
end
local function filehandlertwo(action,one,two,...)
local checkedone=validfilename(one)
if checkedone then
local checkedtwo=validfilename(two)
if checkedtwo then
return action(one,two,...)
else
end
else
end
end
local function iohandler(action,one,...)
if type(one)=="string" then
local checkedone=validfilename(one)
if checkedone then
return action(one,...)
end
elseif one then
return action(one,...)
else
return action()
end
end
local osexecute=sandbox.original(os.execute)
local iopopen=sandbox.original(io.popen)
local reported={}
local function validcommand(name,program,template,checkers,defaults,variables,reporter,strict)
if validbinaries~=false and (validbinaries==true or validbinaries[program]) then
if variables then
for variable,value in next,variables do
local checker=validators[checkers[variable]]
if checker then
value=checker(unquoted(value),strict)
if value then
variables[variable]=optionalquoted(value)
else
report("variable %a with value %a fails the check",variable,value)
return
end
else
report("variable %a has no checker",variable)
return
end
end
for variable,default in next,defaults do
local value=variables[variable]
if not value or value=="" then
local checker=validators[checkers[variable]]
if checker then
default=checker(unquoted(default),strict)
if default then
variables[variable]=optionalquoted(default)
else
report("variable %a with default %a fails the check",variable,default)
return
end
end
end
end
end
local command=program.." "..replace(template,variables)
if reporter then
reporter("executing runner %a: %s",name,command)
elseif trace then
report("executing runner %a: %s",name,command)
end
return command
elseif not reported[name] then
report("executing program %a of runner %a is not permitted",program,name)
reported[name]=true
end
end
local runners={
resultof=function(...)
local command=validcommand(...)
if command then
if trace then
report("resultof: %s",command)
end
local handle=iopopen(command,"r")
if handle then
local result=handle:read("*all") or ""
handle:close()
return result
end
end
end,
execute=function(...)
local command=validcommand(...)
if command then
if trace then
report("execute: %s",command)
end
return osexecute(command)
end
end,
pipeto=function(...)
local command=validcommand(...)
if command then
if trace then
report("pipeto: %s",command)
end
return iopopen(command,"w")
end
end,
}
function sandbox.registerrunner(specification)
if type(specification)=="string" then
local wrapped=validrunners[specification]
inspect(table.sortedkeys(validrunners))
if wrapped then
return wrapped
else
report("unknown predefined runner %a",specification)
return
end
end
if type(specification)~="table" then
report("specification should be a table (or string)")
return
end
local name=specification.name
if type(name)~="string" then
report("invalid name, string expected",name)
return
end
if validrunners[name] then
report("invalid name, runner %a already defined")
return
end
local program=specification.program
if type(program)=="string" then
elseif type(program)=="table" then
program=program[platform] or program.default or program.unix
end
if type(program)~="string" or program=="" then
report("invalid runner %a specified for platform %a",name,platform)
return
end
local template=specification.template
if not template then
report("missing template for runner %a",name)
return
end
local method=specification.method or "execute"
local checkers=specification.checkers or {}
local defaults=specification.defaults or {}
local runner=runners[method]
if runner then
local finalized=finalized
local wrapped=function(variables)
return runner(name,program,template,checkers,defaults,variables,specification.reporter,finalized)
end
validrunners[name]=wrapped
return wrapped
else
validrunners[name]=nil
report("invalid method for runner %a",name)
end
end
function sandbox.getrunner(name)
return name and validrunners[name]
end
local function suspicious(str)
return (find(str,"[/\\]") or find(command,"..",1,true)) and true or false
end
local function binaryrunner(action,command,...)
if validbinaries==false then
report("no binaries permitted, ignoring command: %s",command)
return
end
if type(command)~="string" then
report("command should be a string")
return
end
local program=lpegmatch(p_split,command)
if not program or program=="" then
report("unable to filter binary from command: %s",command)
return
end
if validbinaries==true then
elseif not validbinaries[program] then
report("binary not permitted, ignoring command: %s",command)
return
elseif suspicious(command) then
report("/ \\ or .. found, ignoring command (use sandbox.registerrunner): %s",command)
return
end
return action(command,...)
end
local function dummyrunner(action,command,...)
if type(command)=="table" then
command=concat(command," ",command[0] and 0 or 1)
end
report("ignoring command: %s",command)
end
sandbox.filehandlerone=filehandlerone
sandbox.filehandlertwo=filehandlertwo
sandbox.iohandler=iohandler
function sandbox.disablerunners()
validbinaries=false
end
function sandbox.disablelibraries()
validlibraries=false
end
if FFISUPPORTED and ffi then
function sandbox.disablelibraries()
validlibraries=false
for k,v in next,ffi do
if k~="gc" then
ffi[k]=nil
end
end
end
local fiiload=ffi.load
if fiiload then
local reported={}
function ffi.load(name,...)
if validlibraries==false then
elseif validlibraries==true then
return fiiload(name,...)
elseif validlibraries[nameonly(name)] then
return fiiload(name,...)
else
end
if not reported[name] then
report("using library %a is not permitted",name)
reported[name]=true
end
return nil
end
end
end
local overload=sandbox.overload
local register=sandbox.register
overload(loadfile,filehandlerone,"loadfile")
if io then
overload(io.open,filehandlerone,"io.open")
overload(io.popen,binaryrunner,"io.popen")
overload(io.input,iohandler,"io.input")
overload(io.output,iohandler,"io.output")
overload(io.lines,filehandlerone,"io.lines")
end
if os then
overload(os.execute,binaryrunner,"os.execute")
overload(os.spawn,dummyrunner,"os.spawn")
overload(os.exec,dummyrunner,"os.exec")
overload(os.resultof,binaryrunner,"os.resultof")
overload(os.pipeto,binaryrunner,"os.pipeto")
overload(os.rename,filehandlertwo,"os.rename")
overload(os.remove,filehandlerone,"os.remove")
end
if lfs then
overload(lfs.chdir,filehandlerone,"lfs.chdir")
overload(lfs.mkdir,filehandlerone,"lfs.mkdir")
overload(lfs.rmdir,filehandlerone,"lfs.rmdir")
overload(lfs.isfile,filehandlerone,"lfs.isfile")
overload(lfs.isdir,filehandlerone,"lfs.isdir")
overload(lfs.attributes,filehandlerone,"lfs.attributes")
overload(lfs.dir,filehandlerone,"lfs.dir")
overload(lfs.lock_dir,filehandlerone,"lfs.lock_dir")
overload(lfs.touch,filehandlerone,"lfs.touch")
overload(lfs.link,filehandlertwo,"lfs.link")
overload(lfs.setmode,filehandlerone,"lfs.setmode")
overload(lfs.readlink,filehandlerone,"lfs.readlink")
overload(lfs.shortname,filehandlerone,"lfs.shortname")
overload(lfs.symlinkattributes,filehandlerone,"lfs.symlinkattributes")
end
if zip then
zip.open=register(zip.open,filehandlerone,"zip.open")
end
if fontloader then
fontloader.open=register(fontloader.open,filehandlerone,"fontloader.open")
fontloader.info=register(fontloader.info,filehandlerone,"fontloader.info")
end
if epdf then
epdf.open=register(epdf.open,filehandlerone,"epdf.open")
end
sandbox.registerroot=registerroot
sandbox.registerbinary=registerbinary
sandbox.registerlibrary=registerlibrary
sandbox.validfilename=validfilename
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-mrg"] = package.loaded["util-mrg"] or true
-- original size: 7819, stripped down to: 5881
if not modules then modules={} end modules ['util-mrg']={
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"
}
local gsub,format=string.gsub,string.format
local concat=table.concat
local type,next=type,next
local P,R,S,V,Ct,C,Cs,Cc,Cp,Cmt,Cb,Cg=lpeg.P,lpeg.R,lpeg.S,lpeg.V,lpeg.Ct,lpeg.C,lpeg.Cs,lpeg.Cc,lpeg.Cp,lpeg.Cmt,lpeg.Cb,lpeg.Cg
local lpegmatch,patterns=lpeg.match,lpeg.patterns
utilities=utilities or {}
local merger=utilities.merger or {}
utilities.merger=merger
merger.strip_comment=true
local report=logs.reporter("system","merge")
utilities.report=report
local m_begin_merge="begin library merge"
local m_end_merge="end library merge"
local m_begin_closure="do -- create closure to overcome 200 locals limit"
local m_end_closure="end -- of closure"
local m_pattern="%c+".."%-%-%s+"..m_begin_merge.."%c+(.-)%c+".."%-%-%s+"..m_end_merge.."%c+"
local m_format="\n\n-- "..m_begin_merge.."\n%s\n".."-- "..m_end_merge.."\n\n"
local m_faked="-- ".."created merged file".."\n\n".."-- "..m_begin_merge.."\n\n".."-- "..m_end_merge.."\n\n"
local m_report=[[
-- used libraries : %s
-- skipped libraries : %s
-- original bytes : %s
-- stripped bytes : %s
]]
local m_preloaded=[[package.loaded[%q] = package.loaded[%q] or true]]
local function self_fake()
return m_faked
end
local function self_nothing()
return ""
end
local function self_load(name)
local data=io.loaddata(name) or ""
if data=="" then
report("unknown file %a",name)
else
report("inserting file %a",name)
end
return data or ""
end
local space=patterns.space
local eol=patterns.newline
local equals=P("=")^0
local open=P("[")*Cg(equals,"init")*P("[")*P("\n")^-1
local close=P("]")*C(equals)*P("]")
local closeeq=Cmt(close*Cb("init"),function(s,i,a,b) return a==b end)
local longstring=open*(1-closeeq)^0*close
local quoted=patterns.quoted
local digit=patterns.digit
local emptyline=space^0*eol
local operator1=P("<=")+P(">=")+P("~=")+P("..")+S("/^<>=*+%%")
local operator2=S("*+/")
local operator3=S("-")
local operator4=P("..")
local separator=S(",;")
local ignore=(P("]")*space^1*P("=")*space^1*P("]"))/"]=["+(P("=")*space^1*P("{"))/"={"+(P("(")*space^1)/"("+(P("{")*(space+eol)^1*P("}"))/"{}"
local strings=quoted
local longcmt=(emptyline^0*P("--")*longstring*emptyline^0)/""
local longstr=longstring
local comment=emptyline^0*P("--")*P("-")^0*(1-eol)^0*emptyline^1/"\n"
local optionalspaces=space^0/""
local mandatespaces=space^1/""
local optionalspacing=(eol+space)^0/""
local mandatespacing=(eol+space)^1/""
local pack=digit*space^1*operator4*optionalspacing+optionalspacing*operator1*optionalspacing+optionalspacing*operator2*optionalspaces+mandatespacing*operator3*mandatespaces+optionalspaces*separator*optionalspaces
local lines=emptyline^2/"\n"
local spaces=(space*space)/" "
local spaces=(space*space*space*space)/" "
local compact=Cs ((
ignore+strings+longcmt+longstr+comment+pack+lines+spaces+1
)^1 )
local strip=Cs((emptyline^2/"\n"+1)^0)
local stripreturn=Cs((1-P("return")*space^1*P(1-space-eol)^1*(space+eol)^0*P(-1))^1)
function merger.compact(data)
return lpegmatch(strip,lpegmatch(compact,data))
end
local function self_compact(data)
local delta=0
if merger.strip_comment then
local before=#data
data=lpegmatch(compact,data)
data=lpegmatch(strip,data)
local after=#data
delta=before-after
report("original size %s, compacted to %s, stripped %s",before,after,delta)
data=format("-- original size: %s, stripped down to: %s\n\n%s",before,after,data)
end
return lpegmatch(stripreturn,data) or data,delta
end
local function self_save(name,data)
if data~="" then
io.savedata(name,data)
report("saving %s with size %s",name,#data)
end
end
local function self_swap(data,code)
return data~="" and (gsub(data,m_pattern,function() return format(m_format,code) end,1)) or ""
end
local function self_libs(libs,list)
local result,f,frozen,foundpath={},nil,false,nil
result[#result+1]="\n"
if type(libs)=='string' then libs={ libs } end
if type(list)=='string' then list={ list } end
for i=1,#libs do
local lib=libs[i]
for j=1,#list do
local pth=gsub(list[j],"\\","/")
report("checking library path %a",pth)
local name=pth.."/"..lib
if lfs.isfile(name) then
foundpath=pth
end
end
if foundpath then break end
end
if foundpath then
report("using library path %a",foundpath)
local right,wrong,original,stripped={},{},0,0
for i=1,#libs do
local lib=libs[i]
local fullname=foundpath.."/"..lib
if lfs.isfile(fullname) then
report("using library %a",fullname)
local preloaded=file.nameonly(lib)
local data=io.loaddata(fullname,true)
original=original+#data
local data,delta=self_compact(data)
right[#right+1]=lib
result[#result+1]=m_begin_closure
result[#result+1]=format(m_preloaded,preloaded,preloaded)
result[#result+1]=data
result[#result+1]=m_end_closure
stripped=stripped+delta
else
report("skipping library %a",fullname)
wrong[#wrong+1]=lib
end
end
right=#right>0 and concat(right," ") or "-"
wrong=#wrong>0 and concat(wrong," ") or "-"
report("used libraries: %a",right)
report("skipped libraries: %a",wrong)
report("original bytes: %a",original)
report("stripped bytes: %a",stripped)
result[#result+1]=format(m_report,right,wrong,original,stripped)
else
report("no valid library path found")
end
return concat(result,"\n\n")
end
function merger.selfcreate(libs,list,target)
if target then
self_save(target,self_swap(self_fake(),self_libs(libs,list)))
end
end
function merger.selfmerge(name,libs,list,target)
self_save(target or name,self_swap(self_load(name),self_libs(libs,list)))
end
function merger.selfclean(name)
self_save(name,self_swap(self_load(name),self_nothing()))
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-env"] = package.loaded["util-env"] or true
-- original size: 9738, stripped down to: 5531
if not modules then modules={} end modules ['util-env']={
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"
}
local allocate,mark=utilities.storage.allocate,utilities.storage.mark
local format,sub,match,gsub,find=string.format,string.sub,string.match,string.gsub,string.find
local unquoted,quoted,optionalquoted=string.unquoted,string.quoted,string.optionalquoted
local concat,insert,remove=table.concat,table.insert,table.remove
environment=environment or {}
local environment=environment
local setlocale=os.setlocale
setlocale(nil,nil)
local report=logs.reporter("system")
function os.setlocale(a,b)
if a or b then
if report then
report()
report("You're messing with os.locale in a supposedly locale neutral enviroment. From")
report("now on are on your own and without support. Crashes or unexpected side effects")
report("can happen but don't bother the luatex and context developer team with it.")
report()
report=nil
end
setlocale(a,b)
end
end
local validengines=allocate {
["luatex"]=true,
["luajittex"]=true,
}
local basicengines=allocate {
["luatex"]="luatex",
["texlua"]="luatex",
["texluac"]="luatex",
["luajittex"]="luajittex",
["texluajit"]="luajittex",
}
local luaengines=allocate {
["lua"]=true,
["luajit"]=true,
}
environment.validengines=validengines
environment.basicengines=basicengines
if not arg then
environment.used_as_library=true
elseif luaengines[file.removesuffix(arg[-1])] then
elseif validengines[file.removesuffix(arg[0])] then
if arg[1]=="--luaonly" then
arg[-1]=arg[0]
arg[ 0]=arg[2]
for k=3,#arg do
arg[k-2]=arg[k]
end
remove(arg)
remove(arg)
else
end
local originalzero=file.basename(arg[0])
local specialmapping={ luatools=="base" }
if originalzero~="mtxrun" and originalzero~="mtxrun.lua" then
arg[0]=specialmapping[originalzero] or originalzero
insert(arg,0,"--script")
insert(arg,0,"mtxrun")
end
end
environment.arguments=allocate()
environment.files=allocate()
environment.sortedflags=nil
function environment.initializearguments(arg)
local arguments={}
local files={}
environment.arguments=arguments
environment.files=files
environment.sortedflags=nil
for index=1,#arg do
local argument=arg[index]
if index>0 then
local flag,value=match(argument,"^%-+(.-)=(.-)$")
if flag then
flag=gsub(flag,"^c:","")
arguments[flag]=unquoted(value or "")
else
flag=match(argument,"^%-+(.+)")
if flag then
flag=gsub(flag,"^c:","")
arguments[flag]=true
else
files[#files+1]=argument
end
end
end
end
if not environment.ownname then
if os.selfpath and os.selfname then
environment.ownname=file.addsuffix(file.join(os.selfpath,os.selfname),"lua")
end
end
environment.ownname=file.reslash(environment.ownname or arg[0] or 'unknown.lua')
end
function environment.setargument(name,value)
environment.arguments[name]=value
end
function environment.getargument(name,partial)
local arguments,sortedflags=environment.arguments,environment.sortedflags
if arguments[name] then
return arguments[name]
elseif partial then
if not sortedflags then
sortedflags=allocate(table.sortedkeys(arguments))
for k=1,#sortedflags do
sortedflags[k]="^"..sortedflags[k]
end
environment.sortedflags=sortedflags
end
for k=1,#sortedflags do
local v=sortedflags[k]
if find(name,v) then
return arguments[sub(v,2,#v)]
end
end
end
return nil
end
environment.argument=environment.getargument
function environment.splitarguments(separator)
local done,before,after=false,{},{}
local originalarguments=environment.originalarguments
for k=1,#originalarguments do
local v=originalarguments[k]
if not done and v==separator then
done=true
elseif done then
after[#after+1]=v
else
before[#before+1]=v
end
end
return before,after
end
function environment.reconstructcommandline(arg,noquote)
local resolveprefix=resolvers.resolve
arg=arg or environment.originalarguments
if noquote and #arg==1 then
return unquoted(resolveprefix and resolveprefix(arg[1]) or arg[1])
elseif #arg>0 then
local result={}
for i=1,#arg do
result[i]=optionalquoted(resolveprefix and resolveprefix(arg[i]) or resolveprefix)
end
return concat(result," ")
else
return ""
end
end
function environment.relativepath(path,root)
if not path then
path=""
end
if not file.is_rootbased_path(path) then
if not root then
root=file.pathpart(environment.ownscript or environment.ownname or ".")
end
if root=="" then
root="."
end
path=root.."/"..path
end
return file.collapsepath(path,true)
end
if arg then
local newarg,instring={},false
for index=1,#arg do
local argument=arg[index]
if find(argument,"^\"") then
if find(argument,"\"$") then
newarg[#newarg+1]=gsub(argument,"^\"(.-)\"$","%1")
instring=false
else
newarg[#newarg+1]=gsub(argument,"^\"","")
instring=true
end
elseif find(argument,"\"$") then
if instring then
newarg[#newarg]=newarg[#newarg].." "..gsub(argument,"\"$","")
instring=false
else
newarg[#newarg+1]=argument
end
elseif instring then
newarg[#newarg]=newarg[#newarg].." "..argument
else
newarg[#newarg+1]=argument
end
end
for i=1,-5,-1 do
newarg[i]=arg[i]
end
environment.initializearguments(newarg)
environment.originalarguments=mark(newarg)
environment.rawarguments=mark(arg)
arg={}
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["luat-env"] = package.loaded["luat-env"] or true
-- original size: 6134, stripped down to: 4118
if not modules then modules={} end modules ['luat-env']={
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"
}
local rawset,rawget,loadfile=rawset,rawget,loadfile
local gsub=string.gsub
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local report_lua=logs.reporter("resolvers","lua")
local luautilities=utilities.lua
local luasuffixes=luautilities.suffixes
local texgettoks=tex and tex.gettoks
environment=environment or {}
local environment=environment
local mt={
__index=function(_,k)
if k=="version" then
local version=texgettoks and texgettoks("contextversiontoks")
if version and version~="" then
rawset(environment,"version",version)
return version
else
return "unknown"
end
elseif k=="kind" then
local kind=texgettoks and texgettoks("contextkindtoks")
if kind and kind~="" then
rawset(environment,"kind",kind)
return kind
else
return "unknown"
end
elseif k=="jobname" or k=="formatname" then
local name=tex and tex[k]
if name or name=="" then
rawset(environment,k,name)
return name
else
return "unknown"
end
elseif k=="outputfilename" then
local name=environment.jobname
rawset(environment,k,name)
return name
end
end
}
setmetatable(environment,mt)
function environment.texfile(filename)
return resolvers.findfile(filename,'tex')
end
function environment.luafile(filename)
local resolved=resolvers.findfile(filename,'tex') or ""
if resolved~="" then
return resolved
end
resolved=resolvers.findfile(filename,'texmfscripts') or ""
if resolved~="" then
return resolved
end
return resolvers.findfile(filename,'luatexlibs') or ""
end
local stripindeed=false directives.register("system.compile.strip",function(v) stripindeed=v end)
local function strippable(filename)
if stripindeed then
local modu=modules[file.nameonly(filename)]
return modu and modu.dataonly
else
return false
end
end
function environment.luafilechunk(filename,silent,macros)
filename=file.replacesuffix(filename,"lua")
local fullname=environment.luafile(filename)
if fullname and fullname~="" then
local data=luautilities.loadedluacode(fullname,strippable,filename,macros)
if not silent then
report_lua("loading file %a %s",fullname,not data and "failed" or "succeeded")
end
return data
else
if not silent then
report_lua("unknown file %a",filename)
end
return nil
end
end
function environment.loadluafile(filename,version)
local lucname,luaname,chunk
local basename=file.removesuffix(filename)
if basename==filename then
luaname=file.addsuffix(basename,luasuffixes.lua)
lucname=file.addsuffix(basename,luasuffixes.luc)
else
luaname=filename
lucname=nil
end
local fullname=(lucname and environment.luafile(lucname)) or ""
if fullname~="" then
if trace_locating then
report_lua("loading %a",fullname)
end
chunk=loadfile(fullname)
end
if chunk then
chunk()
if version then
local v=version
if modules and modules[filename] then
v=modules[filename].version
elseif versions and versions[filename] then
v=versions[filename]
end
if v==version then
return true
else
if trace_locating then
report_lua("version mismatch for %a, lua version %a, luc version %a",filename,v,version)
end
environment.loadluafile(filename)
end
else
return true
end
end
fullname=(luaname and environment.luafile(luaname)) or ""
if fullname~="" then
if trace_locating then
report_lua("loading %a",fullname)
end
chunk=loadfile(fullname)
if not chunk then
if trace_locating then
report_lua("unknown file %a",filename)
end
else
chunk()
return true
end
end
return false
end
environment.filenames=setmetatable({},{
__index=function(t,k)
local v=environment.files[k]
if v then
return (gsub(v,"%.+$",""))
end
end,
__newindex=function(t,k)
end,
__len=function(t)
return #environment.files
end,
} )
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-zip"] = package.loaded["util-zip"] or true
-- original size: 18645, stripped down to: 11291
if not modules then modules={} end modules ['util-zip']={
version=1.001,
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local type,tostring,tonumber=type,tostring,tonumber
local sort=table.sort
local find,format,sub,gsub=string.find,string.format,string.sub,string.gsub
local osdate,ostime=os.date,os.time
local ioopen=io.open
local loaddata,savedata=io.loaddata,io.savedata
local filejoin,isdir,dirname,mkdirs=file.join,lfs.isdir,file.dirname,dir.mkdirs
local files=utilities.files
local openfile=files.open
local closefile=files.close
local readstring=files.readstring
local readcardinal2=files.readcardinal2le
local readcardinal4=files.readcardinal4le
local setposition=files.setposition
local getposition=files.getposition
local band=bit32.band
local rshift=bit32.rshift
local lshift=bit32.lshift
local decompress,calculatecrc
if flate then
decompress=flate.flate_decompress
calculatecrc=flate.update_crc32
else
local zlibdecompress=zlib.decompress
local zlibchecksum=zlib.crc32
decompress=function(source,targetsize)
local target=zlibdecompress(source,-15)
if target then
return target
else
return false,1
end
end
calculatecrc=function(buffer,initial)
return zlibchecksum(initial or 0,buffer)
end
end
local zipfiles={}
utilities.zipfiles=zipfiles
local openzipfile,closezipfile,unzipfile,foundzipfile,getziphash,getziplist do
function openzipfile(name)
return {
name=name,
handle=openfile(name,0),
}
end
local function collect(z)
if not z.list then
local list={}
local hash={}
local position=0
local index=0
local handle=z.handle
while true do
setposition(handle,position)
local signature=readstring(handle,4)
if signature=="PK\3\4" then
local version=readcardinal2(handle)
local flag=readcardinal2(handle)
local method=readcardinal2(handle)
local filetime=readcardinal2(handle)
local filedate=readcardinal2(handle)
local crc32=readcardinal4(handle)
local compressed=readcardinal4(handle)
local uncompressed=readcardinal4(handle)
local namelength=readcardinal2(handle)
local extralength=readcardinal2(handle)
local filename=readstring(handle,namelength)
local descriptor=band(flag,8)~=0
local encrypted=band(flag,1)~=0
local acceptable=method==0 or method==8
local skipped=0
local size=0
if encrypted then
size=readcardinal2(handle)
skipbytes(size)
skipped=skipped+size+2
skipbytes(8)
skipped=skipped+8
size=readcardinal2(handle)
skipbytes(size)
skipped=skipped+size+2
size=readcardinal4(handle)
skipbytes(size)
skipped=skipped+size+4
size=readcardinal2(handle)
skipbytes(size)
skipped=skipped+size+2
end
position=position+30+namelength+extralength+skipped
if descriptor then
setposition(handle,position+compressed)
crc32=readcardinal4(handle)
compressed=readcardinal4(handle)
uncompressed=readcardinal4(handle)
end
if acceptable then
index=index+1
local data={
filename=filename,
index=index,
position=position,
method=method,
compressed=compressed,
uncompressed=uncompressed,
crc32=crc32,
encrypted=encrypted,
}
hash[filename]=data
list[index]=data
else
end
position=position+compressed
else
break
end
z.list=list
z.hash=hash
end
end
end
function getziplist(z)
local list=z.list
if not list then
collect(z)
end
return z.list
end
function getziphash(z)
local hash=z.hash
if not hash then
collect(z)
end
return z.hash
end
function foundzipfile(z,name)
return getziphash(z)[name]
end
function closezipfile(z)
local f=z.handle
if f then
closefile(f)
z.handle=nil
end
end
function unzipfile(z,filename,check)
local hash=z.hash
if not hash then
hash=zipfiles.hash(z)
end
local data=hash[filename]
if not data then
end
if data then
local handle=z.handle
local position=data.position
local compressed=data.compressed
if compressed>0 then
setposition(handle,position)
local result=readstring(handle,compressed)
if data.method==8 then
result=decompress(result,data.uncompressed)
end
if check and data.crc32~=calculatecrc(result) then
print("checksum mismatch")
return ""
end
return result
else
return ""
end
end
end
zipfiles.open=openzipfile
zipfiles.close=closezipfile
zipfiles.unzip=unzipfile
zipfiles.hash=getziphash
zipfiles.list=getziplist
zipfiles.found=foundzipfile
end
if flate then do
local writecardinal1=files.writebyte
local writecardinal2=files.writecardinal2le
local writecardinal4=files.writecardinal4le
local logwriter=logs.writer
local globpattern=dir.globpattern
local compress=flate.flate_compress
local checksum=flate.update_crc32
local function fromdostime(dostime,dosdate)
return ostime {
year=rshift(dosdate,9)+1980,
month=band(rshift(dosdate,5),0x0F),
day=band((dosdate ),0x1F),
hour=band(rshift(dostime,11) ),
min=band(rshift(dostime,5),0x3F),
sec=band((dostime ),0x1F),
}
end
local function todostime(time)
local t=osdate("*t",time)
return
lshift(t.year-1980,9)+lshift(t.month,5)+t.day,
lshift(t.hour,11)+lshift(t.min,5)+rshift(t.sec,1)
end
local function openzip(filename,level,comment,verbose)
local f=ioopen(filename,"wb")
if f then
return {
filename=filename,
handle=f,
list={},
level=tonumber(level) or 3,
comment=tostring(comment),
verbose=verbose,
uncompressed=0,
compressed=0,
}
end
end
local function writezip(z,name,data,level,time)
local f=z.handle
local list=z.list
local level=tonumber(level) or z.level or 3
local method=8
local zipped=compress(data,level)
local checksum=checksum(data)
local verbose=z.verbose
if not zipped then
method=0
zipped=data
end
local start=f:seek()
local compressed=#zipped
local uncompressed=#data
z.compressed=z.compressed+compressed
z.uncompressed=z.uncompressed+uncompressed
if verbose then
local pct=100*compressed/uncompressed
if pct>=100 then
logwriter(format("%10i %s",uncompressed,name))
else
logwriter(format("%10i %02.1f %s",uncompressed,pct,name))
end
end
f:write("\x50\x4b\x03\x04")
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,method)
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal4(f,checksum)
writecardinal4(f,compressed)
writecardinal4(f,uncompressed)
writecardinal2(f,#name)
writecardinal2(f,0)
f:write(name)
f:write(zipped)
list[#list+1]={ #zipped,#data,name,checksum,start,time or 0 }
end
local function closezip(z)
local f=z.handle
local list=z.list
local comment=z.comment
local verbose=z.verbose
local count=#list
local start=f:seek()
for i=1,count do
local l=list[i]
local compressed=l[1]
local uncompressed=l[2]
local name=l[3]
local checksum=l[4]
local start=l[5]
local time=l[6]
local date,time=todostime(time)
f:write('\x50\x4b\x01\x02')
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,8)
writecardinal2(f,time)
writecardinal2(f,date)
writecardinal4(f,checksum)
writecardinal4(f,compressed)
writecardinal4(f,uncompressed)
writecardinal2(f,#name)
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal4(f,0)
writecardinal4(f,start)
f:write(name)
end
local stop=f:seek()
local size=stop-start
f:write('\x50\x4b\x05\x06')
writecardinal2(f,0)
writecardinal2(f,0)
writecardinal2(f,count)
writecardinal2(f,count)
writecardinal4(f,size)
writecardinal4(f,start)
if type(comment)=="string" and comment~="" then
writecardinal2(f,#comment)
f:write(comment)
else
writecardinal2(f,0)
end
if verbose then
local compressed=z.compressed
local uncompressed=z.uncompressed
local filename=z.filename
local pct=100*compressed/uncompressed
logwriter("")
if pct>=100 then
logwriter(format("%10i %s",uncompressed,filename))
else
logwriter(format("%10i %02.1f %s",uncompressed,pct,filename))
end
end
f:close()
end
local function zipdir(zipname,path,level,verbose)
if type(zipname)=="table" then
verbose=zipname.verbose
level=zipname.level
path=zipname.path
zipname=zipname.zipname
end
if not zipname or zipname=="" then
return
end
if not path or path=="" then
path="."
end
if not isdir(path) then
return
end
path=gsub(path,"\\+","/")
path=gsub(path,"/+","/")
local list={}
local count=0
globpattern(path,"",true,function(name,size,time)
count=count+1
list[count]={ name,time }
end)
sort(list,function(a,b)
return a[1]<b[1]
end)
local zipf=openzip(zipname,level,comment,verbose)
if zipf then
local p=#path+2
for i=1,count do
local li=list[i]
local name=li[1]
local time=li[2]
local data=loaddata(name)
local name=sub(name,p,#name)
writezip(zipf,name,data,level,time,verbose)
end
closezip(zipf)
end
end
local function unzipdir(zipname,path,verbose)
if type(zipname)=="table" then
verbose=zipname.verbose
path=zipname.path
zipname=zipname.zipname
end
if not zipname or zipname=="" then
return
end
if not path or path=="" then
path="."
end
local z=openzipfile(zipname)
if z then
local list=getziplist(z)
if list then
local total=0
local count=#list
local step=number.idiv(count,10)
local done=0
for i=1,count do
local l=list[i]
local n=l.filename
local d=unzipfile(z,n)
local p=filejoin(path,n)
if mkdirs(dirname(p)) then
if verbose=="steps" then
total=total+#d
done=done+1
if done>=step then
done=0
logwriter(format("%4i files of %4i done, %10i bytes",i,count,total))
end
elseif verbose then
logwriter(n)
end
savedata(p,d)
end
end
if verbose=="steps" then
logwriter(format("%4i files of %4i done, %10i bytes",count,count,total))
end
closezipfile(z)
return true
else
closezipfile(z)
end
end
end
zipfiles.zipdir=zipdir
zipfiles.unzipdir=unzipdir
end end
if flate then
local streams=utilities.streams
local openfile=streams.open
local closestream=streams.close
local setposition=streams.setposition
local getsize=streams.size
local readcardinal4=streams.readcardinal4le
local getstring=streams.getstring
local decompress=flate.gz_decompress
function zipfiles.gunzipfile(filename)
local strm=openfile(filename)
if strm then
setposition(strm,getsize(strm)-4+1)
local size=readcardinal4(strm)
local data=decompress(getstring(strm),size)
closestream(strm)
return data
end
end
elseif gzip then
local openfile=gzip.open
function zipfiles.gunzipfile(filename)
local g=openfile(filename,"rb")
if g then
local d=g:read("*a")
d:close()
return d
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["lxml-tab"] = package.loaded["lxml-tab"] or true
-- original size: 60383, stripped down to: 35698
if not modules then modules={} end modules ['lxml-tab']={
version=1.001,
comment="this module is the basis for the lxml-* ones",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local trace_entities=false trackers.register("xml.entities",function(v) trace_entities=v end)
local report_xml=logs and logs.reporter("xml","core") or function(...) print(string.format(...)) end
if lpeg.setmaxstack then lpeg.setmaxstack(1000) end
xml=xml or {}
local xml=xml
local concat,remove,insert=table.concat,table.remove,table.insert
local type,next,setmetatable,getmetatable,tonumber,rawset,select=type,next,setmetatable,getmetatable,tonumber,rawset,select
local lower,find,match,gsub=string.lower,string.find,string.match,string.gsub
local sort=table.sort
local utfchar=utf.char
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local P,S,R,C,V,C,Cs=lpeg.P,lpeg.S,lpeg.R,lpeg.C,lpeg.V,lpeg.C,lpeg.Cs
local formatters=string.formatters
do
xml.xmlns=xml.xmlns or {}
local check=P(false)
local parse=check
function xml.registerns(namespace,pattern)
check=check+C(P(lower(pattern)))/namespace
parse=P { P(check)+1*V(1) }
end
function xml.checkns(namespace,url)
local ns=lpegmatch(parse,lower(url))
if ns and namespace~=ns then
xml.xmlns[namespace]=ns
end
end
function xml.resolvens(url)
return lpegmatch(parse,lower(url)) or ""
end
end
local nsremap,resolvens=xml.xmlns,xml.resolvens
local stack,level,top,at,xmlnms,errorstr
local entities,parameters
local strip,utfize,resolve,cleanup,resolve_predefined,unify_predefined
local dcache,hcache,acache
local mt,dt,nt
local currentfilename,currentline,linenumbers
local grammar_parsed_text_one
local grammar_parsed_text_two
local grammar_unparsed_text
local handle_hex_entity
local handle_dec_entity
local handle_any_entity_dtd
local handle_any_entity_text
local function preparexmlstate(settings)
if settings then
linenumbers=settings.linenumbers
stack={}
level=0
top={}
at={}
mt={}
dt={}
nt=0
xmlns={}
errorstr=nil
strip=settings.strip_cm_and_dt
utfize=settings.utfize_entities
resolve=settings.resolve_entities
resolve_predefined=settings.resolve_predefined_entities
unify_predefined=settings.unify_predefined_entities
cleanup=settings.text_cleanup
entities=settings.entities or {}
currentfilename=settings.currentresource
currentline=1
parameters={}
reported_at_errors={}
dcache={}
hcache={}
acache={}
if utfize==nil then
settings.utfize_entities=true
utfize=true
end
if resolve_predefined==nil then
settings.resolve_predefined_entities=true
resolve_predefined=true
end
else
linenumbers=false
stack=nil
level=nil
top=nil
at=nil
mt=nil
dt=nil
nt=nil
xmlns=nil
errorstr=nil
strip=nil
utfize=nil
resolve=nil
resolve_predefined=nil
unify_predefined=nil
cleanup=nil
entities=nil
parameters=nil
reported_at_errors=nil
dcache=nil
hcache=nil
acache=nil
currentfilename=nil
currentline=1
end
end
local function initialize_mt(root)
mt={ __index=root }
end
function xml.setproperty(root,k,v)
getmetatable(root).__index[k]=v
end
function xml.checkerror(top,toclose)
return ""
end
local checkns=xml.checkns
local function add_attribute(namespace,tag,value)
if cleanup and value~="" then
value=cleanup(value)
end
if tag=="xmlns" then
xmlns[#xmlns+1]=resolvens(value)
at[tag]=value
elseif namespace=="" then
at[tag]=value
elseif namespace=="xmlns" then
checkns(tag,value)
at["xmlns:"..tag]=value
else
at[namespace..":"..tag]=value
end
end
local function add_empty(spacing,namespace,tag)
if spacing~="" then
nt=nt+1
dt[nt]=spacing
end
local resolved=namespace=="" and xmlns[#xmlns] or nsremap[namespace] or namespace
top=stack[level]
dt=top.dt
nt=#dt+1
local t=linenumbers and {
ns=namespace or "",
rn=resolved,
tg=tag,
at=at,
dt={},
ni=nt,
cf=currentfilename,
cl=currentline,
__p__=top,
} or {
ns=namespace or "",
rn=resolved,
tg=tag,
at=at,
dt={},
ni=nt,
__p__=top,
}
dt[nt]=t
setmetatable(t,mt)
if at.xmlns then
remove(xmlns)
end
at={}
end
local function add_begin(spacing,namespace,tag)
if spacing~="" then
nt=nt+1
dt[nt]=spacing
end
local resolved=namespace=="" and xmlns[#xmlns] or nsremap[namespace] or namespace
dt={}
top=linenumbers and {
ns=namespace or "",
rn=resolved,
tg=tag,
at=at,
dt=dt,
ni=nil,
cf=currentfilename,
cl=currentline,
__p__=stack[level],
} or {
ns=namespace or "",
rn=resolved,
tg=tag,
at=at,
dt=dt,
ni=nil,
__p__=stack[level],
}
setmetatable(top,mt)
nt=0
level=level+1
stack[level]=top
at={}
end
local function add_end(spacing,namespace,tag)
if spacing~="" then
nt=nt+1
dt[nt]=spacing
end
local toclose=stack[level]
level=level-1
top=stack[level]
if level<1 then
errorstr=formatters["unable to close %s %s"](tag,xml.checkerror(top,toclose) or "")
report_xml(errorstr)
elseif toclose.tg~=tag then
errorstr=formatters["unable to close %s with %s %s"](toclose.tg,tag,xml.checkerror(top,toclose) or "")
report_xml(errorstr)
end
dt=top.dt
nt=#dt+1
dt[nt]=toclose
toclose.ni=nt
if toclose.at.xmlns then
remove(xmlns)
end
end
local function add_text(text)
if text=="" then
return
end
if cleanup then
if nt>0 then
local s=dt[nt]
if type(s)=="string" then
dt[nt]=s..cleanup(text)
else
nt=nt+1
dt[nt]=cleanup(text)
end
else
nt=1
dt[1]=cleanup(text)
end
else
if nt>0 then
local s=dt[nt]
if type(s)=="string" then
dt[nt]=s..text
else
nt=nt+1
dt[nt]=text
end
else
nt=1
dt[1]=text
end
end
end
local function add_special(what,spacing,text)
if spacing~="" then
nt=nt+1
dt[nt]=spacing
end
if strip and (what=="@cm@" or what=="@dt@") then
else
nt=nt+1
dt[nt]=linenumbers and {
special=true,
ns="",
tg=what,
ni=nil,
dt={ text },
cf=currentfilename,
cl=currentline,
} or {
special=true,
ns="",
tg=what,
ni=nil,
dt={ text },
}
end
end
local function set_message(txt)
errorstr="garbage at the end of the file: "..gsub(txt,"([ \n\r\t]*)","")
end
local function attribute_value_error(str)
if not reported_at_errors[str] then
report_xml("invalid attribute value %a",str)
reported_at_errors[str]=true
at._error_=str
end
return str
end
local function attribute_specification_error(str)
if not reported_at_errors[str] then
report_xml("invalid attribute specification %a",str)
reported_at_errors[str]=true
at._error_=str
end
return str
end
do
local badentity="&"
xml.placeholders={
unknown_dec_entity=function(str) return str=="" and badentity or formatters["&%s;"](str) end,
unknown_hex_entity=function(str) return formatters["&#x%s;"](str) end,
unknown_any_entity=function(str) return formatters["&#x%s;"](str) end,
}
local function fromhex(s)
local n=tonumber(s,16)
if n then
return utfchar(n)
else
return formatters["h:%s"](s),true
end
end
local function fromdec(s)
local n=tonumber(s)
if n then
return utfchar(n)
else
return formatters["d:%s"](s),true
end
end
local p_rest=(1-P(";"))^0
local p_many=P(1)^0
local parsedentity=P("&#")*(P("x")*(p_rest/fromhex)+(p_rest/fromdec))*P(";")*P(-1)+P ("#")*(P("x")*(p_many/fromhex)+(p_many/fromdec))
xml.parsedentitylpeg=parsedentity
local predefined_unified={
[38]="&",
[42]=""",
[47]="'",
[74]="<",
[76]=">",
}
local predefined_simplified={
[38]="&",amp="&",
[42]='"',quot='"',
[47]="'",apos="'",
[74]="<",lt="<",
[76]=">",gt=">",
}
local nofprivates=0xF0000
local privates_u={
[ [[&]] ]="&",
[ [["]] ]=""",
[ [[']] ]="'",
[ [[<]] ]="<",
[ [[>]] ]=">",
}
local privates_p={
}
local privates_s={
[ [["]] ]="&U+22;",
[ [[#]] ]="&U+23;",
[ [[$]] ]="&U+24;",
[ [[%]] ]="&U+25;",
[ [[&]] ]="&U+26;",
[ [[']] ]="&U+27;",
[ [[<]] ]="&U+3C;",
[ [[>]] ]="&U+3E;",
[ [[\]] ]="&U+5C;",
[ [[{]] ]="&U+7B;",
[ [[|]] ]="&U+7C;",
[ [[}]] ]="&U+7D;",
[ [[~]] ]="&U+7E;",
}
local privates_x={
[ [["]] ]="&U+22;",
[ [[#]] ]="&U+23;",
[ [[$]] ]="&U+24;",
[ [[%]] ]="&U+25;",
[ [[']] ]="&U+27;",
[ [[\]] ]="&U+5C;",
[ [[{]] ]="&U+7B;",
[ [[|]] ]="&U+7C;",
[ [[}]] ]="&U+7D;",
[ [[~]] ]="&U+7E;",
}
local privates_n={
}
local escaped=utf.remapper(privates_u,"dynamic")
local unprivatized=utf.remapper(privates_p,"dynamic")
local unspecialized=utf.remapper(privates_s,"dynamic")
local despecialized=utf.remapper(privates_x,"dynamic")
xml.unprivatized=unprivatized
xml.unspecialized=unspecialized
xml.despecialized=despecialized
xml.escaped=escaped
local function unescaped(s)
local p=privates_n[s]
if not p then
nofprivates=nofprivates+1
p=utfchar(nofprivates)
privates_n[s]=p
s="&"..s..";"
privates_u[p]=s
privates_p[p]=s
privates_s[p]=s
end
return p
end
xml.privatetoken=unescaped
xml.privatecodes=privates_n
xml.specialcodes=privates_s
function xml.addspecialcode(key,value)
privates_s[key]=value or "&"..s..";"
end
handle_hex_entity=function(str)
local h=hcache[str]
if not h then
local n=tonumber(str,16)
h=unify_predefined and predefined_unified[n]
if h then
if trace_entities then
report_xml("utfize, converting hex entity &#x%s; into %a",str,h)
end
elseif utfize then
h=(n and utfchar(n)) or xml.unknown_hex_entity(str) or ""
if not n then
report_xml("utfize, ignoring hex entity &#x%s;",str)
elseif trace_entities then
report_xml("utfize, converting hex entity &#x%s; into %a",str,h)
end
else
if trace_entities then
report_xml("found entity &#x%s;",str)
end
h="&#x"..str..";"
end
hcache[str]=h
end
return h
end
handle_dec_entity=function(str)
local d=dcache[str]
if not d then
local n=tonumber(str)
d=unify_predefined and predefined_unified[n]
if d then
if trace_entities then
report_xml("utfize, converting dec entity &#%s; into %a",str,d)
end
elseif utfize then
d=(n and utfchar(n)) or placeholders.unknown_dec_entity(str) or ""
if not n then
report_xml("utfize, ignoring dec entity &#%s;",str)
elseif trace_entities then
report_xml("utfize, converting dec entity &#%s; into %a",str,d)
end
else
if trace_entities then
report_xml("found entity &#%s;",str)
end
d="&#"..str..";"
end
dcache[str]=d
end
return d
end
handle_any_entity_dtd=function(str)
if resolve then
local a=resolve_predefined and predefined_simplified[str]
if a then
if trace_entities then
report_xml("resolving entity &%s; to predefined %a",str,a)
end
else
if type(resolve)=="function" then
a=resolve(str,entities) or entities[str]
else
a=entities[str]
end
if a then
if type(a)=="function" then
if trace_entities then
report_xml("expanding entity &%s; to function call",str)
end
a=a(str) or ""
end
a=lpegmatch(parsedentity,a) or a
if trace_entities then
report_xml("resolving entity &%s; to internal %a",str,a)
end
else
local unknown_any_entity=placeholders.unknown_any_entity
if unknown_any_entity then
a=unknown_any_entity(str) or ""
end
if a then
if trace_entities then
report_xml("resolving entity &%s; to external %s",str,a)
end
else
if trace_entities then
report_xml("keeping entity &%s;",str)
end
if str=="" then
a=badentity
else
a="&"..str..";"
end
end
end
end
return a
else
local a=acache[str]
if not a then
a=resolve_predefined and predefined_simplified[str]
if a then
acache[str]=a
if trace_entities then
report_xml("entity &%s; becomes %a",str,a)
end
elseif str=="" then
if trace_entities then
report_xml("invalid entity &%s;",str)
end
a=badentity
acache[str]=a
else
if trace_entities then
report_xml("entity &%s; is made private",str)
end
a=unescaped(str)
acache[str]=a
end
end
return a
end
end
handle_any_entity_text=function(str)
if resolve then
local a=resolve_predefined and predefined_simplified[str]
if a then
if trace_entities then
report_xml("resolving entity &%s; to predefined %a",str,a)
end
else
if type(resolve)=="function" then
a=resolve(str,entities) or entities[str]
else
a=entities[str]
end
if a then
if type(a)=="function" then
if trace_entities then
report_xml("expanding entity &%s; to function call",str)
end
a=a(str) or ""
end
a=lpegmatch(grammar_parsed_text_two,a) or a
if type(a)=="number" then
return ""
else
a=lpegmatch(parsedentity,a) or a
if trace_entities then
report_xml("resolving entity &%s; to internal %a",str,a)
end
end
if trace_entities then
report_xml("resolving entity &%s; to internal %a",str,a)
end
else
local unknown_any_entity=placeholders.unknown_any_entity
if unknown_any_entity then
a=unknown_any_entity(str) or ""
end
if a then
if trace_entities then
report_xml("resolving entity &%s; to external %s",str,a)
end
else
if trace_entities then
report_xml("keeping entity &%s;",str)
end
if str=="" then
a=badentity
else
a="&"..str..";"
end
end
end
end
return a
else
local a=acache[str]
if not a then
a=resolve_predefined and predefined_simplified[str]
if a then
acache[str]=a
if trace_entities then
report_xml("entity &%s; becomes %a",str,a)
end
elseif str=="" then
if trace_entities then
report_xml("invalid entity &%s;",str)
end
a=badentity
acache[str]=a
else
if trace_entities then
report_xml("entity &%s; is made private",str)
end
a=unescaped(str)
acache[str]=a
end
end
return a
end
end
local p_rest=(1-P(";"))^1
local spec={
[0x23]="\\Ux{23}",
[0x24]="\\Ux{24}",
[0x25]="\\Ux{25}",
[0x5C]="\\Ux{5C}",
[0x7B]="\\Ux{7B}",
[0x7C]="\\Ux{7C}",
[0x7D]="\\Ux{7D}",
[0x7E]="\\Ux{7E}",
}
local hash=table.setmetatableindex(spec,function(t,k)
local v=utfchar(k)
t[k]=v
return v
end)
local function fromuni(s)
local n=tonumber(s,16)
if n then
return hash[n]
else
return formatters["u:%s"](s),true
end
end
local function fromhex(s)
local n=tonumber(s,16)
if n then
return hash[n]
else
return formatters["h:%s"](s),true
end
end
local function fromdec(s)
local n=tonumber(s)
if n then
return hash[n]
else
return formatters["d:%s"](s),true
end
end
local reparsedentity=P("U+")*(p_rest/fromuni)+P("#")*(
P("x")*(p_rest/fromhex)+p_rest/fromdec
)
local hash=table.setmetatableindex(function(t,k)
local v=utfchar(k)
t[k]=v
return v
end)
local function fromuni(s)
local n=tonumber(s,16)
if n then
return hash[n]
else
return formatters["u:%s"](s),true
end
end
local function fromhex(s)
local n=tonumber(s,16)
if n then
return hash[n]
else
return formatters["h:%s"](s),true
end
end
local function fromdec(s)
local n=tonumber(s)
if n then
return hash[n]
else
return formatters["d:%s"](s),true
end
end
local unescapedentity=P("U+")*(p_rest/fromuni)+P("#")*(
P("x")*(p_rest/fromhex)+p_rest/fromdec
)
xml.reparsedentitylpeg=reparsedentity
xml.unescapedentitylpeg=unescapedentity
end
local escaped=xml.escaped
local unescaped=xml.unescaped
local placeholders=xml.placeholders
local function handle_end_entity(str)
report_xml("error in entity, %a found without ending %a",str,";")
return str
end
local function handle_crap_error(chr)
report_xml("error in parsing, unexpected %a found ",chr)
add_text(chr)
return chr
end
local function handlenewline()
currentline=currentline+1
end
local spacetab=S(' \t')
local space=S(' \r\n\t')
local newline=lpegpatterns.newline/handlenewline
local anything=P(1)
local open=P('<')
local close=P('>')
local squote=S("'")
local dquote=S('"')
local equal=P('=')
local slash=P('/')
local colon=P(':')
local semicolon=P(';')
local ampersand=P('&')
local valid=R('az','AZ','09')+S('_-.')
local name_yes=C(valid^1)*colon*C(valid^1)
local name_nop=C(P(true))*C(valid^1)
local name=name_yes+name_nop
local utfbom=lpegpatterns.utfbom
local spacing=C(space^0)
local space_nl=spacetab+newline
local spacing_nl=Cs((space_nl)^0)
local anything_nl=newline+P(1)
local function weirdentity(k,v)
if trace_entities then
report_xml("registering %s entity %a as %a","weird",k,v)
end
parameters[k]=v
end
local function normalentity(k,v)
if trace_entities then
report_xml("registering %s entity %a as %a","normal",k,v)
end
entities[k]=v
end
local function systementity(k,v,n)
if trace_entities then
report_xml("registering %s entity %a as %a","system",k,v)
end
entities[k]=v
end
local function publicentity(k,v,n)
if trace_entities then
report_xml("registering %s entity %a as %a","public",k,v)
end
entities[k]=v
end
local function entityfile(pattern,k,v,n)
if n then
local okay,data
if resolvers then
okay,data=resolvers.loadbinfile(n)
else
data=io.loaddata(n)
okay=data and data~=""
end
if okay then
if trace_entities then
report_xml("loading public entities %a as %a from %a",k,v,n)
end
lpegmatch(pattern,data)
return
end
end
report_xml("ignoring public entities %a as %a from %a",k,v,n)
end
local function install(spacenewline,spacing,anything)
local anyentitycontent=(1-open-semicolon-space-close-ampersand)^0
local hexentitycontent=R("AF","af","09")^1
local decentitycontent=R("09")^1
local parsedentity=P("#")/""*(
P("x")/""*(hexentitycontent/handle_hex_entity)+(decentitycontent/handle_dec_entity)
)+(anyentitycontent/handle_any_entity_dtd)
local parsedentity_text=P("#")/""*(
P("x")/""*(hexentitycontent/handle_hex_entity)+(decentitycontent/handle_dec_entity)
)+(anyentitycontent/handle_any_entity_text)
local entity=(ampersand/"")*parsedentity*(semicolon/"")+ampersand*(anyentitycontent/handle_end_entity)
local entity_text=(ampersand/"")*parsedentity_text*(semicolon/"")+ampersand*(anyentitycontent/handle_end_entity)
local text_unparsed=Cs((anything-open)^1)
local text_parsed=(Cs((anything-open-ampersand)^1)/add_text+Cs(entity_text)/add_text)^1
local somespace=(spacenewline)^1
local optionalspace=(spacenewline)^0
local value=(squote*Cs((entity+(anything-squote))^0)*squote)+(dquote*Cs((entity+(anything-dquote))^0)*dquote)
local endofattributes=slash*close+close
local whatever=space*name*optionalspace*equal
local wrongvalue=Cs(P(entity+(1-space-endofattributes))^1)/attribute_value_error
local attributevalue=value+wrongvalue
local attribute=(somespace*name*optionalspace*equal*optionalspace*attributevalue)/add_attribute
local attributes=(attribute+somespace^-1*(((anything-endofattributes)^1)/attribute_specification_error))^0
local parsedtext=text_parsed
local unparsedtext=text_unparsed/add_text
local balanced=P { "["*((anything-S"[]")+V(1))^0*"]" }
local emptyelement=(spacing*open*name*attributes*optionalspace*slash*close)/add_empty
local beginelement=(spacing*open*name*attributes*optionalspace*close)/add_begin
local endelement=(spacing*open*slash*name*optionalspace*close)/add_end
local begincomment=open*P("!--")
local endcomment=P("--")*close
local begininstruction=open*P("?")
local endinstruction=P("?")*close
local begincdata=open*P("![CDATA[")
local endcdata=P("]]")*close
local someinstruction=C((anything-endinstruction)^0)
local somecomment=C((anything-endcomment )^0)
local somecdata=C((anything-endcdata )^0)
local begindoctype=open*P("!DOCTYPE")
local enddoctype=close
local beginset=P("[")
local endset=P("]")
local wrdtypename=C((anything-somespace-P(";"))^1)
local doctypename=C((anything-somespace-close)^0)
local elementdoctype=optionalspace*P("<!ELEMENT")*(anything-close)^0*close
local basiccomment=begincomment*((anything-endcomment)^0)*endcomment
local weirdentitytype=P("%")*(somespace*doctypename*somespace*value)/weirdentity
local normalentitytype=(doctypename*somespace*value)/normalentity
local publicentitytype=(doctypename*somespace*P("PUBLIC")*somespace*value)/publicentity
local systementitytype=(doctypename*somespace*P("SYSTEM")*somespace*value*somespace*P("NDATA")*somespace*doctypename)/systementity
local entitydoctype=optionalspace*P("<!ENTITY")*somespace*(systementitytype+publicentitytype+normalentitytype+weirdentitytype)*optionalspace*close
local publicentityfile=(doctypename*somespace*P("PUBLIC")*somespace*value*(somespace*value)^0)/function(...)
entityfile(entitydoctype,...)
end
local function weirdresolve(s)
lpegmatch(entitydoctype,parameters[s])
end
local function normalresolve(s)
lpegmatch(entitydoctype,entities[s])
end
local entityresolve=P("%")*(wrdtypename/weirdresolve )*P(";")+P("&")*(wrdtypename/normalresolve)*P(";")
entitydoctype=entitydoctype+entityresolve
local doctypeset=beginset*optionalspace*P(elementdoctype+entitydoctype+entityresolve+basiccomment+space)^0*optionalspace*endset
local definitiondoctype=doctypename*somespace*doctypeset
local publicdoctype=doctypename*somespace*P("PUBLIC")*somespace*value*somespace*value*somespace*doctypeset
local systemdoctype=doctypename*somespace*P("SYSTEM")*somespace*value*somespace*doctypeset
local simpledoctype=(anything-close)^1
local somedoctype=C((somespace*(
publicentityfile+publicdoctype+systemdoctype+definitiondoctype+simpledoctype)*optionalspace)^0)
local instruction=(spacing*begininstruction*someinstruction*endinstruction)/function(...) add_special("@pi@",...) end
local comment=(spacing*begincomment*somecomment*endcomment )/function(...) add_special("@cm@",...) end
local cdata=(spacing*begincdata*somecdata*endcdata )/function(...) add_special("@cd@",...) end
local doctype=(spacing*begindoctype*somedoctype*enddoctype )/function(...) add_special("@dt@",...) end
local crap_parsed=anything-beginelement-endelement-emptyelement-begininstruction-begincomment-begincdata-ampersand
local crap_unparsed=anything-beginelement-endelement-emptyelement-begininstruction-begincomment-begincdata
local parsedcrap=Cs((crap_parsed^1+entity_text)^1)/handle_crap_error
local parsedcrap=Cs((crap_parsed^1+entity_text)^1)/handle_crap_error
local unparsedcrap=Cs((crap_unparsed )^1)/handle_crap_error
local trailer=space^0*(text_unparsed/set_message)^0
local grammar_parsed_text_one=P { "preamble",
preamble=utfbom^0*instruction^0*(doctype+comment+instruction)^0,
}
local grammar_parsed_text_two=P { "followup",
followup=V("parent")*trailer,
parent=beginelement*V("children")^0*endelement,
children=parsedtext+V("parent")+emptyelement+comment+cdata+instruction+parsedcrap,
}
local grammar_unparsed_text=P { "preamble",
preamble=utfbom^0*instruction^0*(doctype+comment+instruction)^0*V("parent")*trailer,
parent=beginelement*V("children")^0*endelement,
children=unparsedtext+V("parent")+emptyelement+comment+cdata+instruction+unparsedcrap,
}
return grammar_parsed_text_one,grammar_parsed_text_two,grammar_unparsed_text
end
grammar_parsed_text_one_nop,
grammar_parsed_text_two_nop,
grammar_unparsed_text_nop=install(space,spacing,anything)
grammar_parsed_text_one_yes,
grammar_parsed_text_two_yes,
grammar_unparsed_text_yes=install(space_nl,spacing_nl,anything_nl)
local function _xmlconvert_(data,settings,detail)
settings=settings or {}
preparexmlstate(settings)
if settings.linenumbers then
grammar_parsed_text_one=grammar_parsed_text_one_yes
grammar_parsed_text_two=grammar_parsed_text_two_yes
grammar_unparsed_text=grammar_unparsed_text_yes
else
grammar_parsed_text_one=grammar_parsed_text_one_nop
grammar_parsed_text_two=grammar_parsed_text_two_nop
grammar_unparsed_text=grammar_unparsed_text_nop
end
local preprocessor=settings.preprocessor
if data and data~="" and type(preprocessor)=="function" then
data=preprocessor(data,settings) or data
end
if settings.parent_root then
mt=getmetatable(settings.parent_root)
else
initialize_mt(top)
end
level=level+1
stack[level]=top
top.dt={}
dt=top.dt
nt=0
if not data or data=="" then
errorstr="empty xml file"
elseif data==true then
errorstr=detail or "problematic xml file"
elseif utfize or resolve then
local m=lpegmatch(grammar_parsed_text_one,data)
if m then
m=lpegmatch(grammar_parsed_text_two,data,m)
end
if m then
else
errorstr="invalid xml file - parsed text"
end
elseif type(data)=="string" then
if lpegmatch(grammar_unparsed_text,data) then
errorstr=""
else
errorstr="invalid xml file - unparsed text"
end
else
errorstr="invalid xml file - no text at all"
end
local result
if errorstr and errorstr~="" then
result={ dt={ { ns="",tg="error",dt={ errorstr },at={},er=true } } }
setmetatable(result,mt)
setmetatable(result.dt[1],mt)
setmetatable(stack,mt)
local errorhandler=settings.error_handler
if errorhandler==false then
else
errorhandler=errorhandler or xml.errorhandler
if errorhandler then
local currentresource=settings.currentresource
if currentresource and currentresource~="" then
xml.errorhandler(formatters["load error in [%s]: %s"](currentresource,errorstr),currentresource)
else
xml.errorhandler(formatters["load error: %s"](errorstr))
end
end
end
else
result=stack[1]
end
if not settings.no_root then
result={ special=true,ns="",tg='@rt@',dt=result.dt,at={},entities=entities,settings=settings }
setmetatable(result,mt)
local rdt=result.dt
for k=1,#rdt do
local v=rdt[k]
if type(v)=="table" and not v.special then
result.ri=k
v.__p__=result
break
end
end
end
if errorstr and errorstr~="" then
result.error=true
else
errorstr=nil
end
result.statistics={
errormessage=errorstr,
entities={
decimals=dcache,
hexadecimals=hcache,
names=acache,
intermediates=parameters,
}
}
preparexmlstate()
return result
end
local function xmlconvert(data,settings)
local ok,result=pcall(function() return _xmlconvert_(data,settings) end)
if ok then
return result
elseif type(result)=="string" then
return _xmlconvert_(true,settings,result)
else
return _xmlconvert_(true,settings)
end
end
xml.convert=xmlconvert
function xml.inheritedconvert(data,xmldata)
local settings=xmldata.settings
if settings then
settings.parent_root=xmldata
end
local xc=xmlconvert(data,settings)
return xc
end
function xml.is_valid(root)
return root and root.dt and root.dt[1] and type(root.dt[1])=="table" and not root.dt[1].er
end
function xml.package(tag,attributes,data)
local ns,tg=match(tag,"^(.-):?([^:]+)$")
local t={ ns=ns,tg=tg,dt=data or "",at=attributes or {} }
setmetatable(t,mt)
return t
end
function xml.is_valid(root)
return root and not root.error
end
xml.errorhandler=report_xml
function xml.load(filename,settings)
local data=""
if type(filename)=="string" then
local f=io.open(filename,'r')
if f then
data=f:read("*all")
f:close()
end
elseif filename then
data=filename:read("*all")
end
if settings then
settings.currentresource=filename
local result=xmlconvert(data,settings)
settings.currentresource=nil
return result
else
return xmlconvert(data,{ currentresource=filename })
end
end
local no_root={ no_root=true }
function xml.toxml(data)
if type(data)=="string" then
local root={ xmlconvert(data,no_root) }
return (#root>1 and root) or root[1]
else
return data
end
end
local function copy(old,p)
if old then
local new={}
for k,v in next,old do
local t=type(v)=="table"
if k=="at" then
local t={}
for k,v in next,v do
t[k]=v
end
new[k]=t
elseif k=="dt" then
v.__p__=nil
v=copy(v,new)
new[k]=v
v.__p__=p
else
new[k]=v
end
end
local mt=getmetatable(old)
if mt then
setmetatable(new,mt)
end
return new
else
return {}
end
end
xml.copy=copy
function xml.checkbom(root)
if root.ri then
local dt=root.dt
for k=1,#dt do
local v=dt[k]
if type(v)=="table" and v.special and v.tg=="@pi@" and find(v.dt[1],"xml.*version=") then
return
end
end
insert(dt,1,{ special=true,ns="",tg="@pi@",dt={ "xml version='1.0' standalone='yes'" } } )
insert(dt,2,"\n" )
end
end
local f_attribute=formatters['%s=%q']
local function verbose_element(e,handlers,escape)
local handle=handlers.handle
local serialize=handlers.serialize
local ens,etg,eat,edt,ern=e.ns,e.tg,e.at,e.dt,e.rn
local ats=eat and next(eat) and {}
if ats then
local n=0
for k in next,eat do
n=n+1
ats[n]=k
end
if n==1 then
local k=ats[1]
ats=f_attribute(k,escaped(eat[k]))
else
sort(ats)
for i=1,n do
local k=ats[i]
ats[i]=f_attribute(k,escaped(eat[k]))
end
ats=concat(ats," ")
end
end
if ern and trace_entities and ern~=ens then
ens=ern
end
local n=edt and #edt
if ens~="" then
if n and n>0 then
if ats then
handle("<",ens,":",etg," ",ats,">")
else
handle("<",ens,":",etg,">")
end
for i=1,n do
local e=edt[i]
if type(e)=="string" then
handle(escaped(e))
else
serialize(e,handlers)
end
end
handle("</",ens,":",etg,">")
else
if ats then
handle("<",ens,":",etg," ",ats,"/>")
else
handle("<",ens,":",etg,"/>")
end
end
else
if n and n>0 then
if ats then
handle("<",etg," ",ats,">")
else
handle("<",etg,">")
end
for i=1,n do
local e=edt[i]
if type(e)=="string" then
handle(escaped(e))
else
serialize(e,handlers)
end
end
handle("</",etg,">")
else
if ats then
handle("<",etg," ",ats,"/>")
else
handle("<",etg,"/>")
end
end
end
end
local function verbose_pi(e,handlers)
handlers.handle("<?",e.dt[1],"?>")
end
local function verbose_comment(e,handlers)
handlers.handle("<!--",e.dt[1],"-->")
end
local function verbose_cdata(e,handlers)
handlers.handle("<![CDATA[",e.dt[1],"]]>")
end
local function verbose_doctype(e,handlers)
handlers.handle("<!DOCTYPE",e.dt[1],">")
end
local function verbose_root(e,handlers)
handlers.serialize(e.dt,handlers)
end
local function verbose_text(e,handlers)
handlers.handle(escaped(e))
end
local function verbose_document(e,handlers)
local serialize=handlers.serialize
local functions=handlers.functions
for i=1,#e do
local ei=e[i]
if type(ei)=="string" then
functions["@tx@"](ei,handlers)
else
serialize(ei,handlers)
end
end
end
local function serialize(e,handlers,...)
if e then
local initialize=handlers.initialize
local finalize=handlers.finalize
local functions=handlers.functions
if initialize then
local state=initialize(...)
if not state==true then
return state
end
end
local etg=e.tg
if etg then
(functions[etg] or functions["@el@"])(e,handlers)
else
functions["@dc@"](e,handlers)
end
if finalize then
return finalize()
end
end
end
local function xserialize(e,handlers)
if e then
local functions=handlers.functions
local etg=e.tg
if etg then
(functions[etg] or functions["@el@"])(e,handlers)
else
functions["@dc@"](e,handlers)
end
end
end
local handlers={}
local function newhandlers(settings)
local t=table.copy(handlers[settings and settings.parent or "verbose"] or {})
if settings then
for k,v in next,settings do
if type(v)=="table" then
local tk=t[k] if not tk then tk={} t[k]=tk end
for kk,vv in next,v do
tk[kk]=vv
end
else
t[k]=v
end
end
if settings.name then
handlers[settings.name]=t
end
end
utilities.storage.mark(t)
return t
end
local nofunction=function() end
function xml.sethandlersfunction(handler,name,fnc)
handler.functions[name]=fnc or nofunction
end
function xml.gethandlersfunction(handler,name)
return handler.functions[name]
end
function xml.gethandlers(name)
return handlers[name]
end
newhandlers {
name="verbose",
initialize=false,
finalize=false,
serialize=xserialize,
handle=print,
functions={
["@dc@"]=verbose_document,
["@dt@"]=verbose_doctype,
["@rt@"]=verbose_root,
["@el@"]=verbose_element,
["@pi@"]=verbose_pi,
["@cm@"]=verbose_comment,
["@cd@"]=verbose_cdata,
["@tx@"]=verbose_text,
}
}
local result
local xmlfilehandler=newhandlers {
name="file",
initialize=function(name)
result=io.open(name,"wb")
return result
end,
finalize=function()
result:close()
return true
end,
handle=function(...)
result:write(...)
end,
}
function xml.save(root,name)
serialize(root,xmlfilehandler,name)
end
local result,r,threshold={},0,512
local xmlstringhandler=newhandlers {
name="string",
initialize=function()
r=0
return result
end,
finalize=function()
local done=concat(result,"",1,r)
r=0
if r>threshold then
result={}
end
return done
end,
handle=function(...)
for i=1,select("#",...) do
r=r+1
result[r]=select(i,...)
end
end,
}
local function xmltostring(root)
if not root then
return ""
elseif type(root)=="string" then
return root
else
return serialize(root,xmlstringhandler) or ""
end
end
local function __tostring(root)
return (root and xmltostring(root)) or ""
end
initialize_mt=function(root)
mt={ __tostring=__tostring,__index=root }
end
xml.defaulthandlers=handlers
xml.newhandlers=newhandlers
xml.serialize=serialize
xml.tostring=xmltostring
local function xmlstring(e,handle)
if not handle or (e.special and e.tg~="@rt@") then
elseif e.tg then
local edt=e.dt
if edt then
for i=1,#edt do
xmlstring(edt[i],handle)
end
end
else
handle(e)
end
end
xml.string=xmlstring
function xml.settings(e)
while e do
local s=e.settings
if s then
return s
else
e=e.__p__
end
end
return nil
end
function xml.root(e)
local r=e
while e do
e=e.__p__
if e then
r=e
end
end
return r
end
function xml.parent(root)
return root.__p__
end
function xml.body(root)
return root.ri and root.dt[root.ri] or root
end
function xml.name(root)
if not root then
return ""
end
local ns=root.ns
local tg=root.tg
if ns=="" then
return tg
else
return ns..":"..tg
end
end
function xml.erase(dt,k)
if dt then
if k then
dt[k]=""
else for k=1,#dt do
dt[1]={ "" }
end end
end
end
function xml.assign(dt,k,root)
if dt and k then
dt[k]=type(root)=="table" and xml.body(root) or root
return dt[k]
else
return xml.body(root)
end
end
function xml.tocdata(e,wrapper)
local whatever=type(e)=="table" and xmltostring(e.dt) or e or ""
if wrapper then
whatever=formatters["<%s>%s</%s>"](wrapper,whatever,wrapper)
end
local t={ special=true,ns="",tg="@cd@",at={},rn="",dt={ whatever },__p__=e }
setmetatable(t,getmetatable(e))
e.dt={ t }
end
function xml.makestandalone(root)
if root.ri then
local dt=root.dt
for k=1,#dt do
local v=dt[k]
if type(v)=="table" and v.special and v.tg=="@pi@" then
local txt=v.dt[1]
if find(txt,"xml.*version=") then
v.dt[1]=txt.." standalone='yes'"
break
end
end
end
end
return root
end
function xml.kind(e)
local dt=e and e.dt
if dt then
local n=#dt
if n==1 then
local d=dt[1]
if d.special then
local tg=d.tg
if tg=="@cd@" then
return "cdata"
elseif tg=="@cm" then
return "comment"
elseif tg=="@pi@" then
return "instruction"
elseif tg=="@dt@" then
return "declaration"
end
elseif type(d)=="string" then
return "text"
end
return "element"
elseif n>0 then
return "mixed"
end
end
return "empty"
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["lxml-lpt"] = package.loaded["lxml-lpt"] or true
-- original size: 55145, stripped down to: 30992
if not modules then modules={} end modules ['lxml-lpt']={
version=1.001,
comment="this module is the basis for the lxml-* ones",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local concat,remove,insert=table.concat,table.remove,table.insert
local type,next,tonumber,tostring,setmetatable,load,select=type,next,tonumber,tostring,setmetatable,load,select
local format,upper,lower,gmatch,gsub,find,rep=string.format,string.upper,string.lower,string.gmatch,string.gsub,string.find,string.rep
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local setmetatableindex=table.setmetatableindex
local formatters=string.formatters
local trace_lpath=false
local trace_lparse=false
local trace_lprofile=false
local report_lpath=logs.reporter("xml","lpath")
if trackers then
trackers.register("xml.path",function(v)
trace_lpath=v
end)
trackers.register("xml.parse",function(v)
trace_lparse=v
end)
trackers.register("xml.profile",function(v)
trace_lpath=v
trace_lparse=v
trace_lprofile=v
end)
end
local xml=xml
local lpathcalls=0 function xml.lpathcalls () return lpathcalls end
local lpathcached=0 function xml.lpathcached() return lpathcached end
xml.functions=xml.functions or {}
local functions=xml.functions
xml.expressions=xml.expressions or {}
local expressions=xml.expressions
xml.finalizers=xml.finalizers or {}
local finalizers=xml.finalizers
xml.specialhandler=xml.specialhandler or {}
local specialhandler=xml.specialhandler
lpegpatterns.xml=lpegpatterns.xml or {}
local xmlpatterns=lpegpatterns.xml
finalizers.xml=finalizers.xml or {}
finalizers.tex=finalizers.tex or {}
local function fallback (t,name)
local fn=finalizers[name]
if fn then
t[name]=fn
else
report_lpath("unknown sub finalizer %a",name)
fn=function() end
end
return fn
end
setmetatableindex(finalizers.xml,fallback)
setmetatableindex(finalizers.tex,fallback)
xml.defaultprotocol="xml"
local apply_axis={}
apply_axis['root']=function(list)
local collected={}
for l=1,#list do
local ll=list[l]
local rt=ll
while ll do
ll=ll.__p__
if ll then
rt=ll
end
end
collected[l]=rt
end
return collected
end
apply_axis['self']=function(list)
return list
end
apply_axis['child']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
local dt=ll.dt
if dt then
local n=#dt
if n==0 then
ll.en=0
elseif n==1 then
local dk=dt[1]
if dk.tg then
c=c+1
collected[c]=dk
dk.ni=1
dk.ei=1
ll.en=1
end
else
local en=0
for k=1,#dt do
local dk=dt[k]
if dk.tg then
c=c+1
en=en+1
collected[c]=dk
dk.ni=k
dk.ei=en
end
end
ll.en=en
end
end
end
return collected
end
local function collect(list,collected,c)
local dt=list.dt
if dt then
local n=#dt
if n==0 then
list.en=0
elseif n==1 then
local dk=dt[1]
if dk.tg then
c=c+1
collected[c]=dk
dk.ni=1
dk.ei=1
c=collect(dk,collected,c)
list.en=1
else
list.en=0
end
else
local en=0
for k=1,n do
local dk=dt[k]
if dk.tg then
c=c+1
en=en+1
collected[c]=dk
dk.ni=k
dk.ei=en
c=collect(dk,collected,c)
end
end
list.en=en
end
end
return c
end
apply_axis['descendant']=function(list)
local collected={}
local c=0
for l=1,#list do
c=collect(list[l],collected,c)
end
return collected
end
local function collect(list,collected,c)
local dt=list.dt
if dt then
local n=#dt
if n==0 then
list.en=0
elseif n==1 then
local dk=dt[1]
if dk.tg then
c=c+1
collected[c]=dk
dk.ni=1
dk.ei=1
c=collect(dk,collected,c)
list.en=1
end
else
local en=0
for k=1,#dt do
local dk=dt[k]
if dk.tg then
c=c+1
en=en+1
collected[c]=dk
dk.ni=k
dk.ei=en
c=collect(dk,collected,c)
end
end
list.en=en
end
end
return c
end
apply_axis['descendant-or-self']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
if ll.special~=true then
c=c+1
collected[c]=ll
end
c=collect(ll,collected,c)
end
return collected
end
apply_axis['ancestor']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
while ll do
ll=ll.__p__
if ll then
c=c+1
collected[c]=ll
end
end
end
return collected
end
apply_axis['ancestor-or-self']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
c=c+1
collected[c]=ll
while ll do
ll=ll.__p__
if ll then
c=c+1
collected[c]=ll
end
end
end
return collected
end
apply_axis['parent']=function(list)
local collected={}
local c=0
for l=1,#list do
local pl=list[l].__p__
if pl then
c=c+1
collected[c]=pl
end
end
return collected
end
apply_axis['attribute']=function(list)
return {}
end
apply_axis['namespace']=function(list)
return {}
end
apply_axis['following']=function(list)
return {}
end
apply_axis['preceding']=function(list)
return {}
end
apply_axis['following-sibling']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
local p=ll.__p__
local d=p.dt
for i=ll.ni+1,#d do
local di=d[i]
if type(di)=="table" then
c=c+1
collected[c]=di
end
end
end
return collected
end
apply_axis['preceding-sibling']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
local p=ll.__p__
local d=p.dt
for i=1,ll.ni-1 do
local di=d[i]
if type(di)=="table" then
c=c+1
collected[c]=di
end
end
end
return collected
end
apply_axis['reverse-sibling']=function(list)
local collected={}
local c=0
for l=1,#list do
local ll=list[l]
local p=ll.__p__
local d=p.dt
for i=ll.ni-1,1,-1 do
local di=d[i]
if type(di)=="table" then
c=c+1
collected[c]=di
end
end
end
return collected
end
apply_axis['auto-descendant-or-self']=apply_axis['descendant-or-self']
apply_axis['auto-descendant']=apply_axis['descendant']
apply_axis['auto-child']=apply_axis['child']
apply_axis['auto-self']=apply_axis['self']
apply_axis['initial-child']=apply_axis['child']
local function apply_nodes(list,directive,nodes)
local maxn=#nodes
if maxn==3 then
local nns=nodes[2]
local ntg=nodes[3]
if not nns and not ntg then
if directive then
return list
else
return {}
end
else
local collected={}
local c=0
local m=0
local p=nil
if not nns then
for l=1,#list do
local ll=list[l]
local ltg=ll.tg
if ltg then
if directive then
if ntg==ltg then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
elseif ntg~=ltg then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
end
end
elseif not ntg then
for l=1,#list do
local ll=list[l]
local lns=ll.rn or ll.ns
if lns then
if directive then
if lns==nns then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
elseif lns~=nns then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
end
end
else
for l=1,#list do
local ll=list[l]
local ltg=ll.tg
if ltg then
local lns=ll.rn or ll.ns
local ok=ltg==ntg and lns==nns
if directive then
if ok then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
elseif not ok then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
end
end
end
return collected
end
else
local collected={}
local c=0
local m=0
local p=nil
for l=1,#list do
local ll=list[l]
local ltg=ll.tg
if ltg then
local lns=ll.rn or ll.ns
local ok=false
for n=1,maxn,3 do
local nns=nodes[n+1]
local ntg=nodes[n+2]
ok=(not ntg or ltg==ntg) and (not nns or lns==nns)
if ok then
break
end
end
if directive then
if ok then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
elseif not ok then
local llp=ll.__p__;if llp~=p then p=llp;m=1 else m=m+1 end
c=c+1
collected[c]=ll
ll.mi=m
end
end
end
return collected
end
end
local quit_expression=false
local function apply_expression(list,expression,order)
local collected={}
local c=0
quit_expression=false
for l=1,#list do
local ll=list[l]
if expression(list,ll,l,order) then
c=c+1
collected[c]=ll
end
if quit_expression then
break
end
end
return collected
end
local function apply_selector(list,specification)
if xml.applyselector then
apply_selector=xml.applyselector
return apply_selector(list,specification)
else
return list
end
end
local P,V,C,Cs,Cc,Ct,R,S,Cg,Cb=lpeg.P,lpeg.V,lpeg.C,lpeg.Cs,lpeg.Cc,lpeg.Ct,lpeg.R,lpeg.S,lpeg.Cg,lpeg.Cb
local spaces=S(" \n\r\t\f")^0
local lp_space=S(" \n\r\t\f")
local lp_any=P(1)
local lp_noequal=P("!=")/"~="+P("<=")+P(">=")+P("==")
local lp_doequal=P("=")/"=="
local lp_or=P("|")/" or "
local lp_and=P("&")/" and "
local builtin={
text="(ll.dt[1] or '')",
content="ll.dt",
name="((ll.ns~='' and ll.ns..':'..ll.tg) or ll.tg)",
tag="ll.tg",
position="l",
firstindex="1",
firstelement="1",
first="1",
lastindex="(#ll.__p__.dt or 1)",
lastelement="(ll.__p__.en or 1)",
last="#list",
rootposition="order",
order="order",
element="(ll.ei or 1)",
index="(ll.ni or 1)",
match="(ll.mi or 1)",
namespace="ll.ns",
ns="ll.ns",
}
local lp_builtin=lpeg.utfchartabletopattern(builtin)/builtin*((spaces*P("(")*spaces*P(")"))/"")
local lp_attribute=(P("@")+P("attribute::"))/""*Cc("(ll.at and ll.at['")*((R("az","AZ")+S("-_:"))^1)*Cc("'])")
local lp_fastpos_p=P("+")^0*R("09")^1*P(-1)/"l==%0"
local lp_fastpos_n=P("-")*R("09")^1*P(-1)/"(%0<0 and (#list+%0==l))"
local lp_fastpos=lp_fastpos_n+lp_fastpos_p
local lp_reserved=C("and")+C("or")+C("not")+C("div")+C("mod")+C("true")+C("false")
local lp_lua_function=Cs((R("az","AZ","__")^1*(P(".")*R("az","AZ","__")^1)^1)*("("))/"%0"
local lp_function=C(R("az","AZ","__")^1)*P("(")/function(t)
if expressions[t] then
return "expr."..t.."("
else
return "expr.error("
end
end
local lparent=P("(")
local rparent=P(")")
local noparent=1-(lparent+rparent)
local nested=P{lparent*(noparent+V(1))^0*rparent}
local value=P(lparent*C((noparent+nested)^0)*rparent)
local lp_child=Cc("expr.child(ll,'")*R("az","AZ")*R("az","AZ","--","__")^0*Cc("')")
local lp_number=S("+-")*R("09")^1
local lp_string=Cc("'")*R("az","AZ","--","__")^1*Cc("'")
local lp_content=(P("'")*(1-P("'"))^0*P("'")+P('"')*(1-P('"'))^0*P('"'))
local cleaner
local lp_special=(C(P("name")+P("text")+P("tag")+P("count")+P("child")))*value/function(t,s)
if expressions[t] then
s=s and s~="" and lpegmatch(cleaner,s)
if s and s~="" then
return "expr."..t.."(ll,"..s..")"
else
return "expr."..t.."(ll)"
end
else
return "expr.error("..t..")"
end
end
local content=lp_builtin+lp_attribute+lp_special+lp_noequal+lp_doequal+lp_or+lp_and+lp_reserved+lp_lua_function+lp_function+lp_content+
lp_child+lp_any
local converter=Cs (
lp_fastpos+(P { lparent*(V(1))^0*rparent+content } )^0
)
cleaner=Cs ((
lp_reserved+lp_number+lp_string+1 )^1 )
local template_e=[[
local expr = xml.expressions
return function(list,ll,l,order)
return %s
end
]]
local template_f_y=[[
local finalizer = xml.finalizers['%s']['%s']
return function(collection)
return finalizer(collection,%s)
end
]]
local template_f_n=[[
return xml.finalizers['%s']['%s']
]]
local register_last_match={ kind="axis",axis="last-match" }
local register_self={ kind="axis",axis="self" }
local register_parent={ kind="axis",axis="parent" }
local register_descendant={ kind="axis",axis="descendant" }
local register_child={ kind="axis",axis="child" }
local register_descendant_or_self={ kind="axis",axis="descendant-or-self" }
local register_root={ kind="axis",axis="root" }
local register_ancestor={ kind="axis",axis="ancestor" }
local register_ancestor_or_self={ kind="axis",axis="ancestor-or-self" }
local register_attribute={ kind="axis",axis="attribute" }
local register_namespace={ kind="axis",axis="namespace" }
local register_following={ kind="axis",axis="following" }
local register_following_sibling={ kind="axis",axis="following-sibling" }
local register_preceding={ kind="axis",axis="preceding" }
local register_preceding_sibling={ kind="axis",axis="preceding-sibling" }
local register_reverse_sibling={ kind="axis",axis="reverse-sibling" }
local register_auto_descendant_or_self={ kind="axis",axis="auto-descendant-or-self" }
local register_auto_descendant={ kind="axis",axis="auto-descendant" }
local register_auto_self={ kind="axis",axis="auto-self" }
local register_auto_child={ kind="axis",axis="auto-child" }
local register_initial_child={ kind="axis",axis="initial-child" }
local register_all_nodes={ kind="nodes",nodetest=true,nodes={ true,false,false } }
local skip={}
local function errorrunner_e(str,cnv)
if not skip[str] then
report_lpath("error in expression: %s => %s",str,cnv)
skip[str]=cnv or str
end
return false
end
local function errorrunner_f(str,arg)
report_lpath("error in finalizer: %s(%s)",str,arg or "")
return false
end
local function register_nodes(nodetest,nodes)
return { kind="nodes",nodetest=nodetest,nodes=nodes }
end
local function register_selector(specification)
return { kind="selector",specification=specification }
end
local function register_expression(expression)
local converted=lpegmatch(converter,expression)
local runner=load(format(template_e,converted))
runner=(runner and runner()) or function() errorrunner_e(expression,converted) end
return { kind="expression",expression=expression,converted=converted,evaluator=runner }
end
local function register_finalizer(protocol,name,arguments)
local runner
if arguments and arguments~="" then
runner=load(format(template_f_y,protocol or xml.defaultprotocol,name,arguments))
else
runner=load(format(template_f_n,protocol or xml.defaultprotocol,name))
end
runner=(runner and runner()) or function() errorrunner_f(name,arguments) end
return { kind="finalizer",name=name,arguments=arguments,finalizer=runner }
end
local expression=P { "ex",
ex="["*C((V("sq")+V("dq")+(1-S("[]"))+V("ex"))^0)*"]",
sq="'"*(1-S("'"))^0*"'",
dq='"'*(1-S('"'))^0*'"',
}
local arguments=P { "ar",
ar="("*Cs((V("sq")+V("dq")+V("nq")+P(1-P(")")))^0)*")",
nq=((1-S("),'\""))^1)/function(s) return format("%q",s) end,
sq=P("'")*(1-P("'"))^0*P("'"),
dq=P('"')*(1-P('"'))^0*P('"'),
}
local function register_error(str)
return { kind="error",error=format("unparsed: %s",str) }
end
local special_1=P("*")*Cc(register_auto_descendant)*Cc(register_all_nodes)
local special_2=P("/")*Cc(register_auto_self)
local special_3=P("")*Cc(register_auto_self)
local no_nextcolon=P(-1)+#(1-P(":"))
local no_nextlparent=P(-1)+#(1-P("("))
local pathparser=Ct { "patterns",
patterns=spaces*V("protocol")*spaces*(
(V("special")*spaces*P(-1) )+(V("initial")*spaces*V("step")*spaces*(P("/")*spaces*V("step")*spaces)^0 )
),
protocol=Cg(V("letters"),"protocol")*P("://")+Cg(Cc(nil),"protocol"),
step=((V("shortcuts")+V("selector")+P("/")+V("axis"))*spaces*V("nodes")^0+V("error"))*spaces*V("expressions")^0*spaces*V("finalizer")^0,
axis=V("last_match")+V("descendant")+V("child")+V("parent")+V("self")+V("root")+V("ancestor")+V("descendant_or_self")+V("following_sibling")+V("following")+V("reverse_sibling")+V("preceding_sibling")+V("preceding")+V("ancestor_or_self")+#(1-P(-1))*Cc(register_auto_child),
special=special_1+special_2+special_3,
initial=(P("/")*spaces*Cc(register_initial_child))^-1,
error=(P(1)^1)/register_error,
shortcuts_a=V("s_descendant_or_self")+V("s_descendant")+V("s_child")+V("s_parent")+V("s_self")+V("s_root")+V("s_ancestor")+V("s_lastmatch"),
shortcuts=V("shortcuts_a")*(spaces*"/"*spaces*V("shortcuts_a"))^0,
s_descendant_or_self=(P("***/")+P("/"))*Cc(register_descendant_or_self),
s_descendant=P("**")*Cc(register_descendant),
s_child=P("*")*no_nextcolon*Cc(register_child),
s_parent=P("..")*Cc(register_parent),
s_self=P("." )*Cc(register_self),
s_root=P("^^")*Cc(register_root),
s_ancestor=P("^")*Cc(register_ancestor),
s_lastmatch=P("=")*Cc(register_last_match),
descendant=P("descendant::")*Cc(register_descendant),
child=P("child::")*Cc(register_child),
parent=P("parent::")*Cc(register_parent),
self=P("self::")*Cc(register_self),
root=P('root::')*Cc(register_root),
ancestor=P('ancestor::')*Cc(register_ancestor),
descendant_or_self=P('descendant-or-self::')*Cc(register_descendant_or_self),
ancestor_or_self=P('ancestor-or-self::')*Cc(register_ancestor_or_self),
following=P('following::')*Cc(register_following),
following_sibling=P('following-sibling::')*Cc(register_following_sibling),
preceding=P('preceding::')*Cc(register_preceding),
preceding_sibling=P('preceding-sibling::')*Cc(register_preceding_sibling),
reverse_sibling=P('reverse-sibling::')*Cc(register_reverse_sibling),
last_match=P('last-match::')*Cc(register_last_match),
selector=P("{")*C((1-P("}"))^1)*P("}")/register_selector,
nodes=(V("nodefunction")*spaces*P("(")*V("nodeset")*P(")")+V("nodetest")*V("nodeset"))/register_nodes,
expressions=expression/register_expression,
letters=R("az")^1,
name=(1-S("/[]()|:*!"))^1,
negate=P("!")*Cc(false),
nodefunction=V("negate")+P("not")*Cc(false)+Cc(true),
nodetest=V("negate")+Cc(true),
nodename=(V("negate")+Cc(true))*spaces*((V("wildnodename")*P(":")*V("wildnodename"))+(Cc(false)*V("wildnodename"))),
wildnodename=(C(V("name"))+P("*")*Cc(false))*no_nextlparent,
nodeset=spaces*Ct(V("nodename")*(spaces*P("|")*spaces*V("nodename"))^0)*spaces,
finalizer=(Cb("protocol")*P("/")^-1*C(V("name"))*arguments*P(-1))/register_finalizer,
}
xmlpatterns.pathparser=pathparser
local cache={}
local function nodesettostring(set,nodetest)
local t={}
for i=1,#set,3 do
local directive,ns,tg=set[i],set[i+1],set[i+2]
if not ns or ns=="" then ns="*" end
if not tg or tg=="" then tg="*" end
tg=(tg=="@rt@" and "[root]") or format("%s:%s",ns,tg)
t[#t+1]=(directive and tg) or format("not(%s)",tg)
end
if nodetest==false then
return format("not(%s)",concat(t,"|"))
else
return concat(t,"|")
end
end
local function tagstostring(list)
if #list==0 then
return "no elements"
else
local t={}
for i=1,#list do
local li=list[i]
local ns=li.ns
local tg=li.tg
if not ns or ns=="" then ns="*" end
if not tg or tg=="" then tg="*" end
t[i]=(tg=="@rt@" and "[root]") or format("%s:%s",ns,tg)
end
return concat(t," ")
end
end
xml.nodesettostring=nodesettostring
local lpath
local function lshow(parsed)
if type(parsed)=="string" then
parsed=lpath(parsed)
end
report_lpath("%s://%s => %s",parsed.protocol or xml.defaultprotocol,parsed.pattern,
table.serialize(parsed,false))
end
xml.lshow=lshow
local function add_comment(p,str)
local pc=p.comment
if not pc then
p.comment={ str }
else
pc[#pc+1]=str
end
end
lpath=function (pattern)
lpathcalls=lpathcalls+1
if type(pattern)=="table" then
return pattern
else
local parsed=cache[pattern]
if parsed then
lpathcached=lpathcached+1
else
parsed=lpegmatch(pathparser,pattern)
if parsed then
parsed.pattern=pattern
local np=#parsed
if np==0 then
parsed={ pattern=pattern,register_self,state="parsing error" }
report_lpath("parsing error in pattern: %s",pattern)
lshow(parsed)
else
local pi=parsed[1]
if pi.axis=="auto-child" then
if false then
add_comment(parsed,"auto-child replaced by auto-descendant-or-self")
parsed[1]=register_auto_descendant_or_self
else
add_comment(parsed,"auto-child replaced by auto-descendant")
parsed[1]=register_auto_descendant
end
elseif pi.axis=="initial-child" and np>1 and parsed[2].axis then
add_comment(parsed,"initial-child removed")
remove(parsed,1)
end
local np=#parsed
if np>1 then
local pnp=parsed[np]
if pnp.kind=="nodes" and pnp.nodetest==true then
local nodes=pnp.nodes
if nodes[1]==true and nodes[2]==false and nodes[3]==false then
add_comment(parsed,"redundant final wildcard filter removed")
remove(parsed,np)
end
end
end
end
else
parsed={ pattern=pattern }
end
cache[pattern]=parsed
if trace_lparse and not trace_lprofile then
lshow(parsed)
end
end
return parsed
end
end
xml.lpath=lpath
do
local profiled={}
xml.profiled=profiled
local lastmatch=nil
local keepmatch=nil
if directives then
directives.register("xml.path.keeplastmatch",function(v)
keepmatch=v
lastmatch=nil
end)
end
apply_axis["last-match"]=function()
return lastmatch or {}
end
local function profiled_apply(list,parsed,nofparsed,order)
local p=profiled[parsed.pattern]
if p then
p.tested=p.tested+1
else
p={ tested=1,matched=0,finalized=0 }
profiled[parsed.pattern]=p
end
local collected=list
for i=1,nofparsed do
local pi=parsed[i]
local kind=pi.kind
if kind=="axis" then
collected=apply_axis[pi.axis](collected)
elseif kind=="nodes" then
collected=apply_nodes(collected,pi.nodetest,pi.nodes)
elseif kind=="expression" then
collected=apply_expression(collected,pi.evaluator,order)
elseif kind=="selector" then
collected=apply_selector(collected,pi.specification)
elseif kind=="finalizer" then
collected=pi.finalizer(collected)
p.matched=p.matched+1
p.finalized=p.finalized+1
return collected
end
if not collected or #collected==0 then
local pn=i<nofparsed and parsed[nofparsed]
if pn and pn.kind=="finalizer" then
collected=pn.finalizer(collected)
p.finalized=p.finalized+1
return collected
end
return nil
end
end
if collected then
p.matched=p.matched+1
end
return collected
end
local function traced_apply(list,parsed,nofparsed,order)
if trace_lparse then
lshow(parsed)
end
report_lpath("collecting: %s",parsed.pattern)
report_lpath("root tags : %s",tagstostring(list))
report_lpath("order : %s",order or "unset")
local collected=list
for i=1,nofparsed do
local pi=parsed[i]
local kind=pi.kind
if kind=="axis" then
collected=apply_axis[pi.axis](collected)
report_lpath("% 10i : ax : %s",(collected and #collected) or 0,pi.axis)
elseif kind=="nodes" then
collected=apply_nodes(collected,pi.nodetest,pi.nodes)
report_lpath("% 10i : ns : %s",(collected and #collected) or 0,nodesettostring(pi.nodes,pi.nodetest))
elseif kind=="expression" then
collected=apply_expression(collected,pi.evaluator,order)
report_lpath("% 10i : ex : %s -> %s",(collected and #collected) or 0,pi.expression,pi.converted)
elseif kind=="selector" then
collected=apply_selector(collected,pi.specification)
report_lpath("% 10i : se : %s ",(collected and #collected) or 0,pi.specification)
elseif kind=="finalizer" then
collected=pi.finalizer(collected)
report_lpath("% 10i : fi : %s : %s(%s)",(type(collected)=="table" and #collected) or 0,parsed.protocol or xml.defaultprotocol,pi.name,pi.arguments or "")
return collected
end
if not collected or #collected==0 then
local pn=i<nofparsed and parsed[nofparsed]
if pn and pn.kind=="finalizer" then
collected=pn.finalizer(collected)
report_lpath("% 10i : fi : %s : %s(%s)",(type(collected)=="table" and #collected) or 0,parsed.protocol or xml.defaultprotocol,pn.name,pn.arguments or "")
return collected
end
return nil
end
end
return collected
end
local function normal_apply(list,parsed,nofparsed,order)
local collected=list
for i=1,nofparsed do
local pi=parsed[i]
local kind=pi.kind
if kind=="axis" then
local axis=pi.axis
if axis~="self" then
collected=apply_axis[axis](collected)
end
elseif kind=="nodes" then
collected=apply_nodes(collected,pi.nodetest,pi.nodes)
elseif kind=="expression" then
collected=apply_expression(collected,pi.evaluator,order)
elseif kind=="selector" then
collected=apply_selector(collected,pi.specification)
elseif kind=="finalizer" then
return pi.finalizer(collected)
end
if not collected or #collected==0 then
local pf=i<nofparsed and parsed[nofparsed].finalizer
if pf then
return pf(collected)
end
return nil
end
end
return collected
end
local apply=normal_apply
if trackers then
trackers.register("xml.path,xml.parse,xml.profile",function()
if trace_lprofile then
apply=profiled_apply
elseif trace_lpath then
apply=traced_apply
else
apply=normal_apply
end
end)
end
function xml.applylpath(list,pattern)
if not list then
lastmatch=nil
return
end
local parsed=cache[pattern]
if parsed then
lpathcalls=lpathcalls+1
lpathcached=lpathcached+1
elseif type(pattern)=="table" then
lpathcalls=lpathcalls+1
parsed=pattern
else
parsed=lpath(pattern) or pattern
end
if not parsed then
lastmatch=nil
return
end
local nofparsed=#parsed
if nofparsed==0 then
lastmatch=nil
return
end
local collected=apply({ list },parsed,nofparsed,list.mi)
lastmatch=keepmatch and collected or nil
return collected
end
function xml.lastmatch()
return lastmatch
end
local stack={}
function xml.pushmatch()
insert(stack,lastmatch)
end
function xml.popmatch()
lastmatch=remove(stack)
end
end
local applylpath=xml.applylpath
function xml.filter(root,pattern)
return applylpath(root,pattern)
end
expressions.child=function(e,pattern)
return applylpath(e,pattern)
end
expressions.count=function(e,pattern)
local collected=applylpath(e,pattern)
return pattern and (collected and #collected) or 0
end
expressions.oneof=function(s,...)
for i=1,select("#",...) do
if s==select(i,...) then
return true
end
end
return false
end
expressions.error=function(str)
xml.errorhandler(format("unknown function in lpath expression: %s",tostring(str or "?")))
return false
end
expressions.undefined=function(s)
return s==nil
end
expressions.quit=function(s)
if s or s==nil then
quit_expression=true
end
return true
end
expressions.print=function(...)
print(...)
return true
end
expressions.find=find
expressions.upper=upper
expressions.lower=lower
expressions.number=tonumber
expressions.boolean=toboolean
function expressions.contains(str,pattern)
local t=type(str)
if t=="string" then
if find(str,pattern) then
return true
end
elseif t=="table" then
for i=1,#str do
local d=str[i]
if type(d)=="string" and find(d,pattern) then
return true
end
end
end
return false
end
function xml.expressions.idstring(str)
return type(str)=="string" and gsub(str,"^#","") or ""
end
local function traverse(root,pattern,handle)
local collected=applylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
local r=e.__p__
handle(r,r.dt,e.ni)
end
end
end
local function selection(root,pattern,handle)
local collected=applylpath(root,pattern)
if collected then
if handle then
for c=1,#collected do
handle(collected[c])
end
else
return collected
end
end
end
xml.traverse=traverse
xml.selection=selection
local function dofunction(collected,fnc,...)
if collected then
local f=functions[fnc]
if f then
for c=1,#collected do
f(collected[c],...)
end
else
report_lpath("unknown function %a",fnc)
end
end
end
finalizers.xml["function"]=dofunction
finalizers.tex["function"]=dofunction
expressions.text=function(e,n)
local rdt=e.__p__.dt
return rdt and rdt[n] or ""
end
expressions.name=function(e,n)
local found=false
n=tonumber(n) or 0
if n==0 then
found=type(e)=="table" and e
elseif n<0 then
local d=e.__p__.dt
local k=e.ni
for i=k-1,1,-1 do
local di=d[i]
if type(di)=="table" then
if n==-1 then
found=di
break
else
n=n+1
end
end
end
else
local d=e.__p__.dt
local k=e.ni
for i=k+1,#d,1 do
local di=d[i]
if type(di)=="table" then
if n==1 then
found=di
break
else
n=n-1
end
end
end
end
if found then
local ns=found.rn or found.ns or ""
local tg=found.tg
if ns~="" then
return ns..":"..tg
else
return tg
end
else
return ""
end
end
expressions.tag=function(e,n)
if not e then
return ""
else
local found=false
n=tonumber(n) or 0
if n==0 then
found=(type(e)=="table") and e
elseif n<0 then
local d=e.__p__.dt
local k=e.ni
for i=k-1,1,-1 do
local di=d[i]
if type(di)=="table" then
if n==-1 then
found=di
break
else
n=n+1
end
end
end
else
local d=e.__p__.dt
local k=e.ni
for i=k+1,#d,1 do
local di=d[i]
if type(di)=="table" then
if n==1 then
found=di
break
else
n=n-1
end
end
end
end
return (found and found.tg) or ""
end
end
local dummy=function() end
function xml.elements(root,pattern,reverse)
local collected=applylpath(root,pattern)
if not collected then
return dummy
end
local n=#collected
if n==0 then
return dummy
end
if reverse then
local c=n+1
return function()
if c>1 then
c=c-1
local e=collected[c]
local r=e.__p__
return r,r.dt,e.ni
end
end
else
local c=0
return function()
if c<n then
c=c+1
local e=collected[c]
local r=e.__p__
return r,r.dt,e.ni
end
end
end
end
function xml.collected(root,pattern,reverse)
local collected=applylpath(root,pattern)
if not collected then
return dummy
end
local n=#collected
if n==0 then
return dummy
end
if reverse then
local c=n+1
return function()
if c>1 then
c=c-1
return collected[c]
end
end
else
local c=0
return function()
if c<n then
c=c+1
return collected[c]
end
end
end
end
function xml.inspect(collection,pattern)
pattern=pattern or "."
for e in xml.collected(collection,pattern or ".") do
report_lpath("pattern: %s\n\n%s\n",pattern,xml.tostring(e))
end
end
local function split(e)
local dt=e.dt
if dt then
for i=1,#dt do
local dti=dt[i]
if type(dti)=="string" then
dti=gsub(dti,"^[\n\r]*(.-)[\n\r]*","%1")
dti=gsub(dti,"[\n\r]+","\n\n")
dt[i]=dti
else
split(dti)
end
end
end
return e
end
function xml.finalizers.paragraphs(c)
for i=1,#c do
split(c[i])
end
return c
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["lxml-mis"] = package.loaded["lxml-mis"] or true
-- original size: 3574, stripped down to: 1808
if not modules then modules={} end modules ['lxml-mis']={
version=1.001,
comment="this module is the basis for the lxml-* ones",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local xml,lpeg,string=xml,lpeg,string
local type=type
local concat=table.concat
local format,gsub,match=string.format,string.gsub,string.match
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local P,S,R,C,V,Cc,Cs=lpeg.P,lpeg.S,lpeg.R,lpeg.C,lpeg.V,lpeg.Cc,lpeg.Cs
lpegpatterns.xml=lpegpatterns.xml or {}
local xmlpatterns=lpegpatterns.xml
local function xmlgsub(t,old,new)
local dt=t.dt
if dt then
for k=1,#dt do
local v=dt[k]
if type(v)=="string" then
dt[k]=gsub(v,old,new)
else
xmlgsub(v,old,new)
end
end
end
end
function xml.stripleadingspaces(dk,d,k)
if d and k then
local dkm=d[k-1]
if dkm and type(dkm)=="string" then
local s=match(dkm,"\n(%s+)")
xmlgsub(dk,"\n"..rep(" ",#s),"\n")
end
end
end
local normal=(1-S("<&>"))^0
local special=P("<")/"<"+P(">")/">"+P("&")/"&"
local escaped=Cs(normal*(special*normal)^0)
local normal=(1-S"&")^0
local special=P("<")/"<"+P(">")/">"+P("&")/"&"
local unescaped=Cs(normal*(special*normal)^0)
local cleansed=Cs(((P("<")*(1-P(">"))^0*P(">"))/""+1)^0)
xmlpatterns.escaped=escaped
xmlpatterns.unescaped=unescaped
xmlpatterns.cleansed=cleansed
function xml.escaped (str) return lpegmatch(escaped,str) end
function xml.unescaped(str) return lpegmatch(unescaped,str) end
function xml.cleansed (str) return lpegmatch(cleansed,str) end
function xml.fillin(root,pattern,str,check)
local e=xml.first(root,pattern)
if e then
local n=#e.dt
if not check or n==0 or (n==1 and e.dt[1]=="") then
e.dt={ str }
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["lxml-aux"] = package.loaded["lxml-aux"] or true
-- original size: 30771, stripped down to: 19680
if not modules then modules={} end modules ['lxml-aux']={
version=1.001,
comment="this module is the basis for the lxml-* ones",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local trace_manipulations=false trackers.register("lxml.manipulations",function(v) trace_manipulations=v end)
local trace_inclusions=false trackers.register("lxml.inclusions",function(v) trace_inclusions=v end)
local report_xml=logs.reporter("xml")
local xml=xml
local xmlcopy,xmlname=xml.copy,xml.name
local xmlinheritedconvert=xml.inheritedconvert
local xmlapplylpath=xml.applylpath
local type,next,setmetatable,getmetatable=type,next,setmetatable,getmetatable
local insert,remove,fastcopy,concat=table.insert,table.remove,table.fastcopy,table.concat
local gmatch,gsub,format,find,strip=string.gmatch,string.gsub,string.format,string.find,string.strip
local utfbyte=utf.byte
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local striplinepatterns=utilities.strings.striplinepatterns
local function report(what,pattern,c,e)
report_xml("%s element %a, root %a, position %a, index %a, pattern %a",what,xmlname(e),xmlname(e.__p__),c,e.ni,pattern)
end
local function withelements(e,handle,depth)
if e and handle then
local edt=e.dt
if edt then
depth=depth or 0
for i=1,#edt do
local e=edt[i]
if type(e)=="table" then
handle(e,depth)
withelements(e,handle,depth+1)
end
end
end
end
end
xml.withelements=withelements
function xml.withelement(e,n,handle)
if e and n~=0 and handle then
local edt=e.dt
if edt then
if n>0 then
for i=1,#edt do
local ei=edt[i]
if type(ei)=="table" then
if n==1 then
handle(ei)
return
else
n=n-1
end
end
end
elseif n<0 then
for i=#edt,1,-1 do
local ei=edt[i]
if type(ei)=="table" then
if n==-1 then
handle(ei)
return
else
n=n+1
end
end
end
end
end
end
end
function xml.each(root,pattern,handle,reverse)
local collected=xmlapplylpath(root,pattern)
if collected then
if handle then
if reverse then
for c=#collected,1,-1 do
handle(collected[c])
end
else
for c=1,#collected do
handle(collected[c])
end
end
end
return collected
end
end
function xml.processattributes(root,pattern,handle)
local collected=xmlapplylpath(root,pattern)
if collected and handle then
for c=1,#collected do
handle(collected[c].at)
end
end
return collected
end
function xml.collect(root,pattern)
return xmlapplylpath(root,pattern)
end
function xml.collecttexts(root,pattern,flatten)
local collected=xmlapplylpath(root,pattern)
if collected and flatten then
local xmltostring=xml.tostring
for c=1,#collected do
collected[c]=xmltostring(collected[c].dt)
end
end
return collected or {}
end
function xml.collect_tags(root,pattern,nonamespace)
local collected=xmlapplylpath(root,pattern)
if collected then
local t={}
local n=0
for c=1,#collected do
local e=collected[c]
local ns=e.ns
local tg=e.tg
n=n+1
if nonamespace then
t[n]=tg
elseif ns=="" then
t[n]=tg
else
t[n]=ns..":"..tg
end
end
return t
end
end
local no_root={ no_root=true }
local function redo_ni(d)
for k=1,#d do
local dk=d[k]
if type(dk)=="table" then
dk.ni=k
end
end
end
xml.reindex=redo_ni
local function xmltoelement(whatever,root)
if not whatever then
return nil
end
local element
if type(whatever)=="string" then
element=xmlinheritedconvert(whatever,root)
else
element=whatever
end
if element.error then
return whatever
end
if element then
end
return element
end
xml.toelement=xmltoelement
local function copiedelement(element,newparent)
if type(element)=="string" then
return element
else
element=xmlcopy(element).dt
if newparent and type(element)=="table" then
element.__p__=newparent
end
return element
end
end
function xml.delete(root,pattern)
if not pattern or pattern=="" then
local p=root.__p__
if p then
if trace_manipulations then
report('deleting',"--",c,root)
end
local d=p.dt
remove(d,root.ni)
redo_ni(d)
end
else
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
local p=e.__p__
if p then
if trace_manipulations then
report('deleting',pattern,c,e)
end
local d=p.dt
local ni=e.ni
if ni<=#d then
if false then
p.dt[ni]=""
else
remove(d,ni)
redo_ni(d)
end
else
end
end
end
end
end
end
function xml.replace(root,pattern,whatever)
local element=root and xmltoelement(whatever,root)
local collected=element and xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
local p=e.__p__
if p then
if trace_manipulations then
report('replacing',pattern,c,e)
end
local d=p.dt
local n=e.ni
local t=copiedelement(element,p)
if type(t)=="table" then
d[n]=t[1]
for i=2,#t do
n=n+1
insert(d,n,t[i])
end
else
d[n]=t
end
redo_ni(d)
end
end
end
end
local function wrap(e,wrapper)
local t={
rn=e.rn,
tg=e.tg,
ns=e.ns,
at=e.at,
dt=e.dt,
__p__=e,
}
setmetatable(t,getmetatable(e))
e.rn=wrapper.rn or e.rn or ""
e.tg=wrapper.tg or e.tg or ""
e.ns=wrapper.ns or e.ns or ""
e.at=fastcopy(wrapper.at)
e.dt={ t }
end
function xml.wrap(root,pattern,whatever)
if whatever then
local wrapper=xmltoelement(whatever,root)
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
if trace_manipulations then
report('wrapping',pattern,c,e)
end
wrap(e,wrapper)
end
end
else
wrap(root,xmltoelement(pattern))
end
end
local function inject_element(root,pattern,whatever,prepend)
local element=root and xmltoelement(whatever,root)
local collected=element and xmlapplylpath(root,pattern)
local function inject_e(e)
local r=e.__p__
local d=r.dt
local k=e.ni
local rri=r.ri
local edt=(rri and d[rri].dt) or (d and d[k] and d[k].dt)
if edt then
local be,af
local cp=copiedelement(element,e)
if prepend then
be,af=cp,edt
else
be,af=edt,cp
end
local bn=#be
for i=1,#af do
bn=bn+1
be[bn]=af[i]
end
if rri then
r.dt[rri].dt=be
else
d[k].dt=be
end
redo_ni(d)
end
end
if not collected then
elseif collected.tg then
inject_e(collected)
else
for c=1,#collected do
inject_e(collected[c])
end
end
end
local function insert_element(root,pattern,whatever,before)
local element=root and xmltoelement(whatever,root)
local collected=element and xmlapplylpath(root,pattern)
local function insert_e(e)
local r=e.__p__
local d=r.dt
local k=e.ni
if not before then
k=k+1
end
insert(d,k,copiedelement(element,r))
redo_ni(d)
end
if not collected then
elseif collected.tg then
insert_e(collected)
else
for c=1,#collected do
insert_e(collected[c])
end
end
end
xml.insert_element=insert_element
xml.insertafter=insert_element
xml.insertbefore=function(r,p,e) insert_element(r,p,e,true) end
xml.injectafter=inject_element
xml.injectbefore=function(r,p,e) inject_element(r,p,e,true) end
local function include(xmldata,pattern,attribute,recursive,loaddata,level)
pattern=pattern or 'include'
loaddata=loaddata or io.loaddata
local collected=xmlapplylpath(xmldata,pattern)
if collected then
if not level then
level=1
end
for c=1,#collected do
local ek=collected[c]
local name=nil
local ekdt=ek.dt
if ekdt then
local ekat=ek.at
local ekrt=ek.__p__
if ekrt then
local epdt=ekrt.dt
if not attribute or attribute=="" then
name=(type(ekdt)=="table" and ekdt[1]) or ekdt
end
if not name then
for a in gmatch(attribute or "href","([^|]+)") do
name=ekat[a]
if name then
break
end
end
end
local data=nil
if name and name~="" then
local d,n=loaddata(name)
data=d or ""
name=n or name
if trace_inclusions then
report_xml("including %s bytes from %a at level %s by pattern %a and attribute %a (%srecursing)",#data,name,level,pattern,attribute or "",recursive and "" or "not ")
end
end
if not data or data=="" then
epdt[ek.ni]=""
elseif ekat["parse"]=="text" then
epdt[ek.ni]=xml.escaped(data)
else
local settings=xmldata.settings
local savedresource=settings.currentresource
settings.currentresource=name
local xi=xmlinheritedconvert(data,xmldata)
if not xi then
epdt[ek.ni]=""
else
if recursive then
include(xi,pattern,attribute,recursive,loaddata,level+1)
end
local child=xml.body(xi)
child.__p__=ekrt
child.__f__=name
child.cf=name
epdt[ek.ni]=child
local settings=xmldata.settings
local inclusions=settings and settings.inclusions
if inclusions then
inclusions[#inclusions+1]=name
elseif settings then
settings.inclusions={ name }
else
settings={ inclusions={ name } }
xmldata.settings=settings
end
if child.er then
local badinclusions=settings.badinclusions
if badinclusions then
badinclusions[#badinclusions+1]=name
else
settings.badinclusions={ name }
end
end
end
settings.currentresource=savedresource
end
end
end
end
end
end
xml.include=include
function xml.inclusion(e,default)
while e do
local f=e.__f__
if f then
return f
else
e=e.__p__
end
end
return default
end
local function getinclusions(key,e,sorted)
while e do
local settings=e.settings
if settings then
local inclusions=settings[key]
if inclusions then
inclusions=table.unique(inclusions)
if sorted then
table.sort(inclusions)
end
return inclusions
else
e=e.__p__
end
else
e=e.__p__
end
end
end
function xml.inclusions(e,sorted)
return getinclusions("inclusions",e,sorted)
end
function xml.badinclusions(e,sorted)
return getinclusions("badinclusions",e,sorted)
end
local b_collapser=lpegpatterns.b_collapser
local m_collapser=lpegpatterns.m_collapser
local e_collapser=lpegpatterns.e_collapser
local b_stripper=lpegpatterns.b_stripper
local m_stripper=lpegpatterns.m_stripper
local e_stripper=lpegpatterns.e_stripper
local function stripelement(e,nolines,anywhere)
local edt=e.dt
if edt then
local n=#edt
if n==0 then
return e
elseif anywhere then
local t={}
local m=0
for e=1,n do
local str=edt[e]
if type(str)~="string" then
m=m+1
t[m]=str
elseif str~="" then
if nolines then
str=lpegmatch((n==1 and b_collapser) or (n==m and e_collapser) or m_collapser,str)
else
str=lpegmatch((n==1 and b_stripper) or (n==m and e_stripper) or m_stripper,str)
end
if str~="" then
m=m+1
t[m]=str
end
end
end
e.dt=t
else
local str=edt[1]
if type(str)=="string" then
if str~="" then
str=lpegmatch(nolines and b_collapser or b_stripper,str)
end
if str=="" then
remove(edt,1)
n=n-1
else
edt[1]=str
end
end
if n>0 then
str=edt[n]
if type(str)=="string" then
if str=="" then
remove(edt)
else
str=lpegmatch(nolines and e_collapser or e_stripper,str)
if str=="" then
remove(edt)
else
edt[n]=str
end
end
end
end
end
end
return e
end
xml.stripelement=stripelement
function xml.strip(root,pattern,nolines,anywhere)
local collected=xmlapplylpath(root,pattern)
if collected then
for i=1,#collected do
stripelement(collected[i],nolines,anywhere)
end
end
end
local function renamespace(root,oldspace,newspace)
local ndt=#root.dt
for i=1,ndt or 0 do
local e=root[i]
if type(e)=="table" then
if e.ns==oldspace then
e.ns=newspace
if e.rn then
e.rn=newspace
end
end
local edt=e.dt
if edt then
renamespace(edt,oldspace,newspace)
end
end
end
end
xml.renamespace=renamespace
function xml.remaptag(root,pattern,newtg)
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
collected[c].tg=newtg
end
end
end
function xml.remapnamespace(root,pattern,newns)
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
collected[c].ns=newns
end
end
end
function xml.checknamespace(root,pattern,newns)
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
if (not e.rn or e.rn=="") and e.ns=="" then
e.rn=newns
end
end
end
end
function xml.remapname(root,pattern,newtg,newns,newrn)
local collected=xmlapplylpath(root,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
e.tg,e.ns,e.rn=newtg,newns,newrn
end
end
end
function xml.cdatatotext(e)
local dt=e.dt
if #dt==1 then
local first=dt[1]
if first.tg=="@cd@" then
e.dt=first.dt
end
else
end
end
function xml.texttocdata(e)
local dt=e.dt
local s=xml.tostring(dt)
e.tg="@cd@"
e.special=true
e.ns=""
e.rn=""
e.dt={ s }
e.at=nil
end
function xml.elementtocdata(e)
local dt=e.dt
local s=xml.tostring(e)
e.tg="@cd@"
e.special=true
e.ns=""
e.rn=""
e.dt={ s }
e.at=nil
end
xml.builtinentities=table.tohash { "amp","quot","apos","lt","gt" }
local entities=characters and characters.entities or nil
local builtinentities=xml.builtinentities
function xml.addentitiesdoctype(root,option)
if not entities then
require("char-ent")
entities=characters.entities
end
if entities and root and root.tg=="@rt@" and root.statistics then
local list={}
local hexify=option=="hexadecimal"
for k,v in table.sortedhash(root.statistics.entities.names) do
if not builtinentities[k] then
local e=entities[k]
if not e then
e=format("[%s]",k)
elseif hexify then
e=format("&#%05X;",utfbyte(k))
end
list[#list+1]=format(" <!ENTITY %s %q >",k,e)
end
end
local dt=root.dt
local n=dt[1].tg=="@pi@" and 2 or 1
if #list>0 then
insert(dt,n,{ "\n" })
insert(dt,n,{
tg="@dt@",
dt={ format("Something [\n%s\n] ",concat(list)) },
ns="",
special=true,
})
insert(dt,n,{ "\n\n" })
else
end
end
end
xml.all=xml.each
xml.insert=xml.insertafter
xml.inject=xml.injectafter
xml.after=xml.insertafter
xml.before=xml.insertbefore
xml.process=xml.each
xml.obsolete=xml.obsolete or {}
local obsolete=xml.obsolete
xml.strip_whitespace=xml.strip obsolete.strip_whitespace=xml.strip
xml.collect_elements=xml.collect obsolete.collect_elements=xml.collect
xml.delete_element=xml.delete obsolete.delete_element=xml.delete
xml.replace_element=xml.replace obsolete.replace_element=xml.replace
xml.each_element=xml.each obsolete.each_element=xml.each
xml.process_elements=xml.process obsolete.process_elements=xml.process
xml.insert_element_after=xml.insertafter obsolete.insert_element_after=xml.insertafter
xml.insert_element_before=xml.insertbefore obsolete.insert_element_before=xml.insertbefore
xml.inject_element_after=xml.injectafter obsolete.inject_element_after=xml.injectafter
xml.inject_element_before=xml.injectbefore obsolete.inject_element_before=xml.injectbefore
xml.process_attributes=xml.processattributes obsolete.process_attributes=xml.processattributes
xml.collect_texts=xml.collecttexts obsolete.collect_texts=xml.collecttexts
xml.inject_element=xml.inject obsolete.inject_element=xml.inject
xml.remap_tag=xml.remaptag obsolete.remap_tag=xml.remaptag
xml.remap_name=xml.remapname obsolete.remap_name=xml.remapname
xml.remap_namespace=xml.remapnamespace obsolete.remap_namespace=xml.remapnamespace
function xml.cdata(e)
if e then
local dt=e.dt
if dt and #dt==1 then
local first=dt[1]
return first.tg=="@cd@" and first.dt[1] or ""
end
end
return ""
end
function xml.finalizers.xml.cdata(collected)
if collected then
local e=collected[1]
if e then
local dt=e.dt
if dt and #dt==1 then
local first=dt[1]
return first.tg=="@cd@" and first.dt[1] or ""
end
end
end
return ""
end
function xml.insertcomment(e,str,n)
insert(e.dt,n or 1,{
tg="@cm@",
ns="",
special=true,
at={},
dt={ str },
})
end
function xml.insertcdata(e,str,n)
insert(e.dt,n or 1,{
tg="@cd@",
ns="",
special=true,
at={},
dt={ str },
})
end
function xml.setcomment(e,str,n)
e.dt={ {
tg="@cm@",
ns="",
special=true,
at={},
dt={ str },
} }
end
function xml.setcdata(e,str)
e.dt={ {
tg="@cd@",
ns="",
special=true,
at={},
dt={ str },
} }
end
function xml.separate(x,pattern)
local collected=xmlapplylpath(x,pattern)
if collected then
for c=1,#collected do
local e=collected[c]
local d=e.dt
if d==x then
report_xml("warning: xml.separate changes root")
x=d
end
local t={ "\n" }
local n=1
local i=1
local nd=#d
while i<=nd do
while i<=nd do
local di=d[i]
if type(di)=="string" then
if di=="\n" or find(di,"^%s+$") then
i=i+1
else
d[i]=strip(di)
break
end
else
break
end
end
if i>nd then
break
end
t[n+1]="\n"
t[n+2]=d[i]
t[n+3]="\n"
n=n+3
i=i+1
end
t[n+1]="\n"
setmetatable(t,getmetatable(d))
e.dt=t
end
end
return x
end
local helpers=xml.helpers or {}
xml.helpers=helpers
local function normal(e,action)
local edt=e.dt
if edt then
for i=1,#edt do
local str=edt[i]
if type(str)=="string" and str~="" then
edt[i]=action(str)
end
end
end
end
local function recurse(e,action)
local edt=e.dt
if edt then
for i=1,#edt do
local str=edt[i]
if type(str)~="string" then
recurse(str,action)
elseif str~="" then
edt[i]=action(str)
end
end
end
end
function helpers.recursetext(collected,action,recursive)
if recursive then
for i=1,#collected do
recurse(collected[i],action)
end
else
for i=1,#collected do
normal(collected[i],action)
end
end
end
local specials={
["@rt@"]="root",
["@pi@"]="instruction",
["@cm@"]="comment",
["@dt@"]="declaration",
["@cd@"]="cdata",
}
local function convert(x,strip,flat)
local ns=x.ns
local tg=x.tg
local at=x.at
local dt=x.dt
local node=flat and {
[0]=(not x.special and (ns~="" and ns..":"..tg or tg)) or nil,
} or {
_namespace=ns~="" and ns or nil,
_tag=not x.special and tg or nil,
_type=specials[tg] or "_element",
}
if at then
for k,v in next,at do
node[k]=v
end
end
local n=0
for i=1,#dt do
local di=dt[i]
if type(di)=="table" then
if flat and di.special then
else
di=convert(di,strip,flat)
if di then
n=n+1
node[n]=di
end
end
elseif strip then
di=lpegmatch(strip,di)
if di~="" then
n=n+1
node[n]=di
end
else
n=n+1
node[n]=di
end
end
if next(node) then
return node
end
end
function xml.totable(x,strip,flat)
if type(x)=="table" then
if strip then
strip=striplinepatterns[strip]
end
return convert(x,strip,flat)
end
end
function xml.rename(e,namespace,name,attributes)
if type(e)~="table" or not e.tg then
return
end
if type(name)=="table" then
attributes=name
name=namespace
namespace=""
elseif type(name)~="string" then
attributes={}
name=namespace
namespace=""
end
if type(attributes)~="table" then
attributes={}
end
e.ns=namespace
e.rn=namespace
e.tg=name
e.at=attributes
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["lxml-xml"] = package.loaded["lxml-xml"] or true
-- original size: 11096, stripped down to: 7702
if not modules then modules={} end modules ['lxml-xml']={
version=1.001,
comment="this module is the basis for the lxml-* ones",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local tonumber,next=tonumber,next
local concat=table.concat
local find,lower,upper=string.find,string.lower,string.upper
local xml=xml
local finalizers=xml.finalizers.xml
local xmlfilter=xml.filter
local xmltostring=xml.tostring
local xmlserialize=xml.serialize
local xmlcollected=xml.collected
local xmlnewhandlers=xml.newhandlers
local reparsedentity=xml.reparsedentitylpeg
local unescapedentity=xml.unescapedentitylpeg
local parsedentity=reparsedentity
local function first(collected)
return collected and collected[1]
end
local function last(collected)
return collected and collected[#collected]
end
local function all(collected)
return collected
end
local reverse=table.reversed
local function attribute(collected,name)
if collected and #collected>0 then
local at=collected[1].at
return at and at[name]
end
end
local function att(id,name)
local at=id.at
return at and at[name]
end
local function count(collected)
return collected and #collected or 0
end
local function position(collected,n)
if not collected then
return 0
end
local nc=#collected
if nc==0 then
return 0
end
n=tonumber(n) or 0
if n<0 then
return collected[nc+n+1]
elseif n>0 then
return collected[n]
else
return collected[1].mi or 0
end
end
local function match(collected)
return collected and #collected>0 and collected[1].mi or 0
end
local function index(collected)
return collected and #collected>0 and collected[1].ni or 0
end
local function attributes(collected,arguments)
if collected and #collected>0 then
local at=collected[1].at
if arguments then
return at[arguments]
elseif next(at) then
return at
end
end
end
local function chainattribute(collected,arguments)
if collected and #collected>0 then
local e=collected[1]
while e do
local at=e.at
if at then
local a=at[arguments]
if a then
return a
end
else
break
end
e=e.__p__
end
end
return ""
end
local function raw(collected)
if collected and #collected>0 then
local e=collected[1] or collected
return e and xmltostring(e) or ""
else
return ""
end
end
local xmltexthandler=xmlnewhandlers {
name="string",
initialize=function()
result={}
return result
end,
finalize=function()
return concat(result)
end,
handle=function(...)
result[#result+1]=concat {... }
end,
escape=false,
}
local function xmltotext(root)
local dt=root.dt
if not dt then
return ""
end
local nt=#dt
if nt==0 then
return ""
elseif nt==1 and type(dt[1])=="string" then
return dt[1]
else
return xmlserialize(root,xmltexthandler) or ""
end
end
function xml.serializetotext(root)
return root and xmlserialize(root,xmltexthandler) or ""
end
local function text(collected)
if collected then
local e=collected[1] or collected
return e and xmltotext(e) or ""
else
return ""
end
end
local function texts(collected)
if not collected then
return {}
end
local nc=#collected
if nc==0 then
return {}
end
local t,n={},0
for c=1,nc do
local e=collected[c]
if e and e.dt then
n=n+1
t[n]=e.dt
end
end
return t
end
local function tag(collected,n)
if not collected then
return
end
local nc=#collected
if nc==0 then
return
end
local c
if n==0 or not n then
c=collected[1]
elseif n>1 then
c=collected[n]
else
c=collected[nc-n+1]
end
return c and c.tg
end
local function name(collected,n)
if not collected then
return
end
local nc=#collected
if nc==0 then
return
end
local c
if n==0 or not n then
c=collected[1]
elseif n>1 then
c=collected[n]
else
c=collected[nc-n+1]
end
if not c then
elseif c.ns=="" then
return c.tg
else
return c.ns..":"..c.tg
end
end
local function tags(collected,nonamespace)
if not collected then
return
end
local nc=#collected
if nc==0 then
return
end
local t,n={},0
for c=1,nc do
local e=collected[c]
local ns,tg=e.ns,e.tg
n=n+1
if nonamespace or ns=="" then
t[n]=tg
else
t[n]=ns..":"..tg
end
end
return t
end
local function empty(collected,spacesonly)
if not collected then
return true
end
local nc=#collected
if nc==0 then
return true
end
for c=1,nc do
local e=collected[c]
if e then
local edt=e.dt
if edt then
local n=#edt
if n==1 then
local edk=edt[1]
local typ=type(edk)
if typ=="table" then
return false
elseif edk~="" then
return false
elseif spacesonly and not find(edk,"%S") then
return false
end
elseif n>1 then
return false
end
end
end
end
return true
end
finalizers.first=first
finalizers.last=last
finalizers.all=all
finalizers.reverse=reverse
finalizers.elements=all
finalizers.default=all
finalizers.attribute=attribute
finalizers.att=att
finalizers.count=count
finalizers.position=position
finalizers.match=match
finalizers.index=index
finalizers.attributes=attributes
finalizers.chainattribute=chainattribute
finalizers.text=text
finalizers.texts=texts
finalizers.tag=tag
finalizers.name=name
finalizers.tags=tags
finalizers.empty=empty
function xml.first(id,pattern)
return first(xmlfilter(id,pattern))
end
function xml.last(id,pattern)
return last(xmlfilter(id,pattern))
end
function xml.count(id,pattern)
return count(xmlfilter(id,pattern))
end
function xml.attribute(id,pattern,a,default)
return attribute(xmlfilter(id,pattern),a,default)
end
function xml.raw(id,pattern)
if pattern then
return raw(xmlfilter(id,pattern))
else
return raw(id)
end
end
function xml.text(id,pattern)
if pattern then
local collected=xmlfilter(id,pattern)
return collected and #collected>0 and xmltotext(collected[1]) or ""
elseif id then
return xmltotext(id) or ""
else
return ""
end
end
function xml.pure(id,pattern)
if pattern then
local collected=xmlfilter(id,pattern)
if collected and #collected>0 then
parsedentity=unescapedentity
local s=collected and #collected>0 and xmltotext(collected[1]) or ""
parsedentity=reparsedentity
return s
else
return ""
end
else
parsedentity=unescapedentity
local s=xmltotext(id) or ""
parsedentity=reparsedentity
return s
end
end
xml.content=text
function xml.position(id,pattern,n)
return position(xmlfilter(id,pattern),n)
end
function xml.match(id,pattern)
return match(xmlfilter(id,pattern))
end
function xml.empty(id,pattern,spacesonly)
return empty(xmlfilter(id,pattern),spacesonly)
end
xml.all=xml.filter
xml.index=xml.position
xml.found=xml.filter
local function totable(x)
local t={}
for e in xmlcollected(x[1] or x,"/*") do
t[e.tg]=xmltostring(e.dt) or ""
end
return next(t) and t or nil
end
xml.table=totable
finalizers.table=totable
local function textonly(e,t)
if e then
local edt=e.dt
if edt then
for i=1,#edt do
local e=edt[i]
if type(e)=="table" then
textonly(e,t)
else
t[#t+1]=e
end
end
end
end
return t
end
function xml.textonly(e)
return concat(textonly(e,{}))
end
function finalizers.lowerall(collected)
for c=1,#collected do
local e=collected[c]
if not e.special then
e.tg=lower(e.tg)
local eat=e.at
if eat then
local t={}
for k,v in next,eat do
t[lower(k)]=v
end
e.at=t
end
end
end
end
function finalizers.upperall(collected)
for c=1,#collected do
local e=collected[c]
if not e.special then
e.tg=upper(e.tg)
local eat=e.at
if eat then
local t={}
for k,v in next,eat do
t[upper(k)]=v
end
e.at=t
end
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["trac-xml"] = package.loaded["trac-xml"] or true
-- original size: 6407, stripped down to: 4640
if not modules then modules={} end modules ['trac-xml']={
version=1.001,
comment="companion to trac-log.mkiv",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local formatters=string.formatters
local reporters=logs.reporters
local xmlserialize=xml.serialize
local xmlcollected=xml.collected
local xmltext=xml.text
local xmlfirst=xml.first
local function showhelp(specification,...)
local root=xml.convert(specification.helpinfo or "")
if not root then
return
end
local xs=xml.gethandlers("string")
xml.sethandlersfunction(xs,"short",function(e,handler) xmlserialize(e.dt,handler) end)
xml.sethandlersfunction(xs,"ref",function(e,handler) handler.handle("--"..e.at.name) end)
local wantedcategories=select("#",...)==0 and true or table.tohash {... }
local nofcategories=xml.count(root,"/application/flags/category")
local report=specification.report
for category in xmlcollected(root,"/application/flags/category") do
local categoryname=category.at.name or ""
if wantedcategories==true or wantedcategories[categoryname] then
if nofcategories>1 then
report("%s options:",categoryname)
report()
end
for subcategory in xmlcollected(category,"/subcategory") do
for flag in xmlcollected(subcategory,"/flag") do
local name=flag.at.name
local value=flag.at.value
local short=xmltext(xmlfirst(flag,"/short"))
if value then
report("--%-20s %s",formatters["%s=%s"](name,value),short)
else
report("--%-20s %s",name,short)
end
end
report()
end
end
end
for category in xmlcollected(root,"/application/examples/category") do
local title=xmltext(xmlfirst(category,"/title"))
if title and title~="" then
report()
report(title)
report()
end
for subcategory in xmlcollected(category,"/subcategory") do
for example in xmlcollected(subcategory,"/example") do
local command=xmltext(xmlfirst(example,"/command"))
local comment=xmltext(xmlfirst(example,"/comment"))
report(command)
end
report()
end
end
for comment in xmlcollected(root,"/application/comments/comment") do
local comment=xmltext(comment)
report()
report(comment)
report()
end
end
local reporthelp=reporters.help
local exporthelp=reporters.export
local function xmlfound(t)
local helpinfo=t.helpinfo
if type(helpinfo)=="table" then
return false
end
if type(helpinfo)~="string" then
helpinfo="Warning: no helpinfo found."
t.helpinfo=helpinfo
return false
end
if string.find(helpinfo,".xml$") then
local ownscript=environment.ownscript
local helpdata=false
if ownscript then
local helpfile=file.join(file.pathpart(ownscript),helpinfo)
helpdata=io.loaddata(helpfile)
if helpdata=="" then
helpdata=false
end
end
if not helpdata then
local helpfile=resolvers.findfile(helpinfo,"tex")
helpdata=helpfile and io.loaddata(helpfile)
end
if helpdata and helpdata~="" then
helpinfo=helpdata
else
helpinfo=formatters["Warning: help file %a is not found."](helpinfo)
end
end
t.helpinfo=helpinfo
return string.find(t.helpinfo,"^<%?xml") and true or false
end
function reporters.help(t,...)
if xmlfound(t) then
showhelp(t,...)
else
reporthelp(t,...)
end
end
function reporters.export(t,methods,filename)
if not xmlfound(t) then
return exporthelp(t)
end
if not methods or methods=="" then
methods=environment.arguments["exporthelp"]
end
if not filename or filename=="" then
filename=environment.files[1]
end
dofile(resolvers.findfile("trac-exp.lua","tex"))
local exporters=logs.exporters
if not exporters or not methods then
return exporthelp(t)
end
if methods=="all" then
methods=table.keys(exporters)
elseif type(methods)=="string" then
methods=utilities.parsers.settings_to_array(methods)
else
return exporthelp(t)
end
if type(filename)~="string" or filename=="" then
filename=false
elseif file.pathpart(filename)=="" then
t.report("export file %a will not be saved on the current path (safeguard)",filename)
return
end
for i=1,#methods do
local method=methods[i]
local exporter=exporters[method]
if exporter then
local result=exporter(t,method)
if result and result~="" then
if filename then
local fullname=file.replacesuffix(filename,method)
t.report("saving export in %a",fullname)
dir.mkdirs(file.pathpart(fullname))
io.savedata(fullname,result)
else
reporters.lines(t,result)
end
else
t.report("no output from exporter %a",method)
end
else
t.report("unknown exporter %a",method)
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-ini"] = package.loaded["data-ini"] or true
-- original size: 11099, stripped down to: 7152
if not modules then modules={} end modules ['data-ini']={
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",
}
local next,type,getmetatable,rawset=next,type,getmetatable,rawset
local gsub,find,gmatch,char=string.gsub,string.find,string.gmatch,string.char
local filedirname,filebasename,filejoin=file.dirname,file.basename,file.join
local ostype,osname,osuname,ossetenv,osgetenv=os.type,os.name,os.uname,os.setenv,os.getenv
local P,S,R,C,Cs,Cc,lpegmatch=lpeg.P,lpeg.S,lpeg.R,lpeg.C,lpeg.Cs,lpeg.Cc,lpeg.match
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local trace_detail=false trackers.register("resolvers.details",function(v) trace_detail=v end)
local trace_expansions=false trackers.register("resolvers.expansions",function(v) trace_expansions=v end)
local report_initialization=logs.reporter("resolvers","initialization")
resolvers=resolvers or {}
local resolvers=resolvers
texconfig.kpse_init=false
texconfig.shell_escape='t'
if not (environment and environment.default_texmfcnf) and kpse and kpse.default_texmfcnf then
local default_texmfcnf=kpse.default_texmfcnf()
default_texmfcnf=gsub(default_texmfcnf,"$SELFAUTOLOC","selfautoloc:")
default_texmfcnf=gsub(default_texmfcnf,"$SELFAUTODIR","selfautodir:")
default_texmfcnf=gsub(default_texmfcnf,"$SELFAUTOPARENT","selfautoparent:")
default_texmfcnf=gsub(default_texmfcnf,"$HOME","home:")
environment.default_texmfcnf=default_texmfcnf
end
kpse={ original=kpse }
setmetatable(kpse,{
__index=function(kp,name)
report_initialization("fatal error: kpse library is accessed (key: %s)",name)
os.exit()
end
} )
do
local osfontdir=osgetenv("OSFONTDIR")
if osfontdir and osfontdir~="" then
elseif osname=="windows" then
ossetenv("OSFONTDIR","c:/windows/fonts//")
elseif osname=="macosx" then
ossetenv("OSFONTDIR","$HOME/Library/Fonts//;/Library/Fonts//;/System/Library/Fonts//")
end
end
do
local homedir=osgetenv(ostype=="windows" and 'USERPROFILE' or 'HOME') or ''
if not homedir or homedir=="" then
homedir=char(127)
end
homedir=file.collapsepath(homedir)
ossetenv("HOME",homedir)
ossetenv("USERPROFILE",homedir)
environment.homedir=homedir
end
do
local args=environment.originalarguments or arg
if not environment.ownmain then
environment.ownmain=status and string.match(string.lower(status.banner),"this is ([%a]+)") or "luatex"
end
local ownbin=environment.ownbin or args[-2] or arg[-2] or args[-1] or arg[-1] or arg[0] or "luatex"
local ownpath=environment.ownpath or os.selfdir
ownbin=file.collapsepath(ownbin)
ownpath=file.collapsepath(ownpath)
if not ownpath or ownpath=="" or ownpath=="unset" then
ownpath=args[-1] or arg[-1]
ownpath=ownpath and filedirname(gsub(ownpath,"\\","/"))
if not ownpath or ownpath=="" then
ownpath=args[-0] or arg[-0]
ownpath=ownpath and filedirname(gsub(ownpath,"\\","/"))
end
local binary=ownbin
if not ownpath or ownpath=="" then
ownpath=ownpath and filedirname(binary)
end
if not ownpath or ownpath=="" then
if os.binsuffix~="" then
binary=file.replacesuffix(binary,os.binsuffix)
end
local path=osgetenv("PATH")
if path then
for p in gmatch(path,"[^"..io.pathseparator.."]+") do
local b=filejoin(p,binary)
if lfs.isfile(b) then
local olddir=lfs.currentdir()
if lfs.chdir(p) then
local pp=lfs.currentdir()
if trace_locating and p~=pp then
report_initialization("following symlink %a to %a",p,pp)
end
ownpath=pp
lfs.chdir(olddir)
else
if trace_locating then
report_initialization("unable to check path %a",p)
end
ownpath=p
end
break
end
end
end
end
if not ownpath or ownpath=="" then
ownpath="."
report_initialization("forcing fallback to ownpath %a",ownpath)
elseif trace_locating then
report_initialization("using ownpath %a",ownpath)
end
end
environment.ownbin=ownbin
environment.ownpath=ownpath
end
resolvers.ownpath=environment.ownpath
function resolvers.getownpath()
return environment.ownpath
end
do
local ownpath=environment.ownpath or dir.current()
if ownpath then
ossetenv('SELFAUTOLOC',file.collapsepath(ownpath))
ossetenv('SELFAUTODIR',file.collapsepath(ownpath.."/.."))
ossetenv('SELFAUTOPARENT',file.collapsepath(ownpath.."/../.."))
else
report_initialization("error: unable to locate ownpath")
os.exit()
end
end
local texos=environment.texos or osgetenv("TEXOS")
local texmfos=environment.texmfos or osgetenv('SELFAUTODIR')
if not texos or texos=="" then
texos=file.basename(texmfos)
end
ossetenv('TEXMFOS',texmfos)
ossetenv('TEXOS',texos)
ossetenv('SELFAUTOSYSTEM',os.platform)
environment.texos=texos
environment.texmfos=texmfos
local texroot=environment.texroot or osgetenv("TEXROOT")
if not texroot or texroot=="" then
texroot=osgetenv('SELFAUTOPARENT')
ossetenv('TEXROOT',texroot)
end
environment.texroot=file.collapsepath(texroot)
local prefixes=utilities.storage.allocate()
resolvers.prefixes=prefixes
local resolved={}
local abstract={}
local dynamic={}
function resolvers.resetresolve(str)
resolved,abstract={},{}
end
function resolvers.allprefixes(separator)
local all=table.sortedkeys(prefixes)
if separator then
for i=1,#all do
all[i]=all[i]..":"
end
end
return all
end
local function _resolve_(method,target)
local action=prefixes[method]
if action then
return action(target)
else
return method..":"..target
end
end
function resolvers.unresolve(str)
return abstract[str] or str
end
function resolvers.setdynamic(str)
dynamic[str]=true
end
local pattern=Cs((C(R("az")^2)*P(":")*C((1-S(" \"\';,"))^1)/_resolve_+P(1))^0)
local prefix=C(R("az")^2)*P(":")
local target=C((1-S(" \"\';,"))^1)
local notarget=(#S(";,")+P(-1))*Cc("")
local p_resolve=Cs(((prefix*(target+notarget))/_resolve_+P(1))^0)
local p_simple=prefix*P(-1)
local function resolve(str)
if type(str)=="table" then
local res={}
for i=1,#str do
res[i]=resolve(str[i])
end
return res
end
local res=resolved[str]
if res then
return res
end
local simple=lpegmatch(p_simple,str)
local action=prefixes[simple]
if action then
local res=action(res)
if not dynamic[simple] then
resolved[simple]=res
abstract[res]=simple
end
return res
end
res=lpegmatch(p_resolve,str)
resolved[str]=res
abstract[res]=str
return res
end
resolvers.resolve=resolve
if type(osuname)=="function" then
for k,v in next,osuname() do
if not prefixes[k] then
prefixes[k]=function() return v end
end
end
end
if ostype=="unix" then
local pattern
local function makepattern(t,k,v)
if t then
rawset(t,k,v)
end
local colon=P(":")
for k,v in table.sortedpairs(prefixes) do
if p then
p=P(k)+p
else
p=P(k)
end
end
pattern=Cs((p*colon+colon/";"+P(1))^0)
end
makepattern()
table.setmetatablenewindex(prefixes,makepattern)
function resolvers.repath(str)
return lpegmatch(pattern,str)
end
else
function resolvers.repath(str)
return str
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-exp"] = package.loaded["data-exp"] or true
-- original size: 18154, stripped down to: 10416
if not modules then modules={} end modules ['data-exp']={
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",
}
local format,find,gmatch,lower,char,sub=string.format,string.find,string.gmatch,string.lower,string.char,string.sub
local concat,sort=table.concat,table.sort
local sortedkeys=table.sortedkeys
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local Ct,Cs,Cc,Carg,P,C,S=lpeg.Ct,lpeg.Cs,lpeg.Cc,lpeg.Carg,lpeg.P,lpeg.C,lpeg.S
local type,next=type,next
local isdir=lfs.isdir
local collapsepath,joinpath,basename=file.collapsepath,file.join,file.basename
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local trace_expansions=false trackers.register("resolvers.expansions",function(v) trace_expansions=v end)
local trace_globbing=true trackers.register("resolvers.globbing",function(v) trace_globbing=v end)
local report_expansions=logs.reporter("resolvers","expansions")
local report_globbing=logs.reporter("resolvers","globbing")
local resolvers=resolvers
local resolveprefix=resolvers.resolve
local function f_both(a,b)
local t,n={},0
for sb in gmatch(b,"[^,]+") do
for sa in gmatch(a,"[^,]+") do
n=n+1;t[n]=sa..sb
end
end
return concat(t,",")
end
local comma=P(",")
local nocomma=(1-comma)^1
local docomma=comma^1/","
local before=Cs((nocomma*Carg(1)+docomma)^0)
local after=Cs((Carg(1)*nocomma+docomma)^0)
local both=Cs(((C(nocomma)*Carg(1))/function(a,b) return lpegmatch(before,b,1,a) end+docomma)^0)
local function f_first (a,b) return lpegmatch(after,b,1,a) end
local function f_second(a,b) return lpegmatch(before,a,1,b) end
local function f_both (a,b) return lpegmatch(both,b,1,a) end
local left=P("{")
local right=P("}")
local var=P((1-S("{}" ))^0)
local set=P((1-S("{},"))^0)
local other=P(1)
local l_first=Cs((Cc("{")*(C(set)*left*C(var)*right/f_first)*Cc("}")+other )^0 )
local l_second=Cs((Cc("{")*(left*C(var)*right*C(set)/f_second)*Cc("}")+other )^0 )
local l_both=Cs((Cc("{")*(left*C(var)*right*left*C(var)*right/f_both)*Cc("}")+other )^0 )
local l_rest=Cs((left*var*(left/"")*var*(right/"")*var*right+other )^0 )
local stripper_1=lpeg.stripper ("{}@")
local replacer_1=lpeg.replacer { { ",}",",@}" },{ "{,","{@," },}
local function splitpathexpr(str,newlist,validate)
if trace_expansions then
report_expansions("expanding variable %a",str)
end
local t,ok,done=newlist or {},false,false
local n=#t
str=lpegmatch(replacer_1,str)
repeat
local old=str
repeat
local old=str
str=lpegmatch(l_first,str)
until old==str
repeat
local old=str
str=lpegmatch(l_second,str)
until old==str
repeat
local old=str
str=lpegmatch(l_both,str)
until old==str
repeat
local old=str
str=lpegmatch(l_rest,str)
until old==str
until old==str
str=lpegmatch(stripper_1,str)
if validate then
for s in gmatch(str,"[^,]+") do
s=validate(s)
if s then
n=n+1
t[n]=s
end
end
else
for s in gmatch(str,"[^,]+") do
n=n+1
t[n]=s
end
end
if trace_expansions then
for k=1,#t do
report_expansions("% 4i: %s",k,t[k])
end
end
return t
end
local function validate(s)
s=collapsepath(s)
return s~="" and not find(s,"^!*unset/*$") and s
end
resolvers.validatedpath=validate
function resolvers.expandedpathfromlist(pathlist)
local newlist={}
for k=1,#pathlist do
splitpathexpr(pathlist[k],newlist,validate)
end
return newlist
end
local usedhomedir=nil
local donegation=(P("!")/"" )^0
local doslashes=(P("\\")/"/"+1)^0
local function expandedhome()
if not usedhomedir then
usedhomedir=lpegmatch(Cs(donegation*doslashes),environment.homedir or "")
if usedhomedir=="~" or usedhomedir=="" or not isdir(usedhomedir) then
if trace_expansions then
report_expansions("no home dir set, ignoring dependent path using current path")
end
usedhomedir="."
end
end
return usedhomedir
end
local dohome=((P("~")+P("$HOME")+P("%HOME%"))/expandedhome)^0
local cleanup=Cs(donegation*dohome*doslashes)
resolvers.cleanpath=function(str)
return str and lpegmatch(cleanup,str) or ""
end
local expandhome=P("~")/"$HOME"
local dodouble=P('"')/""*(expandhome+(1-P('"')))^0*P('"')/""
local dosingle=P("'")/""*(expandhome+(1-P("'")))^0*P("'")/""
local dostring=(expandhome+1 )^0
local stripper=Cs(
lpegpatterns.unspacer*(dosingle+dodouble+dostring)*lpegpatterns.unspacer
)
function resolvers.checkedvariable(str)
return type(str)=="string" and lpegmatch(stripper,str) or str
end
local cache={}
local splitter=lpeg.tsplitat(";")
local backslashswapper=lpeg.replacer("\\","/")
local function splitconfigurationpath(str)
if str then
local found=cache[str]
if not found then
if str=="" then
found={}
else
local split=lpegmatch(splitter,lpegmatch(backslashswapper,str))
found={}
local noffound=0
for i=1,#split do
local s=split[i]
if not find(s,"^{*unset}*") then
noffound=noffound+1
found[noffound]=s
end
end
if trace_expansions then
report_expansions("splitting path specification %a",str)
for k=1,noffound do
report_expansions("% 4i: %s",k,found[k])
end
end
cache[str]=found
end
end
return found
end
end
resolvers.splitconfigurationpath=splitconfigurationpath
function resolvers.splitpath(str)
if type(str)=='table' then
return str
else
return splitconfigurationpath(str)
end
end
function resolvers.joinpath(str)
if type(str)=='table' then
return joinpath(str)
else
return str
end
end
local attributes,directory=lfs.attributes,lfs.dir
local weird=P(".")^1+lpeg.anywhere(S("~`!#$%^&*()={}[]:;\"\'||<>,?\n\r\t"))
local lessweird=P(".")^1+lpeg.anywhere(S("~`#$%^&*:;\"\'||<>,?\n\r\t"))
local timer={}
local scanned={}
local nofscans=0
local scancache={}
local fullcache={}
local nofsharedscans=0
local addcasecraptoo=true
local function scan(files,remap,spec,path,n,m,r,onlyone,tolerant)
local full=path=="" and spec or (spec..path..'/')
local dirlist={}
local nofdirs=0
local pattern=tolerant and lessweird or weird
local filelist={}
local noffiles=0
for name,mode in directory(full) do
if not lpegmatch(pattern,name) then
if not mode then
mode=attributes(full..name,"mode")
end
if mode=="file" then
n=n+1
noffiles=noffiles+1
filelist[noffiles]=name
elseif mode=="directory" then
m=m+1
nofdirs=nofdirs+1
if path~="" then
dirlist[nofdirs]=path.."/"..name
else
dirlist[nofdirs]=name
end
end
end
end
if noffiles>0 then
sort(filelist)
for i=1,noffiles do
local name=filelist[i]
local lower=lower(name)
local paths=files[lower]
if paths then
if onlyone then
else
if name~=lower then
local rl=remap[lower]
if not rl then
remap[lower]=name
r=r+1
elseif trace_globbing and rl~=name then
report_globbing("confusing filename, name: %a, lower: %a, already: %a",name,lower,rl)
end
if addcasecraptoo then
local paths=files[name]
if not paths then
files[name]=path
elseif type(paths)=="string" then
files[name]={ paths,path }
else
paths[#paths+1]=path
end
end
end
if type(paths)=="string" then
files[lower]={ paths,path }
else
paths[#paths+1]=path
end
end
else
files[lower]=path
if name~=lower then
local rl=remap[lower]
if not rl then
remap[lower]=name
r=r+1
elseif trace_globbing and rl~=name then
report_globbing("confusing filename, name: %a, lower: %a, already: %a",name,lower,rl)
end
end
end
end
end
if nofdirs>0 then
sort(dirlist)
for i=1,nofdirs do
files,remap,n,m,r=scan(files,remap,spec,dirlist[i],n,m,r,onlyonce,tolerant)
end
end
scancache[sub(full,1,-2)]=files
return files,remap,n,m,r
end
function resolvers.scanfiles(path,branch,usecache,onlyonce,tolerant)
local realpath=resolveprefix(path)
if usecache then
local content=fullcache[realpath]
if content then
if trace_locating then
report_expansions("using cached scan of path %a, branch %a",path,branch or path)
end
nofsharedscans=nofsharedscans+1
return content
end
end
statistics.starttiming(timer)
if trace_locating then
report_expansions("scanning path %a, branch %a",path,branch or path)
end
local content
if isdir(realpath) then
local files,remap,n,m,r=scan({},{},realpath..'/',"",0,0,0,onlyonce,tolerant)
content={
metadata={
path=path,
files=n,
directories=m,
remappings=r,
},
files=files,
remap=remap,
}
if trace_locating then
report_expansions("%s files found on %s directories with %s uppercase remappings",n,m,r)
end
else
content={
metadata={
path=path,
files=0,
directories=0,
remappings=0,
},
files={},
remap={},
}
if trace_locating then
report_expansions("invalid path %a",realpath)
end
end
if usecache then
scanned[#scanned+1]=realpath
fullcache[realpath]=content
end
nofscans=nofscans+1
statistics.stoptiming(timer)
return content
end
function resolvers.simplescanfiles(path,branch,usecache)
return resolvers.scanfiles(path,branch,usecache,true,true)
end
function resolvers.scandata()
table.sort(scanned)
return {
n=nofscans,
shared=nofsharedscans,
time=statistics.elapsedtime(timer),
paths=scanned,
}
end
function resolvers.get_from_content(content,path,name)
if not content then
return
end
local files=content.files
if not files then
return
end
local remap=content.remap
if not remap then
return
end
if name then
local used=lower(name)
return path,remap[used] or used
else
local name=path
local used=lower(name)
local path=files[used]
if path then
return path,remap[used] or used
end
end
end
local nothing=function() end
function resolvers.filtered_from_content(content,pattern)
if content and type(pattern)=="string" then
local pattern=lower(pattern)
local files=content.files
local remap=content.remap
if files and remap then
local f=sortedkeys(files)
local n=#f
local i=0
local function iterator()
while i<n do
i=i+1
local k=f[i]
if find(k,pattern) then
return files[k],remap and remap[k] or k
end
end
end
return iterator
end
end
return nothing
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-env"] = package.loaded["data-env"] or true
-- original size: 9360, stripped down to: 6312
if not modules then modules={} end modules ['data-env']={
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",
}
local lower,gsub=string.lower,string.gsub
local next=next
local resolvers=resolvers
local allocate=utilities.storage.allocate
local setmetatableindex=table.setmetatableindex
local suffixonly=file.suffixonly
local formats=allocate()
local suffixes=allocate()
local dangerous=allocate()
local suffixmap=allocate()
local usertypes=allocate()
resolvers.formats=formats
resolvers.suffixes=suffixes
resolvers.dangerous=dangerous
resolvers.suffixmap=suffixmap
resolvers.usertypes=usertypes
local luasuffixes=utilities.lua.suffixes
local relations=allocate {
core={
ofm={
names={ "ofm","omega font metric","omega font metrics" },
variable='OFMFONTS',
suffixes={ 'ofm','tfm' },
},
ovf={
names={ "ovf","omega virtual font","omega virtual fonts" },
variable='OVFFONTS',
suffixes={ 'ovf','vf' },
},
tfm={
names={ "tfm","tex font metric","tex font metrics" },
variable='TFMFONTS',
suffixes={ 'tfm' },
},
vf={
names={ "vf","virtual font","virtual fonts" },
variable='VFFONTS',
suffixes={ 'vf' },
},
otf={
names={ "otf","opentype","opentype font","opentype fonts"},
variable='OPENTYPEFONTS',
suffixes={ 'otf' },
},
ttf={
names={ "ttf","truetype","truetype font","truetype fonts","truetype collection","truetype collections","truetype dictionary","truetype dictionaries" },
variable='TTFONTS',
suffixes={ 'ttf','ttc','dfont' },
},
afm={
names={ "afm","adobe font metric","adobe font metrics" },
variable="AFMFONTS",
suffixes={ "afm" },
},
pfb={
names={ "pfb","type1","type 1","type1 font","type 1 font","type1 fonts","type 1 fonts" },
variable='T1FONTS',
suffixes={ 'pfb','pfa' },
},
fea={
names={ "fea","font feature","font features","font feature file","font feature files" },
variable='FONTFEATURES',
suffixes={ 'fea' },
},
cid={
names={ "cid","cid map","cid maps","cid file","cid files" },
variable='FONTCIDMAPS',
suffixes={ 'cid','cidmap' },
},
fmt={
names={ "fmt","format","tex format" },
variable='TEXFORMATS',
suffixes={ 'fmt' },
},
mem={
names={ 'mem',"metapost format" },
variable='MPMEMS',
suffixes={ 'mem' },
},
mp={
names={ "mp" },
variable='MPINPUTS',
suffixes={ 'mp','mpvi','mpiv','mpii' },
usertype=true,
},
tex={
names={ "tex" },
variable='TEXINPUTS',
suffixes={ "tex","mkvi","mkiv","mkii","cld","lfg","xml" },
usertype=true,
},
icc={
names={ "icc","icc profile","icc profiles" },
variable='ICCPROFILES',
suffixes={ 'icc' },
},
texmfscripts={
names={ "texmfscript","texmfscripts","script","scripts" },
variable='TEXMFSCRIPTS',
suffixes={ 'lua','rb','pl','py' },
},
lua={
names={ "lua" },
variable='LUAINPUTS',
suffixes={ luasuffixes.lua,luasuffixes.luc,luasuffixes.tma,luasuffixes.tmc },
usertype=true,
},
lib={
names={ "lib" },
variable='CLUAINPUTS',
suffixes=os.libsuffix and { os.libsuffix } or { 'dll','so' },
},
bib={
names={ 'bib' },
variable='BIBINPUTS',
suffixes={ 'bib' },
usertype=true,
},
bst={
names={ 'bst' },
variable='BSTINPUTS',
suffixes={ 'bst' },
usertype=true,
},
fontconfig={
names={ 'fontconfig','fontconfig file','fontconfig files' },
variable='FONTCONFIG_PATH',
},
pk={
names={ "pk" },
variable='PKFONTS',
suffixes={ 'pk' },
},
},
obsolete={
enc={
names={ "enc","enc files","enc file","encoding files","encoding file" },
variable='ENCFONTS',
suffixes={ 'enc' },
},
map={
names={ "map","map files","map file" },
variable='TEXFONTMAPS',
suffixes={ 'map' },
},
lig={
names={ "lig files","lig file","ligature file","ligature files" },
variable='LIGFONTS',
suffixes={ 'lig' },
},
opl={
names={ "opl" },
variable='OPLFONTS',
suffixes={ 'opl' },
},
ovp={
names={ "ovp" },
variable='OVPFONTS',
suffixes={ 'ovp' },
},
},
kpse={
base={
names={ 'base',"metafont format" },
variable='MFBASES',
suffixes={ 'base','bas' },
},
cmap={
names={ 'cmap','cmap files','cmap file' },
variable='CMAPFONTS',
suffixes={ 'cmap' },
},
cnf={
names={ 'cnf' },
suffixes={ 'cnf' },
},
web={
names={ 'web' },
suffixes={ 'web','ch' }
},
cweb={
names={ 'cweb' },
suffixes={ 'w','web','ch' },
},
gf={
names={ 'gf' },
suffixes={ '<resolution>gf' },
},
mf={
names={ 'mf' },
variable='MFINPUTS',
suffixes={ 'mf' },
},
mft={
names={ 'mft' },
suffixes={ 'mft' },
},
pk={
names={ 'pk' },
suffixes={ '<resolution>pk' },
},
},
}
resolvers.relations=relations
function resolvers.updaterelations()
for category,categories in next,relations do
for name,relation in next,categories do
local rn=relation.names
local rv=relation.variable
if rn and rv then
local rs=relation.suffixes
local ru=relation.usertype
for i=1,#rn do
local rni=lower(gsub(rn[i]," ",""))
formats[rni]=rv
if rs then
suffixes[rni]=rs
for i=1,#rs do
local rsi=rs[i]
suffixmap[rsi]=rni
end
end
end
if ru then
usertypes[name]=true
end
end
end
end
end
resolvers.updaterelations()
local function simplified(t,k)
return k and rawget(t,lower(gsub(k," ",""))) or nil
end
setmetatableindex(formats,simplified)
setmetatableindex(suffixes,simplified)
setmetatableindex(suffixmap,simplified)
function resolvers.suffixofformat(str)
local s=suffixes[str]
return s and s[1] or ""
end
function resolvers.suffixofformat(str)
return suffixes[str] or {}
end
for name,format in next,formats do
dangerous[name]=true
end
dangerous.tex=nil
function resolvers.formatofvariable(str)
return formats[str] or ''
end
function resolvers.formatofsuffix(str)
return suffixmap[suffixonly(str)] or 'tex'
end
function resolvers.variableofformat(str)
return formats[str] or ''
end
function resolvers.variableofformatorsuffix(str)
local v=formats[str]
if v then
return v
end
v=suffixmap[suffixonly(str)]
if v then
return formats[v]
end
return ''
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-tmp"] = package.loaded["data-tmp"] or true
-- original size: 16284, stripped down to: 10938
if not modules then modules={} end modules ['data-tmp']={
version=1.100,
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"
}
local format,lower,gsub,concat=string.format,string.lower,string.gsub,table.concat
local concat=table.concat
local mkdirs,isdir,isfile=dir.mkdirs,lfs.isdir,lfs.isfile
local addsuffix,is_writable,is_readable=file.addsuffix,file.is_writable,file.is_readable
local formatters=string.formatters
local next,type=next,type
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local trace_cache=false trackers.register("resolvers.cache",function(v) trace_cache=v end)
local report_caches=logs.reporter("resolvers","caches")
local report_resolvers=logs.reporter("resolvers","caching")
local resolvers=resolvers
local cleanpath=resolvers.cleanpath
local directive_cleanup=false directives.register("system.compile.cleanup",function(v) directive_cleanup=v end)
local directive_strip=false directives.register("system.compile.strip",function(v) directive_strip=v end)
local compile=utilities.lua.compile
function utilities.lua.compile(luafile,lucfile,cleanup,strip)
if cleanup==nil then cleanup=directive_cleanup end
if strip==nil then strip=directive_strip end
return compile(luafile,lucfile,cleanup,strip)
end
caches=caches or {}
local caches=caches
local luasuffixes=utilities.lua.suffixes
caches.base=caches.base or "luatex-cache"
caches.more=caches.more or "context"
caches.direct=false
caches.tree=false
caches.force=true
caches.ask=false
caches.relocate=false
caches.defaults={ "TMPDIR","TEMPDIR","TMP","TEMP","HOME","HOMEPATH" }
directives.register("system.caches.fast",function(v) caches.fast=true end)
local writable,readables,usedreadables=nil,{},{}
local function identify()
local texmfcaches=resolvers.cleanpathlist("TEXMFCACHE")
if texmfcaches then
for k=1,#texmfcaches do
local cachepath=texmfcaches[k]
if cachepath~="" then
cachepath=resolvers.resolve(cachepath)
cachepath=resolvers.cleanpath(cachepath)
cachepath=file.collapsepath(cachepath)
local valid=isdir(cachepath)
if valid then
if is_readable(cachepath) then
readables[#readables+1]=cachepath
if not writable and is_writable(cachepath) then
writable=cachepath
end
end
elseif not writable and caches.force then
local cacheparent=file.dirname(cachepath)
if is_writable(cacheparent) and true then
if not caches.ask or io.ask(format("\nShould I create the cache path %s?",cachepath),"no",{ "yes","no" })=="yes" then
mkdirs(cachepath)
if isdir(cachepath) and is_writable(cachepath) then
report_caches("path %a created",cachepath)
writable=cachepath
readables[#readables+1]=cachepath
end
end
end
end
end
end
end
local texmfcaches=caches.defaults
if texmfcaches then
for k=1,#texmfcaches do
local cachepath=texmfcaches[k]
cachepath=resolvers.expansion(cachepath)
if cachepath~="" then
cachepath=resolvers.resolve(cachepath)
cachepath=resolvers.cleanpath(cachepath)
local valid=isdir(cachepath)
if valid and is_readable(cachepath) then
if not writable and is_writable(cachepath) then
readables[#readables+1]=cachepath
writable=cachepath
break
end
end
end
end
end
if not writable then
report_caches("fatal error: there is no valid writable cache path defined")
os.exit()
elseif #readables==0 then
report_caches("fatal error: there is no valid readable cache path defined")
os.exit()
end
writable=dir.expandname(resolvers.cleanpath(writable))
local base,more,tree=caches.base,caches.more,caches.tree or caches.treehash()
if tree then
caches.tree=tree
writable=mkdirs(writable,base,more,tree)
for i=1,#readables do
readables[i]=file.join(readables[i],base,more,tree)
end
else
writable=mkdirs(writable,base,more)
for i=1,#readables do
readables[i]=file.join(readables[i],base,more)
end
end
if trace_cache then
for i=1,#readables do
report_caches("using readable path %a (order %s)",readables[i],i)
end
report_caches("using writable path %a",writable)
end
identify=function()
return writable,readables
end
return writable,readables
end
function caches.usedpaths(separator)
local writable,readables=identify()
if #readables>1 then
local result={}
local done={}
for i=1,#readables do
local readable=readables[i]
if readable==writable then
done[readable]=true
result[#result+1]=formatters["readable+writable: %a"](readable)
elseif usedreadables[i] then
done[readable]=true
result[#result+1]=formatters["readable: %a"](readable)
end
end
if not done[writable] then
result[#result+1]=formatters["writable: %a"](writable)
end
return concat(result,separator or " | ")
else
return writable or "?"
end
end
function caches.configfiles()
return concat(resolvers.configurationfiles(),";")
end
function caches.hashed(tree)
tree=gsub(tree,"[\\/]+$","")
tree=lower(tree)
local hash=md5.hex(tree)
if trace_cache or trace_locating then
report_caches("hashing tree %a, hash %a",tree,hash)
end
return hash
end
function caches.treehash()
local tree=caches.configfiles()
if not tree or tree=="" then
return false
else
return caches.hashed(tree)
end
end
local r_cache,w_cache={},{}
local function getreadablepaths(...)
local tags={... }
local hash=concat(tags,"/")
local done=r_cache[hash]
if not done then
local writable,readables=identify()
if #tags>0 then
done={}
for i=1,#readables do
done[i]=file.join(readables[i],...)
end
else
done=readables
end
r_cache[hash]=done
end
return done
end
local function getwritablepath(...)
local tags={... }
local hash=concat(tags,"/")
local done=w_cache[hash]
if not done then
local writable,readables=identify()
if #tags>0 then
done=mkdirs(writable,...)
else
done=writable
end
w_cache[hash]=done
end
return done
end
caches.getreadablepaths=getreadablepaths
caches.getwritablepath=getwritablepath
function caches.getfirstreadablefile(filename,...)
local fullname,path=caches.setfirstwritablefile(filename,...)
if is_readable(fullname) then
return fullname,path
end
local rd=getreadablepaths(...)
for i=1,#rd do
local path=rd[i]
local fullname=file.join(path,filename)
if is_readable(fullname) then
usedreadables[i]=true
return fullname,path
end
end
return fullname,path
end
function caches.setfirstwritablefile(filename,...)
local wr=getwritablepath(...)
local fullname=file.join(wr,filename)
return fullname,wr
end
function caches.define(category,subcategory)
return function()
return getwritablepath(category,subcategory)
end
end
function caches.setluanames(path,name)
return format("%s/%s.%s",path,name,luasuffixes.tma),format("%s/%s.%s",path,name,luasuffixes.tmc)
end
function caches.loaddata(readables,name,writable)
if type(readables)=="string" then
readables={ readables }
end
for i=1,#readables do
local path=readables[i]
local loader=false
local tmaname,tmcname=caches.setluanames(path,name)
if isfile(tmcname) then
loader=loadfile(tmcname)
end
if not loader and isfile(tmaname) then
local tmacrap,tmcname=caches.setluanames(writable,name)
if isfile(tmcname) then
loader=loadfile(tmcname)
end
utilities.lua.compile(tmaname,tmcname)
if isfile(tmcname) then
loader=loadfile(tmcname)
end
if not loader then
loader=loadfile(tmaname)
end
end
if loader then
loader=loader()
collectgarbage("step")
return loader
end
end
return false
end
function caches.is_writable(filepath,filename)
local tmaname,tmcname=caches.setluanames(filepath,filename)
return is_writable(tmaname)
end
local saveoptions={ compact=true }
function caches.savedata(filepath,filename,data,raw)
local tmaname,tmcname=caches.setluanames(filepath,filename)
data.cache_uuid=os.uuid()
if caches.fast then
file.savedata(tmaname,table.fastserialize(data,true))
elseif caches.direct then
file.savedata(tmaname,table.serialize(data,true,saveoptions))
else
table.tofile(tmaname,data,true,saveoptions)
end
utilities.lua.compile(tmaname,tmcname)
end
local content_state={}
function caches.contentstate()
return content_state or {}
end
function caches.loadcontent(cachename,dataname,filename)
if not filename then
local name=caches.hashed(cachename)
local full,path=caches.getfirstreadablefile(addsuffix(name,luasuffixes.lua),"trees")
filename=file.join(path,name)
end
local blob=loadfile(addsuffix(filename,luasuffixes.luc)) or loadfile(addsuffix(filename,luasuffixes.lua))
if blob then
local data=blob()
if data and data.content then
if data.type==dataname then
if data.version==resolvers.cacheversion then
content_state[#content_state+1]=data.uuid
if trace_locating then
report_resolvers("loading %a for %a from %a",dataname,cachename,filename)
end
return data.content
else
report_resolvers("skipping %a for %a from %a (version mismatch)",dataname,cachename,filename)
end
else
report_resolvers("skipping %a for %a from %a (datatype mismatch)",dataname,cachename,filename)
end
elseif trace_locating then
report_resolvers("skipping %a for %a from %a (no content)",dataname,cachename,filename)
end
elseif trace_locating then
report_resolvers("skipping %a for %a from %a (invalid file)",dataname,cachename,filename)
end
end
function caches.collapsecontent(content)
for k,v in next,content do
if type(v)=="table" and #v==1 then
content[k]=v[1]
end
end
end
function caches.savecontent(cachename,dataname,content,filename)
if not filename then
local name=caches.hashed(cachename)
local full,path=caches.setfirstwritablefile(addsuffix(name,luasuffixes.lua),"trees")
filename=file.join(path,name)
end
local luaname=addsuffix(filename,luasuffixes.lua)
local lucname=addsuffix(filename,luasuffixes.luc)
if trace_locating then
report_resolvers("preparing %a for %a",dataname,cachename)
end
local data={
type=dataname,
root=cachename,
version=resolvers.cacheversion,
date=os.date("%Y-%m-%d"),
time=os.date("%H:%M:%S"),
content=content,
uuid=os.uuid(),
}
local ok=io.savedata(luaname,table.serialize(data,true))
if ok then
if trace_locating then
report_resolvers("category %a, cachename %a saved in %a",dataname,cachename,luaname)
end
if utilities.lua.compile(luaname,lucname) then
if trace_locating then
report_resolvers("%a compiled to %a",dataname,lucname)
end
return true
else
if trace_locating then
report_resolvers("compiling failed for %a, deleting file %a",dataname,lucname)
end
os.remove(lucname)
end
elseif trace_locating then
report_resolvers("unable to save %a in %a (access error)",dataname,luaname)
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-met"] = package.loaded["data-met"] or true
-- original size: 5310, stripped down to: 3784
if not modules then modules={} end modules ['data-met']={
version=1.100,
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"
}
local find,format=string.find,string.format
local sequenced=table.sequenced
local addurlscheme,urlhashed=url.addscheme,url.hashed
local trace_locating=false
local trace_methods=false
trackers.register("resolvers.locating",function(v) trace_methods=v end)
trackers.register("resolvers.methods",function(v) trace_methods=v end)
local report_methods=logs.reporter("resolvers","methods")
local allocate=utilities.storage.allocate
local resolvers=resolvers
local registered={}
local function splitmethod(filename)
if not filename then
return { scheme="unknown",original=filename }
end
if type(filename)=="table" then
return filename
end
filename=file.collapsepath(filename,".")
if not find(filename,"://",1,true) then
return { scheme="file",path=filename,original=filename,filename=filename }
end
local specification=url.hashed(filename)
if not specification.scheme or specification.scheme=="" then
return { scheme="file",path=filename,original=filename,filename=filename }
else
return specification
end
end
resolvers.splitmethod=splitmethod
local function methodhandler(what,first,...)
local method=registered[what]
if method then
local how,namespace=method.how,method.namespace
if how=="uri" or how=="url" then
local specification=splitmethod(first)
local scheme=specification.scheme
local resolver=namespace and namespace[scheme]
if resolver then
if trace_methods then
report_methods("resolving, method %a, how %a, handler %a, argument %a",what,how,scheme,first)
end
return resolver(specification,...)
else
resolver=namespace.default or namespace.file
if resolver then
if trace_methods then
report_methods("resolving, method %a, how %a, handler %a, argument %a",what,how,"default",first)
end
return resolver(specification,...)
elseif trace_methods then
report_methods("resolving, method %a, how %a, handler %a, argument %a",what,how,"unset")
end
end
elseif how=="tag" then
local resolver=namespace and namespace[first]
if resolver then
if trace_methods then
report_methods("resolving, method %a, how %a, tag %a",what,how,first)
end
return resolver(...)
else
resolver=namespace.default or namespace.file
if resolver then
if trace_methods then
report_methods("resolving, method %a, how %a, tag %a",what,how,"default")
end
return resolver(...)
elseif trace_methods then
report_methods("resolving, method %a, how %a, tag %a",what,how,"unset")
end
end
end
else
report_methods("resolving, invalid method %a")
end
end
resolvers.methodhandler=methodhandler
function resolvers.registermethod(name,namespace,how)
registered[name]={ how=how or "tag",namespace=namespace }
namespace["byscheme"]=function(scheme,filename,...)
if scheme=="file" then
return methodhandler(name,filename,...)
else
return methodhandler(name,addurlscheme(filename,scheme),...)
end
end
end
local concatinators=allocate { notfound=file.join }
local locators=allocate { notfound=function() end }
local hashers=allocate { notfound=function() end }
local generators=allocate { notfound=function() end }
resolvers.concatinators=concatinators
resolvers.locators=locators
resolvers.hashers=hashers
resolvers.generators=generators
local registermethod=resolvers.registermethod
registermethod("concatinators",concatinators,"tag")
registermethod("locators",locators,"uri")
registermethod("hashers",hashers,"uri")
registermethod("generators",generators,"uri")
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-res"] = package.loaded["data-res"] or true
-- original size: 68195, stripped down to: 43680
if not modules then modules={} end modules ['data-res']={
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",
}
local gsub,find,lower,upper,match,gmatch=string.gsub,string.find,string.lower,string.upper,string.match,string.gmatch
local concat,insert,remove=table.concat,table.insert,table.remove
local next,type,rawget=next,type,rawget
local os=os
local P,S,R,C,Cc,Cs,Ct,Carg=lpeg.P,lpeg.S,lpeg.R,lpeg.C,lpeg.Cc,lpeg.Cs,lpeg.Ct,lpeg.Carg
local lpegmatch,lpegpatterns=lpeg.match,lpeg.patterns
local formatters=string.formatters
local filedirname=file.dirname
local filebasename=file.basename
local suffixonly=file.suffixonly
local addsuffix=file.addsuffix
local removesuffix=file.removesuffix
local filejoin=file.join
local collapsepath=file.collapsepath
local joinpath=file.joinpath
local is_qualified_path=file.is_qualified_path
local allocate=utilities.storage.allocate
local settings_to_array=utilities.parsers.settings_to_array
local getcurrentdir=lfs.currentdir
local isfile=lfs.isfile
local isdir=lfs.isdir
local setmetatableindex=table.setmetatableindex
local luasuffixes=utilities.lua.suffixes
local trace_locating=false trackers .register("resolvers.locating",function(v) trace_locating=v end)
local trace_detail=false trackers .register("resolvers.details",function(v) trace_detail=v end)
local trace_expansions=false trackers .register("resolvers.expansions",function(v) trace_expansions=v end)
local trace_paths=false trackers .register("resolvers.paths",function(v) trace_paths=v end)
local resolve_otherwise=true directives.register("resolvers.otherwise",function(v) resolve_otherwise=v end)
local report_resolving=logs.reporter("resolvers","resolving")
local resolvers=resolvers
local expandedpathfromlist=resolvers.expandedpathfromlist
local checkedvariable=resolvers.checkedvariable
local splitconfigurationpath=resolvers.splitconfigurationpath
local methodhandler=resolvers.methodhandler
local filtered=resolvers.filtered_from_content
local lookup=resolvers.get_from_content
local cleanpath=resolvers.cleanpath
local resolveprefix=resolvers.resolve
local initializesetter=utilities.setters.initialize
local ostype,osname,osenv,ossetenv,osgetenv=os.type,os.name,os.env,os.setenv,os.getenv
resolvers.cacheversion="1.100"
resolvers.configbanner=""
resolvers.homedir=environment.homedir
resolvers.criticalvars=allocate { "SELFAUTOLOC","SELFAUTODIR","SELFAUTOPARENT","TEXMFCNF","TEXMF","TEXOS" }
resolvers.luacnfname="texmfcnf.lua"
resolvers.luacnffallback="contextcnf.lua"
resolvers.luacnfstate="unknown"
if environment.default_texmfcnf then
resolvers.luacnfspec="home:texmf/web2c;"..environment.default_texmfcnf
else
resolvers.luacnfspec=concat ({
"home:texmf/web2c",
"selfautoparent:/texmf-local/web2c",
"selfautoparent:/texmf-context/web2c",
"selfautoparent:/texmf-dist/web2c",
"selfautoparent:/texmf/web2c",
},";")
end
local unset_variable="unset"
local formats=resolvers.formats
local suffixes=resolvers.suffixes
local usertypes=resolvers.usertypes
local dangerous=resolvers.dangerous
local suffixmap=resolvers.suffixmap
resolvers.defaultsuffixes={ "tex" }
local instance=nil
function resolvers.setenv(key,value,raw)
if instance then
instance.environment[key]=value
ossetenv(key,raw and value or resolveprefix(value))
end
end
local function getenv(key)
local value=rawget(instance.environment,key)
if value and value~="" then
return value
else
local e=osgetenv(key)
return e~=nil and e~="" and checkedvariable(e) or ""
end
end
resolvers.getenv=getenv
resolvers.env=getenv
local function resolvevariable(k)
return instance.expansions[k]
end
local dollarstripper=lpeg.stripper("$")
local inhibitstripper=P("!")^0*Cs(P(1)^0)
local somevariable=P("$")/""
local somekey=C(R("az","AZ","09","__","--")^1)
local somethingelse=P(";")*((1-S("!{}/\\"))^1*P(";")/"")+P(";")*(P(";")/"")+P(1)
local variableexpander=Cs((somevariable*(somekey/resolvevariable)+somethingelse)^1 )
local cleaner=P("\\")/"/"+P(";")*S("!{}/\\")^0*P(";")^1/";"
local variablecleaner=Cs((cleaner+P(1))^0)
local somevariable=R("az","AZ","09","__","--")^1/resolvevariable
local variable=(P("$")/"")*(somevariable+(P("{")/"")*somevariable*(P("}")/""))
local variableresolver=Cs((variable+P(1))^0)
local function expandedvariable(var)
return lpegmatch(variableexpander,var) or var
end
function resolvers.reset()
if trace_locating then
report_resolving("creating instance")
end
local environment={}
local variables={}
local expansions={}
local order={}
instance={
environment=environment,
variables=variables,
expansions=expansions,
order=order,
files={},
setups={},
found={},
foundintrees={},
hashes={},
hashed={},
pathlists=false,
specification={},
lists={},
data={},
fakepaths={},
remember=true,
diskcache=true,
renewcache=false,
renewtree=false,
loaderror=false,
savelists=true,
pattern=nil,
force_suffixes=true,
pathstack={},
}
setmetatableindex(variables,function(t,k)
local v
for i=1,#order do
v=order[i][k]
if v~=nil then
t[k]=v
return v
end
end
if v==nil then
v=""
end
t[k]=v
return v
end)
setmetatableindex(environment,function(t,k)
local v=osgetenv(k)
if v==nil then
v=variables[k]
end
if v~=nil then
v=checkedvariable(v) or ""
end
v=resolvers.repath(v)
t[k]=v
return v
end)
setmetatableindex(expansions,function(t,k)
local v=environment[k]
if type(v)=="string" then
v=lpegmatch(variableresolver,v)
v=lpegmatch(variablecleaner,v)
end
t[k]=v
return v
end)
end
function resolvers.initialized()
return instance~=nil
end
local function reset_hashes()
instance.lists={}
instance.pathlists=false
instance.found={}
end
local function reset_caches()
instance.lists={}
instance.pathlists=false
end
local slash=P("/")
local pathexpressionpattern=Cs (
Cc("^")*(
Cc("%")*S(".-")+slash^2*P(-1)/"/.*"
+slash^2/"/"+(1-slash)*P(-1)*Cc("/")+P(1)
)^1*Cc("$")
)
local cache={}
local function makepathexpression(str)
if str=="." then
return "^%./$"
else
local c=cache[str]
if not c then
c=lpegmatch(pathexpressionpattern,str)
cache[str]=c
end
return c
end
end
local function reportcriticalvariables(cnfspec)
if trace_locating then
for i=1,#resolvers.criticalvars do
local k=resolvers.criticalvars[i]
local v=resolvers.getenv(k) or "unknown"
report_resolving("variable %a set to %a",k,v)
end
report_resolving()
if cnfspec then
report_resolving("using configuration specification %a",type(cnfspec)=="table" and concat(cnfspec,",") or cnfspec)
end
report_resolving()
end
reportcriticalvariables=function() end
end
local function identify_configuration_files()
local specification=instance.specification
if #specification==0 then
local cnfspec=getenv("TEXMFCNF")
if cnfspec=="" then
cnfspec=resolvers.luacnfspec
resolvers.luacnfstate="default"
else
resolvers.luacnfstate="environment"
end
reportcriticalvariables(cnfspec)
local cnfpaths=expandedpathfromlist(resolvers.splitpath(cnfspec))
local function locatecnf(luacnfname,kind)
for i=1,#cnfpaths do
local filepath=cnfpaths[i]
local filename=collapsepath(filejoin(filepath,luacnfname))
local realname=resolveprefix(filename)
if trace_locating then
local fullpath=gsub(resolveprefix(collapsepath(filepath)),"//","/")
local weirdpath=find(fullpath,"/texmf.+/texmf") or not find(fullpath,"/web2c",1,true)
report_resolving("looking for %s %a on %s path %a from specification %a",
kind,luacnfname,weirdpath and "weird" or "given",fullpath,filepath)
end
if isfile(realname) then
specification[#specification+1]=filename
if trace_locating then
report_resolving("found %s configuration file %a",kind,realname)
end
end
end
end
locatecnf(resolvers.luacnfname,"regular")
if #specification==0 then
locatecnf(resolvers.luacnffallback,"fallback")
end
if trace_locating then
report_resolving()
end
elseif trace_locating then
report_resolving("configuration files already identified")
end
end
local function load_configuration_files()
local specification=instance.specification
if #specification>0 then
local luacnfname=resolvers.luacnfname
for i=1,#specification do
local filename=specification[i]
local pathname=filedirname(filename)
local filename=filejoin(pathname,luacnfname)
local realname=resolveprefix(filename)
local blob=loadfile(realname)
if blob then
local setups=instance.setups
local data=blob()
local parent=data and data.parent
if parent then
local filename=filejoin(pathname,parent)
local realname=resolveprefix(filename)
local blob=loadfile(realname)
if blob then
local parentdata=blob()
if parentdata then
report_resolving("loading configuration file %a",filename)
data=table.merged(parentdata,data)
end
end
end
data=data and data.content
if data then
if trace_locating then
report_resolving("loading configuration file %a",filename)
report_resolving()
end
local variables=data.variables or {}
local warning=false
for k,v in next,data do
local variant=type(v)
if variant=="table" then
initializesetter(filename,k,v)
elseif variables[k]==nil then
if trace_locating and not warning then
report_resolving("variables like %a in configuration file %a should move to the 'variables' subtable",
k,resolveprefix(filename))
warning=true
end
variables[k]=v
end
end
setups[pathname]=variables
if resolvers.luacnfstate=="default" then
local cnfspec=variables["TEXMFCNF"]
if cnfspec then
if trace_locating then
report_resolving("reloading configuration due to TEXMF redefinition")
end
resolvers.setenv("TEXMFCNF",cnfspec)
instance.specification={}
identify_configuration_files()
load_configuration_files()
resolvers.luacnfstate="configuration"
break
end
end
else
if trace_locating then
report_resolving("skipping configuration file %a (no content)",filename)
end
setups[pathname]={}
instance.loaderror=true
end
elseif trace_locating then
report_resolving("skipping configuration file %a (no valid format)",filename)
end
instance.order[#instance.order+1]=instance.setups[pathname]
if instance.loaderror then
break
end
end
elseif trace_locating then
report_resolving("warning: no lua configuration files found")
end
end
function resolvers.configurationfiles()
return instance.specification or {}
end
local function load_file_databases()
instance.loaderror=false
instance.files={}
if not instance.renewcache then
local hashes=instance.hashes
for k=1,#hashes do
local hash=hashes[k]
resolvers.hashers.byscheme(hash.type,hash.name)
if instance.loaderror then break end
end
end
end
local function locate_file_databases()
local texmfpaths=resolvers.expandedpathlist("TEXMF")
if #texmfpaths>0 then
for i=1,#texmfpaths do
local path=collapsepath(texmfpaths[i])
path=gsub(path,"/+$","")
local stripped=lpegmatch(inhibitstripper,path)
if stripped~="" then
local runtime=stripped==path
path=cleanpath(path)
local spec=resolvers.splitmethod(stripped)
if runtime and (spec.noscheme or spec.scheme=="file") then
stripped="tree:///"..stripped
elseif spec.scheme=="cache" or spec.scheme=="file" then
stripped=spec.path
end
if trace_locating then
if runtime then
report_resolving("locating list of %a (runtime) (%s)",path,stripped)
else
report_resolving("locating list of %a (cached)",path)
end
end
methodhandler('locators',stripped)
end
end
if trace_locating then
report_resolving()
end
elseif trace_locating then
report_resolving("no texmf paths are defined (using TEXMF)")
end
end
local function generate_file_databases()
local hashes=instance.hashes
for k=1,#hashes do
local hash=hashes[k]
methodhandler('generators',hash.name)
end
if trace_locating then
report_resolving()
end
end
local function save_file_databases()
for i=1,#instance.hashes do
local hash=instance.hashes[i]
local cachename=hash.name
if hash.cache then
local content=instance.files[cachename]
caches.collapsecontent(content)
if trace_locating then
report_resolving("saving tree %a",cachename)
end
caches.savecontent(cachename,"files",content)
elseif trace_locating then
report_resolving("not saving runtime tree %a",cachename)
end
end
end
function resolvers.renew(hashname)
if hashname and hashname~="" then
local expanded=resolvers.expansion(hashname) or ""
if expanded~="" then
if trace_locating then
report_resolving("identifying tree %a from %a",expanded,hashname)
end
hashname=expanded
else
if trace_locating then
report_resolving("identifying tree %a",hashname)
end
end
local realpath=resolveprefix(hashname)
if isdir(realpath) then
if trace_locating then
report_resolving("using path %a",realpath)
end
methodhandler('generators',hashname)
local content=instance.files[hashname]
caches.collapsecontent(content)
if trace_locating then
report_resolving("saving tree %a",hashname)
end
caches.savecontent(hashname,"files",content)
else
report_resolving("invalid path %a",realpath)
end
end
end
local function load_databases()
locate_file_databases()
if instance.diskcache and not instance.renewcache then
load_file_databases()
if instance.loaderror then
generate_file_databases()
save_file_databases()
end
else
generate_file_databases()
if instance.renewcache then
save_file_databases()
end
end
end
function resolvers.appendhash(type,name,cache)
if not instance.hashed[name] then
if trace_locating then
report_resolving("hash %a appended",name)
end
insert(instance.hashes,{ type=type,name=name,cache=cache } )
instance.hashed[name]=cache
end
end
function resolvers.prependhash(type,name,cache)
if not instance.hashed[name] then
if trace_locating then
report_resolving("hash %a prepended",name)
end
insert(instance.hashes,1,{ type=type,name=name,cache=cache } )
instance.hashed[name]=cache
end
end
function resolvers.extendtexmfvariable(specification)
local t=resolvers.splitpath(getenv("TEXMF"))
insert(t,1,specification)
local newspec=concat(t,",")
if instance.environment["TEXMF"] then
instance.environment["TEXMF"]=newspec
elseif instance.variables["TEXMF"] then
instance.variables["TEXMF"]=newspec
else
end
reset_hashes()
end
function resolvers.splitexpansions()
local ie=instance.expansions
for k,v in next,ie do
local t,tn,h,p={},0,{},splitconfigurationpath(v)
for kk=1,#p do
local vv=p[kk]
if vv~="" and not h[vv] then
tn=tn+1
t[tn]=vv
h[vv]=true
end
end
if #t>1 then
ie[k]=t
else
ie[k]=t[1]
end
end
end
function resolvers.datastate()
return caches.contentstate()
end
function resolvers.variable(name)
local name=name and lpegmatch(dollarstripper,name)
local result=name and instance.variables[name]
return result~=nil and result or ""
end
function resolvers.expansion(name)
local name=name and lpegmatch(dollarstripper,name)
local result=name and instance.expansions[name]
return result~=nil and result or ""
end
function resolvers.unexpandedpathlist(str)
local pth=resolvers.variable(str)
local lst=resolvers.splitpath(pth)
return expandedpathfromlist(lst)
end
function resolvers.unexpandedpath(str)
return joinpath(resolvers.unexpandedpathlist(str))
end
function resolvers.pushpath(name)
local pathstack=instance.pathstack
local lastpath=pathstack[#pathstack]
local pluspath=filedirname(name)
if lastpath then
lastpath=collapsepath(filejoin(lastpath,pluspath))
else
lastpath=collapsepath(pluspath)
end
insert(pathstack,lastpath)
if trace_paths then
report_resolving("pushing path %a",lastpath)
end
end
function resolvers.poppath()
local pathstack=instance.pathstack
if trace_paths and #pathstack>0 then
report_resolving("popping path %a",pathstack[#pathstack])
end
remove(pathstack)
end
function resolvers.stackpath()
local pathstack=instance.pathstack
local currentpath=pathstack[#pathstack]
return currentpath~="" and currentpath or nil
end
local done={}
function resolvers.resetextrapaths()
local ep=instance.extra_paths
if not ep then
done={}
instance.extra_paths={}
elseif #ep>0 then
done={}
reset_caches()
end
end
function resolvers.getextrapaths()
return instance.extra_paths or {}
end
function resolvers.registerextrapath(paths,subpaths)
if not subpaths or subpaths=="" then
if not paths or path=="" then
return
elseif done[paths] then
return
end
end
local paths=settings_to_array(paths)
local subpaths=settings_to_array(subpaths)
local ep=instance.extra_paths or {}
local oldn=#ep
local newn=oldn
local nofpaths=#paths
local nofsubpaths=#subpaths
if nofpaths>0 then
if nofsubpaths>0 then
for i=1,nofpaths do
local p=paths[i]
for j=1,nofsubpaths do
local s=subpaths[j]
local ps=p.."/"..s
if not done[ps] then
newn=newn+1
ep[newn]=cleanpath(ps)
done[ps]=true
end
end
end
else
for i=1,nofpaths do
local p=paths[i]
if not done[p] then
newn=newn+1
ep[newn]=cleanpath(p)
done[p]=true
end
end
end
elseif nofsubpaths>0 then
for i=1,oldn do
for j=1,nofsubpaths do
local s=subpaths[j]
local ps=ep[i].."/"..s
if not done[ps] then
newn=newn+1
ep[newn]=cleanpath(ps)
done[ps]=true
end
end
end
end
if newn>0 then
instance.extra_paths=ep
end
if newn~=oldn then
reset_caches()
end
end
function resolvers.pushextrapath(path)
local paths=settings_to_array(path)
if instance.extra_stack then
insert(instance.extra_stack,1,paths)
else
instance.extra_stack={ paths }
end
reset_caches()
end
function resolvers.popextrapath()
if instance.extra_stack then
reset_caches()
return remove(instance.extra_stack,1)
end
end
local function made_list(instance,list,extra_too)
local done={}
local new={}
local newn=0
local function add(p)
for k=1,#p do
local v=p[k]
if not done[v] then
done[v]=true
newn=newn+1
new[newn]=v
end
end
end
for k=1,#list do
local v=list[k]
if done[v] then
elseif find(v,"^[%.%/]$") then
done[v]=true
newn=newn+1
new[newn]=v
else
break
end
end
if extra_too then
local es=instance.extra_stack
if es and #es>0 then
for k=1,#es do
add(es[k])
end
end
local ep=instance.extra_paths
if ep and #ep>0 then
add(ep)
end
end
add(list)
return new
end
function resolvers.cleanpathlist(str)
local t=resolvers.expandedpathlist(str)
if t then
for i=1,#t do
t[i]=collapsepath(cleanpath(t[i]))
end
end
return t
end
function resolvers.expandpath(str)
return joinpath(resolvers.expandedpathlist(str))
end
function resolvers.expandedpathlist(str,extra_too)
if not str then
return {}
elseif instance.savelists then
str=lpegmatch(dollarstripper,str)
local lists=instance.lists
local lst=lists[str]
if not lst then
local l=made_list(instance,resolvers.splitpath(resolvers.expansion(str)),extra_too)
lst=expandedpathfromlist(l)
lists[str]=lst
end
return lst
else
local lst=resolvers.splitpath(resolvers.expansion(str))
return made_list(instance,expandedpathfromlist(lst),extra_too)
end
end
function resolvers.expandedpathlistfromvariable(str)
str=lpegmatch(dollarstripper,str)
local tmp=resolvers.variableofformatorsuffix(str)
return resolvers.expandedpathlist(tmp~="" and tmp or str)
end
function resolvers.expandpathfromvariable(str)
return joinpath(resolvers.expandedpathlistfromvariable(str))
end
function resolvers.cleanedpathlist(v)
local t=resolvers.expandedpathlist(v)
for i=1,#t do
t[i]=resolvers.resolve(resolvers.cleanpath(t[i]))
end
return t
end
function resolvers.expandbraces(str)
local pth=expandedpathfromlist(resolvers.splitpath(str))
return joinpath(pth)
end
function resolvers.registerfilehash(name,content,someerror)
if content then
instance.files[name]=content
else
instance.files[name]={}
if somerror==true then
instance.loaderror=someerror
end
end
end
function resolvers.getfilehashes()
return instance and instance.files or {}
end
function resolvers.gethashes()
return instance and instance.hashes or {}
end
function resolvers.renewcache()
if instance then
instance.renewcache=true
end
end
local function isreadable(name)
local readable=isfile(name)
if trace_detail then
if readable then
report_resolving("file %a is readable",name)
else
report_resolving("file %a is not readable",name)
end
end
return readable
end
local function collect_files(names)
local filelist={}
local noffiles=0
local function check(hash,root,pathname,path,basename,name)
if not pathname or find(path,pathname) then
local variant=hash.type
local search=filejoin(root,path,name)
local result=methodhandler('concatinators',variant,root,path,name)
if trace_detail then
report_resolving("match: variant %a, search %a, result %a",variant,search,result)
end
noffiles=noffiles+1
filelist[noffiles]={ variant,search,result }
end
end
for k=1,#names do
local filename=names[k]
if trace_detail then
report_resolving("checking name %a",filename)
end
local basename=filebasename(filename)
local pathname=filedirname(filename)
if pathname=="" or find(pathname,"^%.") then
pathname=false
else
pathname=gsub(pathname,"%*",".*")
pathname="/"..pathname.."$"
end
local hashes=instance.hashes
for h=1,#hashes do
local hash=hashes[h]
local hashname=hash.name
local content=hashname and instance.files[hashname]
if content then
if trace_detail then
report_resolving("deep checking %a, base %a, pattern %a",hashname,basename,pathname)
end
local path,name=lookup(content,basename)
if path then
local metadata=content.metadata
local realroot=metadata and metadata.path or hashname
if type(path)=="string" then
check(hash,realroot,pathname,path,basename,name)
else
for i=1,#path do
check(hash,realroot,pathname,path[i],basename,name)
end
end
end
elseif trace_locating then
report_resolving("no match in %a (%s)",hashname,basename)
end
end
end
return noffiles>0 and filelist or nil
end
local fit={}
function resolvers.registerintrees(filename,format,filetype,usedmethod,foundname)
local foundintrees=instance.foundintrees
if usedmethod=="direct" and filename==foundname and fit[foundname] then
else
local collapsed=collapsepath(foundname,true)
local t={
filename=filename,
format=format~="" and format or nil,
filetype=filetype~="" and filetype or nil,
usedmethod=usedmethod,
foundname=foundname,
fullname=collapsed,
}
fit[foundname]=t
foundintrees[#foundintrees+1]=t
end
end
function resolvers.foundintrees()
return instance.foundintrees or {}
end
function resolvers.foundintree(fullname)
local f=fit[fullname]
return f and f.usedmethod=="database"
end
local function can_be_dir(name)
local fakepaths=instance.fakepaths
if not fakepaths[name] then
if isdir(name) then
fakepaths[name]=1
else
fakepaths[name]=2
end
end
return fakepaths[name]==1
end
local preparetreepattern=Cs((P(".")/"%%."+P("-")/"%%-"+P(1))^0*Cc("$"))
local collect_instance_files
local function find_analyze(filename,askedformat,allresults)
local filetype=''
local filesuffix=suffixonly(filename)
local wantedfiles={}
wantedfiles[#wantedfiles+1]=filename
if askedformat=="" then
if filesuffix=="" or not suffixmap[filesuffix] then
local defaultsuffixes=resolvers.defaultsuffixes
local formatofsuffix=resolvers.formatofsuffix
for i=1,#defaultsuffixes do
local forcedname=filename..'.'..defaultsuffixes[i]
wantedfiles[#wantedfiles+1]=forcedname
filetype=formatofsuffix(forcedname)
if trace_locating then
report_resolving("forcing filetype %a",filetype)
end
end
else
filetype=resolvers.formatofsuffix(filename)
if trace_locating then
report_resolving("using suffix based filetype %a",filetype)
end
end
else
if filesuffix=="" or not suffixmap[filesuffix] then
local format_suffixes=suffixes[askedformat]
if format_suffixes then
for i=1,#format_suffixes do
wantedfiles[#wantedfiles+1]=filename.."."..format_suffixes[i]
end
end
end
filetype=askedformat
if trace_locating then
report_resolving("using given filetype %a",filetype)
end
end
return filetype,wantedfiles
end
local function find_direct(filename,allresults)
if not dangerous[askedformat] and isreadable(filename) then
if trace_detail then
report_resolving("file %a found directly",filename)
end
return "direct",{ filename }
end
end
local function find_wildcard(filename,allresults)
if find(filename,'*',1,true) then
if trace_locating then
report_resolving("checking wildcard %a",filename)
end
local result=resolvers.findwildcardfiles(filename)
if result then
return "wildcard",result
end
end
end
local function find_qualified(filename,allresults,askedformat,alsostripped)
if not is_qualified_path(filename) then
return
end
if trace_locating then
report_resolving("checking qualified name %a",filename)
end
if isreadable(filename) then
if trace_detail then
report_resolving("qualified file %a found",filename)
end
return "qualified",{ filename }
end
if trace_detail then
report_resolving("locating qualified file %a",filename)
end
local forcedname,suffix="",suffixonly(filename)
if suffix=="" then
local format_suffixes=askedformat=="" and resolvers.defaultsuffixes or suffixes[askedformat]
if format_suffixes then
for i=1,#format_suffixes do
local s=format_suffixes[i]
forcedname=filename.."."..s
if isreadable(forcedname) then
if trace_locating then
report_resolving("no suffix, forcing format filetype %a",s)
end
return "qualified",{ forcedname }
end
end
end
end
if alsostripped and suffix and suffix~="" then
local basename=filebasename(filename)
local pattern=lpegmatch(preparetreepattern,filename)
local savedformat=askedformat
local format=savedformat or ""
if format=="" then
askedformat=resolvers.formatofsuffix(suffix)
end
if not format then
askedformat="othertextfiles"
end
if basename~=filename then
local resolved=collect_instance_files(basename,askedformat,allresults)
if #resolved==0 then
local lowered=lower(basename)
if filename~=lowered then
resolved=collect_instance_files(lowered,askedformat,allresults)
end
end
resolvers.format=savedformat
if #resolved>0 then
local result={}
for r=1,#resolved do
local rr=resolved[r]
if find(rr,pattern) then
result[#result+1]=rr
end
end
if #result>0 then
return "qualified",result
end
end
end
end
end
local function check_subpath(fname)
if isreadable(fname) then
if trace_detail then
report_resolving("found %a by deep scanning",fname)
end
return fname
end
end
local function makepathlist(list,filetype)
local typespec=resolvers.variableofformat(filetype)
local pathlist=resolvers.expandedpathlist(typespec,filetype and usertypes[filetype])
local entry={}
if pathlist and #pathlist>0 then
for k=1,#pathlist do
local path=pathlist[k]
local prescanned=find(path,'^!!')
local resursive=find(path,'//$')
local pathname=lpegmatch(inhibitstripper,path)
local expression=makepathexpression(pathname)
local barename=gsub(pathname,"/+$","")
barename=resolveprefix(barename)
local scheme=url.hasscheme(barename)
local schemename=gsub(barename,"%.%*$",'')
entry[k]={
path=path,
pathname=pathname,
prescanned=prescanned,
recursive=recursive,
expression=expression,
barename=barename,
scheme=scheme,
schemename=schemename,
}
end
entry.typespec=typespec
list[filetype]=entry
else
list[filetype]=false
end
return entry
end
local function find_intree(filename,filetype,wantedfiles,allresults)
local pathlists=instance.pathlists
if not pathlists then
pathlists=setmetatableindex({},makepathlist)
instance.pathlists=pathlists
end
local pathlist=pathlists[filetype]
if pathlist then
local method="intree"
local filelist=collect_files(wantedfiles)
local dirlist={}
local result={}
if filelist then
for i=1,#filelist do
dirlist[i]=filedirname(filelist[i][3]).."/"
end
end
if trace_detail then
report_resolving("checking filename %a in tree",filename)
end
for k=1,#pathlist do
local entry=pathlist[k]
local path=entry.path
local pathname=entry.pathname
local done=false
if filelist then
local expression=entry.expression
if trace_detail then
report_resolving("using pattern %a for path %a",expression,pathname)
end
for k=1,#filelist do
local fl=filelist[k]
local f=fl[2]
local d=dirlist[k]
if find(d,expression) or find(resolveprefix(d),expression) then
result[#result+1]=resolveprefix(fl[3])
done=true
if allresults then
if trace_detail then
report_resolving("match to %a in hash for file %a and path %a, continue scanning",expression,f,d)
end
else
if trace_detail then
report_resolving("match to %a in hash for file %a and path %a, quit scanning",expression,f,d)
end
break
end
elseif trace_detail then
report_resolving("no match to %a in hash for file %a and path %a",expression,f,d)
end
end
end
if done then
method="database"
else
method="filesystem"
local scheme=entry.scheme
if not scheme or scheme=="file" then
local pname=entry.schemename
if not find(pname,"*",1,true) then
if can_be_dir(pname) then
if not done and not entry.prescanned then
if trace_detail then
report_resolving("quick root scan for %a",pname)
end
for k=1,#wantedfiles do
local w=wantedfiles[k]
local fname=check_subpath(filejoin(pname,w))
if fname then
result[#result+1]=fname
done=true
if not allresults then
break
end
end
end
if not done and entry.recursive then
if trace_detail then
report_resolving("scanning filesystem for %a",pname)
end
local files=resolvers.simplescanfiles(pname,false,true)
for k=1,#wantedfiles do
local w=wantedfiles[k]
local subpath=files[w]
if not subpath or subpath=="" then
elseif type(subpath)=="string" then
local fname=check_subpath(filejoin(pname,subpath,w))
if fname then
result[#result+1]=fname
done=true
if not allresults then
break
end
end
else
for i=1,#subpath do
local sp=subpath[i]
if sp=="" then
else
local fname=check_subpath(filejoin(pname,sp,w))
if fname then
result[#result+1]=fname
done=true
if not allresults then
break
end
end
end
end
if done and not allresults then
break
end
end
end
end
end
end
else
end
else
for k=1,#wantedfiles do
local pname=entry.barename
local fname=methodhandler('finders',pname.."/"..wantedfiles[k])
if fname then
result[#result+1]=fname
done=true
if not allresults then
break
end
end
end
end
end
if done and not allresults then
break
end
end
if #result>0 then
return method,result
end
end
end
local function find_onpath(filename,filetype,wantedfiles,allresults)
if trace_detail then
report_resolving("checking filename %a, filetype %a, wanted files %a",filename,filetype,concat(wantedfiles," | "))
end
local result={}
for k=1,#wantedfiles do
local fname=wantedfiles[k]
if fname and isreadable(fname) then
filename=fname
result[#result+1]=filejoin('.',fname)
if not allresults then
break
end
end
end
if #result>0 then
return "onpath",result
end
end
local function find_otherwise(filename,filetype,wantedfiles,allresults)
local filelist=collect_files(wantedfiles)
local fl=filelist and filelist[1]
if fl then
return "otherwise",{ resolveprefix(fl[3]) }
end
end
collect_instance_files=function(filename,askedformat,allresults)
if not filename or filename=="" then
return {}
end
askedformat=askedformat or ""
filename=collapsepath(filename,".")
filename=gsub(filename,"^%./",getcurrentdir().."/")
if allresults then
local filetype,wantedfiles=find_analyze(filename,askedformat)
local results={
{ find_direct (filename,true) },
{ find_wildcard (filename,true) },
{ find_qualified(filename,true,askedformat) },
{ find_intree (filename,filetype,wantedfiles,true) },
{ find_onpath (filename,filetype,wantedfiles,true) },
{ find_otherwise(filename,filetype,wantedfiles,true) },
}
local result,status,done={},{},{}
for k,r in next,results do
local method,list=r[1],r[2]
if method and list then
for i=1,#list do
local c=collapsepath(list[i])
if not done[c] then
result[#result+1]=c
done[c]=true
end
status[#status+1]=formatters["%-10s: %s"](method,c)
end
end
end
if trace_detail then
report_resolving("lookup status: %s",table.serialize(status,filename))
end
return result,status
else
local method,result,stamp,filetype,wantedfiles
if instance.remember then
if askedformat=="" then
stamp=formatters["%s::%s"](suffixonly(filename),filename)
else
stamp=formatters["%s::%s"](askedformat,filename)
end
result=stamp and instance.found[stamp]
if result then
if trace_locating then
report_resolving("remembered file %a",filename)
end
return result
end
end
method,result=find_direct(filename)
if not result then
method,result=find_wildcard(filename)
if not result then
method,result=find_qualified(filename,false,askedformat)
if not result then
filetype,wantedfiles=find_analyze(filename,askedformat)
method,result=find_intree(filename,filetype,wantedfiles)
if not result then
method,result=find_onpath(filename,filetype,wantedfiles)
if resolve_otherwise and not result then
method,result=find_otherwise(filename,filetype,wantedfiles)
end
end
end
end
end
if result and #result>0 then
local foundname=collapsepath(result[1])
resolvers.registerintrees(filename,askedformat,filetype,method,foundname)
result={ foundname }
else
result={}
end
if stamp then
if trace_locating then
report_resolving("remembering file %a using hash %a",filename,stamp)
end
instance.found[stamp]=result
end
return result
end
end
local function findfiles(filename,filetype,allresults)
if not filename or filename=="" then
return {}
end
local result,status=collect_instance_files(filename,filetype or "",allresults)
if not result or #result==0 then
local lowered=lower(filename)
if filename~=lowered then
result,status=collect_instance_files(lowered,filetype or "",allresults)
end
end
return result or {},status
end
function resolvers.findfiles(filename,filetype)
if not filename or filename=="" then
return ""
else
return findfiles(filename,filetype,true)
end
end
function resolvers.findfile(filename,filetype)
if not filename or filename=="" then
return ""
else
return findfiles(filename,filetype,false)[1] or ""
end
end
function resolvers.findpath(filename,filetype)
return filedirname(findfiles(filename,filetype,false)[1] or "")
end
local function findgivenfiles(filename,allresults)
local base=filebasename(filename)
local result={}
local hashes=instance.hashes
local function okay(hash,path,name)
local found=methodhandler('concatinators',hash.type,hash.name,path,name)
if found and found~="" then
result[#result+1]=resolveprefix(found)
return not allresults
end
end
for k=1,#hashes do
local hash=hashes[k]
local content=instance.files[hash.name]
if content then
local path,name=lookup(content,base)
if not path then
elseif type(path)=="string" then
if okay(hash,path,name) then
return result
end
else
for i=1,#path do
if okay(hash,path[i],name) then
return result
end
end
end
end
end
return result
end
function resolvers.findgivenfiles(filename)
return findgivenfiles(filename,true)
end
function resolvers.findgivenfile(filename)
return findgivenfiles(filename,false)[1] or ""
end
local makewildcard=Cs(
(P("^")^0*P("/")*P(-1)+P(-1))/".*"+(P("^")^0*P("/")/"")^0*(P("*")/".*"+P("-")/"%%-"+P(".")/"%%."+P("?")/"."+P("\\")/"/"+P(1))^0
)
function resolvers.wildcardpattern(pattern)
return lpegmatch(makewildcard,pattern) or pattern
end
local function findwildcardfiles(filename,allresults,result)
local result=result or {}
local base=filebasename(filename)
local dirn=filedirname(filename)
local path=lower(lpegmatch(makewildcard,dirn) or dirn)
local name=lower(lpegmatch(makewildcard,base) or base)
local files=instance.files
if find(name,"*",1,true) then
local hashes=instance.hashes
local function okay(found,path,base,hashname,hashtype)
if find(found,path) then
local full=methodhandler('concatinators',hashtype,hashname,found,base)
if full and full~="" then
result[#result+1]=resolveprefix(full)
return not allresults
end
end
end
for k=1,#hashes do
local hash=hashes[k]
local hashname=hash.name
local hashtype=hash.type
if hashname and hashtype then
for found,base in filtered(files[hashname],name) do
if type(found)=='string' then
if okay(found,path,base,hashname,hashtype) then
break
end
else
for i=1,#found do
if okay(found[i],path,base,hashname,hashtype) then
break
end
end
end
end
end
end
else
local function okayokay(found,path,base,hashname,hashtype)
if find(found,path) then
local full=methodhandler('concatinators',hashtype,hashname,found,base)
if full and full~="" then
result[#result+1]=resolveprefix(full)
return not allresults
end
end
end
local hashes=instance.hashes
for k=1,#hashes do
local hash=hashes[k]
local hashname=hash.name
local hashtype=hash.type
if hashname and hashtype then
local found,base=lookup(content,base)
if not found then
elseif type(found)=='string' then
if okay(found,path,base,hashname,hashtype) then
break
end
else
for i=1,#found do
if okay(found[i],path,base,hashname,hashtype) then
break
end
end
end
end
end
end
return result
end
function resolvers.findwildcardfiles(filename,result)
return findwildcardfiles(filename,true,result)
end
function resolvers.findwildcardfile(filename)
return findwildcardfiles(filename,false)[1] or ""
end
function resolvers.automount()
end
function resolvers.starttiming()
statistics.starttiming(instance)
end
function resolvers.stoptiming()
statistics.stoptiming(instance)
end
function resolvers.load(option)
resolvers.starttiming()
identify_configuration_files()
load_configuration_files()
if option~="nofiles" then
load_databases()
resolvers.automount()
end
resolvers.stoptiming()
local files=instance.files
return files and next(files) and true
end
function resolvers.loadtime()
return statistics.elapsedtime(instance)
end
local function report(str)
if trace_locating then
report_resolving(str)
else
print(str)
end
end
function resolvers.dowithfilesandreport(command,files,...)
if files and #files>0 then
if trace_locating then
report('')
end
if type(files)=="string" then
files={ files }
end
for f=1,#files do
local file=files[f]
local result=command(file,...)
if type(result)=='string' then
report(result)
else
for i=1,#result do
report(result[i])
end
end
end
end
end
function resolvers.showpath(str)
return joinpath(resolvers.expandedpathlist(resolvers.formatofvariable(str)))
end
function resolvers.registerfile(files,name,path)
if files[name] then
if type(files[name])=='string' then
files[name]={ files[name],path }
else
files[name]=path
end
else
files[name]=path
end
end
function resolvers.dowithpath(name,func)
local pathlist=resolvers.expandedpathlist(name)
for i=1,#pathlist do
func("^"..cleanpath(pathlist[i]))
end
end
function resolvers.dowithvariable(name,func)
func(expandedvariable(name))
end
function resolvers.locateformat(name)
local engine=environment.ownmain or "luatex"
local barename=removesuffix(name)
local fullname=addsuffix(barename,"fmt")
local fmtname=caches.getfirstreadablefile(fullname,"formats",engine) or ""
if fmtname=="" then
fmtname=resolvers.findfile(fullname)
fmtname=cleanpath(fmtname)
end
if fmtname~="" then
local barename=removesuffix(fmtname)
local luaname=addsuffix(barename,luasuffixes.lua)
local lucname=addsuffix(barename,luasuffixes.luc)
local luiname=addsuffix(barename,luasuffixes.lui)
if isfile(luiname) then
return barename,luiname
elseif isfile(lucname) then
return barename,lucname
elseif isfile(luaname) then
return barename,luaname
end
end
return nil,nil
end
function resolvers.booleanvariable(str,default)
local b=resolvers.expansion(str)
if b=="" then
return default
else
b=toboolean(b)
return (b==nil and default) or b
end
end
function resolvers.dowithfilesintree(pattern,handle,before,after)
local hashes=instance.hashes
for i=1,#hashes do
local hash=hashes[i]
local blobtype=hash.type
local blobpath=hash.name
if blobtype and blobpath then
local total=0
local checked=0
local done=0
if before then
before(blobtype,blobpath,pattern)
end
for path,name in filtered(instance.files[blobpath],pattern) do
if type(path)=="string" then
checked=checked+1
if handle(blobtype,blobpath,path,name) then
done=done+1
end
else
checked=checked+#path
for i=1,#path do
if handle(blobtype,blobpath,path[i],name) then
done=done+1
end
end
end
end
if after then
after(blobtype,blobpath,pattern,checked,done)
end
end
end
end
local obsolete=resolvers.obsolete or {}
resolvers.obsolete=obsolete
resolvers.find_file=resolvers.findfile obsolete.find_file=resolvers.findfile
resolvers.find_files=resolvers.findfiles obsolete.find_files=resolvers.findfiles
function resolvers.knownvariables(pattern)
if instance then
local environment=instance.environment
local variables=instance.variables
local expansions=instance.expansions
local order=instance.order
local pattern=upper(pattern or "")
local result={}
for i=1,#order do
for key in next,order[i] do
if result[key]==nil and key~="" and (pattern=="" or find(upper(key),pattern)) then
result[key]={
environment=rawget(environment,key),
variable=key,
expansion=expansions[key],
resolved=resolveprefix(expansions[key]),
}
end
end
end
return result
else
return {}
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-pre"] = package.loaded["data-pre"] or true
-- original size: 4854, stripped down to: 2889
if not modules then modules={} end modules ['data-pre']={
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"
}
local resolvers=resolvers
local prefixes=resolvers.prefixes
local cleanpath=resolvers.cleanpath
local findgivenfile=resolvers.findgivenfile
local expansion=resolvers.expansion
local getenv=resolvers.getenv
local basename=file.basename
local dirname=file.dirname
local joinpath=file.join
local isfile=lfs.isfile
prefixes.environment=function(str)
return cleanpath(expansion(str))
end
local function relative(str,n)
if not isfile(str) then
local pstr="./"..str
if isfile(pstr) then
str=pstr
else
local p="../"
for i=1,n or 2 do
local pstr=p..str
if isfile(pstr) then
str=pstr
break
else
p=p.."../"
end
end
end
end
return cleanpath(str)
end
local function locate(str)
local fullname=findgivenfile(str) or ""
return cleanpath(fullname~="" and fullname or str)
end
prefixes.relative=relative
prefixes.locate=locate
prefixes.auto=function(str)
local fullname=relative(str)
if not isfile(fullname) then
fullname=locate(str)
end
return fullname
end
prefixes.filename=function(str)
local fullname=findgivenfile(str) or ""
return cleanpath(basename((fullname~="" and fullname) or str))
end
prefixes.pathname=function(str)
local fullname=findgivenfile(str) or ""
return cleanpath(dirname((fullname~="" and fullname) or str))
end
prefixes.selfautoloc=function(str)
local pth=getenv('SELFAUTOLOC')
return cleanpath(str and joinpath(pth,str) or pth)
end
prefixes.selfautoparent=function(str)
local pth=getenv('SELFAUTOPARENT')
return cleanpath(str and joinpath(pth,str) or pth)
end
prefixes.selfautodir=function(str)
local pth=getenv('SELFAUTODIR')
return cleanpath(str and joinpath(pth,str) or pth)
end
prefixes.home=function(str)
local pth=getenv('HOME')
return cleanpath(str and joinpath(pth,str) or pth)
end
prefixes.env=prefixes.environment
prefixes.rel=prefixes.relative
prefixes.loc=prefixes.locate
prefixes.kpse=prefixes.locate
prefixes.full=prefixes.locate
prefixes.file=prefixes.filename
prefixes.path=prefixes.pathname
local function toppath()
local inputstack=resolvers.inputstack
if not inputstack then
return "."
end
local pathname=dirname(inputstack[#inputstack] or "")
if pathname=="" then
return "."
else
return pathname
end
end
local function jobpath()
local path=resolvers.stackpath()
if not path or path=="" then
return "."
else
return path
end
end
resolvers.toppath=toppath
resolvers.jobpath=jobpath
prefixes.toppath=function(str) return cleanpath(joinpath(toppath(),str)) end
prefixes.jobpath=function(str) return cleanpath(joinpath(jobpath(),str)) end
resolvers.setdynamic("toppath")
resolvers.setdynamic("jobpath")
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-inp"] = package.loaded["data-inp"] or true
-- original size: 910, stripped down to: 818
if not modules then modules={} end modules ['data-inp']={
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"
}
local allocate=utilities.storage.allocate
local resolvers=resolvers
local methodhandler=resolvers.methodhandler
local registermethod=resolvers.registermethod
local finders=allocate { helpers={},notfound=function() end }
local openers=allocate { helpers={},notfound=function() end }
local loaders=allocate { helpers={},notfound=function() return false,nil,0 end }
registermethod("finders",finders,"uri")
registermethod("openers",openers,"uri")
registermethod("loaders",loaders,"uri")
resolvers.finders=finders
resolvers.openers=openers
resolvers.loaders=loaders
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-out"] = package.loaded["data-out"] or true
-- original size: 530, stripped down to: 470
if not modules then modules={} end modules ['data-out']={
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"
}
local allocate=utilities.storage.allocate
local resolvers=resolvers
local registermethod=resolvers.registermethod
local savers=allocate { helpers={} }
resolvers.savers=savers
registermethod("savers",savers,"uri")
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-fil"] = package.loaded["data-fil"] or true
-- original size: 3863, stripped down to: 3170
if not modules then modules={} end modules ['data-fil']={
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"
}
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local report_files=logs.reporter("resolvers","files")
local resolvers=resolvers
local resolveprefix=resolvers.resolve
local finders,openers,loaders,savers=resolvers.finders,resolvers.openers,resolvers.loaders,resolvers.savers
local locators,hashers,generators,concatinators=resolvers.locators,resolvers.hashers,resolvers.generators,resolvers.concatinators
local checkgarbage=utilities.garbagecollector and utilities.garbagecollector.check
function locators.file(specification)
local filename=specification.filename
local realname=resolveprefix(filename)
if realname and realname~='' and lfs.isdir(realname) then
if trace_locating then
report_files("file locator %a found as %a",filename,realname)
end
resolvers.appendhash('file',filename,true)
elseif trace_locating then
report_files("file locator %a not found",filename)
end
end
function hashers.file(specification)
local pathname=specification.filename
local content=caches.loadcontent(pathname,'files')
resolvers.registerfilehash(pathname,content,content==nil)
end
function generators.file(specification)
local pathname=specification.filename
local content=resolvers.scanfiles(pathname,false,true)
resolvers.registerfilehash(pathname,content,true)
end
concatinators.file=file.join
function finders.file(specification,filetype)
local filename=specification.filename
local foundname=resolvers.findfile(filename,filetype)
if foundname and foundname~="" then
if trace_locating then
report_files("file finder: %a found",filename)
end
return foundname
else
if trace_locating then
report_files("file finder: %a not found",filename)
end
return finders.notfound()
end
end
function openers.helpers.textopener(tag,filename,f)
return {
reader=function() return f:read () end,
close=function() logs.show_close(filename) return f:close() end,
}
end
function openers.file(specification,filetype)
local filename=specification.filename
if filename and filename~="" then
local f=io.open(filename,"r")
if f then
if trace_locating then
report_files("file opener: %a opened",filename)
end
return openers.helpers.textopener("file",filename,f)
end
end
if trace_locating then
report_files("file opener: %a not found",filename)
end
return openers.notfound()
end
function loaders.file(specification,filetype)
local filename=specification.filename
if filename and filename~="" then
local f=io.open(filename,"rb")
if f then
logs.show_load(filename)
if trace_locating then
report_files("file loader: %a loaded",filename)
end
local s=f:read("*a")
if checkgarbage then
checkgarbage(#s)
end
f:close()
if s then
return true,s,#s
end
end
end
if trace_locating then
report_files("file loader: %a not found",filename)
end
return loaders.notfound()
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-con"] = package.loaded["data-con"] or true
-- original size: 5029, stripped down to: 3432
if not modules then modules={} end modules ['data-con']={
version=1.100,
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"
}
local format,lower,gsub=string.format,string.lower,string.gsub
local trace_cache=false trackers.register("resolvers.cache",function(v) trace_cache=v end)
local trace_containers=false trackers.register("resolvers.containers",function(v) trace_containers=v end)
local trace_storage=false trackers.register("resolvers.storage",function(v) trace_storage=v end)
containers=containers or {}
local containers=containers
containers.usecache=true
local report_containers=logs.reporter("resolvers","containers")
local allocated={}
local mt={
__index=function(t,k)
if k=="writable" then
local writable=caches.getwritablepath(t.category,t.subcategory) or { "." }
t.writable=writable
return writable
elseif k=="readables" then
local readables=caches.getreadablepaths(t.category,t.subcategory) or { "." }
t.readables=readables
return readables
end
end,
__storage__=true
}
function containers.define(category,subcategory,version,enabled)
if category and subcategory then
local c=allocated[category]
if not c then
c={}
allocated[category]=c
end
local s=c[subcategory]
if not s then
s={
category=category,
subcategory=subcategory,
storage={},
enabled=enabled,
version=version or math.pi,
trace=false,
}
setmetatable(s,mt)
c[subcategory]=s
end
return s
end
end
function containers.is_usable(container,name)
return container.enabled and caches and caches.is_writable(container.writable,name)
end
function containers.is_valid(container,name)
if name and name~="" then
local storage=container.storage[name]
return storage and storage.cache_version==container.version
else
return false
end
end
function containers.read(container,name)
local storage=container.storage
local stored=storage[name]
if not stored and container.enabled and caches and containers.usecache then
stored=caches.loaddata(container.readables,name,container.writable)
if stored and stored.cache_version==container.version then
if trace_cache or trace_containers then
report_containers("action %a, category %a, name %a","load",container.subcategory,name)
end
else
stored=nil
end
storage[name]=stored
elseif stored then
if trace_cache or trace_containers then
report_containers("action %a, category %a, name %a","reuse",container.subcategory,name)
end
end
return stored
end
function containers.write(container,name,data)
if data then
data.cache_version=container.version
if container.enabled and caches then
local unique,shared=data.unique,data.shared
data.unique,data.shared=nil,nil
caches.savedata(container.writable,name,data)
if trace_cache or trace_containers then
report_containers("action %a, category %a, name %a","save",container.subcategory,name)
end
data.unique,data.shared=unique,shared
end
if trace_cache or trace_containers then
report_containers("action %a, category %a, name %a","store",container.subcategory,name)
end
container.storage[name]=data
end
return data
end
function containers.content(container,name)
return container.storage[name]
end
function containers.cleanname(name)
return (gsub(lower(name),"[^%w\128-\255]+","-"))
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-use"] = package.loaded["data-use"] or true
-- original size: 4434, stripped down to: 3180
if not modules then modules={} end modules ['data-use']={
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"
}
local format,lower,gsub,find=string.format,string.lower,string.gsub,string.find
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local report_mounts=logs.reporter("resolvers","mounts")
local resolvers=resolvers
resolvers.automounted=resolvers.automounted or {}
function resolvers.automount(usecache)
local mountpaths=resolvers.cleanpathlist(resolvers.expansion('TEXMFMOUNT'))
if (not mountpaths or #mountpaths==0) and usecache then
mountpaths=caches.getreadablepaths("mount")
end
if mountpaths and #mountpaths>0 then
resolvers.starttiming()
for k=1,#mountpaths do
local root=mountpaths[k]
local f=io.open(root.."/url.tmi")
if f then
for line in f:lines() do
if line then
if find(line,"^[%%#%-]") then
elseif find(line,"^zip://") then
if trace_locating then
report_mounts("mounting %a",line)
end
table.insert(resolvers.automounted,line)
resolvers.usezipfile(line)
end
end
end
f:close()
end
end
resolvers.stoptiming()
end
end
statistics.register("used config file",function() return caches.configfiles() end)
statistics.register("used cache path",function() return caches.usedpaths() end)
function statistics.savefmtstatus(texname,formatbanner,sourcefile,kind,banner)
local enginebanner=status.banner
if formatbanner and enginebanner and sourcefile then
local luvname=file.replacesuffix(texname,"luv")
local luvdata={
enginebanner=enginebanner,
formatbanner=formatbanner,
sourcehash=md5.hex(io.loaddata(resolvers.findfile(sourcefile)) or "unknown"),
sourcefile=sourcefile,
luaversion=LUAVERSION,
}
io.savedata(luvname,table.serialize(luvdata,true))
lua.registerfinalizer(function()
if jit then
logs.report("format banner","%s lua: %s jit",banner,LUAVERSION)
else
logs.report("format banner","%s lua: %s",banner,LUAVERSION)
end
logs.newline()
end)
end
end
function statistics.checkfmtstatus(texname)
local enginebanner=status.banner
if enginebanner and texname then
local luvname=file.replacesuffix(texname,"luv")
if lfs.isfile(luvname) then
local luv=dofile(luvname)
if luv and luv.sourcefile then
local sourcehash=md5.hex(io.loaddata(resolvers.findfile(luv.sourcefile)) or "unknown")
local luvbanner=luv.enginebanner or "?"
if luvbanner~=enginebanner then
return format("engine mismatch (luv: %s <> bin: %s)",luvbanner,enginebanner)
end
local luvhash=luv.sourcehash or "?"
if luvhash~=sourcehash then
return format("source mismatch (luv: %s <> bin: %s)",luvhash,sourcehash)
end
local luvluaversion=luv.luaversion or 0
if luvluaversion~=LUAVERSION then
return format("lua mismatch (luv: %s <> bin: %s)",luvluaversion,LUAVERSION)
end
else
return "invalid status file"
end
else
return "missing status file"
end
end
return true
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-zip"] = package.loaded["data-zip"] or true
-- original size: 10263, stripped down to: 7556
if not modules then modules={} end modules ['data-zip']={
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"
}
local format,find,match=string.format,string.find,string.match
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local report_zip=logs.reporter("resolvers","zip")
local resolvers=resolvers
zip=zip or {}
local zip=zip
local archives=zip.archives or {}
zip.archives=archives
local registeredfiles=zip.registeredfiles or {}
zip.registeredfiles=registeredfiles
local zipfiles=utilities.zipfiles
local openzip,closezip,validfile,wholefile,filehandle,traversezip
if zipfiles then
local ipairs=ipairs
openzip=zipfiles.open
closezip=zipfiles.close
validfile=zipfiles.found
wholefile=zipfiles.unzip
traversezip=function(zfile)
return ipairs(zipfiles.list(zfile))
end
local streams=utilities.streams
local openstream=streams.open
local readstring=streams.readstring
local streamsize=streams.size
local metatable={
close=streams.close,
read=function(stream,n)
readstring(stream,n=="*a" and streamsize(stream) or n)
end
}
filehandle=function(zfile,queryname)
local data=wholefile(zfile,queryname)
if data then
local stream=openstream(data)
if stream then
return setmetatableindex(stream,metatable)
end
end
end
else
openzip=zip.open
closezip=zip.close
validfile=function(zfile,queryname)
local dfile=zfile:open(queryname)
if dfile then
dfile:close()
return true
end
return false
end
traversezip=function(zfile)
return z:files()
end
wholefile=function(zfile,queryname)
local dfile=zfile:open(queryname)
if dfile then
local s=dfile:read("*all")
dfile:close()
return s
end
end
filehandle=function(zfile,queryname)
local dfile=zfile:open(queryname)
if dfile then
return dfile
end
end
end
local function validzip(str)
if not find(str,"^zip://") then
return "zip:///"..str
else
return str
end
end
function zip.openarchive(name)
if not name or name=="" then
return nil
else
local arch=archives[name]
if not arch then
local full=resolvers.findfile(name) or ""
arch=full~="" and openzip(full) or false
archives[name]=arch
end
return arch
end
end
function zip.closearchive(name)
if not name or (name=="" and archives[name]) then
closezip(archives[name])
archives[name]=nil
end
end
function resolvers.locators.zip(specification)
local archive=specification.filename
local zipfile=archive and archive~="" and zip.openarchive(archive)
if trace_locating then
if zipfile then
report_zip("locator: archive %a found",archive)
else
report_zip("locator: archive %a not found",archive)
end
end
end
function resolvers.hashers.zip(specification)
local archive=specification.filename
if trace_locating then
report_zip("loading file %a",archive)
end
resolvers.usezipfile(specification.original)
end
function resolvers.concatinators.zip(zipfile,path,name)
if not path or path=="" then
return format('%s?name=%s',zipfile,name)
else
return format('%s?name=%s/%s',zipfile,path,name)
end
end
function resolvers.finders.zip(specification)
local original=specification.original
local archive=specification.filename
if archive then
local query=url.query(specification.query)
local queryname=query.name
if queryname then
local zfile=zip.openarchive(archive)
if zfile then
if trace_locating then
report_zip("finder: archive %a found",archive)
end
if validfile(zfile,queryname) then
if trace_locating then
report_zip("finder: file %a found",queryname)
end
return specification.original
elseif trace_locating then
report_zip("finder: file %a not found",queryname)
end
elseif trace_locating then
report_zip("finder: unknown archive %a",archive)
end
end
end
if trace_locating then
report_zip("finder: %a not found",original)
end
return resolvers.finders.notfound()
end
function resolvers.openers.zip(specification)
local original=specification.original
local archive=specification.filename
if archive then
local query=url.query(specification.query)
local queryname=query.name
if queryname then
local zfile=zip.openarchive(archive)
if zfile then
if trace_locating then
report_zip("opener; archive %a opened",archive)
end
local handle=filehandle(zfile,queryname)
if handle then
if trace_locating then
report_zip("opener: file %a found",queryname)
end
return resolvers.openers.helpers.textopener('zip',original,handle)
elseif trace_locating then
report_zip("opener: file %a not found",queryname)
end
elseif trace_locating then
report_zip("opener: unknown archive %a",archive)
end
end
end
if trace_locating then
report_zip("opener: %a not found",original)
end
return resolvers.openers.notfound()
end
function resolvers.loaders.zip(specification)
local original=specification.original
local archive=specification.filename
if archive then
local query=url.query(specification.query)
local queryname=query.name
if queryname then
local zfile=zip.openarchive(archive)
if zfile then
if trace_locating then
report_zip("loader: archive %a opened",archive)
end
local data=wholefile(zfile,queryname)
if data then
logs.show_load(original)
if trace_locating then
report_zip("loader; file %a loaded",original)
end
return true,data,#data
elseif trace_locating then
report_zip("loader: file %a not found",queryname)
end
elseif trace_locating then
report_zip("loader; unknown archive %a",archive)
end
end
end
if trace_locating then
report_zip("loader: %a not found",original)
end
return resolvers.openers.notfound()
end
function resolvers.usezipfile(archive)
local specification=resolvers.splitmethod(archive)
local archive=specification.filename
if archive and not registeredfiles[archive] then
local z=zip.openarchive(archive)
if z then
local tree=url.query(specification.query).tree or ""
if trace_locating then
report_zip("registering: archive %a",archive)
end
resolvers.starttiming()
resolvers.prependhash('zip',archive)
resolvers.extendtexmfvariable(archive)
registeredfiles[archive]=z
resolvers.registerfilehash(archive,resolvers.registerzipfile(z,tree))
resolvers.stoptiming()
elseif trace_locating then
report_zip("registering: unknown archive %a",archive)
end
elseif trace_locating then
report_zip("registering: archive %a not found",archive)
end
end
function resolvers.registerzipfile(z,tree)
local names={}
local files={}
local remap={}
local n=0
local filter=tree=="" and "^(.+)/(.-)$" or format("^%s/(.+)/(.-)$",tree)
local register=resolvers.registerfile
if trace_locating then
report_zip("registering: using filter %a",filter)
end
for i in traversezip(z) do
local filename=i.filename
local path,name=match(filename,filter)
if not path then
n=n+1
register(names,filename,"")
local usedname=lower(filename)
files[usedname]=""
if usedname~=filename then
remap[usedname]=filename
end
elseif name and name~="" then
n=n+1
register(names,name,path)
local usedname=lower(name)
files[usedname]=path
if usedname~=name then
remap[usedname]=name
end
else
end
end
report_zip("registering: %s files registered",n)
return {
files=files,
remap=remap,
}
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-tre"] = package.loaded["data-tre"] or true
-- original size: 8478, stripped down to: 5223
if not modules then modules={} end modules ['data-tre']={
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"
}
local find,gsub,lower=string.find,string.gsub,string.lower
local basename,dirname,joinname=file.basename,file.dirname,file .join
local globdir,isdir,isfile=dir.glob,lfs.isdir,lfs.isfile
local P,lpegmatch=lpeg.P,lpeg.match
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local report_trees=logs.reporter("resolvers","trees")
local resolvers=resolvers
local resolveprefix=resolvers.resolve
local notfound=resolvers.finders.notfound
local lookup=resolvers.get_from_content
local collectors={}
local found={}
function resolvers.finders.tree(specification)
local spec=specification.filename
local okay=found[spec]
if okay==nil then
if spec~="" then
local path=dirname(spec)
local name=basename(spec)
if path=="" then
path="."
end
local names=collectors[path]
if not names then
local pattern=find(path,"/%*+$") and path or (path.."/*")
names=globdir(pattern)
collectors[path]=names
end
local pattern="/"..gsub(name,"([%.%-%+])","%%%1").."$"
for i=1,#names do
local fullname=names[i]
if find(fullname,pattern) then
found[spec]=fullname
return fullname
end
end
local pattern=lower(pattern)
for i=1,#names do
local fullname=lower(names[i])
if find(fullname,pattern) then
if isfile(fullname) then
found[spec]=fullname
return fullname
else
break
end
end
end
end
okay=notfound()
found[spec]=okay
end
return okay
end
function resolvers.locators.tree(specification)
local name=specification.filename
local realname=resolveprefix(name)
if realname and realname~='' and isdir(realname) then
if trace_locating then
report_trees("locator %a found",realname)
end
resolvers.appendhash('tree',name,false)
elseif trace_locating then
report_trees("locator %a not found",name)
end
end
function resolvers.hashers.tree(specification)
local name=specification.filename
if trace_locating then
report_trees("analyzing %a",name)
end
resolvers.methodhandler("hashers",name)
resolvers.generators.file(specification)
end
local collectors={}
local splitter=lpeg.splitat("/**/")
local stripper=lpeg.replacer { [P("/")*P("*")^1*P(-1)]="" }
table.setmetatableindex(collectors,function(t,k)
local rootname=lpegmatch(stripper,k)
local dataname=joinname(rootname,"dirlist")
local content=caches.loadcontent(dataname,"files",dataname)
if not content then
content=resolvers.scanfiles(rootname,nil,nil,false,true)
caches.savecontent(dataname,"files",content,dataname)
end
t[k]=content
return content
end)
local function checked(root,p,n)
if p then
if type(p)=="table" then
for i=1,#p do
local fullname=joinname(root,p[i],n)
if isfile(fullname) then
return fullname
end
end
else
local fullname=joinname(root,p,n)
if isfile(fullname) then
return fullname
end
end
end
return notfound()
end
local function resolve(specification)
local filename=specification.filename
if filename~="" then
local root,rest=lpegmatch(splitter,filename)
if root and rest then
local path,name=dirname(rest),basename(rest)
if name~=rest then
local content=collectors[root]
local p,n=lookup(content,name)
if not p then
return notfound()
end
local pattern=".*/"..path.."$"
local istable=type(p)=="table"
if istable then
for i=1,#p do
local pi=p[i]
if pi==path or find(pi,pattern) then
local fullname=joinname(root,pi,n)
if isfile(fullname) then
return fullname
end
end
end
elseif p==path or find(p,pattern) then
local fullname=joinname(root,p,n)
if isfile(fullname) then
return fullname
end
end
local queries=specification.queries
if queries and queries.option=="fileonly" then
return checked(root,p,n)
else
return notfound()
end
end
end
local path,name=dirname(filename),basename(filename)
local root=lpegmatch(stripper,path)
local content=collectors[path]
local p,n=lookup(content,name)
if p then
return checked(root,p,n)
end
end
return notfound()
end
resolvers.finders .dirlist=resolve
resolvers.locators .dirlist=resolvers.locators .tree
resolvers.hashers .dirlist=resolvers.hashers .tree
resolvers.generators.dirlist=resolvers.generators.file
resolvers.openers .dirlist=resolvers.openers .file
resolvers.loaders .dirlist=resolvers.loaders .file
function resolvers.finders.dirfile(specification)
local queries=specification.queries
if queries then
queries.option="fileonly"
else
specification.queries={ option="fileonly" }
end
return resolve(specification)
end
resolvers.locators .dirfile=resolvers.locators .dirlist
resolvers.hashers .dirfile=resolvers.hashers .dirlist
resolvers.generators.dirfile=resolvers.generators.dirlist
resolvers.openers .dirfile=resolvers.openers .dirlist
resolvers.loaders .dirfile=resolvers.loaders .dirlist
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-sch"] = package.loaded["data-sch"] or true
-- original size: 6753, stripped down to: 5268
if not modules then modules={} end modules ['data-sch']={
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"
}
local load,tonumber=load,tonumber
local gsub,concat,format=string.gsub,table.concat,string.format
local finders,openers,loaders=resolvers.finders,resolvers.openers,resolvers.loaders
local trace_schemes=false trackers.register("resolvers.schemes",function(v) trace_schemes=v end)
local report_schemes=logs.reporter("resolvers","schemes")
local http=require("socket.http")
local ltn12=require("ltn12")
if mbox then mbox=nil end
local resolvers=resolvers
local schemes=resolvers.schemes or {}
resolvers.schemes=schemes
local cleaners={}
schemes.cleaners=cleaners
local threshold=24*60*60
directives.register("schemes.threshold",function(v) threshold=tonumber(v) or threshold end)
function cleaners.none(specification)
return specification.original
end
function cleaners.strip(specification)
local path,name=file.splitbase(specification.original)
if path=="" then
return (gsub(name,"[^%a%d%.]+","-"))
else
return (gsub((gsub(path,"%.","-").."-"..name),"[^%a%d%.]+","-"))
end
end
function cleaners.md5(specification)
return file.addsuffix(md5.hex(specification.original),file.suffix(specification.path))
end
local cleaner=cleaners.strip
directives.register("schemes.cleanmethod",function(v) cleaner=cleaners[v] or cleaners.strip end)
function resolvers.schemes.cleanname(specification)
local hash=cleaner(specification)
if trace_schemes then
report_schemes("hashing %a to %a",specification.original,hash)
end
return hash
end
local cached={}
local loaded={}
local reused={}
local thresholds={}
local handlers={}
local runner=sandbox.registerrunner {
name="curl resolver",
method="execute",
program="curl",
template="--silent --insecure --create-dirs --output %cachename% %original%",
checkers={
cachename="cache",
original="url",
}
}
local function fetch(specification)
local original=specification.original
local scheme=specification.scheme
local cleanname=schemes.cleanname(specification)
local cachename=caches.setfirstwritablefile(cleanname,"schemes")
if not cached[original] then
statistics.starttiming(schemes)
if not io.exists(cachename) or (os.difftime(os.time(),lfs.attributes(cachename).modification)>(thresholds[protocol] or threshold)) then
cached[original]=cachename
local handler=handlers[scheme]
if handler then
if trace_schemes then
report_schemes("fetching %a, protocol %a, method %a",original,scheme,"built-in")
end
logs.flush()
handler(specification,cachename)
else
if trace_schemes then
report_schemes("fetching %a, protocol %a, method %a",original,scheme,"curl")
end
logs.flush()
runner {
original=original,
cachename=cachename,
}
end
end
if io.exists(cachename) then
cached[original]=cachename
if trace_schemes then
report_schemes("using cached %a, protocol %a, cachename %a",original,scheme,cachename)
end
else
cached[original]=""
if trace_schemes then
report_schemes("using missing %a, protocol %a",original,scheme)
end
end
loaded[scheme]=loaded[scheme]+1
statistics.stoptiming(schemes)
else
if trace_schemes then
report_schemes("reusing %a, protocol %a",original,scheme)
end
reused[scheme]=reused[scheme]+1
end
return cached[original]
end
local function finder(specification,filetype)
return resolvers.methodhandler("finders",fetch(specification),filetype)
end
local opener=openers.file
local loader=loaders.file
local function install(scheme,handler,newthreshold)
handlers [scheme]=handler
loaded [scheme]=0
reused [scheme]=0
finders [scheme]=finder
openers [scheme]=opener
loaders [scheme]=loader
thresholds[scheme]=newthreshold or threshold
end
schemes.install=install
local function http_handler(specification,cachename)
local tempname=cachename..".tmp"
local f=io.open(tempname,"wb")
local status,message=http.request {
url=specification.original,
sink=ltn12.sink.file(f)
}
if not status then
os.remove(tempname)
else
os.remove(cachename)
os.rename(tempname,cachename)
end
return cachename
end
install('http',http_handler)
install('https')
install('ftp')
statistics.register("scheme handling time",function()
local l,r,nl,nr={},{},0,0
for k,v in table.sortedhash(loaded) do
if v>0 then
nl=nl+1
l[nl]=k..":"..v
end
end
for k,v in table.sortedhash(reused) do
if v>0 then
nr=nr+1
r[nr]=k..":"..v
end
end
local n=nl+nr
if n>0 then
l=nl>0 and concat(l) or "none"
r=nr>0 and concat(r) or "none"
return format("%s seconds, %s processed, threshold %s seconds, loaded: %s, reused: %s",
statistics.elapsedtime(schemes),n,threshold,l,r)
else
return nil
end
end)
local httprequest=http.request
local toquery=url.toquery
local function fetchstring(url,data)
local q=data and toquery(data)
if q then
url=url.."?"..q
end
local reply=httprequest(url)
return reply
end
schemes.fetchstring=fetchstring
function schemes.fetchtable(url,data)
local reply=fetchstring(url,data)
if reply then
local s=load("return "..reply)
if s then
return s()
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-lua"] = package.loaded["data-lua"] or true
-- original size: 4207, stripped down to: 3041
if not modules then modules={} end modules ['data-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"
}
local package,lpeg=package,lpeg
local gsub=string.gsub
local concat=table.concat
local addsuffix=file.addsuffix
local P,S,Cs,lpegmatch=lpeg.P,lpeg.S,lpeg.Cs,lpeg.match
local luasuffixes={ 'tex','lua' }
local libsuffixes={ 'lib' }
local luaformats={ 'TEXINPUTS','LUAINPUTS' }
local libformats={ 'CLUAINPUTS' }
local helpers=package.helpers or {}
local methods=helpers.methods or {}
local resolvers=resolvers
local resolveprefix=resolvers.resolve
helpers.report=logs.reporter("resolvers","libraries")
trackers.register("resolvers.libraries",function(v) helpers.trace=v end)
trackers.register("resolvers.locating",function(v) helpers.trace=v end)
helpers.sequence={
"already loaded",
"preload table",
"lua variable format",
"lib variable format",
"lua extra list",
"lib extra list",
"path specification",
"cpath specification",
"all in one fallback",
"not loaded",
}
local pattern=Cs(P("!")^0/""*(P("/")*P(-1)/"/"+P("/")^1/"/"+1)^0)
function helpers.cleanpath(path)
return resolveprefix(lpegmatch(pattern,path))
end
local loadedaslib=helpers.loadedaslib
local registerpath=helpers.registerpath
local lualibfile=helpers.lualibfile
local luaformatpaths
local libformatpaths
local function getluaformatpaths()
if not luaformatpaths then
luaformatpaths={}
for i=1,#luaformats do
registerpath("lua format","lua",luaformatpaths,resolvers.expandedpathlistfromvariable(luaformats[i]))
end
end
return luaformatpaths
end
local function getlibformatpaths()
if not libformatpaths then
libformatpaths={}
for i=1,#libformats do
registerpath("lib format","lib",libformatpaths,resolvers.expandedpathlistfromvariable(libformats[i]))
end
end
return libformatpaths
end
local function loadedbyformat(name,rawname,suffixes,islib,what)
local trace=helpers.trace
local report=helpers.report
for i=1,#suffixes do
local format=suffixes[i]
local resolved=resolvers.findfile(name,format) or ""
if trace then
report("%s format, identifying %a using format %a",what,name,format)
end
if resolved~="" then
if trace then
report("%s format, %a found on %a",what,name,resolved)
end
if islib then
return loadedaslib(resolved,rawname)
else
return loadfile(resolved)
end
end
end
end
helpers.loadedbyformat=loadedbyformat
methods["lua variable format"]=function(name)
if helpers.trace then
helpers.report("%s format, checking %s paths","lua",#getluaformatpaths())
end
return loadedbyformat(addsuffix(lualibfile(name),"lua"),name,luasuffixes,false,"lua")
end
methods["lib variable format"]=function(name)
if helpers.trace then
helpers.report("%s format, checking %s paths","lib",#getlibformatpaths())
end
return loadedbyformat(addsuffix(lualibfile(name),os.libsuffix),name,libsuffixes,true,"lib")
end
resolvers.loadlualib=require
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-aux"] = package.loaded["data-aux"] or true
-- original size: 2452, stripped down to: 1877
if not modules then modules={} end modules ['data-aux']={
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"
}
local find=string.find
local type,next=type,next
local trace_locating=false trackers.register("resolvers.locating",function(v) trace_locating=v end)
local resolvers=resolvers
local report_scripts=logs.reporter("resolvers","scripts")
function resolvers.updatescript(oldname,newname)
local scriptpath="context/lua"
newname=file.addsuffix(newname,"lua")
local oldscript=resolvers.cleanpath(oldname)
if trace_locating then
report_scripts("to be replaced old script %a",oldscript)
end
local newscripts=resolvers.findfiles(newname) or {}
if #newscripts==0 then
if trace_locating then
report_scripts("unable to locate new script")
end
else
for i=1,#newscripts do
local newscript=resolvers.cleanpath(newscripts[i])
if trace_locating then
report_scripts("checking new script %a",newscript)
end
if oldscript==newscript then
if trace_locating then
report_scripts("old and new script are the same")
end
elseif not find(newscript,scriptpath,1,true) then
if trace_locating then
report_scripts("new script should come from %a",scriptpath)
end
elseif not (find(oldscript,file.removesuffix(newname).."$") or find(oldscript,newname.."$")) then
if trace_locating then
report_scripts("invalid new script name")
end
else
local newdata=io.loaddata(newscript)
if newdata then
if trace_locating then
report_scripts("old script content replaced by new content: %s",oldscript)
end
io.savedata(oldscript,newdata)
break
elseif trace_locating then
report_scripts("unable to load new script")
end
end
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-tmf"] = package.loaded["data-tmf"] or true
-- original size: 2601, stripped down to: 1549
if not modules then modules={} end modules ['data-tmf']={
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"
}
local resolvers=resolvers
local report_tds=logs.reporter("resolvers","tds")
function resolvers.load_tree(tree,resolve)
if type(tree)=="string" and tree~="" then
local getenv,setenv=resolvers.getenv,resolvers.setenv
local texos="texmf-"..os.platform
local oldroot=environment.texroot
local newroot=file.collapsepath(tree)
local newtree=file.join(newroot,texos)
local newpath=file.join(newtree,"bin")
if not lfs.isdir(newtree) then
report_tds("no %a under tree %a",texos,tree)
os.exit()
end
if not lfs.isdir(newpath) then
report_tds("no '%s/bin' under tree %a",texos,tree)
os.exit()
end
local texmfos=newtree
environment.texroot=newroot
environment.texos=texos
environment.texmfos=texmfos
if resolve then
resolvers.luacnfspec=resolvers.resolve(resolvers.luacnfspec)
end
setenv('SELFAUTOPARENT',newroot)
setenv('SELFAUTODIR',newtree)
setenv('SELFAUTOLOC',newpath)
setenv('TEXROOT',newroot)
setenv('TEXOS',texos)
setenv('TEXMFOS',texmfos)
setenv('TEXMFCNF',resolvers.luacnfspec,true)
setenv('PATH',newpath..io.pathseparator..getenv('PATH'))
report_tds("changing from root %a to %a",oldroot,newroot)
report_tds("prepending %a to PATH",newpath)
report_tds("setting TEXMFCNF to %a",resolvers.luacnfspec)
report_tds()
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["data-lst"] = package.loaded["data-lst"] or true
-- original size: 1823, stripped down to: 1542
if not modules then modules={} end modules ['data-lst']={
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"
}
local type=type
local concat,sortedhash=table.concat,table.sortedhash
local resolvers=resolvers
local listers=resolvers.listers or {}
resolvers.listers=listers
local resolveprefix=resolvers.resolve
local report_lists=logs.reporter("resolvers","lists")
local report_resolved=logs.reporter("system","resolved")
local function tabstr(str)
if type(str)=='table' then
return concat(str," | ")
else
return str
end
end
function listers.variables(pattern)
local result=resolvers.knownvariables(pattern)
for key,value in sortedhash(result) do
report_lists(key)
report_lists(" env: %s",tabstr(value.environment or "unset"))
report_lists(" var: %s",tabstr(value.variable or "unset"))
report_lists(" exp: %s",tabstr(value.expansion or "unset"))
report_lists(" res: %s",tabstr(value.resolved or "unset"))
end
end
function listers.configurations()
local configurations=resolvers.configurationfiles()
for i=1,#configurations do
report_resolved("file : %s",resolveprefix(configurations[i]))
end
report_resolved("")
local list=resolvers.expandedpathfromlist(resolvers.splitpath(resolvers.luacnfspec))
for i=1,#list do
local li=resolveprefix(list[i])
if lfs.isdir(li) then
report_resolved("path - %s",li)
else
report_resolved("path + %s",li)
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["util-lib"] = package.loaded["util-lib"] or true
-- original size: 16094, stripped down to: 8443
if not modules then modules={} end modules ['util-lib']={
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",
}
local type=type
local next=next
local pcall=pcall
local gsub=string.gsub
local find=string.find
local sort=table.sort
local pathpart=file.pathpart
local nameonly=file.nameonly
local joinfile=file.join
local removesuffix=file.removesuffix
local addsuffix=file.addsuffix
local findfile=resolvers.findfile
local findfiles=resolvers.findfiles
local expandpaths=resolvers.expandedpathlistfromvariable
local qualifiedpath=file.is_qualified_path
local isfile=lfs.isfile
local done=false
local function locate(required,version,trace,report,action)
if type(required)~="string" then
report("provide a proper library name")
return
end
if trace then
report("requiring library %a with version %a",required,version or "any")
end
local found_library=nil
local required_full=gsub(required,"%.","/")
local required_path=pathpart(required_full)
local required_base=nameonly(required_full)
if qualifiedpath(required) then
if isfile(addsuffix(required,os.libsuffix)) then
if trace then
report("qualified name %a found",required)
end
found_library=required
else
if trace then
report("qualified name %a not found",required)
end
end
else
local required_name=required_base.."."..os.libsuffix
local version=type(version)=="string" and version~="" and version or false
local engine="luatex"
if trace and not done then
local list=expandpaths("lib")
for i=1,#list do
report("tds path %i: %s",i,list[i])
end
end
local function found(locate,asked_library,how,...)
if trace then
report("checking %s: %a",how,asked_library)
end
return locate(asked_library,...)
end
local function check(locate,...)
local found=nil
if version then
local asked_library=joinfile(required_path,version,required_name)
if trace then
report("checking %s: %a","with version",asked_library)
end
found=locate(asked_library,...)
end
if not found or found=="" then
local asked_library=joinfile(required_path,required_name)
if trace then
report("checking %s: %a","with version",asked_library)
end
found=locate(asked_library,...)
end
return found and found~="" and found or false
end
local function attempt(checkpattern)
if trace then
report("checking tds lib paths strictly")
end
local found=findfile and check(findfile,"lib")
if found and (not checkpattern or find(found,checkpattern)) then
return found
end
if trace then
report("checking tds lib paths with wildcard")
end
local asked_library=joinfile(required_path,".*",required_name)
if trace then
report("checking %s: %a","latest version",asked_library)
end
local list=findfiles(asked_library,"lib",true)
if list and #list>0 then
sort(list)
local found=list[#list]
if found and (not checkpattern or find(found,checkpattern)) then
return found
end
end
if trace then
report("checking lib paths")
end
package.extralibpath(environment.ownpath)
local paths=package.libpaths()
local pattern="/[^/]+%."..os.libsuffix.."$"
for i=1,#paths do
required_path=gsub(paths[i],pattern,"")
local found=check(lfs.isfound)
if type(found)=="string" and (not checkpattern or find(found,checkpattern)) then
return found
end
end
return false
end
if engine then
if trace then
report("attemp 1, engine %a",engine)
end
found_library=attempt("/"..engine.."/")
if not found_library then
if trace then
report("attemp 2, no engine",asked_library)
end
found_library=attempt()
end
else
found_library=attempt()
end
end
if not found_library then
if trace then
report("not found: %a",required)
end
library=false
else
if trace then
report("found: %a",found_library)
end
local result,message=action(found_library,required_base)
if result then
library=result
else
library=false
report("load error: message %a, library %a",tostring(message or "unknown"),found_library or "no library")
end
end
if trace then
if not library then
report("unknown library: %a",required)
else
report("stored library: %a",required)
end
end
return library or nil
end
do
local report_swiglib=logs.reporter("swiglib")
local trace_swiglib=false
local savedrequire=require
local loadedlibs={}
local loadlib=package.loadlib
local pushdir=dir.push
local popdir=dir.pop
trackers.register("resolvers.swiglib",function(v) trace_swiglib=v end)
function requireswiglib(required,version)
local library=loadedlibs[library]
if library==nil then
local trace_swiglib=trace_swiglib or package.helpers.trace
library=locate(required,version,trace_swiglib,report_swiglib,function(name,base)
pushdir(pathpart(name))
local opener="luaopen_"..base
if trace_swiglib then
report_swiglib("opening: %a with %a",name,opener)
end
local library,message=loadlib(name,opener)
local libtype=type(library)
if libtype=="function" then
library=library()
else
report_swiglib("load error: %a returns %a, message %a, library %a",opener,libtype,(string.gsub(message or "no message","[%s]+$","")),found_library or "no library")
library=false
end
popdir()
return library
end)
loadedlibs[required]=library or false
end
return library
end
function require(name,version)
if find(name,"^swiglib%.") then
return requireswiglib(name,version)
else
return savedrequire(name)
end
end
local swiglibs={}
local initializer="core"
function swiglib(name,version)
local library=swiglibs[name]
if not library then
statistics.starttiming(swiglibs)
if trace_swiglib then
report_swiglib("loading %a",name)
end
if not find(name,"%."..initializer.."$") then
fullname="swiglib."..name.."."..initializer
else
fullname="swiglib."..name
end
library=requireswiglib(fullname,version)
swiglibs[name]=library
statistics.stoptiming(swiglibs)
end
return library
end
statistics.register("used swiglibs",function()
if next(swiglibs) then
return string.format("%s, initial load time %s seconds",table.concat(table.sortedkeys(swiglibs)," "),statistics.elapsedtime(swiglibs))
end
end)
end
if FFISUPPORTED and ffi and ffi.load then
local report_ffilib=logs.reporter("ffilib")
local trace_ffilib=false
local savedffiload=ffi.load
trackers.register("resolvers.ffilib",function(v) trace_ffilib=v end)
local loaded={}
local function locateindeed(name)
name=removesuffix(name)
local l=loaded[name]
if l==nil then
local state,library=pcall(savedffiload,name)
if type(library)=="userdata" then
l=library
elseif type(state)=="userdata" then
l=state
else
l=false
end
loaded[name]=l
elseif trace_ffilib then
report_ffilib("reusing already loaded %a",name)
end
return l
end
local function getlist(required)
local list=directives.value("system.librarynames" )
if type(list)=="table" then
list=list[required]
if type(list)=="table" then
if trace then
report("using lookup list for library %a: % | t",required,list)
end
return list
end
end
return { required }
end
function ffilib(name,version)
name=removesuffix(name)
local l=loaded[name]
if l~=nil then
if trace_ffilib then
report_ffilib("reusing already loaded %a",name)
end
return l
end
local list=getlist(name)
if version=="system" then
for i=1,#list do
local library=locateindeed(list[i])
if type(library)=="userdata" then
return library
end
end
else
for i=1,#list do
local library=locate(list[i],version,trace_ffilib,report_ffilib,locateindeed)
if type(library)=="userdata" then
return library
end
end
end
end
function ffi.load(name)
local list=getlist(name)
for i=1,#list do
local library=ffilib(list[i])
if type(library)=="userdata" then
return library
end
end
if trace_ffilib then
report_ffilib("trying to load %a using normal loader",name)
end
for i=1,#list do
local state,library=pcall(savedffiload,list[i])
if type(library)=="userdata" then
return library
elseif type(state)=="userdata" then
return library
end
end
end
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["luat-sta"] = package.loaded["luat-sta"] or true
-- original size: 5703, stripped down to: 2321
if not modules then modules={} end modules ['luat-sta']={
version=1.001,
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local gmatch,match=string.gmatch,string.match
local type=type
states=states or {}
local states=states
states.data=states.data or {}
local data=states.data
states.hash=states.hash or {}
local hash=states.hash
states.tag=states.tag or ""
states.filename=states.filename or ""
function states.save(filename,tag)
tag=tag or states.tag
filename=file.addsuffix(filename or states.filename,'lus')
io.savedata(filename,
"-- generator : luat-sta.lua\n".."-- state tag : "..tag.."\n\n"..table.serialize(data[tag or states.tag] or {},true)
)
end
function states.load(filename,tag)
states.filename=filename
states.tag=tag or "whatever"
states.filename=file.addsuffix(states.filename,'lus')
data[states.tag],hash[states.tag]=(io.exists(filename) and dofile(filename)) or {},{}
end
local function set_by_tag(tag,key,value,default,persistent)
local d,h=data[tag],hash[tag]
if d then
if type(d)=="table" then
local dkey,hkey=key,key
local pre,post=match(key,"(.+)%.([^%.]+)$")
if pre and post then
for k in gmatch(pre,"[^%.]+") do
local dk=d[k]
if not dk then
dk={}
d[k]=dk
elseif type(dk)=="string" then
break
end
d=dk
end
dkey,hkey=post,key
end
if value==nil then
value=default
elseif value==false then
elseif persistent then
value=value or d[dkey] or default
else
value=value or default
end
d[dkey],h[hkey]=value,value
elseif type(d)=="string" then
data[tag],hash[tag]=value,value
end
end
end
local function get_by_tag(tag,key,default)
local h=hash[tag]
if h and h[key] then
return h[key]
else
local d=data[tag]
if d then
for k in gmatch(key,"[^%.]+") do
local dk=d[k]
if dk~=nil then
d=dk
else
return default
end
end
if d==false then
return false
else
return d or default
end
end
end
end
states.set_by_tag=set_by_tag
states.get_by_tag=get_by_tag
function states.set(key,value,default,persistent)
set_by_tag(states.tag,key,value,default,persistent)
end
function states.get(key,default)
return get_by_tag(states.tag,key,default)
end
end -- of closure
do -- create closure to overcome 200 locals limit
package.loaded["luat-fmt"] = package.loaded["luat-fmt"] or true
-- original size: 9637, stripped down to: 7253
if not modules then modules={} end modules ['luat-fmt']={
version=1.001,
comment="companion to mtxrun",
author="Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright="PRAGMA ADE / ConTeXt Development Team",
license="see context related readme files"
}
local format=string.format
local concat=table.concat
local quoted=string.quoted
local luasuffixes=utilities.lua.suffixes
local report_format=logs.reporter("resolvers","formats")
local function primaryflags()
local arguments=environment.arguments
local flags={}
if arguments.silent then
flags[#flags+1]="--interaction=batchmode"
end
return concat(flags," ")
end
local function secondaryflags()
local arguments=environment.arguments
local trackers=arguments.trackers
local directives=arguments.directives
local flags={}
if trackers and trackers~="" then
flags[#flags+1]="--c:trackers="..quoted(trackers)
end
if directives and directives~="" then
flags[#flags+1]="--c:directives="..quoted(directives)
end
if arguments.silent then
flags[#flags+1]="--c:silent"
end
if arguments.errors then
flags[#flags+1]="--c:errors"
end
if arguments.jit then
flags[#flags+1]="--c:jiton"
end
if arguments.ansi then
flags[#flags+1]="--c:ansi"
end
if arguments.strip then
flags[#flags+1]="--c:strip"
end
if arguments.lmtx then
flags[#flags+1]="--c:lmtx"
end
return concat(flags," ")
end
local template=[[--ini %primaryflags% --lua=%luafile% %texfile% %secondaryflags% %dump% %redirect%]]
local checkers={
primaryflags="string",
secondaryflags="string",
luafile="readable",
texfile="readable",
redirect="string",
dump="string",
}
local runners={
luatex=sandbox.registerrunner {
name="make luatex format",
program="luatex",
template=template,
checkers=checkers,
reporter=report_format,
},
luametatex=sandbox.registerrunner {
name="make luametatex format",
program="luametatex",
template=template,
checkers=checkers,
reporter=report_format,
},
luajittex=sandbox.registerrunner {
name="make luajittex format",
program="luajittex",
template=template,
checkers=checkers,
reporter=report_format,
},
}
function environment.make_format(name,arguments)
local engine=environment.ownmain or "luatex"
local silent=environment.arguments.silent
local errors=environment.arguments.errors
local olddir=dir.current()
local path=caches.getwritablepath("formats",engine) or ""
if path~="" then
lfs.chdir(path)
end
report_format("using format path %a",dir.current())
local texsourcename=file.addsuffix(name,"mkiv")
local fulltexsourcename=resolvers.findfile(texsourcename,"tex") or ""
if fulltexsourcename=="" then
texsourcename=file.addsuffix(name,"tex")
fulltexsourcename=resolvers.findfile(texsourcename,"tex") or ""
end
if fulltexsourcename=="" then
report_format("no tex source file with name %a (mkiv or tex)",name)
lfs.chdir(olddir)
return
else
report_format("using tex source file %a",fulltexsourcename)
end
local texsourcepath=dir.expandname(file.dirname(fulltexsourcename))
local specificationname=file.replacesuffix(fulltexsourcename,"lus")
local fullspecificationname=resolvers.findfile(specificationname,"tex") or ""
if fullspecificationname=="" then
specificationname=file.join(texsourcepath,"context.lus")
fullspecificationname=resolvers.findfile(specificationname,"tex") or ""
end
if fullspecificationname=="" then
report_format("unknown stub specification %a",specificationname)
lfs.chdir(olddir)
return
end
local specificationpath=file.dirname(fullspecificationname)
local usedluastub=nil
local usedlualibs=dofile(fullspecificationname)
if type(usedlualibs)=="string" then
usedluastub=file.join(file.dirname(fullspecificationname),usedlualibs)
elseif type(usedlualibs)=="table" then
report_format("using stub specification %a",fullspecificationname)
local texbasename=file.basename(name)
local luastubname=file.addsuffix(texbasename,luasuffixes.lua)
local lucstubname=file.addsuffix(texbasename,luasuffixes.luc)
report_format("creating initialization file %a",luastubname)
utilities.merger.selfcreate(usedlualibs,specificationpath,luastubname)
if utilities.lua.compile(luastubname,lucstubname) and lfs.isfile(lucstubname) then
report_format("using compiled initialization file %a",lucstubname)
usedluastub=lucstubname
else
report_format("using uncompiled initialization file %a",luastubname)
usedluastub=luastubname
end
else
report_format("invalid stub specification %a",fullspecificationname)
lfs.chdir(olddir)
return
end
local specification={
primaryflags=primaryflags(),
secondaryflags=secondaryflags(),
luafile=quoted(usedluastub),
texfile=quoted(fulltexsourcename),
dump=os.platform=="unix" and "\\\\dump" or "\\dump",
}
local runner=runners[engine]
if not runner then
report_format("format %a cannot be generated, no runner available for engine %a",name,engine)
elseif silent then
statistics.starttiming()
specification.redirect="> temp.log"
local result=runner(specification)
local runtime=statistics.stoptiming()
if result~=0 then
print(format("%s silent make > fatal error when making format %q",engine,name))
else
print(format("%s silent make > format %q made in %.3f seconds",engine,name,runtime))
end
os.remove("temp.log")
else
runner(specification)
end
local pattern=file.removesuffix(file.basename(usedluastub)).."-*.mem"
local mp=dir.glob(pattern)
if mp then
for i=1,#mp do
local name=mp[i]
report_format("removing related mplib format %a",file.basename(name))
os.remove(name)
end
end
lfs.chdir(olddir)
end
local template=[[%flags% --fmt=%fmtfile% --lua=%luafile% %texfile% %more%]]
local checkers={
flags="string",
more="string",
fmtfile="readable",
luafile="readable",
texfile="readable",
}
local runners={
luatex=sandbox.registerrunner {
name="run luatex format",
program="luatex",
template=template,
checkers=checkers,
reporter=report_format,
},
luajittex=sandbox.registerrunner {
name="run luajittex format",
program="luajittex",
template=template,
checkers=checkers,
reporter=report_format,
},
}
function environment.run_format(name,data,more)
if name and name~="" then
local engine=environment.ownmain or "luatex"
local barename=file.removesuffix(name)
local fmtname=caches.getfirstreadablefile(file.addsuffix(barename,"fmt"),"formats",engine)
if fmtname=="" then
fmtname=resolvers.findfile(file.addsuffix(barename,"fmt")) or ""
end
fmtname=resolvers.cleanpath(fmtname)
if fmtname=="" then
report_format("no format with name %a",name)
else
local barename=file.removesuffix(name)
local luaname=file.addsuffix(barename,"luc")
if not lfs.isfile(luaname) then
luaname=file.addsuffix(barename,"lua")
end
if not lfs.isfile(luaname) then
report_format("using format name %a",fmtname)
report_format("no luc/lua file with name %a",barename)
else
local runner=runners[engine]
if not runner then
report_format("format %a cannot be run, no runner available for engine %a",name,engine)
else
runner {
flags=primaryflags(),
fmtfile=quoted(barename),
luafile=quoted(luaname),
texfile=quoted(data),
more=more,
}
end
end
end
end
end
end -- of closure
-- used libraries : l-bit32.lua l-lua.lua l-macro.lua l-sandbox.lua l-package.lua l-lpeg.lua l-function.lua l-string.lua l-table.lua l-io.lua l-number.lua l-set.lua l-os.lua l-file.lua l-gzip.lua l-md5.lua l-sha.lua l-url.lua l-dir.lua l-boolean.lua l-unicode.lua l-math.lua util-str.lua util-tab.lua util-fil.lua util-sac.lua util-sto.lua util-prs.lua util-fmt.lua util-soc-imp-reset.lua util-soc-imp-socket.lua util-soc-imp-copas.lua util-soc-imp-ltn12.lua util-soc-imp-mime.lua util-soc-imp-url.lua util-soc-imp-headers.lua util-soc-imp-tp.lua util-soc-imp-http.lua util-soc-imp-ftp.lua util-soc-imp-smtp.lua trac-set.lua trac-log.lua trac-inf.lua trac-pro.lua util-lua.lua util-deb.lua util-tpl.lua util-sbx.lua util-mrg.lua util-env.lua luat-env.lua util-zip.lua lxml-tab.lua lxml-lpt.lua lxml-mis.lua lxml-aux.lua lxml-xml.lua trac-xml.lua data-ini.lua data-exp.lua data-env.lua data-tmp.lua data-met.lua data-res.lua data-pre.lua data-inp.lua data-out.lua data-fil.lua data-con.lua data-use.lua data-zip.lua data-tre.lua data-sch.lua data-lua.lua data-aux.lua data-tmf.lua data-lst.lua util-lib.lua luat-sta.lua luat-fmt.lua
-- skipped libraries : -
-- original bytes : 1019480
-- stripped bytes : 403728
-- end library merge
-- We need this hack till luatex is fixed.
--
-- for k,v in pairs(arg) do print(k,v) end
if arg and (arg[0] == 'luatex' or arg[0] == 'luatex.exe') and arg[1] == "--luaonly" then
arg[-1]=arg[0] arg[0]=arg[2] for k=3,#arg do arg[k-2]=arg[k] end arg[#arg]=nil arg[#arg]=nil
end
-- End of hack.
local format, gsub, gmatch, match, find = string.format, string.gsub, string.gmatch, string.match, string.find
local concat = table.concat
local ownname = environment and environment.ownname or arg[0] or 'mtxrun.lua'
local ownpath = gsub(match(ownname,"^(.+)[\\/].-$") or ".","\\","/")
local owntree = environment and environment.ownpath or ownpath
local ownlibs = { -- order can be made better
'l-bit32.lua',
'l-lua.lua',
'l-macro.lua',
'l-sandbox.lua',
'l-package.lua',
'l-lpeg.lua',
'l-function.lua',
'l-string.lua',
'l-table.lua',
'l-io.lua',
'l-number.lua',
'l-set.lua',
'l-os.lua',
'l-file.lua',
'l-gzip.lua',
'l-md5.lua',
'l-sha.lua',
'l-url.lua',
'l-dir.lua',
'l-boolean.lua',
'l-unicode.lua',
'l-math.lua',
'util-str.lua', -- code might move to l-string
'util-tab.lua',
'util-fil.lua',
'util-sac.lua',
'util-sto.lua',
'util-prs.lua',
'util-fmt.lua',
'util-soc-imp-reset.lua',
'util-soc-imp-socket.lua',
'util-soc-imp-copas.lua',
'util-soc-imp-ltn12.lua',
-- 'util-soc-imp-mbox.lua',
'util-soc-imp-mime.lua',
'util-soc-imp-url.lua',
'util-soc-imp-headers.lua',
'util-soc-imp-tp.lua',
'util-soc-imp-http.lua',
'util-soc-imp-ftp.lua',
'util-soc-imp-smtp.lua',
'trac-set.lua',
'trac-log.lua',
'trac-inf.lua', -- was before trac-set
'trac-pro.lua', -- not really needed
'util-lua.lua', -- indeed here?
'util-deb.lua',
'util-tpl.lua',
'util-sbx.lua',
'util-mrg.lua',
'util-env.lua',
'luat-env.lua', -- can come before inf (as in mkiv)
'util-zip.lua',
'lxml-tab.lua',
'lxml-lpt.lua',
-- 'lxml-ent.lua',
'lxml-mis.lua',
'lxml-aux.lua',
'lxml-xml.lua',
'trac-xml.lua',
'data-ini.lua',
'data-exp.lua',
'data-env.lua',
'data-tmp.lua',
'data-met.lua',
'data-res.lua',
'data-pre.lua',
'data-inp.lua',
'data-out.lua',
'data-fil.lua',
'data-con.lua',
'data-use.lua',
-- 'data-tex.lua',
-- 'data-bin.lua',
'data-zip.lua',
'data-tre.lua',
'data-sch.lua',
'data-lua.lua',
'data-aux.lua', -- updater
'data-tmf.lua',
'data-lst.lua',
'util-lib.lua', -- swiglib
'luat-sta.lua',
'luat-fmt.lua',
}
-- c:/data/develop/tex-context/tex/texmf-win64/bin/../../texmf-context/tex/context/base/mkiv/data-tmf.lua
-- c:/data/develop/context/sources/data-tmf.lua
local ownlist = {
-- '.',
-- ownpath ,
owntree .. "/../../../../context/sources", -- HH's development path
--
owntree .. "/../../texmf-local/tex/context/base/mkiv",
owntree .. "/../../texmf-context/tex/context/base/mkiv",
owntree .. "/../../texmf/tex/context/base/mkiv",
owntree .. "/../../../texmf-local/tex/context/base/mkiv",
owntree .. "/../../../texmf-context/tex/context/base/mkiv",
owntree .. "/../../../texmf/tex/context/base/mkiv",
--
owntree .. "/../../texmf-local/tex/context/base",
owntree .. "/../../texmf-context/tex/context/base",
owntree .. "/../../texmf/tex/context/base",
owntree .. "/../../../texmf-local/tex/context/base",
owntree .. "/../../../texmf-context/tex/context/base",
owntree .. "/../../../texmf/tex/context/base",
}
if ownpath == "." then table.remove(ownlist,1) end
own = {
name = ownname,
path = ownpath,
tree = owntree,
list = ownlist,
libs = ownlibs,
}
local function locate_libs()
for l=1,#ownlibs do
local lib = ownlibs[l]
for p =1,#ownlist do
local pth = ownlist[p]
local filename = pth .. "/" .. lib
local found = lfs.isfile(filename)
if found then
package.path = package.path .. ";" .. pth .. "/?.lua" -- in case l-* does a require
return pth
end
end
end
end
local function load_libs()
local found = locate_libs()
if found then
for l=1,#ownlibs do
local filename = found .. "/" .. ownlibs[l]
local codeblob = loadfile(filename)
if codeblob then
codeblob()
end
end
else
resolvers = nil
end
end
if not resolvers then
load_libs()
end
if not resolvers then
print("")
print("Mtxrun is unable to start up due to lack of libraries. You may")
print("try to run 'lua mtxrun.lua --selfmerge' in the path where this")
print("script is located (normally under ..../scripts/context/lua) which")
print("will make this script library independent.")
os.exit()
end
-- verbosity
----- e_verbose = environment.arguments["verbose"]
local e_verbose = false
-- some common flags (also passed through environment)
local e_silent = environment.argument("silent")
local e_errors = environment.argument("errors")
local e_noconsole = environment.argument("noconsole")
local e_trackers = environment.argument("trackers")
local e_directives = environment.argument("directives")
local e_experiments = environment.argument("experiments")
local t = { }
if type(e_directives) == "string" then
t[#t+1] = e_directives
end
if type(e_silent) == "string" then
t[#t+1] = format("logs.blocked={%s}",e_silent)
elseif e_silent == true then
t[#t+1] = "logs.blocked"
end
if type(e_errors) == "string" then
t[#t+1] = format("logs.errors={%s}",e_errors)
elseif e_errors == true then
t[#t+1] = "logs.errors"
end
if e_noconsole then
t[#t+1] = format("logs.target=file")
end
if #t > 0 then
e_directives = concat(t,",")
end
if e_trackers then trackers .enable(e_trackers) end
if e_directives then directives .enable(e_directives) end
if e_experiments then experiments.enable(e_experiments) end
if not environment.trackers then environment.trackers = e_trackers end
if not environment.directives then environment.directives = e_directives end
if not environment.experiments then environment.experiments = e_experiments end
--
resolvers.reset()
local helpinfo = [[
<?xml version="1.0" ?>
<application>
<metadata>
<entry name="name">mtxrun</entry>
<entry name="detail">ConTeXt TDS Runner Tool</entry>
<entry name="version">1.33</entry>
</metadata>
<flags>
<category name="basic">
<subcategory>
<flag name="script"><short>run an mtx script (lua prefered method) (<ref name="noquotes"/>), no script gives list</short></flag>
<flag name="evaluate"><short>run code passed on the commandline (between quotes)</short></flag>
<flag name="execute"><short>run a script or program (texmfstart method) (<ref name="noquotes"/>)</short></flag>
<flag name="resolve"><short>resolve prefixed arguments</short></flag>
<flag name="ctxlua"><short>run internally (using preloaded libs)</short></flag>
<flag name="internal"><short>run script using built in libraries (same as <ref name="ctxlua"/>)</short></flag>
<flag name="locate"><short>locate given filename in database (default) or system (<ref name="first"/> <ref name="all"/> <ref name="detail"/>)</short></flag>
</subcategory>
<subcategory>
<flag name="tree" value="pathtotree"><short>use given texmf tree (default file: setuptex.tmf)</short></flag>
<flag name="path" value="runpath"><short>go to given path before execution</short></flag>
<flag name="ifchanged" value="filename"><short>only execute when given file has changed (md checksum)</short></flag>
<flag name="iftouched" value="old,new"><short>only execute when given file has changed (time stamp)</short></flag>
</subcategory>
<subcategory>
<flag name="makestubs"><short>create stubs for (context related) scripts</short></flag>
<flag name="removestubs"><short>remove stubs (context related) scripts</short></flag>
<flag name="stubpath" value="binpath"><short>paths where stubs wil be written</short></flag>
<flag name="windows"><short>create windows (mswin) stubs</short></flag>
<flag name="unix"><short>create unix (linux) stubs</short></flag>
</subcategory>
<subcategory>
<flag name="verbose"><short>give a bit more info</short></flag>
<flag name="trackers" value="list"><short>enable given trackers</short></flag>
<flag name="progname" value="str"><short>format or backend</short></flag>
<flag name="systeminfo" value="str"><short>show current operating system, processor, etc</short></flag>
</subcategory>
<subcategory>
<flag name="edit"><short>launch editor with found file</short></flag>
<flag name="launch"><short>launch files like manuals, assumes os support (<ref name="all"/>,<ref name="list"/>)</short></flag>
</subcategory>
<subcategory>
<flag name="timedrun"><short>run a script and time its run</short></flag>
<flag name="autogenerate"><short>regenerate databases if needed (handy when used to run context in an editor)</short></flag>
</subcategory>
<subcategory>
<flag name="usekpse"><short>use kpse as fallback (when no mkiv and cache installed, often slower)</short></flag>
<flag name="forcekpse"><short>force using kpse (handy when no mkiv and cache installed but less functionality)</short></flag>
</subcategory>
<subcategory>
<flag name="prefixes"><short>show supported prefixes</short></flag>
</subcategory>
<subcategory>
<flag name="generate"><short>generate file database</short></flag>
</subcategory>
<subcategory>
<flag name="variables"><short>show configuration variables</short></flag>
<flag name="configurations"><short>show configuration order</short></flag>
</subcategory>
<subcategory>
<flag name="directives"><short>show (known) directives</short></flag>
<flag name="trackers"><short>show (known) trackers</short></flag>
<flag name="experiments"><short>show (known) experiments</short></flag>
</subcategory>
<subcategory>
<flag name="expand-braces"><short>expand complex variable</short></flag>
<flag name="resolve-path"><short>expand variable (completely resolve paths)</short></flag>
<flag name="expand-path"><short>expand variable (resolve paths)</short></flag>
<flag name="expand-var"><short>expand variable (resolve references)</short></flag>
<flag name="show-path"><short>show path expansion of ...</short></flag>
<flag name="var-value"><short>report value of variable</short></flag>
<flag name="find-file"><short>report file location</short></flag>
<flag name="find-path"><short>report path of file</short></flag>
</subcategory>
<subcategory>
<flag name="pattern" value="string"><short>filter variables</short></flag>
</subcategory>
</category>
</flags>
</application>
]]
local application = logs.application {
name = "mtxrun",
banner = "ConTeXt TDS Runner Tool 1.32",
helpinfo = helpinfo,
}
local report = application.report
messages = messages or { } -- for the moment
runners = runners or { } -- global (might become local)
runners.applications = {
["lua"] = "luatex --luaonly",
["luc"] = "luatex --luaonly",
["pl"] = "perl",
["py"] = "python",
["rb"] = "ruby",
}
runners.suffixes = {
'rb', 'lua', 'py', 'pl'
}
runners.registered = {
texexec = { 'texexec.rb', false }, -- context mkii runner (only tool not to be luafied)
texutil = { 'texutil.rb', true }, -- old perl based index sorter for mkii (old versions need it)
texfont = { 'texfont.pl', true }, -- perl script that makes mkii font metric files
texfind = { 'texfind.pl', false }, -- perltk based tex searching tool, mostly used at pragma
texshow = { 'texshow.pl', false }, -- perltk based context help system, will be luafied
-- texwork = { 'texwork.pl', false }, -- perltk based editing environment, only used at pragma
makempy = { 'makempy.pl', true },
mptopdf = { 'mptopdf.pl', true },
pstopdf = { 'pstopdf.rb', true }, -- converts ps (and some more) images, does some cleaning (replaced)
-- examplex = { 'examplex.rb', false },
concheck = { 'concheck.rb', false },
runtools = { 'runtools.rb', true },
textools = { 'textools.rb', true },
tmftools = { 'tmftools.rb', true },
ctxtools = { 'ctxtools.rb', true },
rlxtools = { 'rlxtools.rb', true },
pdftools = { 'pdftools.rb', true },
mpstools = { 'mpstools.rb', true },
-- exatools = { 'exatools.rb', true },
xmltools = { 'xmltools.rb', true },
-- luatools = { 'luatools.lua', true },
mtxtools = { 'mtxtools.rb', true },
pdftrimwhite = { 'pdftrimwhite.pl', false },
}
runners.launchers = {
windows = { },
unix = { },
}
-- like runners.libpath("framework"): looks on script's subpath
function runners.libpath(...)
package.prepend_libpath(file.dirname(environment.ownscript),...)
package.prepend_libpath(file.dirname(environment.ownname) ,...)
end
function runners.prepare()
local checkname = environment.argument("ifchanged")
if type(checkname) == "string" and checkname ~= "" then
local oldchecksum = file.loadchecksum(checkname)
local newchecksum = file.checksum(checkname)
if oldchecksum == newchecksum then
if e_verbose then
report("file '%s' is unchanged",checkname)
end
return "skip"
elseif e_verbose then
report("file '%s' is changed, processing started",checkname)
end
file.savechecksum(checkname)
end
local touchname = environment.argument("iftouched")
if type(touchname) == "string" and touchname ~= "" then
local oldname, newname = string.splitup(touchname, ",")
if oldname and newname and oldname ~= "" and newname ~= "" then
if not file.needs_updating(oldname,newname) then
if e_verbose then
report("file '%s' and '%s' have same age",oldname,newname)
end
return "skip"
elseif e_verbose then
report("file '%s' is older than '%s'",oldname,newname)
end
end
end
local runpath = environment.argument("path")
if type(runpath) == "string" and not lfs.chdir(runpath) then
report("unable to change to path '%s'",runpath)
return "error"
end
runners.prepare = function() end
return "run"
end
function runners.execute_script(fullname,internal,nosplit)
local noquote = environment.argument("noquotes")
if fullname and fullname ~= "" then
local state = runners.prepare()
if state == 'error' then
return false
elseif state == 'skip' then
return true
elseif state == "run" then
local path, name, suffix = file.splitname(fullname)
local result = ""
if path ~= "" then
result = fullname
elseif name then
name = gsub(name,"^int[%a]*:",function()
internal = true
return ""
end )
name = gsub(name,"^script:","")
if suffix == "" and runners.registered[name] and runners.registered[name][1] then
name = runners.registered[name][1]
suffix = file.suffix(name)
end
if suffix == "" then
-- loop over known suffixes
for _,s in pairs(runners.suffixes) do
result = resolvers.findfile(name .. "." .. s, 'texmfscripts')
if result ~= "" then
break
end
end
elseif runners.applications[suffix] then
result = resolvers.findfile(name, 'texmfscripts')
else
-- maybe look on path
result = resolvers.findfile(name, 'other text files')
end
end
if result and result ~= "" then
if not no_split then
local before, after = environment.splitarguments(fullname) -- already done
environment.arguments_before, environment.arguments_after = before, after
end
if internal then
arg = { } for _,v in pairs(environment.arguments_after) do arg[#arg+1] = v end
environment.ownscript = result
dofile(result)
else
local texmfcnf = resolvers.getenv("TEXMFCNF")
if not texmfcnf or texmfcnf == "" then
texmfcnf = resolvers.expandedpathfromlist(resolvers.splitpath(resolvers.resolve(resolvers.luacnfspec)))
resolvers.setenv("TEXMFCNF",table.concat(texmfcnf,";")) -- for running texexec etc (after tl change to texmf-dist)
end
local binary = runners.applications[file.suffix(result)]
result = string.quoted(string.unquoted(result))
-- if string.match(result,' ') and not string.match(result,"^\".*\"$") then
-- result = '"' .. result .. '"'
-- end
if binary and binary ~= "" then
result = binary .. " " .. result
end
local command = result .. " " .. environment.reconstructcommandline(environment.arguments_after,noquote)
if e_verbose then
report()
report("executing: %s",command)
report()
report()
io.flush()
end
-- no os.exec because otherwise we get the wrong return value
local code = os.execute(command) -- maybe spawn
if code == 0 then
return true
else
if binary then
binary = file.addsuffix(binary,os.binsuffix)
for p in gmatch(os.getenv("PATH"),"[^"..io.pathseparator.."]+") do
if lfs.isfile(file.join(p,binary)) then
return false
end
end
report()
report("This script needs '%s' which seems not to be installed.",binary)
report()
end
return false
end
end
end
end
end
return false
end
function runners.execute_program(fullname)
local noquote = environment.argument("noquotes")
if fullname and fullname ~= "" then
local state = runners.prepare()
if state == 'error' then
return false
elseif state == 'skip' then
return true
elseif state == "run" then
local before, after = environment.splitarguments(fullname)
for k=1,#after do after[k] = resolvers.resolve(after[k]) end
environment.initializearguments(after)
fullname = gsub(fullname,"^bin:","")
local command = fullname .. " " .. (environment.reconstructcommandline(after or "",noquote) or "")
report()
report("executing: %s",command)
report()
report()
io.flush()
local code = os.exec(command) -- (fullname,unpack(after)) does not work / maybe spawn
return code == 0
end
end
return false
end
-- the --usekpse flag will fallback (not default) on kpse (hm, we can better update mtx-stubs)
local windows_stub = '@echo off\013\010setlocal\013\010set ownpath=%%~dp0%%\013\010texlua "%%ownpath%%mtxrun.lua" --usekpse --execute %s %%*\013\010endlocal\013\010'
local unix_stub = '#!/bin/sh\010mtxrun --usekpse --execute %s \"$@\"\010'
function runners.handle_stubs(create)
local stubpath = environment.argument('stubpath') or '.' -- 'auto' no longer subpathssupported
local windows = environment.argument('windows') or environment.argument('mswin') or false
local unix = environment.argument('unix') or environment.argument('linux') or false
if not windows and not unix then
if os.platform == "unix" then
unix = true
else
windows = true
end
end
for _,v in pairs(runners.registered) do
local name, doit = v[1], v[2]
if doit then
local base = gsub(file.basename(name), "%.(.-)$", "")
if create then
if windows then
io.savedata(file.join(stubpath,base..".bat"),format(windows_stub,name))
report("windows stub for '%s' created",base)
end
if unix then
io.savedata(file.join(stubpath,base),format(unix_stub,name))
report("unix stub for '%s' created",base)
end
else
if windows and (os.remove(file.join(stubpath,base..'.bat')) or os.remove(file.join(stubpath,base..'.cmd'))) then
report("windows stub for '%s' removed", base)
end
if unix and (os.remove(file.join(stubpath,base)) or os.remove(file.join(stubpath,base..'.sh'))) then
report("unix stub for '%s' removed",base)
end
end
end
end
end
function runners.resolve_string(filename)
if filename and filename ~= "" then
runners.report_location(resolvers.resolve(filename))
end
end
-- differs from texmfstart where locate appends .com .exe .bat ... todo
function runners.locate_file(filename) -- was given file but only searches in tree
if filename and filename ~= "" then
if environment.argument("first") then
runners.report_location(resolvers.findfile(filename))
-- resolvers.dowithfilesandreport(resolvers.findfile,filename)
elseif environment.argument("all") then
local result, status = resolvers.findfiles(filename)
if status and environment.argument("detail") then
runners.report_location(status)
else
runners.report_location(result)
end
else
runners.report_location(resolvers.findgivenfile(filename))
-- resolvers.dowithfilesandreport(resolvers.findgivenfile,filename)
end
end
end
function runners.locate_platform()
runners.report_location(os.platform)
end
function runners.report_location(result)
if type(result) == "table" then
for i=1,#result do
if i > 1 then
io.write("\n")
end
io.write(result[i])
end
else
io.write(result)
end
end
function runners.edit_script(filename) -- we assume that gvim is present on most systems (todo: also in cnf file)
local editor = os.getenv("MTXRUN_EDITOR") or os.getenv("TEXMFSTART_EDITOR") or os.getenv("EDITOR") or 'gvim'
local rest = resolvers.resolve(filename)
if rest ~= "" then
local command = editor .. " " .. rest
if e_verbose then
report()
report("starting editor: %s",command)
report()
report()
end
os.launch(command)
end
end
function runners.save_script_session(filename, list)
local t = { }
for i=1,#list do
local key = list[i]
t[key] = environment.arguments[key]
end
io.savedata(filename,table.serialize(t,true))
end
function runners.load_script_session(filename)
if lfs.isfile(filename) then
local t = io.loaddata(filename)
if t then
t = loadstring(t)
if t then t = t() end
for key, value in pairs(t) do
environment.arguments[key] = value
end
end
end
end
function resolvers.launch(str)
-- maybe we also need to test on mtxrun.launcher.suffix environment
-- variable or on windows consult the assoc and ftype vars and such
local launchers = runners.launchers[os.platform] if launchers then
local suffix = file.suffix(str) if suffix then
local runner = launchers[suffix] if runner then
str = runner .. " " .. str
end
end
end
os.launch(str)
end
function runners.launch_file(filename)
local allresults = environment.arguments["all"]
local pattern = environment.arguments["pattern"]
local listonly = environment.arguments["list"]
if not pattern or pattern == "" then
pattern = filename
end
if not pattern or pattern == "" then
report("provide name or --pattern=")
else
local t = resolvers.findfiles(pattern,nil,allresults)
if not t or #t == 0 then
t = resolvers.findfiles("*/" .. pattern,nil,allresults)
end
if not t or #t == 0 then
t = resolvers.findfiles("*/" .. pattern .. "*",nil,allresults)
end
if t and #t > 0 then
for i=1,#t do
local name = t[i]
if listonly then
report("% 3i: %-30s %s",i,file.basename(name),file.dirname(name))
else
report("launching: %s",name)
resolvers.launch(name)
if not allresults then
break
end
end
end
if listonly then
io.write("\n")
io.write("\n[select number]\n\n>> ")
local answer = tonumber(io.read())
if answer then
io.write("\n")
local name = t[answer]
if name then
report("launching: %s",name)
resolvers.launch(name)
else
report("invalid number")
end
end
end
else
report("no match for %s", pattern)
end
end
end
local mtxprefixes = {
{ "^mtx%-", "mtx-" },
{ "^mtx%-t%-", "mtx-t-" },
}
function runners.find_mtx_script(filename)
local function found(name)
local path = file.dirname(name)
if path and path ~= "" then
return false
else
local fullname = own and own.path and file.join(own.path,name)
return io.exists(fullname) and fullname
end
end
filename = file.addsuffix(filename,"lua")
local basename = file.removesuffix(file.basename(filename))
local suffix = file.suffix(filename)
-- qualified path, raw name
local fullname = file.is_qualified_path(filename) and io.exists(filename) and filename
if fullname and fullname ~= "" then
return fullname
end
-- current path, raw name
fullname = "./" .. filename
fullname = io.exists(fullname) and fullname
if fullname and fullname ~= "" then
return fullname
end
-- mtx- prefix checking
for i=1,#mtxprefixes do
local mtxprefix = mtxprefixes[i]
mtxprefix = find(filename,mtxprefix[1]) and "" or mtxprefix[2]
-- context namespace, mtx-<filename>
fullname = mtxprefix .. filename
fullname = found(fullname) or resolvers.findfile(fullname)
if fullname and fullname ~= "" then
return fullname
end
-- context namespace, mtx-<filename>s
fullname = mtxprefix .. basename .. "s" .. "." .. suffix
fullname = found(fullname) or resolvers.findfile(fullname)
if fullname and fullname ~= "" then
return fullname
end
-- context namespace, mtx-<filename minus trailing s>
fullname = mtxprefix .. gsub(basename,"s$","") .. "." .. suffix
fullname = found(fullname) or resolvers.findfile(fullname)
if fullname and fullname ~= "" then
return fullname
end
end
-- context namespace, just <filename>
fullname = resolvers.findfile(filename)
return fullname
end
function runners.register_arguments(...)
local arguments = environment.arguments_after
local passedon = { ... }
for i=#passedon,1,-1 do
local pi = passedon[i]
if pi then
table.insert(arguments,1,pi)
end
end
end
function runners.execute_ctx_script(filename,...)
runners.register_arguments(...)
local arguments = environment.arguments_after
local fullname = runners.find_mtx_script(filename) or ""
if file.suffix(fullname) == "cld" then
-- handy in editors where we force --autopdf
report("running cld script: %s",filename)
table.insert(arguments,1,fullname)
table.insert(arguments,"--autopdf")
fullname = runners.find_mtx_script("context") or ""
end
-- retry after generate but only if --autogenerate
if fullname == "" and environment.argument("autogenerate") then -- might become the default
resolvers.renewcache()
trackers.enable("resolvers.locating")
resolvers.load()
--
fullname = runners.find_mtx_script(filename) or ""
end
-- that should do it
if fullname ~= "" then
local state = runners.prepare()
if state == 'error' then
return false
elseif state == 'skip' then
return true
elseif state == "run" then
-- load and save ... kind of undocumented
arg = { } for _,v in pairs(arguments) do arg[#arg+1] = resolvers.resolve(v) end
environment.initializearguments(arg)
local loadname = environment.arguments['load']
if loadname then
if type(loadname) ~= "string" then loadname = file.basename(fullname) end
loadname = file.replacesuffix(loadname,"cfg")
runners.load_script_session(loadname)
end
filename = environment.files[1]
if e_verbose then
report("using script: %s (if --path is used don't run on path where mtxrun lives)\n",fullname)
end
environment.ownscript = fullname
dofile(fullname)
local savename = environment.arguments['save']
if savename then
if type(savename) ~= "string" then savename = file.basename(fullname) end
savename = file.replacesuffix(savename,"cfg")
runners.save_script_session(savename,save_list)
end
return true
end
else
if filename == "" or filename == "help" then
local context = resolvers.findfile("mtx-context.lua")
trackers.enable("resolvers.locating")
if context ~= "" then
local result = dir.glob((gsub(context,"mtx%-context","mtx-*"))) -- () needed
local valid = { }
table.sort(result)
for i=1,#result do
local scriptname = result[i]
local scriptbase = match(scriptname,".*mtx%-([^%-]-)%.lua")
if scriptbase then
local data = io.loaddata(scriptname)
local application = match(data,"local application.-=.-(%{.-%})")
if application then
application = loadstring("return " .. application)
if application then
application = application()
local banner = application.banner
if banner then
local description, version = match(banner,"^(.-) ([%d.]+)$")
if description then
valid[#valid+1] = { scriptbase, version, description }
else
valid[#valid+1] = { scriptbase, "", banner }
end
end
end
end
end
end
if #valid > 0 then
application.identify()
report("no script name given, known scripts:")
report()
for k=1,#valid do
local v = valid[k]
report("%-12s %4s %s",v[1],v[2],v[3])
end
end
else
report("no script name given")
end
else
filename = file.addsuffix(filename,"lua")
if file.is_qualified_path(filename) then
report("unknown script '%s'",filename)
else
report("unknown script '%s' or 'mtx-%s'",filename,filename)
end
end
return false
end
end
function runners.prefixes()
application.identify()
report()
report(concat(resolvers.allprefixes(true)," "))
end
function runners.timedrun(filename) -- just for me
if filename and filename ~= "" then
runners.timed(function() os.execute(filename) end)
end
end
function runners.timed(action)
statistics.timed(action,true)
end
function runners.associate(filename)
os.launch(filename)
end
function runners.evaluate(code,filename) -- for Luigi
if code == "loop" then
while true do
io.write("> ")
local code = io.read()
if code ~= "" then
local temp = string.match(code,"^= (.*)$")
if temp then
code = "print("..temp..")"
end
local compiled, message = loadstring(code)
if type(compiled) ~= "function" then
io.write("! " .. (message or code).."\n")
else
io.write(compiled())
end
end
end
else
if type(code) ~= "string" or code == "" then
code = filename
end
if code ~= "" then
local compiled, message = loadstring(code)
if type(compiled) ~= "function" then
io.write("invalid lua code: " .. (message or code))
return
end
io.write(compiled())
end
end
end
function runners.gethelp(filename)
local url = environment.argument("url")
if url and url ~= "" then
local command = string.gsub(environment.argument("command") or "unknown","^%s*\\*(.-)%s*$","%1")
url = utilities.templates.replace(url,{ command = command })
os.launch(url)
else
report("no --url given")
end
end
function runners.systeminfo()
report("architecture : %s",os.platform or "<unset>")
report("operating system : %s",os.name or "<unset>")
report("file architecture : %s",os.type or "<unset>")
report("binary path : %s",os.selfdir or "<unset>")
report("binary suffix : %s",os.binsuffix or "<unset>")
report("library suffix : %s",os.libsuffix or "<unset>")
end
-- this is a bit dirty ... first we store the first filename and next we
-- split the arguments so that we only see the ones meant for this script
-- ... later we will use the second half
local filename = environment.files[1] or ""
local ok = true
local before, after = environment.splitarguments(filename)
environment.arguments_before, environment.arguments_after = before, after
environment.initializearguments(before)
e_verbose = environment.arguments["verbose"] -- delayed till here (we need the ones before script)
if e_verbose then
trackers.enable("resolvers.locating")
end
-- maybe the unset has to go to this level
local is_mkii_stub = runners.registered[file.removesuffix(file.basename(filename))]
local e_argument = environment.argument
if e_argument("timedlog") then
logs.settimedlog()
end
if e_argument("usekpse") or e_argument("forcekpse") or is_mkii_stub then
resolvers.load_tree(e_argument('tree'),true) -- force resolve of TEXMFCNF
os.setenv("engine","")
os.setenv("progname","")
local remapper = {
otf = "opentype fonts",
ttf = "truetype fonts",
ttc = "truetype fonts",
pfb = "type1 fonts",
other = "other text files",
}
local progname = e_argument("progname") or 'context'
local function kpse_initialized()
texconfig.kpse_init = true
local t = os.clock()
local k = kpse.original.new("luatex",progname)
local dummy = k:find_file("mtxrun.lua") -- so that we're initialized
report("kpse fallback with progname '%s' initialized in %s seconds",progname,os.clock()-t)
kpse_initialized = function() return k end
return k
end
local findfile = resolvers.findfile
local showpath = resolvers.showpath
if e_argument("forcekpse") then
function resolvers.findfile(name,kind)
return (kpse_initialized():find_file(resolvers.cleanpath(name),(kind ~= "" and (remapper[kind] or kind)) or "tex") or "") or ""
end
function resolvers.showpath(name)
return (kpse_initialized():show_path(name)) or ""
end
elseif e_argument("usekpse") or is_mkii_stub then
resolvers.load()
function resolvers.findfile(name,kind)
local found = findfile(name,kind) or ""
if found ~= "" then
return found
else
return (kpse_initialized():find_file(resolvers.cleanpath(name),(kind ~= "" and (remapper[kind] or kind)) or "tex") or "") or ""
end
end
function resolvers.showpath(name)
local found = showpath(name) or ""
if found ~= "" then
return found
else
return (kpse_initialized():show_path(name)) or ""
end
end
end
function runners.loadbase()
end
else
function runners.loadbase(...)
if not resolvers.load(...) then
report("forcing cache reload")
resolvers.renewcache()
trackers.enable("resolvers.locating")
if not resolvers.load(...) then
report("the resolver databases are not present or outdated")
end
end
end
resolvers.load_tree(e_argument('tree'),e_argument("resolve"))
end
-- joke .. reminds me of messing with gigi terminals
do
local a_locale = e_argument("locale")
if a_locale then
-- I really hate this crap but am too tired of discussing it over and over
-- again so for the sake of usiage outside context we will provide ways to
-- use locales in an otherwise supposed to be locale agnostic system. And
-- forget about support in case of interferences.
report()
report(what == "force" and "forcing locale:" or "original locale:")
report()
report(" collate : %s",status.lc_collate or "<unset>")
report(" ctype : %s",status.lc_ctype or "<unset>")
report(" monetary : %s",status.lc_monetary or "<unset>")
report(" numeric : %s",status.lc_numeric or "<unset>")
report(" time : %s",status.lc_time or "<unset>")
report()
end
if a_locale == "force" then
os.setlocale(status.lc_collate ,"collate")
os.setlocale(status.lc_ctype ,"ctype")
os.setlocale(status.lc_monetary,"monetary")
os.setlocale(status.lc_numeric ,"numeric")
os.setlocale(status.lc_time ,"time")
else
function os.setlocale()
end
end
end
if e_argument("ansi") then
logs.setformatters("ansi")
local script = e_argument("script") or e_argument("scripts")
if type(script) == "string" then
logs.writer("]0;"..script.."") -- for Alan to test
end
end
if e_argument("script") or e_argument("scripts") then
-- run a script by loading it (using libs), pass args
if e_argument("nofiledatabase") then
-- handy for mtx-update
else
runners.loadbase()
end
if is_mkii_stub then
ok = runners.execute_script(filename,false,true)
else
ok = runners.execute_ctx_script(filename)
end
elseif e_argument("evaluate") then
runners.evaluate(e_argument("evaluate"),filename)
elseif e_argument("selfmerge") then
-- embed used libraries
runners.loadbase()
local found = locate_libs()
if found then
local mtxrun = resolvers.findfile("mtxrun.lua") -- includes local name
if lfs.isfile(mtxrun) then
utilities.merger.selfmerge(mtxrun,own.libs,{ found })
application.report("runner updated on resolved path: %s",mtxrun)
else
utilities.merger.selfmerge(own.name,own.libs,{ found })
application.report("runner updated on relative path: %s",own.name)
end
end
elseif e_argument("selfclean") then
-- remove embedded libraries
runners.loadbase()
local mtxrun = resolvers.findfile("mtxrun.lua") -- includes local name
if lfs.isfile(mtxrun) then
utilities.merger.selfclean(mtxrun)
application.report("runner cleaned on resolved path: %s",mtxrun)
else
utilities.merger.selfclean(own.name)
application.report("runner cleaned on relative path: %s",own.name)
end
elseif e_argument("selfupdate") then
runners.loadbase()
trackers.enable("resolvers.locating")
resolvers.updatescript(own.name,"mtxrun")
elseif e_argument("ctxlua") or e_argument("internal") then
-- run a script by loading it (using libs)
runners.loadbase()
ok = runners.execute_script(filename,true)
elseif e_argument("execute") then
-- execute script
runners.loadbase()
ok = runners.execute_script(filename)
elseif e_argument("direct") then
-- equals bin:
runners.loadbase()
ok = runners.execute_program(filename)
elseif e_argument("edit") then
-- edit file
runners.loadbase()
runners.edit_script(filename)
elseif e_argument("launch") then
runners.loadbase()
runners.launch_file(filename)
elseif e_argument("associate") then
runners.associate(filename)
elseif e_argument("gethelp") then
runners.gethelp()
elseif e_argument("makestubs") then
-- make stubs (depricated)
runners.handle_stubs(true)
elseif e_argument("removestubs") then
-- remove stub (depricated)
runners.loadbase()
runners.handle_stubs(false)
elseif e_argument("resolve") then
-- resolve string
runners.loadbase()
runners.resolve_string(filename)
elseif e_argument("locate") then
-- locate file (only database)
runners.loadbase()
runners.locate_file(filename)
elseif e_argument("platform") or e_argument("show-platform") then
-- locate platform
runners.loadbase()
runners.locate_platform()
elseif e_argument("prefixes") then
runners.loadbase()
runners.prefixes()
elseif e_argument("timedrun") then
-- locate platform
runners.loadbase()
runners.timedrun(filename)
elseif e_argument("variables") or e_argument("show-variables") or e_argument("expansions") or e_argument("show-expansions") then
-- luatools: runners.execute_ctx_script("mtx-base","--expansions",filename)
resolvers.load("nofiles")
resolvers.listers.variables(e_argument("pattern"))
elseif e_argument("configurations") or e_argument("show-configurations") then
-- luatools: runners.execute_ctx_script("mtx-base","--configurations",filename)
resolvers.load("nofiles")
resolvers.listers.configurations()
elseif e_argument("find-file") then
-- luatools: runners.execute_ctx_script("mtx-base","--find-file",filename)
resolvers.load()
local e_all = e_argument("all")
local e_pattern = e_argument("pattern")
local e_format = e_argument("format")
local finder = e_all and resolvers.findfiles or resolvers.findfile
if not e_pattern then
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(finder,environment.files,e_format)
elseif type(e_pattern) == "string" then
resolvers.dowithfilesandreport(finder,{ e_pattern },e_format)
end
elseif e_argument("find-path") then
-- luatools: runners.execute_ctx_script("mtx-base","--find-path",filename)
resolvers.load()
local path = resolvers.findpath(filename)
if e_verbose then
report(path)
else
print(path)
end
elseif e_argument("expand-braces") then
-- luatools: runners.execute_ctx_script("mtx-base","--expand-braces",filename)
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.expandbraces, environment.files)
elseif e_argument("expand-path") then
-- luatools: runners.execute_ctx_script("mtx-base","--expand-path",filename)
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.expandpath, environment.files)
elseif e_argument("resolve-path") then
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.cleanedpathlist, environment.files)
elseif e_argument("expand-var") or e_argument("expand-variable") then
-- luatools: runners.execute_ctx_script("mtx-base","--expand-var",filename)
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.expansion, environment.files)
elseif e_argument("show-path") or e_argument("path-value") then
-- luatools: runners.execute_ctx_script("mtx-base","--show-path",filename)
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.showpath, environment.files)
elseif e_argument("var-value") or e_argument("show-value") then
-- luatools: runners.execute_ctx_script("mtx-base","--show-value",filename)
resolvers.load("nofiles")
runners.register_arguments(filename)
environment.initializearguments(environment.arguments_after)
resolvers.dowithfilesandreport(resolvers.variable,environment.files)
elseif e_argument("format-path") then
-- luatools: runners.execute_ctx_script("mtx-base","--format-path",filename)
resolvers.load()
report(caches.getwritablepath("format"))
elseif e_argument("pattern") then
-- luatools
runners.execute_ctx_script("mtx-base","--pattern='" .. e_argument("pattern") .. "'",filename)
elseif e_argument("generate") then
-- luatools
if filename and filename ~= "" then
resolvers.load("nofiles")
trackers.enable("resolvers.locating")
resolvers.renew(filename)
else
resolvers.renewcache()
trackers.enable("resolvers.locating")
resolvers.load()
end
e_verbose = true
elseif e_argument("make") or e_argument("ini") or e_argument("compile") then
-- luatools: runners.execute_ctx_script("mtx-base","--make",filename)
resolvers.load()
trackers.enable("resolvers.locating")
environment.make_format(filename)
elseif e_argument("run") then
-- luatools
runners.execute_ctx_script("mtx-base","--run",filename)
elseif e_argument("fmt") then
-- luatools
runners.execute_ctx_script("mtx-base","--fmt",filename)
elseif e_argument("help") and filename=='base' then
-- luatools
runners.execute_ctx_script("mtx-base","--help")
elseif e_argument("version") then
application.version()
application.report("source path",environment.ownbin)
elseif e_argument("directives") then
directives.show()
elseif e_argument("trackers") then
trackers.show()
elseif e_argument("experiments") then
experiments.show()
elseif e_argument("exporthelp") then
runners.loadbase()
application.export(e_argument("exporthelp"),filename)
elseif e_argument("systeminfo") then
runners.systeminfo()
elseif e_argument("locale") then
-- already done
elseif e_argument("help") or filename=='help' or filename == "" then
application.help()
elseif find(filename,"^bin:") then
runners.loadbase()
ok = runners.execute_program(filename)
elseif is_mkii_stub then
-- execute mkii script
runners.loadbase()
ok = runners.execute_script(filename,false,true)
elseif false then
runners.loadbase()
ok = runners.execute_ctx_script(filename)
if not ok then
ok = runners.execute_script(filename)
end
elseif environment.files[1] == 'texmfcnf.lua' then -- so that we don't need to load mtx-base
resolvers.load("nofiles")
resolvers.listers.configurations()
else
runners.loadbase()
runners.execute_ctx_script("mtx-base",filename)
end
if e_verbose then
report()
report("elapsed lua time: %0.3f seconds",os.runtime())
end
if os.type ~= "windows" then
texio.write("\n") -- is this still valid?
end
if ok == false then ok = 1 elseif ok == true or ok == nil then ok = 0 end
-- os.exit(ok,true) -- true forces a cleanup in 5.2+
os.exit(ok) -- true forces a cleanup in 5.2+ but reports a wrong number then