merge from eroux

1 files changed, 0 insertions, 297 deletions

diff --git a/otfl-basics-gen.lua b/otfl-basics-gen.lua
deleted file mode 100644
index 288cfa2..0000000
--- a/otfl-basics-gen.lua
+++ /dev/null
@@ -1,297 +0,0 @@
-if not modules then modules = { } end modules ['luat-basics-gen'] = {
-    version   = 1.100,
-    comment   = "companion to luatex-*.tex",
-    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
-    copyright = "PRAGMA ADE / ConTeXt Development Team",
-    license   = "see context related readme files"
-}
-
-if context then
-    texio.write_nl("fatal error: this module is not for context")
-    os.exit()
-end
-
-local dummyfunction = function() end
------ dummyreporter = function(c) return function(...) texio.write_nl(c .. " : " .. string.format(...)) end end
-local dummyreporter = function(c) return function(...) texio.write_nl(c .. " : " .. string.formatters(...)) end end
-
-statistics = {
-    register      = dummyfunction,
-    starttiming   = dummyfunction,
-    stoptiming    = dummyfunction,
-    elapsedtime   = nil,
-}
-
-directives = {
-    register      = dummyfunction,
-    enable        = dummyfunction,
-    disable       = dummyfunction,
-}
-
-trackers = {
-    register      = dummyfunction,
-    enable        = dummyfunction,
-    disable       = dummyfunction,
-}
-
-experiments = {
-    register      = dummyfunction,
-    enable        = dummyfunction,
-    disable       = dummyfunction,
-}
-
-storage = { -- probably no longer needed
-    register      = dummyfunction,
-    shared        = { },
-}
-
-logs = {
-    new           = dummyreporter,
-    reporter      = dummyreporter,
-    messenger     = dummyreporter,
-    report        = dummyfunction,
-}
-
-callbacks = {
-    register = function(n,f) return callback.register(n,f) end,
-
-}
-
-utilities = {
-    storage = {
-        allocate = function(t) return t or { } end,
-        mark     = function(t) return t or { } end,
-    },
-}
-
-characters = characters or {
-    data = { }
-}
-
--- we need to cheat a bit here
-
-texconfig.kpse_init = true
-
-resolvers = resolvers or { } -- no fancy file helpers used
-
-local remapper = {
-    otf    = "opentype fonts",
-    ttf    = "truetype fonts",
-    ttc    = "truetype fonts",
-    dfont  = "truetype fonts", -- "truetype dictionary",
-    cid    = "cid maps",
-    cidmap = "cid maps",
-    fea    = "font feature files",
-    pfa    = "type1 fonts", -- this is for Khaled, in ConTeXt we don't use this!
-    pfb    = "type1 fonts", -- this is for Khaled, in ConTeXt we don't use this!
-}
-
-function resolvers.findfile(name,fileformat)
-    name = string.gsub(name,"\\","/")
-    if not fileformat or fileformat == "" then
-        fileformat = file.suffix(name)
-        if fileformat == "" then
-            fileformat = "tex"
-        end
-    end
-    fileformat = string.lower(fileformat)
-    fileformat = remapper[fileformat] or fileformat
-    local found = kpse.find_file(name,fileformat)
-    if not found or found == "" then
-        found = kpse.find_file(name,"other text files")
-    end
-    return found
-end
-
--- function resolvers.findbinfile(name,fileformat)
---     if not fileformat or fileformat == "" then
---         fileformat = file.suffix(name)
---     end
---     return resolvers.findfile(name,(fileformat and remapper[fileformat]) or fileformat)
--- end
-
-resolvers.findbinfile = resolvers.findfile
-
-function resolvers.resolve(s)
-    return s
-end
-
-function resolvers.unresolve(s)
-    return s
-end
-
--- Caches ... I will make a real stupid version some day when I'm in the
--- mood. After all, the generic code does not need the more advanced
--- ConTeXt features. Cached data is not shared between ConTeXt and other
--- usage as I don't want any dependency at all. Also, ConTeXt might have
--- different needs and tricks added.
-
---~ containers.usecache = true
-
-caches = { }
-
-local writable, readables = nil, { }
-
-if not caches.namespace or caches.namespace == "" or caches.namespace == "context" then
-    caches.namespace = 'generic'
-end
-
-do
-
-    local cachepaths = kpse.expand_path('$TEXMFCACHE') or ""
-
-    if cachepaths == "" then
-        cachepaths = kpse.expand_path('$TEXMFVAR')
-    end
-
-    if cachepaths == "" then
-        cachepaths = kpse.expand_path('$VARTEXMF')
-    end
-
-    if cachepaths == "" then
-        cachepaths = "."
-    end
-
-    cachepaths = string.split(cachepaths,os.type == "windows" and ";" or ":")
-
-    for i=1,#cachepaths do
-        if file.is_writable(cachepaths[i]) then
-            writable = file.join(cachepaths[i],"luatex-cache")
-            lfs.mkdir(writable)
-            writable = file.join(writable,caches.namespace)
-            lfs.mkdir(writable)
-            break
-        end
-    end
-
-    for i=1,#cachepaths do
-        if file.is_readable(cachepaths[i]) then
-            readables[#readables+1] = file.join(cachepaths[i],"luatex-cache",caches.namespace)
-        end
-    end
-
-    if not writable then
-        texio.write_nl("quiting: fix your writable cache path")
-        os.exit()
-    elseif #readables == 0 then
-        texio.write_nl("quiting: fix your readable cache path")
-        os.exit()
-    elseif #readables == 1 and readables[1] == writable then
-        texio.write(string.format("(using cache: %s)",writable))
-    else
-        texio.write(string.format("(using write cache: %s)",writable))
-        texio.write(string.format("(using read cache: %s)",table.concat(readables, " ")))
-    end
-
-end
-
-function caches.getwritablepath(category,subcategory)
-    local path = file.join(writable,category)
-    lfs.mkdir(path)
-    path = file.join(path,subcategory)
-    lfs.mkdir(path)
-    return path
-end
-
-function caches.getreadablepaths(category,subcategory)
-    local t = { }
-    for i=1,#readables do
-        t[i] = file.join(readables[i],category,subcategory)
-    end
-    return t
-end
-
-local function makefullname(path,name)
-    if path and path ~= "" then
-        name = "temp-" .. name -- clash prevention
-        return file.addsuffix(file.join(path,name),"lua"), file.addsuffix(file.join(path,name),"luc")
-    end
-end
-
-function caches.is_writable(path,name)
-    local fullname = makefullname(path,name)
-    return fullname and file.is_writable(fullname)
-end
-
-function caches.loaddata(paths,name)
-    for i=1,#paths do
-        local data = false
-        local luaname, lucname = makefullname(paths[i],name)
-        if lucname and lfs.isfile(lucname) then -- maybe also check for size
-            texio.write(string.format("(load luc: %s)",lucname))
-            data = loadfile(lucname)
-            if data then
-                data = data()
-            end
-            if data then
-                return data
-            else
-                texio.write(string.format("(loading failed: %s)",lucname))
-            end
-        end
-        if luaname and lfs.isfile(luaname) then
-            texio.write(string.format("(load lua: %s)",luaname))
-            data = loadfile(luaname)
-            if data then
-                data = data()
-            end
-            if data then
-                return data
-            end
-        end
-    end
-end
-
-function caches.savedata(path,name,data)
-    local luaname, lucname = makefullname(path,name)
-    if luaname then
-        texio.write(string.format("(save: %s)",luaname))
-        table.tofile(luaname,data,true,{ reduce = true })
-        if lucname and type(caches.compile) == "function" then
-            os.remove(lucname) -- better be safe
-            texio.write(string.format("(save: %s)",lucname))
-            caches.compile(data,luaname,lucname)
-        end
-    end
-end
-
--- According to KH os.execute is not permitted in plain/latex so there is
--- no reason to use the normal context way. So the method here is slightly
--- different from the one we have in context. We also use different suffixes
--- as we don't want any clashes (sharing cache files is not that handy as
--- context moves on faster.)
---
--- Beware: serialization might fail on large files (so maybe we should pcall
--- this) in which case one should limit the method to luac and enable support
--- for execution.
-
-caches.compilemethod = "both"
-
-function caches.compile(data,luaname,lucname)
-    local done = false
-    if caches.compilemethod == "luac" or caches.compilemethod == "both" then
-        done = os.spawn("texluac -o " .. string.quoted(lucname) .. " -s " .. string.quoted(luaname)) == 0
-    end
-    if not done and (caches.compilemethod == "dump" or caches.compilemethod == "both") then
-        local d = io.loaddata(luaname)
-        if not d or d == "" then
-            d = table.serialize(data,true) -- slow
-        end
-        if d and d ~= "" then
-            local f = io.open(lucname,'w')
-            if f then
-                local s = loadstring(d)
-                if s then
-                    f:write(string.dump(s,true))
-                end
-                f:close()
-            end
-        end
-    end
-end
-
---
-
-function table.setmetatableindex(t,f)
-    setmetatable(t,{ __index = f })
-end