NEWS updatev1.08

4 files changed, 519 insertions, 3 deletions

diff --git a/NEWS b/NEWS
index fcfb1e2..9c09af3 100644
--- a/NEWS
+++ b/NEWS
@@ -1,8 +1,19 @@
 Change History
 --------------
 
-Currrent git, luaotfload v1.08:
-    * XXX
+2010/05/28, luaotfload v1.08:
+    * fix misc. bugs with system fonts scanning
+    * parse fontconfig configuration directly, no longer dependant on 'fc-list'
+    * now if no font names database is found, luaotfload will generate it, also
+      it will force an update of the database if the asked font can not be
+      found
+    * avoid loading non-tfm fonts when the user asks for tfm font
+    * update the documentation
+    * blacklist .ttc and LastResort font on mac.
+    * sync with ConTeXt beta 2010.05.22
+    * fix attribute handling
+    * clarify license
+    * misc. bug fixes
 
 2010/05/10, luaotfload v1.07:
     * using the new luatexbase package
diff --git a/luaotfload.dtx b/luaotfload.dtx
index 28c1aeb..8de140e 100644
--- a/luaotfload.dtx
+++ b/luaotfload.dtx
@@ -547,6 +547,7 @@ luaotfload.loadmodule('font-oti.lua')
 luaotfload.loadmodule('font-otb.lua')
 luaotfload.loadmodule('font-otn.lua')
 luaotfload.loadmodule('font-ota.lua')
+luaotfload.loadmodule('font-otp.lua')
 luaotfload.loadmodule('font-otc.lua')
 luaotfload.loadmodule('font-def.lua')
 luaotfload.loadmodule('font-xtx.lua')
diff --git a/otfl-font-dum.lua b/otfl-font-dum.lua
index 2de1ae1..dbdf5d7 100644
--- a/otfl-font-dum.lua
+++ b/otfl-font-dum.lua
@@ -10,7 +10,7 @@ fonts = fonts or { }
 
 -- general
 
-fonts.otf.pack          = false
+fonts.otf.pack          = true
 fonts.tfm.resolve_vf    = false -- no sure about this
 fonts.tfm.fontname_mode = "specification" -- somehow latex needs this
 
