[fontloader] sync Context as of 2016-04-07

1 files changed, 1532 insertions, 0 deletions

diff --git a/src/fontloader/misc/fontloader-font-otj.lua b/src/fontloader/misc/fontloader-font-otj.lua
new file mode 100644
index 0000000..aae70d1
--- /dev/null
+++ b/src/fontloader/misc/fontloader-font-otj.lua
@@ -0,0 +1,1532 @@
+if not modules then modules = { } end modules ['font-otj'] = {
+    version   = 1.001,
+    comment   = "companion to font-lib.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files",
+}
+
+-- This property based variant is not faster but looks nicer than the attribute one. We
+-- need to use rawget (which is apbout 4 times slower than a direct access but we cannot
+-- get/set that one for our purpose! This version does a bit more with discretionaries
+-- (and Kai has tested it with his collection of weird fonts.)
+
+-- There is some duplicate code here (especially in the the pre/post/replace branches) but
+-- we go for speed. We could store a list of glyph and mark nodes when registering but it's
+-- cleaner to have an identification pass here. Also, I need to keep tracing in mind so
+-- being too clever here is dangerous.
+
+-- The subtype test is not needed as there will be no (new) properties set, given that we
+-- reset the properties.
+
+-- As we have a rawget on properties we don't need one on injections.
+
+-- The use_advance code is just a test and is meant for testing and manuals. There is no
+-- performance (or whatever) gain and using kerns is somewhat cleaner (at least for now).
+
+if not nodes.properties then return end
+
+local next, rawget = next, rawget
+local utfchar = utf.char
+local fastcopy = table.fastcopy
+
+local registertracker = trackers.register
+
+local trace_injections  = false  registertracker("fonts.injections",         function(v) trace_injections = v end)
+local trace_marks       = false  registertracker("fonts.injections.marks",   function(v) trace_marks      = v end)
+local trace_cursive     = false  registertracker("fonts.injections.cursive", function(v) trace_cursive    = v end)
+local trace_spaces      = false  registertracker("otf.spaces",               function(v) trace_spaces  = v end)
+
+-- use_advance is just an experiment: it makes copying glyphs (instead of new_glyph) dangerous
+
+local use_advance       = false  directives.register("fonts.injections.advance", function(v) use_advance = v end)
+
+local report_injections = logs.reporter("fonts","injections")
+local report_spaces     = logs.reporter("fonts","spaces")
+
+local attributes, nodes, node = attributes, nodes, node
+
+fonts                    = fonts
+local hashes             = fonts.hashes
+local fontdata           = hashes.identifiers
+local parameters         = fonts.hashes.parameters
+local resources          = fonts.hashes.resources
+
+nodes.injections         = nodes.injections or { }
+local injections         = nodes.injections
+
+local tracers            = nodes.tracers
+local setcolor           = tracers and tracers.colors.set
+local resetcolor         = tracers and tracers.colors.reset
+
+local nodecodes          = nodes.nodecodes
+local glyph_code         = nodecodes.glyph
+local disc_code          = nodecodes.disc
+local kern_code          = nodecodes.kern
+local glue_code          = nodecodes.glue
+
+local nuts               = nodes.nuts
+local nodepool           = nuts.pool
+
+local newkern            = nodepool.kern
+
+local tonode             = nuts.tonode
+local tonut              = nuts.tonut
+
+local getfield           = nuts.getfield
+local setfield           = nuts.setfield
+local getnext            = nuts.getnext
+local getprev            = nuts.getprev
+local getid              = nuts.getid
+local getfont            = nuts.getfont
+local getsubtype         = nuts.getsubtype
+local getchar            = nuts.getchar
+local getboth            = nuts.getboth
+
+local ischar             = nuts.is_char
+
+local getdisc            = nuts.getdisc
+local setdisc            = nuts.setdisc
+
+local traverse_id        = nuts.traverse_id
+local traverse_char      = nuts.traverse_char
+local insert_node_before = nuts.insert_before
+local insert_node_after  = nuts.insert_after
+local find_tail          = nuts.tail
+
+local properties         = nodes.properties.data
+
+function injections.installnewkern(nk)
+    newkern = nk or newkern
+end
+
+local nofregisteredkerns    = 0
+local nofregisteredpairs    = 0
+local nofregisteredmarks    = 0
+local nofregisteredcursives = 0
+local keepregisteredcounts  = false
+
+function injections.keepcounts()
+    keepregisteredcounts = true
+end
+
+function injections.resetcounts()
+    nofregisteredkerns    = 0
+    nofregisteredpairs    = 0
+    nofregisteredmarks    = 0
+    nofregisteredcursives = 0
+    keepregisteredcounts  = false
+end
+
+-- We need to make sure that a possible metatable will not kick in unexpectedly.
+
+-- function injections.reset(n)
+--     local p = rawget(properties,n)
+--     if p and rawget(p,"injections") then
+--         p.injections = nil
+--     end
+-- end
+
+-- function injections.copy(target,source)
+--     local sp = rawget(properties,source)
+--     if sp then
+--         local tp = rawget(properties,target)
+--         local si = rawget(sp,"injections")
+--         if si then
+--             si = fastcopy(si)
+--             if tp then
+--                 tp.injections = si
+--             else
+--                 propertydata[target] = {
+--                     injections = si,
+--                 }
+--             end
+--         else
+--             if tp then
+--                 tp.injections = nil
+--             end
+--         end
+--     end
+-- end
+
+function injections.reset(n)
+    local p = rawget(properties,n)
+    if p then
+        p.injections = false -- { }
+    else
+        properties[n] = false -- { injections = { } }
+    end
+end
+
+function injections.copy(target,source)
+    local sp = rawget(properties,source)
+    if sp then
+        local tp = rawget(properties,target)
+     -- local si = rawget(sp,"injections")
+        local si = sp.injections
+        if si then
+            si = fastcopy(si)
+            if tp then
+                tp.injections = si
+            else
+                propertydata[target] = {
+                    injections = si,
+                }
+            end
+        elseif tp then
+            tp.injections = false -- { }
+        else
+            properties[target] = { injections = { } }
+        end
+    else
+        local tp = rawget(properties,target)
+        if tp then
+            tp.injections = false -- { }
+        else
+            properties[target] = false -- { injections = { } }
+        end
+    end
+end
+
+function injections.setligaindex(n,index)
+    local p = rawget(properties,n)
+    if p then
+     -- local i = rawget(p,"injections")
+        local i = p.injections
+        if i then
+            i.ligaindex = index
+        else
+            p.injections = {
+                ligaindex = index
+            }
+        end
+    else
+        properties[n] = {
+            injections = {
+                ligaindex = index
+            }
+        }
+    end
+end
+
+function injections.getligaindex(n,default)
+    local p = rawget(properties,n)
+    if p then
+     -- local i = rawget(p,"injections")
+        local i = p.injections
+        if i then
+            return i.ligaindex or default
+        end
+    end
+    return default
+end
+
+function injections.setcursive(start,nxt,factor,rlmode,exit,entry,tfmstart,tfmnext) -- hm: nuts or nodes
+    local dx =  factor*(exit[1]-entry[1])
+    local dy = -factor*(exit[2]-entry[2])
+    local ws = tfmstart.width
+    local wn = tfmnext.width
+    nofregisteredcursives = nofregisteredcursives + 1
+    if rlmode < 0 then
+        dx = -(dx + wn)
+    else
+        dx = dx - ws
+    end
+    if dx == 0 then
+     -- get rid of funny -0
+        dx = 0
+    end
+    --
+    local p = rawget(properties,start)
+    if p then
+     -- local i = rawget(p,"injections")
+        local i = p.injections
+        if i then
+            i.cursiveanchor = true
+        else
+            p.injections = {
+                cursiveanchor = true,
+            }
+        end
+    else
+        properties[start] = {
+            injections = {
+                cursiveanchor = true,
+            },
+        }
+    end
+    local p = rawget(properties,nxt)
+    if p then
+     -- local i = rawget(p,"injections")
+        local i = p.injections
+        if i then
+            i.cursivex = dx
+            i.cursivey = dy
+        else
+            p.injections = {
+                cursivex = dx,
+                cursivey = dy,
+            }
+        end
+    else
+        properties[nxt] = {
+            injections = {
+                cursivex = dx,
+                cursivey = dy,
+            },
+        }
+    end
+    return dx, dy, nofregisteredcursives
+end
+
+function injections.setpair(current,factor,rlmode,r2lflag,spec,injection) -- r2lflag & tfmchr not used
+    local x = factor*spec[1]
+    local y = factor*spec[2]
+    local w = factor*spec[3]
+    local h = factor*spec[4]
+    if x ~= 0 or w ~= 0 or y ~= 0 or h ~= 0 then -- okay?
+        local yoffset   = y - h
+        local leftkern  = x      -- both kerns are set in a pair kern compared
+        local rightkern = w - x  -- to normal kerns where we set only leftkern
+        if leftkern ~= 0 or rightkern ~= 0 or yoffset ~= 0 then
+            nofregisteredpairs = nofregisteredpairs + 1
+            if rlmode and rlmode < 0 then
+                leftkern, rightkern = rightkern, leftkern
+            end
+            if not injection then
+                injection = "injections"
+            end
+            local p = rawget(properties,current)
+            if p then
+             -- local i = p[injection]
+                local i = rawget(p,injection)
+                if i then
+                    if leftkern ~= 0 then
+                        i.leftkern  = (i.leftkern  or 0) + leftkern
+                    end
+                    if rightkern ~= 0 then
+                        i.rightkern = (i.rightkern or 0) + rightkern
+                    end
+                    if yoffset ~= 0 then
+                        i.yoffset = (i.yoffset or 0) + yoffset
+                    end
+                elseif leftkern ~= 0 or rightkern ~= 0 then
+                    p[injection] = {
+                        leftkern  = leftkern,
+                        rightkern = rightkern,
+                        yoffset   = yoffset,
+                    }
+                else
+                    p[injection] = {
+                        yoffset = yoffset,
+                    }
+                end
+            elseif leftkern ~= 0 or rightkern ~= 0 then
+                properties[current] = {
+                    [injection] = {
+                        leftkern  = leftkern,
+                        rightkern = rightkern,
+                        yoffset   = yoffset,
+                    },
+                }
+            else
+                properties[current] = {
+                    [injection] = {
+                        yoffset = yoffset,
+                    },
+                }
+            end
+            return x, y, w, h, nofregisteredpairs
+         end
+    end
+    return x, y, w, h -- no bound
+end
+
+-- This needs checking for rl < 0 but it is unlikely that a r2l script uses kernclasses between
+-- glyphs so we're probably safe (KE has a problematic font where marks interfere with rl < 0 in
+-- the previous case)
+
+function injections.setkern(current,factor,rlmode,x,injection)
+    local dx = factor * x
+    if dx ~= 0 then
+        nofregisteredkerns = nofregisteredkerns + 1
+        local p = rawget(properties,current)
+        if not injection then
+            injection = "injections"
+        end
+        if p then
+         -- local i = rawget(p,injection)
+            local i = rawget(p,injection)
+            if i then
+                i.leftkern = dx + (i.leftkern or 0)
+            else
+                p[injection] = {
+                    leftkern = dx,
+                }
+            end
+        else
+            properties[current] = {
+                [injection] = {
+                    leftkern = dx,
+                },
+            }
+        end
+        return dx, nofregisteredkerns
+    else
+        return 0, 0
+    end
+end
+
+function injections.setmark(start,base,factor,rlmode,ba,ma,tfmbase,mkmk) -- ba=baseanchor, ma=markanchor
+    local dx, dy = factor*(ba[1]-ma[1]), factor*(ba[2]-ma[2])
+    nofregisteredmarks = nofregisteredmarks + 1
+    if rlmode >= 0 then
+        dx = tfmbase.width - dx -- see later commented ox
+    end
+    local p = rawget(properties,start)
+    -- hm, dejavu serif does a sloppy mark2mark before mark2base
+    if p then
+     -- local i = rawget(p,"injections")
+        local i = p.injections
+        if i then
+            if i.markmark then
+                -- out of order mkmk: yes or no or option
+            else
+                i.markx        = dx
+                i.marky        = dy
+                i.markdir      = rlmode or 0
+                i.markbase     = nofregisteredmarks
+                i.markbasenode = base
+                i.markmark     = mkmk
+            end
+        else
+            p.injections = {
+                markx        = dx,
+                marky        = dy,
+                markdir      = rlmode or 0,
+                markbase     = nofregisteredmarks,
+                markbasenode = base,
+                markmark     = mkmk,
+            }
+        end
+    else
+        properties[start] = {
+            injections = {
+                markx        = dx,
+                marky        = dy,
+                markdir      = rlmode or 0,
+                markbase     = nofregisteredmarks,
+                markbasenode = base,
+                markmark     = mkmk,
+            },
+        }
+    end
+    return dx, dy, nofregisteredmarks
+end
+
+local function dir(n)
+    return (n and n<0 and "r-to-l") or (n and n>0 and "l-to-r") or "unset"
+end
+
+local function showchar(n,nested)
+    local char = getchar(n)
+    report_injections("%wfont %s, char %U, glyph %c",nested and 2 or 0,getfont(n),char,char)
+end
+
+local function show(n,what,nested,symbol)
+    if n then
+        local p = rawget(properties,n)
+        if p then
+            local i = rawget(p,what)
+            if i then
+                local leftkern  = i.leftkern  or 0
+                local rightkern = i.rightkern or 0
+                local yoffset   = i.yoffset   or 0
+                local markx     = i.markx     or 0
+                local marky     = i.marky     or 0
+                local markdir   = i.markdir   or 0
+                local markbase  = i.markbase  or 0
+                local cursivex  = i.cursivex  or 0
+                local cursivey  = i.cursivey  or 0
+                local ligaindex = i.ligaindex or 0
+                local cursbase  = i.cursiveanchor
+                local margin    = nested and 4 or 2
+                --
+                if rightkern ~= 0 or yoffset ~= 0 then
+                    report_injections("%w%s pair: lx %p, rx %p, dy %p",margin,symbol,leftkern,rightkern,yoffset)
+                elseif leftkern ~= 0 then
+                    report_injections("%w%s kern: dx %p",margin,symbol,leftkern)
+                end
+                if markx ~= 0 or marky ~= 0 or markbase ~= 0 then
+                    report_injections("%w%s mark: dx %p, dy %p, dir %s, base %s",margin,symbol,markx,marky,markdir,markbase ~= 0 and "yes" or "no")
+                end
+                if cursivex ~= 0 or cursivey ~= 0 then
+                    if cursbase then
+                        report_injections("%w%s curs: base dx %p, dy %p",margin,symbol,cursivex,cursivey)
+                    else
+                        report_injections("%w%s curs: dx %p, dy %p",margin,symbol,cursivex,cursivey)
+                    end
+                elseif cursbase then
+                    report_injections("%w%s curs: base",margin,symbol)
+                end
+                if ligaindex ~= 0 then
+                    report_injections("%w%s liga: index %i",margin,symbol,ligaindex)
+                end
+            end
+        end
+    end
+end
+
+local function showsub(n,what,where)
+    report_injections("begin subrun: %s",where)
+    for n in traverse_id(glyph_code,n) do
+        showchar(n,where)
+        show(n,what,where," ")
+    end
+    report_injections("end subrun")
+end
+
+local function trace(head,where)
+    report_injections("begin run %s: %s kerns, %s pairs, %s marks and %s cursives registered",
+        where or "",nofregisteredkerns,nofregisteredpairs,nofregisteredmarks,nofregisteredcursives)
+    local n = head
+    while n do
+        local id = getid(n)
+        if id == glyph_code then
+            showchar(n)
+            show(n,"injections",false," ")
+            show(n,"preinjections",false,"<")
+            show(n,"postinjections",false,">")
+            show(n,"replaceinjections",false,"=")
+            show(n,"emptyinjections",false,"*")
+        elseif id == disc_code then
+            local pre, post, replace = getdisc(n)
+            if pre then
+                showsub(pre,"preinjections","pre")
+            end
+            if post then
+                showsub(post,"postinjections","post")
+            end
+            if replace then
+                showsub(replace,"replaceinjections","replace")
+            end
+            show(n,"emptyinjections",false,"*")
+        end
+        n = getnext(n)
+    end
+    report_injections("end run")
+end
+
+local function show_result(head)
+    local current  = head
+    local skipping = false
+    while current do
+        local id = getid(current)
+        if id == glyph_code then
+            report_injections("char: %C, width %p, xoffset %p, yoffset %p",
+                getchar(current),getfield(current,"width"),getfield(current,"xoffset"),getfield(current,"yoffset"))
+            skipping = false
+        elseif id == kern_code then
+            report_injections("kern: %p",getfield(current,"kern"))
+            skipping = false
+        elseif not skipping then
+            report_injections()
+            skipping = true
+        end
+        current = getnext(current)
+    end
+end
+
+-- G  +D-pre        G
+--     D-post+
+--    +D-replace+
+--
+-- G  +D-pre       +D-pre
+--     D-post      +D-post
+--    +D-replace   +D-replace
+
+local function inject_kerns_only(head,where)
+    head = tonut(head)
+    if trace_injections then
+        trace(head,"kerns")
+    end
+    local current     = head
+    local prev        = nil
+    local next        = nil
+    local prevdisc    = nil
+    local prevglyph   = nil
+    local pre         = nil -- saves a lookup
+    local post        = nil -- saves a lookup
+    local replace     = nil -- saves a lookup
+    local pretail     = nil -- saves a lookup
+    local posttail    = nil -- saves a lookup
+    local replacetail = nil -- saves a lookup
+    while current do
+        local id   = getid(current)
+        local next = getnext(current)
+        if id == glyph_code then
+            if getsubtype(current) < 256 then
+                local p = rawget(properties,current)
+                if p then
+                 -- local i = rawget(p,"injections")
+                    local i = p.injections
+                    if i then
+                        -- left|glyph|right
+                        local leftkern = i.leftkern
+                        if leftkern and leftkern ~= 0 then
+                            if use_advance then
+                                setfield(current,"xoffset",leftkern)
+                                setfield(current,"xadvance",leftkern)
+                            else
+                                insert_node_before(head,current,newkern(leftkern))
+                            end
+                        end
+                    end
+                    if prevdisc then
+                        local done = false
+                        if post then
+                         -- local i = rawget(p,"postinjections")
+                            local i = p.postinjections
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    if use_advance then
+                                        setfield(post,"xadvance",leftkern)
+                                    else
+                                        insert_node_after(post,posttail,newkern(leftkern))
+                                        done = true
+                                    end
+                                end
+                            end
+                        end
+                        if replace then
+                         -- local i = rawget(p,"replaceinjections")
+                            local i = p.replaceinjections
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    if use_advance then
+                                        setfield(replace,"xadvance",leftkern)
+                                    else
+                                        insert_node_after(replace,replacetail,newkern(leftkern))
+                                        done = true
+                                    end
+                                end
+                            end
+                        else
+                         -- local i = rawget(p,"emptyinjections")
+                            local i = p.emptyinjections
+                            if i then
+                                -- glyph|disc|glyph (special case)
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    setfield(prev,"replace",newkern(leftkern)) -- maybe also leftkern
+                                end
+                            end
+                        end
+                        if done then
+                            setdisc(prevdisc,pre,post,replace)
+                        end
+                    end
+                end
+            end
+            prevdisc  = nil
+            prevglyph = current
+        elseif id == disc_code then
+            pre, post, replace, pretail, posttail, replacetail = getdisc(current,true)
+            local done = false
+            if pre then
+                -- left|pre glyphs|right
+                for n in traverse_char(pre) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"preinjections")
+                        local i = p.injections or p.preinjections
+                        if i then
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                if use_advance then
+                                    setfield(pre,"xoffset",leftkern)
+                                    setfield(pre,"xadvance",leftkern)
+                                else
+                                    pre  = insert_node_before(pre,n,newkern(leftkern))
+                                    done = true
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+            if post then
+                -- left|post glyphs|right
+                for n in traverse_char(post) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"postinjections")
+                        local i = p.injections or p.postinjections
+                        if i then
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                if use_advance then
+                                    setfield(post,"xoffset",leftkern)
+                                    setfield(post,"xadvance",leftkern)
+                                else
+                                    post = insert_node_before(post,n,newkern(leftkern))
+                                    done = true
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+            if replace then
+                -- left|replace glyphs|right
+                for n in traverse_char(replace) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"replaceinjections")
+                        local i = p.injections or p.replaceinjections
+                        if i then
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                if use_advance then
+                                    setfield(replace,"xoffset",leftkern)
+                                    setfield(replace,"xadvance",leftkern)
+                                else
+                                    replace = insert_node_before(replace,n,newkern(leftkern))
+                                    done    = true
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+            if done then
+                setdisc(current,pre,post,replace)
+            end
+            prevglyph = nil
+            prevdisc  = current
+        else
+            prevglyph = nil
+            prevdisc  = nil
+        end
+        prev    = current
+        current = next
+    end
+    --
+    if keepregisteredcounts then
+        keepregisteredcounts = false
+    else
+        nofregisteredkerns   = 0
+    end
+    return tonode(head), true
+end
+
+local function inject_pairs_only(head,where)
+    head = tonut(head)
+    if trace_injections then
+        trace(head,"pairs")
+    end
+    local current     = head
+    local prev        = nil
+    local next        = nil
+    local prevdisc    = nil
+    local prevglyph   = nil
+    local pre         = nil -- saves a lookup
+    local post        = nil -- saves a lookup
+    local replace     = nil -- saves a lookup
+    local pretail     = nil -- saves a lookup
+    local posttail    = nil -- saves a lookup
+    local replacetail = nil -- saves a lookup
+    while current do
+        local id   = getid(current)
+        local next = getnext(current)
+        if id == glyph_code then
+            if getsubtype(current) < 256 then
+                local p = rawget(properties,current)
+                if p then
+                 -- local i = rawget(p,"injections")
+                    local i = p.injections
+                    if i then
+                        -- left|glyph|right
+                        local yoffset = i.yoffset
+                        if yoffset and yoffset ~= 0 then
+                            setfield(current,"yoffset",yoffset)
+                        end
+                        local leftkern = i.leftkern
+                        if leftkern and leftkern ~= 0 then
+                            insert_node_before(head,current,newkern(leftkern))
+                        end
+                        local rightkern = i.rightkern
+                        if rightkern and rightkern ~= 0 then
+                            insert_node_after(head,current,newkern(rightkern))
+                        end
+                    else
+                     -- local i = rawget(p,"emptyinjections")
+                        local i = p.emptyinjections
+                        if i then
+                            -- glyph|disc|glyph (special case)
+-- is this okay?
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                if next and getid(next) == disc_code then
+                                    if replace then
+                                        -- error, we expect an empty one
+                                    else
+                                        setfield(next,"replace",newkern(rightkern)) -- maybe also leftkern
+                                    end
+                                end
+                            end
+                        end
+                    end
+                    if prevdisc then
+                        local done = false
+                        if post then
+                         -- local i = rawget(p,"postinjections")
+                            local i = p.postinjections
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    insert_node_after(post,posttail,newkern(leftkern))
+                                    done = true
+                                end
+                            end
+                        end
+                        if replace then
+                         -- local i = rawget(p,"replaceinjections")
+                            local i = p.replaceinjections
+                            if i then
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    insert_node_after(replace,replacetail,newkern(leftkern))
+                                    done = true
+                                end
+                            end
+                        else
+                            local i = p.emptyinjections
+                            if i then
+-- new .. okay?
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    setfield(prev,"replace",newkern(leftkern)) -- maybe also leftkern
+                                end
+                            end
+                        end
+                        if done then
+                            setdisc(prevdisc,pre,post,replace)
+                        end
+                    end
+                end
+            end
+            prevdisc  = nil
+            prevglyph = current
+        elseif id == disc_code then
+            pre, post, replace, pretail, posttail, replacetail = getdisc(current,true)
+            local done = false
+            if pre then
+                -- left|pre glyphs|right
+                for n in traverse_char(pre) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"preinjections")
+                        local i = p.injections or p.preinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                pre  = insert_node_before(pre,n,newkern(leftkern))
+                                done = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(pre,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                    end
+                end
+            end
+            if post then
+                -- left|post glyphs|right
+                for n in traverse_char(post) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"postinjections")
+                        local i = p.injections or p.postinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                post = insert_node_before(post,n,newkern(leftkern))
+                                done = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(post,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                    end
+                end
+            end
+            if replace then
+                -- left|replace glyphs|right
+                for n in traverse_char(replace) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"replaceinjections")
+                        local i = p.injections or p.replaceinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                replace = insert_node_before(replace,n,newkern(leftkern))
+                                done    = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(replace,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                    end
+                end
+            end
+            if prevglyph then
+                if pre then
+                    local p = rawget(properties,prevglyph)
+                    if p then
+                     -- local i = rawget(p,"preinjections")
+                        local i = p.preinjections
+                        if i then
+                            -- glyph|pre glyphs
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                pre  = insert_node_before(pre,pre,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                    end
+                end
+                if replace then
+                    local p = rawget(properties,prevglyph)
+                    if p then
+                     -- local i = rawget(p,"replaceinjections")
+                        local i = p.replaceinjections
+                        if i then
+                            -- glyph|replace glyphs
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                replace = insert_node_before(replace,replace,newkern(rightkern))
+                                done    = true
+                            end
+                        end
+                    end
+                end
+            end
+            if done then
+                setdisc(current,pre,post,replace)
+            end
+            prevglyph = nil
+            prevdisc  = current
+        else
+            prevglyph = nil
+            prevdisc  = nil
+        end
+        prev    = current
+        current = next
+    end
+    --
+    if keepregisteredcounts then
+        keepregisteredcounts = false
+    else
+        nofregisteredkerns   = 0
+    end
+    return tonode(head), true
+end
+
+-- local function showoffset(n,flag)
+--     local ox = getfield(n,"xoffset")
+--     local oy = getfield(n,"yoffset")
+--     if flag then
+--         if ox == 0 then
+--             setcolor(n,oy == 0 and "darkgray" or "darkgreen")
+--         else
+--             setcolor(n,oy == 0 and "darkblue" or "darkred")
+--         end
+--     else
+--         if ox == 0 then
+--             setcolor(n,oy == 0 and "gray" or "green")
+--         else
+--             setcolor(n,oy == 0 and "blue" or "red")
+--         end
+--     end
+-- end
+
+local function showoffset(n,flag)
+    local o = getfield(n,"xoffset")
+    if o == 0 then
+        o = getfield(n,"yoffset")
+    end
+    if o ~= 0 then
+        setcolor(n,flag and "darkred" or "darkgreen")
+    else
+        resetcolor(n)
+    end
+end
+
+local function inject_everything(head,where)
+    head = tonut(head)
+    if trace_injections then
+        trace(head,"everything")
+    end
+    local hascursives   = nofregisteredcursives > 0
+    local hasmarks      = nofregisteredmarks    > 0
+    --
+    local current       = head
+    local last          = nil
+    local font          = font
+    local markdata      = nil
+    local prev          = nil
+    local next          = nil
+    local prevdisc      = nil
+    local prevglyph     = nil
+    local pre           = nil -- saves a lookup
+    local post          = nil -- saves a lookup
+    local replace       = nil -- saves a lookup
+    local pretail       = nil -- saves a lookup
+    local posttail      = nil -- saves a lookup
+    local replacetail   = nil -- saves a lookup
+    --
+    local cursiveanchor = nil
+    local minc          = 0
+    local maxc          = 0
+    local glyphs        = { }
+    local marks         = { }
+    local nofmarks      = 0
+    --
+    -- move out
+    --
+    local function processmark(p,n,pn) -- p = basenode
+        local px = getfield(p,"xoffset")
+        local ox = 0
+        local rightkern = nil
+        local pp = rawget(properties,p)
+        if pp then
+         -- pp = rawget(pp,"injections")
+            pp = pp.injections
+            if pp then
+                rightkern = pp.rightkern
+            end
+        end
+        if rightkern then -- x and w ~= 0
+            if pn.markdir < 0 then
+                -- kern(w-x) glyph(p) kern(x) mark(n)
+                ox = px - pn.markx - rightkern
+             -- report_injections("r2l case 1: %p",ox)
+            else
+                -- kern(x) glyph(p) kern(w-x) mark(n)
+             -- ox = px - getfield(p,"width") + pn.markx - pp.leftkern
+                --
+                -- According to Kai we don't need to handle leftkern here but I'm
+                -- pretty sure I've run into a case where it was needed so maybe
+                -- some day we need something more clever here.
+                --
+                if false then
+                    -- a mark with kerning
+                    local leftkern = pp.leftkern
+                    if leftkern then
+                        ox = px - pn.markx - leftkern
+                    else
+                        ox = px - pn.markx
+                    end
+                else
+                    ox = px - pn.markx
+                end
+            end
+        else
+         -- if pn.markdir < 0 then
+         --     ox = px - pn.markx
+         --  -- report_injections("r2l case 3: %p",ox)
+         -- else
+         --  -- ox = px - getfield(p,"width") + pn.markx
+                ox = px - pn.markx
+             -- report_injections("l2r case 3: %p",ox)
+         -- end
+            local wn = getfield(n,"width") -- in arial marks have widths
+            if wn ~= 0 then
+                -- bad: we should center
+                pn.leftkern  = -wn/2
+                pn.rightkern = -wn/2
+            end
+        end
+        local oy = getfield(n,"yoffset") + getfield(p,"yoffset") + pn.marky
+        setfield(n,"xoffset",ox)
+        setfield(n,"yoffset",oy)
+        if trace_marks then
+            showoffset(n,true)
+        end
+    end
+    -- todo: marks in disc
+    while current do
+        local id   = getid(current)
+        local next = getnext(current)
+        if id == glyph_code then
+            if getsubtype(current) < 256 then
+                local p = rawget(properties,current)
+                if p then
+                 -- local i = rawget(p,"injections")
+                    local i = p.injections
+                    if i then
+                        local pm = i.markbasenode
+                        if pm then
+                            nofmarks = nofmarks + 1
+                            marks[nofmarks] = current
+                        else
+                            if hascursives then
+                                local cursivex = i.cursivex
+                                if cursivex then
+                                    if cursiveanchor then
+                                        if cursivex ~= 0 then
+                                            i.leftkern = (i.leftkern or 0) + cursivex
+                                        end
+                                        if maxc == 0 then
+                                            minc = 1
+                                            maxc = 1
+                                            glyphs[1] = cursiveanchor
+                                        else
+                                            maxc = maxc + 1
+                                            glyphs[maxc] = cursiveanchor
+                                        end
+                                        properties[cursiveanchor].cursivedy = i.cursivey -- cursiveprops
+                                        last = current
+                                    else
+                                        maxc = 0
+                                    end
+                                elseif maxc > 0 then
+                                    local ny = getfield(current,"yoffset")
+                                    for i=maxc,minc,-1 do
+                                        local ti = glyphs[i]
+                                        ny = ny + properties[ti].cursivedy
+                                        setfield(ti,"yoffset",ny) -- why not add ?
+                                        if trace_cursive then
+                                            showoffset(ti)
+                                        end
+                                    end
+                                    maxc = 0
+                                    cursiveanchor = nil
+                                end
+                                if i.cursiveanchor then
+                                    cursiveanchor = current -- no need for both now
+                                else
+                                    if maxc > 0 then
+                                        local ny = getfield(current,"yoffset")
+                                        for i=maxc,minc,-1 do
+                                            local ti = glyphs[i]
+                                            ny = ny + properties[ti].cursivedy
+                                            setfield(ti,"yoffset",ny) -- why not add ?
+                                            if trace_cursive then
+                                                showoffset(ti)
+                                            end
+                                        end
+                                        maxc = 0
+                                    end
+                                    cursiveanchor = nil
+                                end
+                            end
+                            -- left|glyph|right
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(current,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                insert_node_before(head,current,newkern(leftkern))
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(head,current,newkern(rightkern))
+                            end
+                        end
+                    else
+                     -- local i = rawget(p,"emptyinjections")
+                        local i = p.emptyinjections
+                        if i then
+                            -- glyph|disc|glyph (special case)
+-- okay?
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                if next and getid(next) == disc_code then
+                                    if replace then
+                                        -- error, we expect an empty one
+                                    else
+                                        setfield(next,"replace",newkern(rightkern)) -- maybe also leftkern
+                                    end
+                                end
+                            end
+                        end
+                    end
+                    if prevdisc then
+                        if p then
+                            local done = false
+                            if post then
+                             -- local i = rawget(p,"postinjections")
+                                local i = p.postinjections
+                                if i then
+                                    local leftkern = i.leftkern
+                                    if leftkern and leftkern ~= 0 then
+                                        insert_node_after(post,posttail,newkern(leftkern))
+                                        done = true
+                                    end
+                                end
+                            end
+                            if replace then
+                             -- local i = rawget(p,"replaceinjections")
+                                local i = p.replaceinjections
+                                if i then
+                                    local leftkern = i.leftkern
+                                    if leftkern and leftkern ~= 0 then
+                                        insert_node_after(replace,replacetail,newkern(leftkern))
+                                        done = true
+                                    end
+                                end
+                            else
+                             -- local i = rawget(p,"emptyinjections")
+                                local i = p.emptyinjections
+                                local leftkern = i.leftkern
+                                if leftkern and leftkern ~= 0 then
+                                    setfield(prev,"replace",newkern(leftkern)) -- maybe also leftkern
+                                end
+                            end
+                            if done then
+                                setdisc(prevdisc,pre,post,replace)
+                            end
+                        end
+                    end
+                else
+                    -- cursive
+                    if hascursives and maxc > 0 then
+                        local ny = getfield(current,"yoffset")
+                        for i=maxc,minc,-1 do
+                            local ti = glyphs[i]
+                            ny = ny + properties[ti].cursivedy
+                            setfield(ti,"yoffset",getfield(ti,"yoffset") + ny) -- can be mark
+                        end
+                        maxc = 0
+                        cursiveanchor = nil
+                    end
+                end
+            end
+            prevdisc  = nil
+            prevglyph = current
+        elseif id == disc_code then
+            pre, post, replace, pretail, posttail, replacetail = getdisc(current,true)
+            local done = false
+            if pre then
+                -- left|pre glyphs|right
+                for n in traverse_char(pre) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"preinjections")
+                        local i = p.injections or p.preinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                pre  = insert_node_before(pre,n,newkern(leftkern))
+                                done = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(pre,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                        if hasmarks then
+                            local pm = i.markbasenode
+                            if pm then
+                                processmark(pm,current,i)
+                            end
+                        end
+                    end
+                end
+            end
+            if post then
+                -- left|post glyphs|right
+                for n in traverse_char(post) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"postinjections")
+                        local i = p.injections or p.postinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                post = insert_node_before(post,n,newkern(leftkern))
+                                done = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(post,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                        if hasmarks then
+                            local pm = i.markbasenode
+                            if pm then
+                                processmark(pm,current,i)
+                            end
+                        end
+                    end
+                end
+            end
+            if replace then
+                -- left|replace glyphs|right
+                for n in traverse_char(replace) do
+                    local p = rawget(properties,n)
+                    if p then
+                     -- local i = rawget(p,"injections") or rawget(p,"replaceinjections")
+                        local i = p.injections or p.replaceinjections
+                        if i then
+                            local yoffset = i.yoffset
+                            if yoffset and yoffset ~= 0 then
+                                setfield(n,"yoffset",yoffset)
+                            end
+                            local leftkern = i.leftkern
+                            if leftkern and leftkern ~= 0 then
+                                replace = insert_node_before(replace,n,newkern(leftkern))
+                                done    = true
+                            end
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                insert_node_after(replace,n,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                        if hasmarks then
+                            local pm = i.markbasenode
+                            if pm then
+                                processmark(pm,current,i)
+                            end
+                        end
+                    end
+                end
+            end
+            if prevglyph then
+                if pre then
+                    local p = rawget(properties,prevglyph)
+                    if p then
+                     -- local i = rawget(p,"preinjections")
+                        local i = p.preinjections
+                        if i then
+                            -- glyph|pre glyphs
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                pre  = insert_node_before(pre,pre,newkern(rightkern))
+                                done = true
+                            end
+                        end
+                    end
+                end
+                if replace then
+                    local p = rawget(properties,prevglyph)
+                    if p then
+                     -- local i = rawget(p,"replaceinjections")
+                        local i = p.replaceinjections
+                        if i then
+                            -- glyph|replace glyphs
+                            local rightkern = i.rightkern
+                            if rightkern and rightkern ~= 0 then
+                                replace = insert_node_before(replace,replace,newkern(rightkern))
+                                done    = true
+                            end
+                        end
+                    end
+                end
+            end
+            if done then
+                setdisc(current,pre,post,replace)
+            end
+            prevglyph = nil
+            prevdisc  = current
+        else
+            prevglyph = nil
+            prevdisc  = nil
+        end
+        prev    = current
+        current = next
+    end
+    -- cursive
+    if hascursives and maxc > 0 then
+        local ny = getfield(last,"yoffset")
+        for i=maxc,minc,-1 do
+            local ti = glyphs[i]
+            ny = ny + properties[ti].cursivedy
+            setfield(ti,"yoffset",ny) -- why not add ?
+            if trace_cursive then
+                showoffset(ti)
+            end
+        end
+    end
+    --
+    if nofmarks > 0 then
+        for i=1,nofmarks do
+            local m = marks[i]
+            local p = rawget(properties,m)
+         -- local i = rawget(p,"injections")
+            local i = p.injections
+            local b = i.markbasenode
+            processmark(b,m,i)
+        end
+    elseif hasmarks then
+        -- sometyhing bad happened
+    end
+    --
+    if keepregisteredcounts then
+        keepregisteredcounts  = false
+    else
+        nofregisteredkerns    = 0
+        nofregisteredpairs    = 0
+        nofregisteredmarks    = 0
+        nofregisteredcursives = 0
+    end
+    return tonode(head), true
+end
+
+-- space triggers
+
+local triggers = false
+
+function nodes.injections.setspacekerns(font,sequence)
+    if triggers then
+        triggers[font] = sequence
+    else
+        triggers = { [font] = sequence }
+    end
+end
+
+local function injectspaces(head)
+
+    if not triggers then
+        return head, false
+    end
+
+    local lastfont   = nil
+    local spacekerns = nil
+    local leftkerns  = nil
+    local rightkerns = nil
+    local factor     = 0
+    local threshold  = 0
+    local leftkern   = false
+    local rightkern  = false
+
+    local function updatefont(font,trig)
+     -- local resources  = resources[font]
+     -- local spacekerns = resources.spacekerns
+     -- if spacekerns then
+     --     leftkerns  = spacekerns.left
+     --     rightkerns = spacekerns.right
+     -- end
+        leftkerns  = trig.left
+        rightkerns = trig.right
+        local par  = parameters[font]
+        factor     = par.factor
+        threshold  = par.spacing.width - 1 -- get rid of rounding errors
+        lastfont   = font
+    end
+
+    for n in traverse_id(glue_code,tonut(head)) do
+        local prev, next = getboth(n)
+        local prevchar = ischar(prev)
+        local nextchar = ischar(next)
+        if nextchar then
+            local font = getfont(next)
+            local trig = triggers[font]
+            if trig then
+                if lastfont ~= font then
+                    updatefont(font,trig)
+                end
+                if rightkerns then
+                    rightkern = rightkerns[nextchar]
+                end
+            end
+        end
+        if prevchar then
+            local font = getfont(next)
+            local trig = triggers[font]
+            if trig then
+                if lastfont ~= font then
+                    updatefont(font,trig)
+                end
+                if leftkerns then
+                    leftkern = leftkerns[prevchar]
+                end
+            end
+        end
+        if leftkern then
+            local old = getfield(n,"width")
+            if old >= threshold then
+                if rightkern then
+                    local new = old + (leftkern + rightkern) * factor
+                    if trace_spaces then
+                        report_spaces("%C [%p -> %p] %C",prevchar,old,new,nextchar)
+                    end
+                    setfield(n,"width",new)
+                    leftkern  = false
+                else
+                    local new = old + leftkern * factor
+                    if trace_spaces then
+                        report_spaces("%C [%p -> %p]",prevchar,old,new)
+                    end
+                    setfield(n,"width",new)
+                end
+            end
+            leftkern  = false
+        elseif rightkern then
+            local old = getfield(n,"width")
+            if old >= threshold then
+                local new = old + rightkern * factor
+                if trace_spaces then
+                    report_spaces("[%p -> %p] %C",nextchar,old,new)
+                end
+                setfield(n,"width",new)
+            end
+            rightkern = false
+        end
+    end
+
+    triggers = false
+    return head, true
+end
+
+--
+
+function injections.handler(head,where)
+    if triggers then
+        head = injectspaces(head)
+    end
+    if nofregisteredmarks > 0 or nofregisteredcursives > 0 then
+        return inject_everything(head,where)
+    elseif nofregisteredpairs > 0 then
+        return inject_pairs_only(head,where)
+    elseif nofregisteredkerns > 0 then
+        return inject_kerns_only(head,where)
+    else
+        return head, false
+    end
+end