update util-tab

1 files changed, 227 insertions, 200 deletions

diff --git a/lualibs-util-tab.lua b/lualibs-util-tab.lua
index 7950a03..7a2da29 100644
--- a/lualibs-util-tab.lua
+++ b/lualibs-util-tab.lua
@@ -1,4 +1,4 @@
-if not modules then modules = { } end modules ['l-aux'] = {
+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",
@@ -6,252 +6,279 @@ if not modules then modules = { } end modules ['l-aux'] = {
     license   = "see context related readme files"
 }
 
--- for inline, no store split : for s in string.gmatch(str,",* *([^,]+)") do .. end
+utilities        = utilities or {}
+utilities.tables = utilities.tables or { }
+local tables     = utilities.tables
 
-aux = aux or { }
+local format, gmatch, rep, gsub = string.format, string.gmatch, string.rep, string.gsub
+local concat, insert, remove = table.concat, table.insert, table.remove
+local setmetatable, getmetatable, tonumber, tostring = setmetatable, getmetatable, tonumber, tostring
+local type, next, rawset, tonumber, loadstring = type, next, rawset, tonumber, loadstring
+local lpegmatch, P, Cs = lpeg.match, lpeg.P, lpeg.Cs
 
-local concat, format, gmatch = table.concat, string.format, string.gmatch
-local tostring, type = tostring, type
-local lpegmatch = lpeg.match
-
-local P, R, V = lpeg.P, lpeg.R, lpeg.V
-
-local escape, left, right = P("\\"), P('{'), P('}')
-
-lpeg.patterns.balanced = P {
-    [1] = ((escape * (left+right)) + (1 - (left+right)) + V(2))^0,
-    [2] = left * V(1) * right
-}
-
-local space     = lpeg.P(' ')
-local equal     = lpeg.P("=")
-local comma     = lpeg.P(",")
-local lbrace    = lpeg.P("{")
-local rbrace    = lpeg.P("}")
-local nobrace   = 1 - (lbrace+rbrace)
-local nested    = lpeg.P { lbrace * (nobrace + lpeg.V(1))^0 * rbrace }
-local spaces    = space^0
-
-local value     = lpeg.P(lbrace * lpeg.C((nobrace + nested)^0) * rbrace) + lpeg.C((nested + (1-comma))^0)
-
-local key       = lpeg.C((1-equal-comma)^1)
-local pattern_a = (space+comma)^0 * (key * equal * value + key * lpeg.C(""))
-local pattern_c = (space+comma)^0 * (key * equal * value)
-
-local key       = lpeg.C((1-space-equal-comma)^1)
-local pattern_b = spaces * comma^0 * spaces * (key * ((spaces * equal * spaces * value) + lpeg.C("")))
-
--- "a=1, b=2, c=3, d={a{b,c}d}, e=12345, f=xx{a{b,c}d}xx, g={}" : outer {} removes, leading spaces ignored
-
-local hash = { }
-
-local function set(key,value) -- using Carg is slower here
-    hash[key] = value
+function tables.definetable(target) -- defines undefined tables
+    local composed, t, n = nil, { }, 0
+    for name in gmatch(target,"([^%.]+)") do
+        n = n + 1
+        if composed then
+            composed = composed .. "." .. name
+        else
+            composed = name
+        end
+        t[n] = format("%s = %s or { }",composed,composed)
+    end
+    return concat(t,"\n")
 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
-
-aux.settings_to_hash_pattern_a = pattern_a_s
-aux.settings_to_hash_pattern_b = pattern_b_s
-aux.settings_to_hash_pattern_c = pattern_c_s
-
-function aux.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
+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 aux.settings_to_hash(str,existing)
-    if str and str ~= "" then
-        hash = existing or { }
-        if moretolerant then
-            lpegmatch(pattern_b_s,str)
-        else
-            lpegmatch(pattern_a_s,str)
+function tables.migratetable(target,v,root)
+    local t = root or _G
+    local names = string.split(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
-        return hash
-    else
-        return { }
     end
+    t[names[#names]] = v
 end
 
-function aux.settings_to_hash_tolerant(str,existing)
-    if str and str ~= "" then
-        hash = existing or { }
-        lpegmatch(pattern_b_s,str)
-        return hash
-    else
-        return { }
+function tables.removevalue(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
     end
 end
 
-function aux.settings_to_hash_strict(str,existing)
-    if str and str ~= "" then
-        hash = existing or { }
-        lpegmatch(pattern_c_s,str)
-        return next(hash) and hash
-    else
-        return nil
+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
 
-local separator = comma * space^0
-local value     = lpeg.P(lbrace * lpeg.C((nobrace + nested)^0) * rbrace) + lpeg.C((nested + (1-comma))^0)
-local pattern   = lpeg.Ct(value*(separator*value)^0)
-
--- "aap, {noot}, mies" : outer {} removes, leading spaces ignored
-
-aux.settings_to_array_pattern = pattern
-
--- we could use a weak table as cache
+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
 
-function aux.settings_to_array(str)
-    if not str or str == "" then
-        return { }
-    else
-        return lpegmatch(pattern,str)
+-- experimental
+
+local function toxml(t,d,result,step)
+    for k, v in table.sortedpairs(t) do
+        if type(v) == "table" then
+            if type(k) == "number" then
+                result[#result+1] = format("%s<entry n='%s'>",d,k)
+                toxml(v,d..step,result,step)
+                result[#result+1] = format("%s</entry>",d,k)
+            else
+                result[#result+1] = format("%s<%s>",d,k)
+                toxml(v,d..step,result,step)
+                result[#result+1] = format("%s</%s>",d,k)
+            end
+        elseif type(k) == "number" then
+            result[#result+1] = format("%s<entry n='%s'>%s</entry>",d,k,v,k)
+        else
+            result[#result+1] = format("%s<%s>%s</%s>",d,k,tostring(v),k)
+        end
     end
 end
 
-local function set(t,v)
-    t[#t+1] = v
+function table.toxml(t,name,nobanner,indent,spaces)
+    local noroot = name == false
+    local result = (nobanner or noroot) and { } or { "<?xml version='1.0' standalone='yes' ?>" }
+    local indent = rep(" ",indent or 0)
+    local spaces = rep(" ",spaces or 1)
+    if noroot then
+        toxml( t, inndent, result, spaces)
+    else
+        toxml( { [name or "root"] = t }, indent, result, spaces)
+    end
+    return concat(result,"\n")
 end
 
-local value   = lpeg.P(lpeg.Carg(1)*value) / set
-local pattern = value*(separator*value)^0 * lpeg.Carg(1)
+-- also experimental
 
-function aux.add_settings_to_array(t,str)
-    return lpegmatch(pattern,str,nil,t)
-end
+-- encapsulate(table,utilities.tables)
+-- encapsulate(table,utilities.tables,true)
+-- encapsulate(table,true)
 
-function aux.hash_to_string(h,separator,yes,no,strict,omit)
-    if h then
-        local t, s = { }, table.sortedkeys(h)
-        omit = omit and table.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
-                            t[#t+1] = key .. '=' .. yes
-                        elseif not strict then
-                            t[#t+1] = key .. '=' .. no
-                        end
-                    elseif value or not strict then
-                        t[#t+1] = key .. '=' .. tostring(value)
-                    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(format("\ninvalid inheritance '%s' in '%s': %s",key,tostring(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(format("\ninvalid overload '%s' in '%s'",key,tostring(core)))
+                    os.exit()
                 else
-                    t[#t+1] = key .. '=' .. value
+                    rawset(t,key,value)
                 end
             end
-        end
-        return concat(t,separator or ",")
-    else
-        return ""
+        } )
     end
 end
 
-function aux.array_to_string(a,separator)
-    if a then
-        return concat(a,separator or ",")
+local function serialize(t,r,outer) -- no mixes
+    r[#r+1] = "{"
+    local n = #t
+    if n > 0 then
+        for i=1,n do
+            local v = t[i]
+            local tv = type(v)
+            if tv == "string" then
+                r[#r+1] = format("%q,",v)
+            elseif tv == "number" then
+                r[#r+1] = format("%s,",v)
+            elseif tv == "table" then
+                serialize(v,r)
+            elseif tv == "boolean" then
+                r[#r+1] = format("%s,",tostring(v))
+            end
+        end
     else
-        return ""
+        for k, v in next, t do
+            local tv = type(v)
+            if tv == "string" then
+                r[#r+1] = format("[%q]=%q,",k,v)
+            elseif tv == "number" then
+                r[#r+1] = format("[%q]=%s,",k,v)
+            elseif tv == "table" then
+                r[#r+1] = format("[%q]=",k)
+                serialize(v,r)
+            elseif tv == "boolean" then
+                r[#r+1] = format("[%q]=%s,",k,tostring(v))
+            end
+        end
     end
-end
-
-function aux.settings_to_set(str,t)
-    t = t or { }
-    for s in gmatch(str,"%s*([^,]+)") do
-        t[s] = true
+    if outer then
+        r[#r+1] = "}"
+    else
+        r[#r+1] = "},"
     end
-    return t
+    return r
 end
 
-local value     = lbrace * lpeg.C((nobrace + nested)^0) * rbrace
-local pattern   = lpeg.Ct((space + value)^0)
-
-function aux.arguments_to_table(str)
-    return lpegmatch(pattern,str)
+function table.fastserialize(t,prefix)
+    return concat(serialize(t,{ prefix or "return" },true))
 end
 
--- temporary here
-
-function aux.getparameters(self,class,parentclass,settings)
-    local sc = self[class]
-    if not sc then
-        sc = table.clone(self[parent])
-        self[class] = sc
+function table.deserialize(str)
+    if not str or str == "" then
+        return
+    end
+    local code = loadstring(str)
+    if not code then
+        return
     end
-    aux.settings_to_hash(settings,sc)
+    code = code()
+    if not code then
+        return
+    end
+    return code
 end
 
--- temporary here
-
-local digit         = lpeg.R("09")
-local period        = lpeg.P(".")
-local zero          = lpeg.P("0")
-local trailingzeros = zero^0 * -digit -- suggested by Roberto R
-local case_1        = period * trailingzeros / ""
-local case_2        = period * (digit - trailingzeros)^1 * (trailingzeros / "")
-local number        = digit^1 * (case_1 + case_2)
-local stripper      = lpeg.Cs((number + 1)^0)
-
---~ local sample = "bla 11.00 bla 11 bla 0.1100 bla 1.00100 bla 0.00 bla 0.001 bla 1.1100 bla 0.100100100 bla 0.00100100100"
---~ collectgarbage("collect")
---~ str = string.rep(sample,10000)
---~ local ts = os.clock()
---~ lpegmatch(stripper,str)
---~ print(#str, os.clock()-ts, lpegmatch(stripper,sample))
-
-lpeg.patterns.strip_zeros = stripper
-
-function aux.strip_zeros(str)
-    return lpegmatch(stripper,str)
+-- inspect(table.fastserialize { a = 1, b = { 4, { 5, 6 } }, c = { d = 7, e = 'f"g\nh' } })
+
+function table.load(filename)
+    if filename then
+        local t = io.loaddata(filename)
+        if t and t ~= "" then
+            t = loadstring(t)
+            if type(t) == "function" then
+                t = t()
+                if type(t) == "table" then
+                    return t
+                end
+            end
+        end
+    end
 end
 
-function aux.definetable(target) -- defines undefined tables
-    local composed, t = nil, { }
-    for name in gmatch(target,"([^%.]+)") do
-        if composed then
-            composed = composed .. "." .. name
-        else
-            composed = name
+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] = format("%s=%q",k,v)
         end
-        t[#t+1] = format("%s = %s or { }",composed,composed)
+        r[i] = format(" {%s},\n",concat(l))
     end
-    return concat(t,"\n")
+    return format("return {\n%s}",concat(r))
 end
 
-function aux.accesstable(target)
-    local t = _G
-    for name in gmatch(target,"([^%.]+)") do
-        t = t[name]
+local function fastdrop(t)
+    local r = { "return {\n" }
+    for i=1,#t do
+        local ti = t[i]
+        r[#r+1] = " {"
+        for k, v in next, ti do
+            r[#r+1] = format("%s=%q",k,v)
+        end
+        r[#r+1] = "},\n"
     end
-    return t
+    r[#r+1] = "}"
+    return concat(r)
 end
 
--- as we use this a lot ...
-
---~ function aux.cachefunction(action,weak)
---~     local cache = { }
---~     if weak then
---~         setmetatable(cache, { __mode = "kv" } )
---~     end
---~     local function reminder(str)
---~         local found = cache[str]
---~         if not found then
---~             found = action(str)
---~             cache[str] = found
---~         end
---~         return found
---~     end
---~     return reminder, cache
---~ end
+function table.drop(t,slow)
+    if #t == 0 then
+        return "return { }"
+    elseif slow == true then
+        return slowdrop(t) -- less memory
+    else
+        return fastdrop(t) -- some 15% faster
+    end
+end