diff --git a/otfl-font-otp.lua b/otfl-font-otp.lua
new file mode 100644
index 0000000..a80c515
--- /dev/null
+++ b/otfl-font-otp.lua
@@ -0,0 +1,504 @@
+if not modules then modules = { } end modules ['font-otp'] = {
+    version   = 1.001,
+    comment   = "companion to font-otf.lua (packing)",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- todo: pack math (but not that much to share)
+
+local next, type, tostring = next, type, tostring
+local sort, concat = table.sort, table.concat
+
+local trace_loading = false  trackers.register("otf.loading", function(v) trace_loading = v end)
+
+fonts               = fonts               or { }
+fonts.otf           = fonts.otf           or { }
+fonts.otf.enhancers = fonts.otf.enhancers or { }
+fonts.otf.glists    = fonts.otf.glists    or { "gsub", "gpos" }
+
+local criterium, threshold, tabstr = 1, 0, table.serialize
+
+local function tabstr(t) -- hashed from core-uti / experiment
+    local s = { }
+    for k, v in next, t do
+        if type(v) == "table" then
+            s[#s+1] = k.."={"..tabstr(v).."}"
+        else
+            s[#s+1] = k.."="..tostring(v)
+        end
+    end
+    sort(s)
+    return concat(s,",")
+end
+
+function fonts.otf.enhancers.pack(data)
+    if data then
+        local h, t, c = { }, { }, { }
+        local hh, tt, cc = { }, { }, { }
+        local function pack_1(v)
+            -- v == table
+            local tag = tabstr(v)
+            local ht = h[tag]
+            if not ht then
+                ht = #t+1
+                t[ht] = v
+                h[tag] = ht
+                c[ht] = 1
+            else
+                c[ht] = c[ht] + 1
+            end
+            return ht
+        end
+        local function pack_2(v)
+            -- v == number
+            if c[v] <= criterium then
+                return t[v]
+            else
+                -- compact hash
+                local hv = hh[v]
+                if not hv then
+                    hv = #tt+1
+                    tt[hv] = t[v]
+                    hh[v] = hv
+                    cc[hv] = c[v]
+                end
+                return hv
+            end
+        end
+        local function success(stage,pass)
+            if #t == 0 then
+                if trace_loading then
+                    logs.report("load otf","pack quality: nothing to pack")
+                end
+                return false
+            elseif #t >= threshold then
+                local one, two, rest = 0, 0, 0
+                if pass == 1 then
+                    for k,v in next, c do
+                        if v == 1 then
+                            one = one + 1
+                        elseif v == 2 then
+                            two = two + 1
+                        else
+                            rest = rest + 1
+                        end
+                    end
+                else
+                    for k,v in next, cc do
+                        if v >20 then
+                            rest = rest + 1
+                        elseif v >10 then
+                            two = two + 1
+                        else
+                            one = one + 1
+                        end
+                    end
+                    data.tables = tt
+                end
+                if trace_loading then
+                    logs.report("load otf","pack quality: stage %s, pass %s, %s packed, 1-10:%s, 11-20:%s, rest:%s (criterium: %s)", stage, pass, one+two+rest, one, two, rest, criterium)
+                end
+                return true
+            else
+                if trace_loading then
+                    logs.report("load otf","pack quality: stage %s, pass %s, %s packed, aborting pack (threshold: %s)", stage, pass, #t, threshold)
+                end
+                return false
+            end
+        end
+        for pass=1,2 do
+            local pack = (pass == 1 and pack_1) or pack_2
+            for k, v in next, data.glyphs do
+                v.boundingbox = pack(v.boundingbox)
+                local l = v.slookups
+                if l then
+                    for k,v in next, l do
+                        l[k] = pack(v)
+                    end
+                end
+                local l = v.mlookups
+                if l then
+                    for k,v in next, l do
+                        for kk=1,#v do
+                            local vkk = v[kk]
+                            local what = vkk[1]
+                            if what == "pair" then
+                                local t = vkk[3] if t then vkk[3] = pack(t) end
+                                local t = vkk[4] if t then vkk[4] = pack(t) end
+                            elseif what == "position" then
+                                local t = vkk[2] if t then vkk[2] = pack(t) end
+                            end
+                        --  v[kk] = pack(vkk)
+                        end
+                    end
+                end
+                local m = v.mykerns
+                if m then
+                    for k,v in next, m do
+                        m[k] = pack(v)
+                    end
+                end
+                local m = v.math
+                if m then
+                    local mk = m.kerns
+                    if mk then
+                        for k,v in next, mk do
+                            mk[k] = pack(v)
+                        end
+                    end
+                end
+                local a = v.anchors
+                if a then
+                    for k,v in next, a do
+                        if k == "baselig" then
+                            for kk, vv in next, v do
+                                for kkk=1,#vv do
+                                    vv[kkk] = pack(vv[kkk])
+                                end
+                            end
+                        else
+                            for kk, vv in next, v do
+                                v[kk] = pack(vv)
+                            end
+                        end
+                    end
+                end
+            end
+            if data.lookups then
+                for k, v in next, data.lookups do
+                    if v.rules then
+                        for kk, vv in next, v.rules do
+                            local l = vv.lookups
+                            if l then
+                                vv.lookups = pack(l)
+                            end
+                            local c = vv.coverage
+                            if c then
+                                local cc = c.before  if cc then c.before  = pack(cc) end
+                                local cc = c.after   if cc then c.after   = pack(cc) end
+                                local cc = c.current if cc then c.current = pack(cc) end
+                            end
+                            local c = vv.reversecoverage
+                            if c then
+                                local cc = c.before  if cc then c.before  = pack(cc) end
+                                local cc = c.after   if cc then c.after   = pack(cc) end
+                                local cc = c.current if cc then c.current = pack(cc) end
+                            end
+                            -- no need to pack vv.glyphs
+                            local c = vv.glyphs
+                            if c then
+                                if c.fore == "" then c.fore = nil end
+                                if c.back == "" then c.back = nil end
+                            end
+                        end
+                    end
+                end
+            end
+            if data.luatex then
+                local la = data.luatex.anchor_to_lookup
+                if la then
+                    for lookup, ldata in next, la do
+                        la[lookup] = pack(ldata)
+                    end
+                end
+                local la = data.luatex.lookup_to_anchor
+                if la then
+                    for lookup, ldata in next, la do
+                        la[lookup] = pack(ldata)
+                    end
+                end
+                local ls = data.luatex.sequences
+                if ls then
+                    for feature, fdata in next, ls do
+                        local flags = fdata.flags
+                        if flags then
+                            fdata.flags = pack(flags)
+                        end
+                        local subtables = fdata.subtables
+                        if subtables then
+                            fdata.subtables = pack(subtables)
+                        end
+                        local features = fdata.features
+                        if features then
+                            for script, sdata in next, features do
+                                features[script] = pack(sdata)
+                            end
+                        end
+                    end
+                end
+                local ls = data.luatex.lookups
+                if ls then
+                    for lookup, fdata in next, ls do
+                        local flags = fdata.flags
+                        if flags then
+                            fdata.flags = pack(flags)
+                        end
+                        local subtables = fdata.subtables
+                        if subtables then
+                            fdata.subtables = pack(subtables)
+                        end
+                    end
+                end
+                local lf = data.luatex.features
+                if lf then
+                    for _, g in next, fonts.otf.glists do
+                        local gl = lf[g]
+                        if gl then
+                            for feature, spec in next, gl do
+                                gl[feature] = pack(spec)
+                            end
+                        end
+                    end
+                end
+            end
+            if not success(1,pass) then
+                return
+            end
+        end
+        if #t > 0 then
+            for pass=1,2 do
+                local pack = (pass == 1 and pack_1) or pack_2
+                for k, v in next, data.glyphs do
+                    local m = v.mykerns
+                    if m then
+                        v.mykerns = pack(m)
+                    end
+                    local m = v.math
+                    if m then
+                        local mk = m.kerns
+                        if mk then
+                            m.kerns = pack(mk)
+                        end
+                    end
+                    local a = v.anchors
+                    if a then
+                        v.anchors = pack(a)
+                    end
+                    local l = v.mlookups
+                    if l then
+                        for k,v in next, l do
+                            for kk=1,#v do
+                                v[kk] = pack(v[kk])
+                            end
+                        end
+                    end
+                end
+                local ls = data.luatex.sequences
+                if ls then
+                    for feature, fdata in next, ls do
+                        fdata.features = pack(fdata.features)
+                    end
+                end
+                if not success(2,pass) then
+--~                     return
+                end
+            end
+        end
+    end
+end
+
+function fonts.otf.enhancers.unpack(data)
+    if data then
+        local t = data.tables
+        if t then
+            local unpacked = { }
+            for k, v in next, data.glyphs do
+                local tv = t[v.boundingbox] if tv then v.boundingbox = tv end
+                local l = v.slookups
+                if l then
+                    for k,v in next, l do
+                        local tv = t[v] if tv then l[k] = tv end
+                    end
+                end
+                local l = v.mlookups
+                if l then
+                    for k,v in next, l do
+                        for i=1,#v do
+                            local vi = v[i]
+                            local tv = t[vi]
+                            if tv then
+                                v[i] = tv
+                                if unpacked[tv] then
+                                    vi = false
+                                else
+                                    unpacked[tv], vi = true, tv
+                                end
+                            end
+                            if vi then
+                                local what = vi[1]
+                                if what == "pair" then
+                                    local tv = t[vi[3]] if tv then vi[3] = tv end
+                                    local tv = t[vi[4]] if tv then vi[4] = tv end
+                                elseif what == "position" then
+                                    local tv = t[vi[2]] if tv then vi[2] = tv end
+                                end
+                            end
+                        end
+                    end
+                end
+                local m = v.mykerns
+                if m then
+                    local tm = t[m]
+                    if tm then
+                        v.mykerns = tm
+                        if unpacked[tm] then
+                            m = false
+                        else
+                            unpacked[tm], m = true, tm
+                        end
+                    end
+                    if m then
+                        for k,v in next, m do
+                            local tv = t[v] if tv then m[k] = tv end
+                        end
+                    end
+                end
+                local m = v.math
+                if m then
+                    local mk = m.kerns
+                    if mk then
+                        local tm = t[mk]
+                        if tm then
+                            m.kerns = tm
+                            if unpacked[tm] then
+                                mk = false
+                            else
+                                unpacked[tm], mk = true, tm
+                            end
+                        end
+                        if mk then
+                            for k,v in next, mk do
+                                local tv = t[v] if tv then mk[k] = tv end
+                            end
+                        end
+                    end
+                end
+                local a = v.anchors
+                if a then
+                    local ta = t[a]
+                    if ta then
+                        v.anchors = ta
+                        if not unpacked[ta] then
+                            unpacked[ta], a = true, ta
+                        else
+                            a = false
+                        end
+                    end
+                    if a then
+                        for k,v in next, a do
+                            if k == "baselig" then
+                                for kk, vv in next, v do
+                                    for kkk=1,#vv do
+                                        local tv = t[vv[kkk]] if tv then vv[kkk] = tv end
+                                    end
+                                end
+                            else
+                                for kk, vv in next, v do
+                                    local tv = t[vv] if tv then v[kk] = tv end
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+            if data.lookups then
+                for k, v in next, data.lookups do
+                    local r = v.rules
+                    if r then
+                        for kk, vv in next, r do
+                            local l = vv.lookups
+                            if l then
+                                local tv = t[l] if tv then vv.lookups = tv end
+                            end
+                            local c = vv.coverage
+                            if c then
+                                local cc = c.before  if cc then local tv = t[cc] if tv then c.before  = tv end end
+                                      cc = c.after   if cc then local tv = t[cc] if tv then c.after   = tv end end
+                                      cc = c.current if cc then local tv = t[cc] if tv then c.current = tv end end
+                            end
+                            local c = vv.reversecoverage
+                            if c then
+                                local cc = c.before  if cc then local tv = t[cc] if tv then c.before  = tv end end
+                                      cc = c.after   if cc then local tv = t[cc] if tv then c.after   = tv end end
+                                      cc = c.current if cc then local tv = t[cc] if tv then c.current = tv end end
+                            end
+                            -- no need to unpack vv.glyphs
+                        end
+                    end
+                end
+            end
+            local luatex = data.luatex
+            if luatex then
+                local la = luatex.anchor_to_lookup
+                if la then
+                    for lookup, ldata in next, la do
+                        local tv = t[ldata] if tv then la[lookup] = tv end
+                    end
+                end
+                local la = luatex.lookup_to_anchor
+                if la then
+                    for lookup, ldata in next, la do
+                        local tv = t[ldata] if tv then la[lookup] = tv end
+                    end
+                end
+                local ls = luatex.sequences
+                if ls then
+                    for feature, fdata in next, ls do
+                        local flags = fdata.flags
+                        if flags then
+                            local tv = t[flags] if tv then fdata.flags = tv end
+                        end
+                        local subtables = fdata.subtables
+                        if subtables then
+                            local tv = t[subtables] if tv then fdata.subtables = tv end
+                        end
+                        local features = fdata.features
+                        if features then
+                            local tv = t[features]
+                            if tv then
+                                fdata.features = tv
+                                if not unpacked[tv] then
+                                    unpacked[tv], features = true, tv
+                                else
+                                    features = false
+                                end
+                            end
+                            if features then
+                                for script, sdata in next, features do
+                                    local tv = t[sdata] if tv then features[script] = tv end
+                                end
+                            end
+                        end
+                    end
+                end
+                local ls = luatex.lookups
+                if ls then
+                    for lookups, fdata in next, ls do
+                        local flags = fdata.flags
+                        if flags then
+                            local tv = t[flags] if tv then fdata.flags = tv end
+                        end
+                        local subtables = fdata.subtables
+                        if subtables then
+                            local tv = t[subtables] if tv then fdata.subtables = tv end
+                        end
+                    end
+                end
+                local lf = luatex.features
+                if lf then
+                    for _, g in next, fonts.otf.glists do
+                        local gl = lf[g]
+                        if gl then
+                            for feature, spec in next, gl do
+                                local tv = t[spec] if tv then gl[feature] = tv end
+                            end
+                        end
+                    end
+                end
+            end
+            data.tables = nil
+        end
+    end
+end