update l-file l-table; add yet uncommitted changes

6 files changed, 823 insertions, 411 deletions

diff --git a/lualibs-file.lua b/lualibs-file.lua
index 2bfc070..7ab9fbc 100644
--- a/lualibs-file.lua
+++ b/lualibs-file.lua
@@ -8,47 +8,101 @@ if not modules then modules = { } end modules ['l-file'] = {
 
 -- needs a cleanup
 
-file = file or { }
+file       = file or { }
+local file = file
 
-local concat = table.concat
-local find, gmatch, match, gsub, sub, char = string.find, string.gmatch, string.match, string.gsub, string.sub, string.char
+local insert, concat = table.insert, table.concat
+local find, gmatch, match, gsub, sub, char, lower = string.find, string.gmatch, string.match, string.gsub, string.sub, string.char, string.lower
 local lpegmatch = lpeg.match
 
-function file.removesuffix(filename)
-    return (gsub(filename,"%.[%a%d]+$",""))
+local P, R, S, C, Cs, Cp, Cc = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cs, lpeg.Cp, lpeg.Cc
+
+local function dirname(name,default)
+    return match(name,"^(.+)[/\\].-$") or (default or "")
 end
 
-function file.addsuffix(filename, suffix)
-    if not suffix or suffix == "" then
-        return filename
-    elseif not find(filename,"%.[%a%d]+$") then
-        return filename .. "." .. suffix
-    else
-        return filename
-    end
+local function basename(name)
+    return match(name,"^.+[/\\](.-)$") or name
 end
 
-function file.replacesuffix(filename, suffix)
-    return (gsub(filename,"%.[%a%d]+$","")) .. "." .. suffix
+-- local function nameonly(name)
+--     return (gsub(match(name,"^.+[/\\](.-)$") or name,"%..*$",""))
+-- end
+
+local function nameonly(name)
+    return (gsub(match(name,"^.+[/\\](.-)$") or name,"%.[%a%d]+$",""))
 end
 
-function file.dirname(name,default)
-    return match(name,"^(.+)[/\\].-$") or (default or "")
+local function suffixonly(name,default)
+    return match(name,"^.+%.([^/\\]-)$") or default or ""
 end
 
-function file.basename(name)
-    return match(name,"^.+[/\\](.-)$") or name
+local function splitname(name)
+    local n, s = match(name,"^(.+)%.([^/\\]-)$")
+    return n or name, s or ""
 end
 
-function file.nameonly(name)
-    return (gsub(match(name,"^.+[/\\](.-)$") or name,"%..*$",""))
+file.basename   = basename
+
+file.pathpart   = dirname
+file.dirname    = dirname
+
+file.nameonly   = nameonly
+
+file.suffixonly = suffixonly
+file.extname    = suffixonly -- obsolete
+file.suffix     = suffixonly
+
+function file.removesuffix(filename)
+    return (gsub(filename,"%.[%a%d]+$",""))
 end
 
-function file.extname(name,default)
-    return match(name,"^.+%.([^/\\]-)$") or default or ""
+function file.addsuffix(filename, suffix, criterium)
+    if not suffix or suffix == "" then
+        return filename
+    elseif criterium == true then
+        return filename .. "." .. suffix
+    elseif not criterium then
+        local n, s = splitname(filename)
+        if not s or s == "" then
+            return filename .. "." .. suffix
+        else
+            return filename
+        end
+    else
+        local n, s = splitname(filename)
+        if s and s ~= "" then
+            local t = type(criterium)
+            if t == "table" then
+                -- keep if in criterium
+                for i=1,#criterium do
+                    if s == criterium[i] then
+                        return filename
+                    end
+                end
+            elseif t == "string" then
+                -- keep if criterium
+                if s == criterium then
+                    return filename
+                end
+            end
+        end
+        return n .. "." .. suffix
+    end
 end
 
-file.suffix = file.extname
+--~ print("1 " .. file.addsuffix("name","new")                   .. " -> name.new")
+--~ print("2 " .. file.addsuffix("name.old","new")               .. " -> name.old")
+--~ print("3 " .. file.addsuffix("name.old","new",true)          .. " -> name.old.new")
+--~ print("4 " .. file.addsuffix("name.old","new","new")         .. " -> name.new")
+--~ print("5 " .. file.addsuffix("name.old","new","old")         .. " -> name.old")
+--~ print("6 " .. file.addsuffix("name.old","new","foo")         .. " -> name.new")
+--~ print("7 " .. file.addsuffix("name.old","new",{"foo","bar"}) .. " -> name.new")
+--~ print("8 " .. file.addsuffix("name.old","new",{"old","bar"}) .. " -> name.old")
+
+function file.replacesuffix(filename, suffix)
+    return (gsub(filename,"%.[%a%d]+$","")) .. "." .. suffix
+end
 
 --~ function file.join(...)
 --~     local pth = concat({...},"/")
@@ -67,10 +121,10 @@ file.suffix = file.extname
 local trick_1 = char(1)
 local trick_2 = "^" .. trick_1 .. "/+"
 
-function file.join(...)
+function file.join(...) -- rather dirty
     local lst = { ... }
     local a, b = lst[1], lst[2]
-    if a == "" then
+    if not a or a == "" then -- not a added
         lst[1] = trick_1
     elseif b and find(a,"^/+$") and find(b,"^/") then
         lst[1] = ""
@@ -100,74 +154,165 @@ end
 --~ print(file.join("http:///a","/y"))
 --~ print(file.join("//nas-1","/y"))
 
-function file.iswritable(name)
-    local a = lfs.attributes(name) or lfs.attributes(file.dirname(name,"."))
-    return a and sub(a.permissions,2,2) == "w"
+-- We should be able to use:
+--
+-- function file.is_writable(name)
+--     local a = attributes(name) or attributes(dirname(name,"."))
+--     return a and sub(a.permissions,2,2) == "w"
+-- end
+--
+-- But after some testing Taco and I came up with:
+
+function file.is_writable(name)
+    if 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
 
-function file.isreadable(name)
-    local a = lfs.attributes(name)
+function file.is_readable(name)
+    local a = attributes(name)
     return a and sub(a.permissions,1,1) == "r"
 end
 
-file.is_readable = file.isreadable
-file.is_writable = file.iswritable
+file.isreadable = file.is_readable -- depricated
+file.iswritable = file.is_writable -- depricated
 
--- todo: lpeg
+function file.size(name)
+    local a = attributes(name)
+    return a and a.size or 0
+end
 
---~ function file.split_path(str)
---~     local t = { }
---~     str = gsub(str,"\\", "/")
---~     str = gsub(str,"(%a):([;/])", "%1\001%2")
---~     for name in gmatch(str,"([^;:]+)") do
---~         if name ~= "" then
---~             t[#t+1] = gsub(name,"\001",":")
---~         end
---~     end
---~     return t
---~ end
+-- todo: lpeg \\ / .. does not save much
 
 local checkedsplit = string.checkedsplit
 
-function file.split_path(str,separator)
+function file.splitpath(str,separator) -- string
     str = gsub(str,"\\","/")
     return checkedsplit(str,separator or io.pathseparator)
 end
 
-function file.join_path(tab)
-    return concat(tab,io.pathseparator) -- can have trailing //
+function file.joinpath(tab,separator) -- table
+    return concat(tab,separator or io.pathseparator) -- can have trailing //
 end
 
 -- we can hash them weakly
 
-function file.collapse_path(str)
+--~ function file.collapsepath(str) -- fails on b.c/..
+--~     str = gsub(str,"\\","/")
+--~     if find(str,"/") then
+--~         str = gsub(str,"^%./",(gsub(getcurrentdir(),"\\","/")) .. "/") -- ./xx in qualified
+--~         str = gsub(str,"/%./","/")
+--~         local n, m = 1, 1
+--~         while n > 0 or m > 0 do
+--~             str, n = gsub(str,"[^/%.]+/%.%.$","")
+--~             str, m = gsub(str,"[^/%.]+/%.%./","")
+--~         end
+--~         str = gsub(str,"([^/])/$","%1")
+--~     --  str = gsub(str,"^%./","") -- ./xx in qualified
+--~         str = gsub(str,"/%.$","")
+--~     end
+--~     if str == "" then str = "." end
+--~     return str
+--~ end
+--~
+--~ The previous one fails on "a.b/c"  so Taco came up with a split based
+--~ variant. After some skyping we got it sort of compatible with the old
+--~ one. After that the anchoring to currentdir was added in a better way.
+--~ Of course there are some optimizations too. Finally we had to deal with
+--~ windows drive prefixes and things like sys://.
+
+function file.collapsepath(str,anchor)
+    if anchor and not find(str,"^/") and not find(str,"^%a:") then
+        str = getcurrentdir() .. "/" .. str
+    end
+    if str == "" or str =="." then
+        return "."
+    elseif find(str,"^%.%.") then
+        str = gsub(str,"\\","/")
+        return str
+    elseif not find(str,"%.") then
+        str = gsub(str,"\\","/")
+        return str
+    end
     str = gsub(str,"\\","/")
-    if find(str,"/") then
-        str = gsub(str,"^%./",(gsub(lfs.currentdir(),"\\","/")) .. "/") -- ./xx in qualified
-        str = gsub(str,"/%./","/")
-        local n, m = 1, 1
-        while n > 0 or m > 0 do
-            str, n = gsub(str,"[^/%.]+/%.%.$","")
-            str, m = gsub(str,"[^/%.]+/%.%./","")
+    local starter, rest = match(str,"^(%a+:/*)(.-)$")
+    if starter then
+        str = rest
+    end
+    local oldelements = checkedsplit(str,"/")
+    local newelements = { }
+    local i = #oldelements
+    while i > 0 do
+        local element = oldelements[i]
+        if element == '.' then
+            -- do nothing
+        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
-        str = gsub(str,"([^/])/$","%1")
-    --  str = gsub(str,"^%./","") -- ./xx in qualified
-        str = gsub(str,"/%.$","")
+        i = i - 1
+    end
+    if #newelements == 0 then
+        return starter or "."
+    elseif starter then
+        return starter .. concat(newelements, '/')
+    elseif find(str,"^/") then
+        return "/" .. concat(newelements,'/')
+    else
+        return concat(newelements, '/')
     end
-    if str == "" then str = "." end
-    return str
 end
 
---~ print(file.collapse_path("/a"))
---~ print(file.collapse_path("a/./b/.."))
---~ print(file.collapse_path("a/aa/../b/bb"))
---~ print(file.collapse_path("a/../.."))
---~ print(file.collapse_path("a/.././././b/.."))
---~ print(file.collapse_path("a/./././b/.."))
---~ print(file.collapse_path("a/b/c/../.."))
-
-function file.robustname(str)
-    return (gsub(str,"[^%a%d%/%-%.\\]+","-"))
+--~ local function test(str)
+--~    print(string.format("%-20s %-15s %-15s",str,file.collapsepath(str),file.collapsepath(str,true)))
+--~ end
+--~ test("a/b.c/d") test("b.c/d") test("b.c/..")
+--~ test("/") test("c:/..") test("sys://..")
+--~ test("") test("./") test(".") test("..") test("./..") test("../..")
+--~ test("a") test("./a") test("/a") test("a/../..")
+--~ test("a/./b/..") test("a/aa/../b/bb") test("a/.././././b/..") test("a/./././b/..")
+--~ test("a/b/c/../..") test("./a/b/c/../..") test("a/b/c/../..")
+
+function file.robustname(str,strict)
+    str = gsub(str,"[^%a%d%/%-%.\\]+","-")
+    if strict then
+        return lower(gsub(str,"^%-*(.-)%-*$","%1"))
+    else
+        return str
+    end
 end
 
 file.readdata = io.loaddata
@@ -179,31 +324,31 @@ end
 
 -- lpeg variants, slightly faster, not always
 
---~ local period    = lpeg.P(".")
---~ local slashes   = lpeg.S("\\/")
+--~ local period    = P(".")
+--~ local slashes   = S("\\/")
 --~ local noperiod  = 1-period
 --~ local noslashes = 1-slashes
 --~ local name      = noperiod^1
 
---~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * lpeg.C(noperiod^1) * -1
+--~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * C(noperiod^1) * -1
 
---~ function file.extname(name)
+--~ function file.suffixonly(name)
 --~     return lpegmatch(pattern,name) or ""
 --~ end
 
---~ local pattern = lpeg.Cs(((period * noperiod^1 * -1)/"" + 1)^1)
+--~ local pattern = Cs(((period * noperiod^1 * -1)/"" + 1)^1)
 
 --~ function file.removesuffix(name)
 --~     return lpegmatch(pattern,name)
 --~ end
 
---~ local pattern = (noslashes^0 * slashes)^1 * lpeg.C(noslashes^1) * -1
+--~ local pattern = (noslashes^0 * slashes)^1 * C(noslashes^1) * -1
 
 --~ function file.basename(name)
 --~     return lpegmatch(pattern,name) or name
 --~ end
 
---~ local pattern = (noslashes^0 * slashes)^1 * lpeg.Cp() * noslashes^1 * -1
+--~ local pattern = (noslashes^0 * slashes)^1 * Cp() * noslashes^1 * -1
 
 --~ function file.dirname(name)
 --~     local p = lpegmatch(pattern,name)
@@ -214,7 +359,7 @@ end
 --~     end
 --~ end
 
---~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * lpeg.Cp() * noperiod^1 * -1
+--~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * Cp() * noperiod^1 * -1
 
 --~ function file.addsuffix(name, suffix)
 --~     local p = lpegmatch(pattern,name)
@@ -225,7 +370,7 @@ end
 --~     end
 --~ end
 
---~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * lpeg.Cp() * noperiod^1 * -1
+--~ local pattern = (noslashes^0 * slashes)^0 * (noperiod^1 * period)^1 * Cp() * noperiod^1 * -1
 
 --~ function file.replacesuffix(name,suffix)
 --~     local p = lpegmatch(pattern,name)
@@ -236,7 +381,7 @@ end
 --~     end
 --~ end
 
---~ local pattern = (noslashes^0 * slashes)^0 * lpeg.Cp() * ((noperiod^1 * period)^1 * lpeg.Cp() + lpeg.P(true)) * noperiod^1 * -1
+--~ local pattern = (noslashes^0 * slashes)^0 * Cp() * ((noperiod^1 * period)^1 * Cp() + P(true)) * noperiod^1 * -1
 
 --~ function file.nameonly(name)
 --~     local a, b = lpegmatch(pattern,name)
@@ -249,7 +394,7 @@ end
 --~     end
 --~ end
 
---~ local test = file.extname
+--~ local test = file.suffixonly
 --~ local test = file.basename
 --~ local test = file.dirname
 --~ local test = file.addsuffix
@@ -268,11 +413,14 @@ end
 
 -- also rewrite previous
 
-local letter    = lpeg.R("az","AZ") + lpeg.S("_-+")
-local separator = lpeg.P("://")
+local letter    = R("az","AZ") + S("_-+")
+local separator = P("://")
+
+local qualified = P(".")^0 * P("/") + letter*P(":") + letter^1*separator + letter^1 * P("/")
+local rootbased = P("/") + letter*P(":")
 
-local qualified = lpeg.P(".")^0 * lpeg.P("/") + letter*lpeg.P(":") + letter^1*separator + letter^1 * lpeg.P("/")
-local rootbased = lpeg.P("/") + letter*lpeg.P(":")
+lpeg.patterns.qualified = qualified
+lpeg.patterns.rootbased = rootbased
 
 -- ./name ../name  /name c: :// name/name
 
@@ -284,19 +432,61 @@ function file.is_rootbased_path(filename)
     return lpegmatch(rootbased,filename) ~= nil
 end
 
-local slash  = lpeg.S("\\/")
-local period = lpeg.P(".")
-local drive  = lpeg.C(lpeg.R("az","AZ")) * lpeg.P(":")
-local path   = lpeg.C(((1-slash)^0 * slash)^0)
-local suffix = period * lpeg.C(lpeg.P(1-period)^0 * lpeg.P(-1))
-local base   = lpeg.C((1-suffix)^0)
+-- actually these are schemes
+
+local slash  = S("\\/")
+local period = P(".")
+local drive  = C(R("az","AZ")) * P(":")
+local path   = C(((1-slash)^0 * slash)^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) -- trick: two extra captures
+local pattern_d =           path  *   rest
+
+function file.splitname(str,splitdrive)
+    if splitdrive then
+        return lpegmatch(pattern_a,str) -- returns drive, path, base, suffix
+    else
+        return lpegmatch(pattern_b,str) -- returns path, base, suffix
+    end
+end
 
-local pattern = (drive + lpeg.Cc("")) * (path + lpeg.Cc("")) * (base + lpeg.Cc("")) * (suffix + lpeg.Cc(""))
+function file.splitbase(str)
+    return lpegmatch(pattern_d,str) -- returns path, base+suffix
+end
 
-function file.splitname(str) -- returns drive, path, base, suffix
-    return lpegmatch(pattern,str)
+function file.nametotable(str,splitdrive) -- returns table
+    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
 
+-- print(file.splitbase("a/b/c.txt"))
+
 -- function test(t) for k, v in next, t do print(v, "=>", file.splitname(v)) end end
 --
 -- test { "c:", "c:/aa", "c:/aa/bb", "c:/aa/bb/cc", "c:/aa/bb/cc.dd", "c:/aa/bb/cc.dd.ee" }
@@ -307,8 +497,15 @@ end
 --~ -- todo:
 --~
 --~ if os.type == "windows" then
---~     local currentdir = lfs.currentdir
---~     function lfs.currentdir()
+--~     local currentdir = getcurrentdir
+--~     function getcurrentdir()
 --~         return (gsub(currentdir(),"\\","/"))
 --~     end
 --~ end
+
+-- for myself:
+
+function file.strip(name,dir)
+    local b, a = match(name,"^(.-)" .. dir .. "(.*)$")
+    return a ~= "" and a or name
+end
diff --git a/lualibs-io.lua b/lualibs-io.lua
index a9269ab..657b755 100644
--- a/lualibs-io.lua
+++ b/lualibs-io.lua
@@ -234,3 +234,65 @@ function io.ask(question,default,options)
         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 256 * a + b
+    elseif n == 3 then
+        local a, b, c = byte(f:read(3),1,3)
+        return 256*256 * a + 256 * b + c
+    elseif n == 4 then
+        local a, b, c, d = byte(f:read(4),1,4)
+        return 256*256*256 * a + 256*256 * b + 256 * c + d
+    elseif n == 8 then
+        local a, b = readnumber(f,4), readnumber(f,4)
+        return 256 * a + b
+    elseif n == 12 then
+        local a, b, c = readnumber(f,4), readnumber(f,4), readnumber(f,4)
+        return 256*256 * a + 256 * b + c
+    elseif n == -2 then
+        local b, a = byte(f:read(2),1,2)
+        return 256*a + b
+    elseif n == -3 then
+        local c, b, a = byte(f:read(3),1,3)
+        return 256*256 * a + 256 * b + c
+    elseif n == -4 then
+        local d, c, b, a = byte(f:read(4),1,4)
+        return 256*256*256 * a + 256*256 * b + 256*c + d
+    elseif n == -8 then
+        local h, g, f, e, d, c, b, a = byte(f:read(8),1,8)
+        return 256*256*256*256*256*256*256 * a +
+                   256*256*256*256*256*256 * b +
+                       256*256*256*256*256 * c +
+                           256*256*256*256 * d +
+                               256*256*256 * e +
+                                   256*256 * f +
+                                       256 * 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),"%z","")
+    return str
+end
+
+--
+
+if not io.i_limiter then function io.i_limiter() end end -- dummy so we can test safely
+if not io.o_limiter then function io.o_limiter() end end -- dummy so we can test safely
diff --git a/lualibs-math.lua b/lualibs-math.lua
index 4669a51..43f60b5 100644
--- a/lualibs-math.lua
+++ b/lualibs-math.lua
@@ -9,21 +9,15 @@ if not modules then modules = { } end modules ['l-math'] = {
 local floor, sin, cos, tan = math.floor, math.sin, math.cos, math.tan
 
 if not math.round then
-    function math.round(x)
-        return floor(x + 0.5)
-    end
+    function math.round(x) return floor(x + 0.5) end
 end
 
 if not math.div then
-    function math.div(n,m)
-        return floor(n/m)
-    end
+    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
+    function math.mod(n,m) return n % m end
 end
 
 local pipi = 2*math.pi/360
diff --git a/lualibs-os.lua b/lualibs-os.lua
index 95d007d..799f449 100644
--- a/lualibs-os.lua
+++ b/lualibs-os.lua
@@ -115,8 +115,8 @@ if not os.__getenv__ then
     end
 
 end
-local find, format, gsub = string.find, string.format, string.gsub
-local random, ceil = math.random, math.ceil
+
+-- end of environment hack
 
 local execute, spawn, exec, iopopen, ioflush = os.execute, os.spawn or os.execute, os.exec or os.execute, io.popen, io.flush
 
@@ -381,3 +381,74 @@ function os.timezone(delta)
         return 1
     end
 end
+
+local timeformat = format("%%s%s",os.timezone(true))
+local dateformat = "!%Y-%m-%d %H:%M:%S"
+
+function os.fulltime(t,default)
+    t = tonumber(t) or 0
+    if t > 0 then
+        -- valid time
+    elseif default then
+        return default
+    else
+        t = nil
+    end
+    return format(timeformat,date(dateformat,t))
+end
+
+local dateformat = "%Y-%m-%d %H:%M:%S"
+
+function os.localtime(t,default)
+    t = tonumber(t) or 0
+    if t > 0 then
+        -- valid time
+    elseif default then
+        return default
+    else
+        t = nil
+    end
+    return date(dateformat,t)
+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
+
+-- print(os.which("inkscape.exe"))
+-- print(os.which("inkscape"))
+-- print(os.which("gs.exe"))
+-- print(os.which("ps2pdf"))
diff --git a/lualibs-table.lua b/lualibs-table.lua
index ee395d0..80f28c2 100644
--- a/lualibs-table.lua
+++ b/lualibs-table.lua
@@ -6,17 +6,19 @@ if not modules then modules = { } end modules ['l-table'] = {
     license   = "see context related readme files"
 }
 
-table.join = table.concat
-
+local type, next, tostring, tonumber, ipairs = type, next, tostring, tonumber, ipairs
+local table, string = table, string
 local concat, sort, insert, remove = table.concat, table.sort, table.insert, table.remove
 local format, find, gsub, lower, dump, match = string.format, string.find, string.gsub, string.lower, string.dump, string.match
 local getmetatable, setmetatable = getmetatable, setmetatable
-local type, next, tostring, tonumber, ipairs = type, next, tostring, tonumber, ipairs
+local getinfo = debug.getinfo
 
 -- Starting with version 5.2 Lua no longer provide ipairs, which makes
 -- sense. As we already used the for loop and # in most places the
 -- impact on ConTeXt was not that large; the remaining ipairs already
--- have been replaced. In a similar fashio we also hardly used pairs.
+-- have been replaced. In a similar fashion we also hardly used pairs.
+--
+-- Hm, actually ipairs was retained, but we no longer use it anyway.
 --
 -- Just in case, we provide the fallbacks as discussed in Programming
 -- in Lua (http://www.lua.org/pil/7.3.html):
@@ -63,97 +65,134 @@ end
 -- extra functions, some might go (when not used)
 
 function table.strip(tab)
-    local lst = { }
+    local lst, l = { }, 0
     for i=1,#tab do
         local s = gsub(tab[i],"^%s*(.-)%s*$","%1")
         if s == "" then
             -- skip this one
         else
-            lst[#lst+1] = s
+            l = l + 1
+            lst[l] = s
         end
     end
     return lst
 end
 
 function table.keys(t)
-    local k = { }
-    for key, _ in next, t do
-        k[#k+1] = key
+    if t then
+        local keys, k = { }, 0
+        for key, _ in next, t do
+            k = k + 1
+            keys[k] = key
+        end
+        return keys
+    else
+        return { }
     end
-    return k
 end
 
 local function compare(a,b)
-    return (tostring(a) < tostring(b))
+    local ta, tb = type(a), type(b) -- needed, else 11 < 2
+    if ta == tb then
+        return a < b
+    else
+        return tostring(a) < tostring(b)
+    end
 end
 
 local function sortedkeys(tab)
-    local srt, kind = { }, 0 -- 0=unknown 1=string, 2=number 3=mixed
-    for key,_ in next, tab do
-        srt[#srt+1] = key
-        if kind == 3 then
-            -- no further check
-        else
-            local tkey = type(key)
-            if tkey == "string" then
-            --  if kind == 2 then kind = 3 else kind = 1 end
-                kind = (kind == 2 and 3) or 1
-            elseif tkey == "number" then
-            --  if kind == 1 then kind = 3 else kind = 2 end
-                kind = (kind == 1 and 3) or 2
+    if tab then
+        local srt, category, s = { }, 0, 0 -- 0=unknown 1=string, 2=number 3=mixed
+        for key,_ in next, tab do
+            s = s + 1
+            srt[s] = key
+            if category == 3 then
+                -- no further check
             else
-                kind = 3
+                local tkey = type(key)
+                if tkey == "string" then
+                    category = (category == 2 and 3) or 1
+                elseif tkey == "number" then
+                    category = (category == 1 and 3) or 2
+                else
+                    category = 3
+                end
             end
         end
-    end
-    if kind == 0 or kind == 3 then
-        sort(srt,compare)
+        if category == 0 or category == 3 then
+            sort(srt,compare)
+        else
+            sort(srt)
+        end
+        return srt
     else
-        sort(srt)
+        return { }
     end
-    return srt
 end
 
 local function sortedhashkeys(tab) -- fast one
-    local srt = { }
-    for key,_ in next, tab do
-        srt[#srt+1] = key
+    if tab then
+        local srt, s = { }, 0
+        for key,_ in next, tab do
+            if key then
+                s= s + 1
+                srt[s] = key
+            end
+        end
+        sort(srt)
+        return srt
+    else
+        return { }
     end
-    sort(srt)
-    return srt
 end
 
 table.sortedkeys     = sortedkeys
 table.sortedhashkeys = sortedhashkeys
 
-function table.sortedhash(t)
-    local s = sortedhashkeys(t) -- maybe just sortedkeys
-    local n = 0
-    local function kv(s)
-        n = n + 1
-        local k = s[n]
-        return k, t[k]
+local function nothing() end
+
+local function sortedhash(t)
+    if t then
+        local n, s = 0, sortedkeys(t) -- the robust one
+        local function kv(s)
+            n = n + 1
+            local k = s[n]
+            return k, t[k]
+        end
+        return kv, s
+    else
+        return nothing
     end
-    return kv, s
 end
 
-table.sortedpairs = table.sortedhash
+table.sortedhash  = sortedhash
+table.sortedpairs = sortedhash
 
-function table.append(t, list)
-    for _,v in next, list do
-        insert(t,v)
+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)
-    for k,v in next, list do
-        insert(t,k,v)
+    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, ...) -- first one is target
-    t = t or {}
-    local lst = {...}
+    t = t or { }
+    local lst = { ... }
     for i=1,#lst do
         for k, v in next, lst[i] do
             t[k] = v
@@ -163,7 +202,7 @@ function table.merge(t, ...) -- first one is target
 end
 
 function table.merged(...)
-    local tmp, lst = { }, {...}
+    local tmp, lst = { }, { ... }
     for i=1,#lst do
         for k, v in next, lst[i] do
             tmp[k] = v
@@ -173,41 +212,45 @@ function table.merged(...)
 end
 
 function table.imerge(t, ...)
-    local lst = {...}
+    local lst, nt = { ... }, #t
     for i=1,#lst do
         local nst = lst[i]
         for j=1,#nst do
-            t[#t+1] = nst[j]
+            nt = nt + 1
+            t[nt] = nst[j]
         end
     end
     return t
 end
 
 function table.imerged(...)
-    local tmp, lst = { }, {...}
+    local tmp, ntmp, lst = { }, 0, {...}
     for i=1,#lst do
         local nst = lst[i]
         for j=1,#nst do
-            tmp[#tmp+1] = nst[j]
+            ntmp = ntmp + 1
+            tmp[ntmp] = nst[j]
         end
     end
     return tmp
 end
 
-local function fastcopy(old) -- fast one
+local function fastcopy(old,metatabletoo) -- fast one
     if old then
         local new = { }
         for k,v in next, old do
             if type(v) == "table" then
-                new[k] = fastcopy(v) -- was just table.copy
+                new[k] = fastcopy(v,metatabletoo) -- was just table.copy
             else
                 new[k] = v
             end
         end
-        -- optional second arg
-        local mt = getmetatable(old)
-        if mt then
-            setmetatable(new,mt)
+        if metatabletoo then
+            -- optional second arg
+            local mt = getmetatable(old)
+            if mt then
+                setmetatable(new,mt)
+            end
         end
         return new
     else
@@ -215,6 +258,8 @@ local function fastcopy(old) -- fast one
     end
 end
 
+-- todo : copy without metatable
+
 local function copy(t, tables) -- taken from lua wiki, slightly adapted
     tables = tables or { }
     local tcopy = {}
@@ -247,33 +292,14 @@ end
 table.fastcopy = fastcopy
 table.copy     = copy
 
--- roughly: copy-loop : unpack : sub == 0.9 : 0.4 : 0.45 (so in critical apps, use unpack)
-
-function table.sub(t,i,j)
-    return { unpack(t,i,j) }
-end
-
-function table.replace(a,b)
-    for k,v in next, b do
-        a[k] = v
+function table.derive(parent)
+    local child = { }
+    if parent then
+        setmetatable(child,{ __index = parent })
     end
+    return child
 end
 
--- slower than #t on indexed tables (#t only returns the size of the numerically indexed slice)
-
-function table.is_empty(t) -- obolete, use inline code instead
-    return not t or not next(t)
-end
-
-function table.one_entry(t) -- obolete, use inline code instead
-    local n = next(t)
-    return n and not next(t,n)
-end
-
---~ function table.starts_at(t) -- obsolete, not nice anyway
---~     return ipairs(t,1)(t,0)
---~ end
-
 function table.tohash(t,value)
     local h = { }
     if t then
@@ -286,27 +312,19 @@ function table.tohash(t,value)
 end
 
 function table.fromhash(t)
-    local h = { }
+    local hsh, h = { }, 0
     for k, v in next, t do -- no ipairs here
-        if v then h[#h+1] = k end
+        if v then
+            h = h + 1
+            hsh[h] = k
+        end
     end
-    return h
+    return hsh
 end
 
---~ print(table.serialize(t), "\n")
---~ print(table.serialize(t,"name"), "\n")
---~ print(table.serialize(t,false), "\n")
---~ print(table.serialize(t,true), "\n")
---~ print(table.serialize(t,"name",true), "\n")
---~ print(table.serialize(t,"name",true,true), "\n")
-
-table.serialize_functions = true
-table.serialize_compact   = true
-table.serialize_inline    = true
-
 local noquotes, hexify, handle, reduce, compact, inline, functions
 
-local reserved = table.tohash { -- intercept a language flaw, no reserved words as key
+local reserved = table.tohash { -- intercept a language inconvenience: no reserved words as key
     'and', 'break', 'do', 'else', 'elseif', 'end', 'false', 'for', 'function', 'if',
     'in', 'local', 'nil', 'not', 'or', 'repeat', 'return', 'then', 'true', 'until', 'while',
 }
@@ -318,20 +336,23 @@ local function simple_table(t)
             n = n + 1
         end
         if n == #t then
-            local tt = { }
+            local tt, nt = { }, 0
             for i=1,#t do
                 local v = t[i]
                 local tv = type(v)
                 if tv == "number" then
+                    nt = nt + 1
                     if hexify then
-                        tt[#tt+1] = format("0x%04X",v)
+                        tt[nt] = format("0x%04X",v)
                     else
-                        tt[#tt+1] = tostring(v) -- tostring not needed
+                        tt[nt] = tostring(v) -- tostring not needed
                     end
                 elseif tv == "boolean" then
-                    tt[#tt+1] = tostring(v)
+                    nt = nt + 1
+                    tt[nt] = tostring(v)
                 elseif tv == "string" then
-                    tt[#tt+1] = format("%q",v)
+                    nt = nt + 1
+                    tt[nt] = format("%q",v)
                 else
                     tt = nil
                     break
@@ -352,36 +373,56 @@ end
 
 -- problem: there no good number_to_string converter with the best resolution
 
+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))
-        elseif name then
-        --~ handle(format("%s%s={",depth,key(name)))
-            if type(name) == "number" then -- or find(k,"^%d+$") then
+        else
+            local tn = type(name)
+            if tn == "number" then -- or find(k,"^%d+$") then
                 if hexify then
                     handle(format("%s[0x%04X]={",depth,name))
                 else
                     handle(format("%s[%s]={",depth,name))
                 end
-            elseif noquotes and not reserved[name] and find(name,"^%a[%w%_]*$") then
-                handle(format("%s%s={",depth,name))
+            elseif tn == "string" then
+                if noquotes and not reserved[name] and find(name,"^%a[%w%_]*$") then
+                    handle(format("%s%s={",depth,name))
+                else
+                    handle(format("%s[%q]={",depth,name))
+                end
+            elseif tn == "boolean" then
+                handle(format("%s[%s]={",depth,tostring(name)))
             else
-                handle(format("%s[%q]={",depth,name))
+                handle(format("%s{",depth))
             end
-        else
-            handle(format("%s{",depth))
         end
     end
     -- we could check for k (index) being number (cardinal)
     if root and next(root) then
-        local first, last = nil, 0 -- #root cannot be trusted here (will be ok in 5.2 when ipairs is gone)
+     -- local first, last = nil, 0 -- #root cannot be trusted here (will be ok in 5.2 when ipairs is gone)
+     -- if compact then
+     --     -- NOT: for k=1,#root do (we need to quit at nil)
+     --     for k,v in ipairs(root) do -- can we use next?
+     --         if not first then first = k end
+     --         last = last + 1
+     --     end
+     -- end
+        local first, last = nil, 0
         if compact then
-            -- NOT: for k=1,#root do (we need to quit at nil)
-            for k,v in ipairs(root) do -- can we use next?
-                if not first then first = k end
-                last = last + 1
+            last = #root
+            for k=1,last do
+--                 if not root[k] then
+                if root[k] == nil then
+                    last = k - 1
+                    break
+                end
+            end
+            if last > 0 then
+                first = 1
             end
         end
         local sk = sortedkeys(root)
@@ -391,8 +432,8 @@ local function do_serialize(root,name,depth,level,indexed)
             --~ if v == root then
                 -- circular
             --~ else
-            local t = type(v)
-            if compact and first and type(k) == "number" and k >= first and k <= last then
+            local t, tk = type(v), type(k)
+            if compact and first and tk == "number" and k >= first and k <= last then
                 if t == "number" then
                     if hexify then
                         handle(format("%s 0x%04X,",depth,v))
@@ -434,17 +475,18 @@ local function do_serialize(root,name,depth,level,indexed)
                     handle(format("%s __p__=nil,",depth))
                 end
             elseif t == "number" then
-            --~ if hexify then
-            --~     handle(format("%s %s=0x%04X,",depth,key(k),v))
-            --~ else
-            --~     handle(format("%s %s=%s,",depth,key(k),v)) -- %.99g
-            --~ end
-                if type(k) == "number" then -- or find(k,"^%d+$") then
+                if tk == "number" then -- or find(k,"^%d+$") then
                     if hexify then
                         handle(format("%s [0x%04X]=0x%04X,",depth,k,v))
                     else
                         handle(format("%s [%s]=%s,",depth,k,v)) -- %.99g
                     end
+                elseif tk == "boolean" then
+                    if hexify then
+                        handle(format("%s [%s]=0x%04X,",depth,tostring(k),v))
+                    else
+                        handle(format("%s [%s]=%s,",depth,tostring(k),v)) -- %.99g
+                    end
                 elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                     if hexify then
                         handle(format("%s %s=0x%04X,",depth,k,v))
@@ -460,26 +502,28 @@ local function do_serialize(root,name,depth,level,indexed)
                 end
             elseif t == "string" then
                 if reduce and tonumber(v) then
-                --~ handle(format("%s %s=%s,",depth,key(k),v))
-                    if type(k) == "number" then -- or find(k,"^%d+$") then
+                    if tk == "number" then -- or find(k,"^%d+$") then
                         if hexify then
                             handle(format("%s [0x%04X]=%s,",depth,k,v))
                         else
                             handle(format("%s [%s]=%s,",depth,k,v))
                         end
+                    elseif tk == "boolean" then
+                        handle(format("%s [%s]=%s,",depth,tostring(k),v))
                     elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                         handle(format("%s %s=%s,",depth,k,v))
                     else
                         handle(format("%s [%q]=%s,",depth,k,v))
                     end
                 else
-                --~ handle(format("%s %s=%q,",depth,key(k),v))
-                    if type(k) == "number" then -- or find(k,"^%d+$") then
+                    if tk == "number" then -- or find(k,"^%d+$") then
                         if hexify then
                             handle(format("%s [0x%04X]=%q,",depth,k,v))
                         else
                             handle(format("%s [%s]=%q,",depth,k,v))
                         end
+                    elseif tk == "boolean" then
+                        handle(format("%s [%s]=%q,",depth,tostring(k),v))
                     elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                         handle(format("%s %s=%q,",depth,k,v))
                     else
@@ -488,13 +532,14 @@ local function do_serialize(root,name,depth,level,indexed)
                 end
             elseif t == "table" then
                 if not next(v) then
-                    --~ handle(format("%s %s={},",depth,key(k)))
-                    if type(k) == "number" then -- or find(k,"^%d+$") then
+                    if tk == "number" then -- or find(k,"^%d+$") then
                         if hexify then
                             handle(format("%s [0x%04X]={},",depth,k))
                         else
                             handle(format("%s [%s]={},",depth,k))
                         end
+                    elseif tk == "boolean" then
+                        handle(format("%s [%s]={},",depth,tostring(k)))
                     elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                         handle(format("%s %s={},",depth,k))
                     else
@@ -503,13 +548,14 @@ local function do_serialize(root,name,depth,level,indexed)
                 elseif inline then
                     local st = simple_table(v)
                     if st then
-                    --~ handle(format("%s %s={ %s },",depth,key(k),concat(st,", ")))
-                        if type(k) == "number" then -- or find(k,"^%d+$") then
+                        if tk == "number" then -- or find(k,"^%d+$") then
                             if hexify then
                                 handle(format("%s [0x%04X]={ %s },",depth,k,concat(st,", ")))
                             else
                                 handle(format("%s [%s]={ %s },",depth,k,concat(st,", ")))
                             end
+                        elseif tk == "boolean" then -- or find(k,"^%d+$") then
+                            handle(format("%s [%s]={ %s },",depth,tostring(k),concat(st,", ")))
                         elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                             handle(format("%s %s={ %s },",depth,k,concat(st,", ")))
                         else
@@ -522,13 +568,14 @@ local function do_serialize(root,name,depth,level,indexed)
                     do_serialize(v,k,depth,level+1)
                 end
             elseif t == "boolean" then
-            --~ handle(format("%s %s=%s,",depth,key(k),tostring(v)))
-                if type(k) == "number" then -- or find(k,"^%d+$") then
+                if tk == "number" then -- or find(k,"^%d+$") then
                     if hexify then
                         handle(format("%s [0x%04X]=%s,",depth,k,tostring(v)))
                     else
                         handle(format("%s [%s]=%s,",depth,k,tostring(v)))
                     end
+                elseif tk == "boolean" then -- or find(k,"^%d+$") then
+                    handle(format("%s [%s]=%s,",depth,tostring(k),tostring(v)))
                 elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                     handle(format("%s %s=%s,",depth,k,tostring(v)))
                 else
@@ -536,27 +583,31 @@ local function do_serialize(root,name,depth,level,indexed)
                 end
             elseif t == "function" then
                 if functions then
-                    --~ handle(format('%s %s=loadstring(%q),',depth,key(k),dump(v)))
-                    if type(k) == "number" then -- or find(k,"^%d+$") then
+                    local f = getinfo(v).what == "C" and dump(dummy) or dump(v)
+                 -- local f = getinfo(v).what == "C" and dump(function(...) return v(...) end) or dump(v)
+                    if tk == "number" then -- or find(k,"^%d+$") then
                         if hexify then
-                            handle(format("%s [0x%04X]=loadstring(%q),",depth,k,dump(v)))
+                            handle(format("%s [0x%04X]=loadstring(%q),",depth,k,f))
                         else
-                            handle(format("%s [%s]=loadstring(%q),",depth,k,dump(v)))
+                            handle(format("%s [%s]=loadstring(%q),",depth,k,f))
                         end
+                    elseif tk == "boolean" then
+                        handle(format("%s [%s]=loadstring(%q),",depth,tostring(k),f))
                     elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
-                        handle(format("%s %s=loadstring(%q),",depth,k,dump(v)))
+                        handle(format("%s %s=loadstring(%q),",depth,k,f))
                     else
-                        handle(format("%s [%q]=loadstring(%q),",depth,k,dump(v)))
+                        handle(format("%s [%q]=loadstring(%q),",depth,k,f))
                     end
                 end
             else
-                --~ handle(format("%s %s=%q,",depth,key(k),tostring(v)))
-                if type(k) == "number" then -- or find(k,"^%d+$") then
+                if tk == "number" then -- or find(k,"^%d+$") then
                     if hexify then
                         handle(format("%s [0x%04X]=%q,",depth,k,tostring(v)))
                     else
                         handle(format("%s [%s]=%q,",depth,k,tostring(v)))
                     end
+                elseif tk == "boolean" then -- or find(k,"^%d+$") then
+                    handle(format("%s [%s]=%q,",depth,tostring(k),tostring(v)))
                 elseif noquotes and not reserved[k] and find(k,"^%a[%w%_]*$") then
                     handle(format("%s %s=%q,",depth,k,tostring(v)))
                 else
@@ -574,15 +625,34 @@ end
 -- replacing handle by a direct t[#t+1] = ... (plus test) is not much
 -- faster (0.03 on 1.00 for zapfino.tma)
 
-local function serialize(root,name,_handle,_reduce,_noquotes,_hexify)
-    noquotes = _noquotes
-    hexify = _hexify
-    handle = _handle or print
-    reduce = _reduce or false
-    compact = table.serialize_compact
-    inline  = compact and table.serialize_inline
-    functions = table.serialize_functions
+local function serialize(_handle,root,name,specification) -- handle wins
     local tname = type(name)
+    if type(specification) == "table" then
+        noquotes  = specification.noquotes
+        hexify    = specification.hexify
+        handle    = _handle or specification.handle or print
+        reduce    = specification.reduce or false
+        functions = specification.functions
+        compact   = specification.compact
+        inline    = specification.inline and compact
+        if functions == nil then
+            functions = true
+        end
+        if compact == nil then
+            compact = true
+        end
+        if inline == nil then
+            inline = compact
+        end
+    else
+        noquotes  = false
+        hexify    = false
+        handle    = _handle or print
+        reduce    = false
+        compact   = true
+        inline    = true
+        functions = true
+    end
     if tname == "string" then
         if name == "return" then
             handle("return {")
@@ -604,8 +674,17 @@ local function serialize(root,name,_handle,_reduce,_noquotes,_hexify)
     else
         handle("t={")
     end
-    if root and next(root) then
-        do_serialize(root,name,"",0,indexed)
+    if root then
+        -- The dummy access will initialize a table that has a delayed initialization
+        -- using a metatable. (maybe explicitly test for metatable)
+        if getmetatable(root) then -- todo: make this an option, maybe even per subtable
+            local dummy = root._w_h_a_t_e_v_e_r_
+            root._w_h_a_t_e_v_e_r_ = nil
+        end
+        -- Let's forget about empty tables.
+        if next(root) then
+            do_serialize(root,name,"",0)
+        end
     end
     handle("}")
 end
@@ -619,18 +698,17 @@ end
 --~ 'return' : return     { }
 --~ number   : [number] = { }
 
-function table.serialize(root,name,reduce,noquotes,hexify)
-    local t = { }
+function table.serialize(root,name,specification)
+    local t, n = { }, 0
     local function flush(s)
-        t[#t+1] = s
+        n = n + 1
+        t[n] = s
     end
-    serialize(root,name,flush,reduce,noquotes,hexify)
+    serialize(flush,root,name,specification)
     return concat(t,"\n")
 end
 
-function table.tohandle(handle,root,name,reduce,noquotes,hexify)
-    serialize(root,name,handle,reduce,noquotes,hexify)
-end
+table.tohandle = serialize
 
 -- sometimes tables are real use (zapfino extra pro is some 85M) in which
 -- case a stepwise serialization is nice; actually, we could consider:
@@ -641,73 +719,63 @@ end
 --
 -- so this is on the todo list
 
-table.tofile_maxtab = 2*1024
+local maxtab = 2*1024
 
-function table.tofile(filename,root,name,reduce,noquotes,hexify)
+function table.tofile(filename,root,name,specification)
     local f = io.open(filename,'w')
     if f then
-        local maxtab = table.tofile_maxtab
         if maxtab > 1 then
-            local t = { }
+            local t, n = { }, 0
             local function flush(s)
-                t[#t+1] = s
-                if #t > maxtab then
+                n = n + 1
+                t[n] = s
+                if n > maxtab then
                     f:write(concat(t,"\n"),"\n") -- hm, write(sometable) should be nice
-                    t = { }
+                    t, n = { }, 0 -- we could recycle t if needed
                 end
             end
-            serialize(root,name,flush,reduce,noquotes,hexify)
+            serialize(flush,root,name,specification)
             f:write(concat(t,"\n"),"\n")
         else
             local function flush(s)
                 f:write(s,"\n")
             end
-            serialize(root,name,flush,reduce,noquotes,hexify)
+            serialize(flush,root,name,specification)
         end
         f:close()
+        io.flush()
     end
 end
 
-local function flatten(t,f,complete) -- is this used? meybe a variant with next, ...
-    for i=1,#t do
-        local v = t[i]
-        if type(v) == "table" then
-            if complete or type(v[1]) == "table" then
-                flatten(v,f,complete)
+local function flattened(t,f,depth)
+    if f == nil then
+        f = { }
+        depth = 0xFFFF
+    elseif tonumber(f) then
+        -- assume then only two arguments are given
+        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
+                f[k] = v
             end
-        else
-            f[#f+1] = v
         end
     end
-end
-
-function table.flatten(t)
-    local f = { }
-    flatten(t,f,true)
-    return f
-end
-
-function table.unnest(t) -- bad name
-    local f = { }
-    flatten(t,f,false)
-    return f
-end
-
-table.flatten_one_level = table.unnest
-
--- a better one:
-
-local function flattened(t,f)
-    if not f then
-        f = { }
-    end
-    for k, v in next, t do
-        if type(v) == "table" then
-            flattened(v,f)
+    local n = #f
+    for k=1,#t do
+        local v = t[k]
+        if depth > 0 and type(v) == "table" then
+            flattened(v,f,depth-1)
+            n = #f
         else
-            f[k] = v
+            n = n + 1
+            f[n] = v
         end
     end
     return f
@@ -715,49 +783,27 @@ end
 
 table.flattened = flattened
 
--- the next three may disappear
-
-function table.remove_value(t,value) -- todo: n
-    if value then
-        for i=1,#t do
-            if t[i] == value then
-                remove(t,i)
-                -- remove all, so no: return
-            end
-        end
+local function unnest(t,f) -- only used in mk, for old times sake
+    if not f then          -- and only relevant for token lists
+        f = { }
     end
-end
-
-function table.insert_before_value(t,value,str)
-    if str then
-        if value then
-            for i=1,#t do
-                if t[i] == value then
-                    insert(t,i,str)
-                    return
-                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
-        insert(t,1,str)
-    elseif value then
-        insert(t,1,value)
     end
+    return f
 end
 
-function table.insert_after_value(t,value,str)
-    if str then
-        if value then
-            for i=1,#t do
-                if t[i] == value then
-                    insert(t,i+1,str)
-                    return
-                end
-            end
-        end
-        t[#t+1] = str
-    elseif value then
-        t[#t+1] = value
-    end
+function table.unnest(t) -- bad name
+    return unnest(t)
 end
 
 local function are_equal(a,b,n,m) -- indexed
@@ -784,7 +830,7 @@ end
 
 local function identical(a,b) -- assumes same structure
     for ka, va in next, a do
-        local vb = b[k]
+        local vb = b[ka]
         if va == vb then
             -- same
         elseif type(va) == "table" and  type(vb) == "table" then
@@ -798,8 +844,8 @@ local function identical(a,b) -- assumes same structure
     return true
 end
 
-table.are_equal = are_equal
 table.identical = identical
+table.are_equal = are_equal
 
 -- maybe also make a combined one
 
@@ -825,86 +871,126 @@ function table.contains(t, v)
 end
 
 function table.count(t)
-    local n, e = 0, next(t)
-    while e do
-        n, e = n + 1, next(t,e)
+    local n = 0
+    for k, v in next, t do
+        n = n + 1
     end
     return n
 end
 
-function table.swapped(t)
-    local s = { }
+function table.swapped(t,s) -- hash
+    local n = { }
+    if s then
+--~         for i=1,#s do
+--~             n[i] = s[i]
+--~         end
+        for k, v in next, s do
+            n[k] = v
+        end
+    end
+--~     for i=1,#t do
+--~         local ti = t[i] -- don't ask but t[i] can be nil
+--~         if ti then
+--~             n[ti] = i
+--~         end
+--~     end
     for k, v in next, t do
-        s[v] = k
+        n[v] = k
     end
-    return s
+    return n
 end
 
---~ function table.are_equal(a,b)
---~     return table.serialize(a) == table.serialize(b)
---~ end
-
-function table.clone(t,p) -- t is optional or nil or table
-    if not p then
-        t, p = { }, t or { }
-    elseif not t then
-        t = { }
+function table.reversed(t)
+    if t then
+        local tt, 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
-    setmetatable(t, { __index = function(_,key) return p[key] end }) -- why not __index = p ?
-    return t
 end
 
-function table.hexed(t,seperator)
-    local tt = { }
-    for i=1,#t do tt[i] = format("0x%04X",t[i]) end
-    return concat(tt,seperator or " ")
+function table.sequenced(t,sep) -- hash only
+    if t then
+        local s, 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
+                    s[n] = k .. "=" .. tostring(v)
+                end
+            else
+                n = n + 1
+                s[n] = k .. "=" .. tostring(v)
+            end
+        end
+        return concat(s, sep or " | ")
+    else
+        return ""
+    end
 end
 
-function table.reverse_hash(h)
-    local r = { }
-    for k,v in next, h do
-        r[v] = lower(gsub(k," ",""))
+function table.print(t,...)
+    if type(t) ~= "table" then
+        print(tostring(t))
+    else
+        table.tohandle(print,t,...)
     end
-    return r
 end
 
-function table.reverse(t)
-    local tt = { }
-    if #t > 0 then
-        for i=#t,1,-1 do
-            tt[#tt+1] = t[i]
-        end
-    end
-    return tt
+-- -- -- obsolete but we keep them for a while and might comment them later -- -- --
+
+-- roughly: copy-loop : unpack : sub == 0.9 : 0.4 : 0.45 (so in critical apps, use unpack)
+
+function table.sub(t,i,j)
+    return { unpack(t,i,j) }
 end
 
-function table.insert_before_value(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)
+-- slower than #t on indexed tables (#t only returns the size of the numerically indexed slice)
+
+function table.is_empty(t)
+    return not t or not next(t)
 end
 
-function table.insert_after_value(t,value,extra)
-    for i=1,#t do
-        if t[i] == extra then
-            remove(t,i)
-        end
+function table.has_one_entry(t)
+    return t and not next(t,next(t))
+end
+
+-- new
+
+function table.loweredkeys(t) -- maybe utf
+    local l = { }
+    for k, v in next, t do
+        l[lower(k)] = v
     end
-    for i=1,#t do
-        if t[i] == value then
-            insert(t,i+1,extra)
-            return
+    return l
+end
+
+-- new, might move (maybe duplicate)
+
+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
-    insert(t,#t+1,extra)
+    return new
 end
 
+-- function table.sorted(t,...)
+--     table.sort(t,...)
+--     return t -- still sorts in-place
+-- end
diff --git a/lualibs-url.lua b/lualibs-url.lua
index 83b8fcc..ab50028 100644
--- a/lualibs-url.lua
+++ b/lualibs-url.lua
@@ -339,3 +339,5 @@ end
 
 --~ test("zip:///oeps/oeps.zip#bla/bla.tex")
 --~ test("zip:///oeps/oeps.zip?bla/bla.tex")
+
+--~ table.print(url.hashed("/test?test"))