if not modules then modules = { } end modules ['font-otn'] = { version = 1.001, comment = "companion to font-ini.mkiv", author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", copyright = "PRAGMA ADE / ConTeXt Development Team", license = "see context related readme files", } -- todo: looks like we have a leak somewhere (probably in ligatures) -- todo: copy attributes to disc -- this is a context version which can contain experimental code, but when we -- have serious patches we also need to change the other two font-otn files -- preprocessors = { "nodes" } -- anchor class : mark, mkmk, curs, mklg (todo) -- anchor type : mark, basechar, baselig, basemark, centry, cexit, max (todo) -- this is still somewhat preliminary and it will get better in due time; -- much functionality could only be implemented thanks to the husayni font -- of Idris Samawi Hamid to who we dedicate this module. -- in retrospect it always looks easy but believe it or not, it took a lot -- of work to get proper open type support done: buggy fonts, fuzzy specs, -- special made testfonts, many skype sessions between taco, idris and me, -- torture tests etc etc ... unfortunately the code does not show how much -- time it took ... -- todo: -- -- extension infrastructure (for usage out of context) -- sorting features according to vendors/renderers -- alternative loop quitters -- check cursive and r2l -- find out where ignore-mark-classes went -- default features (per language, script) -- handle positions (we need example fonts) -- handle gpos_single (we might want an extra width field in glyph nodes because adding kerns might interfere) -- mark (to mark) code is still not what it should be (too messy but we need some more extreem husayni tests) -- remove some optimizations (when I have a faster machine) -- -- beware: -- -- we do some disc jugling where we need to keep in mind that the -- pre, post and replace fields can have prev pointers to a nesting -- node ... i wonder if that is still needed -- -- not possible: -- -- \discretionary {alpha-} {betagammadelta} -- {\discretionary {alphabeta-} {gammadelta} -- {\discretionary {alphabetagamma-} {delta} -- {alphabetagammadelta}}} --[[ldx--
This module is a bit more split up that I'd like but since we also want to test
with plain
The specification of OpenType is kind of vague. Apart from a lack of a proper free specifications there's also the problem that Microsoft and Adobe may have their own interpretation of how and in what order to apply features. In general the Microsoft website has more detailed specifications and is a better reference. There is also some information in the FontForge help files.
Because there is so much possible, fonts might contain bugs and/or be made to work with certain rederers. These may evolve over time which may have the side effect that suddenly fonts behave differently.
After a lot of experiments (mostly by Taco, me and Idris) we're now at yet another
implementation. Of course all errors are mine and of course the code can be
improved. There are quite some optimizations going on here and processing speed
is currently acceptable. Not all functions are implemented yet, often because I
lack the fonts for testing. Many scripts are not yet supported either, but I will
look into them as soon as
Because there are different interpretations possible, I will extend the code with more (configureable) variants. I can also add hooks for users so that they can write their own extensions.
Glyphs are indexed not by unicode but in their own way. This is because there is no
relationship with unicode at all, apart from the fact that a font might cover certain
ranges of characters. One character can have multiple shapes. However, at the
The raw table as it coms from
This module is sparsely documented because it is a moving target. The table format of the reader changes and we experiment a lot with different methods for supporting features.
As with the
Incrementing the version number will force a re-cache. We jump the number by one
when there's a fix in the
We get hits on a mark, but we're not sure if the it has to be applied so we need to explicitly test for basechar, baselig and basemark entries.
--ldx]]-- function handlers.gpos_mark2base(head,start,kind,lookupname,markanchors,sequence) local markchar = getchar(start) if marks[markchar] then local base = getprev(start) -- [glyph] [start=mark] if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then local basechar = getchar(base) if marks[basechar] then while true do base = getprev(base) if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then basechar = getchar(base) if not marks[basechar] then break end else if trace_bugs then logwarning("%s: no base for mark %s",pref(kind,lookupname),gref(markchar)) end return head, start, false end end end local baseanchors = descriptions[basechar] if baseanchors then baseanchors = baseanchors.anchors end if baseanchors then local baseanchors = baseanchors['basechar'] if baseanchors then local al = anchorlookups[lookupname] for anchor,ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) if trace_marks then logprocess("%s, anchor %s, bound %s: anchoring mark %s to basechar %s => (%p,%p)", pref(kind,lookupname),anchor,bound,gref(markchar),gref(basechar),dx,dy) end return head, start, true end end end if trace_bugs then logwarning("%s, no matching anchors for mark %s and base %s",pref(kind,lookupname),gref(markchar),gref(basechar)) end end elseif trace_bugs then -- logwarning("%s: char %s is missing in font",pref(kind,lookupname),gref(basechar)) onetimemessage(currentfont,basechar,"no base anchors",report_fonts) end elseif trace_bugs then logwarning("%s: prev node is no char",pref(kind,lookupname)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",pref(kind,lookupname),gref(markchar)) end return head, start, false end function handlers.gpos_mark2ligature(head,start,kind,lookupname,markanchors,sequence) -- check chainpos variant local markchar = getchar(start) if marks[markchar] then local base = getprev(start) -- [glyph] [optional marks] [start=mark] if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then local basechar = getchar(base) if marks[basechar] then while true do base = getprev(base) if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then basechar = getchar(base) if not marks[basechar] then break end else if trace_bugs then logwarning("%s: no base for mark %s",pref(kind,lookupname),gref(markchar)) end return head, start, false end end end local index = getligaindex(start) local baseanchors = descriptions[basechar] if baseanchors then baseanchors = baseanchors.anchors if baseanchors then local baseanchors = baseanchors['baselig'] if baseanchors then local al = anchorlookups[lookupname] for anchor, ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then ba = ba[index] if ba then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) -- index if trace_marks then logprocess("%s, anchor %s, index %s, bound %s: anchoring mark %s to baselig %s at index %s => (%p,%p)", pref(kind,lookupname),anchor,index,bound,gref(markchar),gref(basechar),index,dx,dy) end return head, start, true else if trace_bugs then logwarning("%s: no matching anchors for mark %s and baselig %s with index %a",pref(kind,lookupname),gref(markchar),gref(basechar),index) end end end end end if trace_bugs then logwarning("%s: no matching anchors for mark %s and baselig %s",pref(kind,lookupname),gref(markchar),gref(basechar)) end end end elseif trace_bugs then -- logwarning("%s: char %s is missing in font",pref(kind,lookupname),gref(basechar)) onetimemessage(currentfont,basechar,"no base anchors",report_fonts) end elseif trace_bugs then logwarning("%s: prev node is no char",pref(kind,lookupname)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",pref(kind,lookupname),gref(markchar)) end return head, start, false end function handlers.gpos_mark2mark(head,start,kind,lookupname,markanchors,sequence) local markchar = getchar(start) if marks[markchar] then local base = getprev(start) -- [glyph] [basemark] [start=mark] local slc = getligaindex(start) if slc then -- a rather messy loop ... needs checking with husayni while base do local blc = getligaindex(base) if blc and blc ~= slc then base = getprev(base) else break end end end if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then -- subtype test can go local basechar = getchar(base) local baseanchors = descriptions[basechar] if baseanchors then baseanchors = baseanchors.anchors if baseanchors then baseanchors = baseanchors['basemark'] if baseanchors then local al = anchorlookups[lookupname] for anchor,ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) if trace_marks then logprocess("%s, anchor %s, bound %s: anchoring mark %s to basemark %s => (%p,%p)", pref(kind,lookupname),anchor,bound,gref(markchar),gref(basechar),dx,dy) end return head, start, true end end end if trace_bugs then logwarning("%s: no matching anchors for mark %s and basemark %s",pref(kind,lookupname),gref(markchar),gref(basechar)) end end end elseif trace_bugs then -- logwarning("%s: char %s is missing in font",pref(kind,lookupname),gref(basechar)) onetimemessage(currentfont,basechar,"no base anchors",report_fonts) end elseif trace_bugs then logwarning("%s: prev node is no mark",pref(kind,lookupname)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",pref(kind,lookupname),gref(markchar)) end return head, start, false end function handlers.gpos_cursive(head,start,kind,lookupname,exitanchors,sequence) -- to be checked local alreadydone = cursonce and getprop(start,a_cursbase) if not alreadydone then local done = false local startchar = getchar(start) if marks[startchar] then if trace_cursive then logprocess("%s: ignoring cursive for mark %s",pref(kind,lookupname),gref(startchar)) end else local nxt = getnext(start) while not done and nxt and getid(nxt) == glyph_code and getfont(nxt) == currentfont and getsubtype(nxt)<256 do local nextchar = getchar(nxt) if marks[nextchar] then -- should not happen (maybe warning) nxt = getnext(nxt) else local entryanchors = descriptions[nextchar] if entryanchors then entryanchors = entryanchors.anchors if entryanchors then entryanchors = entryanchors['centry'] if entryanchors then local al = anchorlookups[lookupname] for anchor, entry in next, entryanchors do if al[anchor] then local exit = exitanchors[anchor] if exit then local dx, dy, bound = setcursive(start,nxt,tfmdata.parameters.factor,rlmode,exit,entry,characters[startchar],characters[nextchar]) if trace_cursive then logprocess("%s: moving %s to %s cursive (%p,%p) using anchor %s and bound %s in rlmode %s",pref(kind,lookupname),gref(startchar),gref(nextchar),dx,dy,anchor,bound,rlmode) end done = true break end end end end end elseif trace_bugs then -- logwarning("%s: char %s is missing in font",pref(kind,lookupname),gref(startchar)) onetimemessage(currentfont,startchar,"no entry anchors",report_fonts) end break end end end return head, start, done else if trace_cursive and trace_details then logprocess("%s, cursive %s is already done",pref(kind,lookupname),gref(getchar(start)),alreadydone) end return head, start, false end end function handlers.gpos_single(head,start,kind,lookupname,kerns,sequence,injection) local startchar = getchar(start) local dx, dy, w, h = setpair(start,tfmdata.parameters.factor,rlmode,sequence.flags[4],kerns,injection) -- ,characters[startchar]) if trace_kerns then logprocess("%s: shifting single %s by (%p,%p) and correction (%p,%p)",pref(kind,lookupname),gref(startchar),dx,dy,w,h) end return head, start, false end function handlers.gpos_pair(head,start,kind,lookupname,kerns,sequence,lookuphash,i,injection) -- todo: kerns in disc nodes: pre, post, replace -> loop over disc too -- todo: kerns in components of ligatures local snext = getnext(start) if not snext then return head, start, false else local prev, done = start, false local factor = tfmdata.parameters.factor local lookuptype = lookuptypes[lookupname] while snext and getid(snext) == glyph_code and getfont(snext) == currentfont and getsubtype(snext)<256 do local nextchar = getchar(snext) local krn = kerns[nextchar] if not krn and marks[nextchar] then prev = snext snext = getnext(snext) else if not krn then -- skip elseif type(krn) == "table" then if lookuptype == "pair" then -- probably not needed local a, b = krn[2], krn[3] if a and #a > 0 then local startchar = getchar(start) local x, y, w, h = setpair(start,factor,rlmode,sequence.flags[4],a,injection) -- characters[startchar]) if trace_kerns then logprocess("%s: shifting first of pair %s and %s by (%p,%p) and correction (%p,%p)",pref(kind,lookupname),gref(startchar),gref(nextchar),x,y,w,h) end end if b and #b > 0 then local startchar = getchar(start) local x, y, w, h = setpair(snext,factor,rlmode,sequence.flags[4],b,injection) -- characters[nextchar]) if trace_kerns then logprocess("%s: shifting second of pair %s and %s by (%p,%p) and correction (%p,%p)",pref(kind,lookupname),gref(startchar),gref(nextchar),x,y,w,h) end end else -- wrong ... position has different entries report_process("%s: check this out (old kern stuff)",pref(kind,lookupname)) -- local a, b = krn[2], krn[6] -- if a and a ~= 0 then -- local k = setkern(snext,factor,rlmode,a) -- if trace_kerns then -- logprocess("%s: inserting first kern %s between %s and %s",pref(kind,lookupname),k,gref(getchar(prev)),gref(nextchar)) -- end -- end -- if b and b ~= 0 then -- logwarning("%s: ignoring second kern xoff %s",pref(kind,lookupname),b*factor) -- end end done = true elseif krn ~= 0 then local k = setkern(snext,factor,rlmode,krn,injection) if trace_kerns then logprocess("%s: inserting kern %s between %s and %s",pref(kind,lookupname),k,gref(getchar(prev)),gref(nextchar)) end done = true end break end end return head, start, done end end --[[ldx--I will implement multiple chain replacements once I run into a font that uses it. It's not that complex to handle.
--ldx]]-- local chainmores = { } local chainprocs = { } local function logprocess(...) if trace_steps then registermessage(...) end report_subchain(...) end local logwarning = report_subchain local function logprocess(...) if trace_steps then registermessage(...) end report_chain(...) end local logwarning = report_chain -- We could share functions but that would lead to extra function calls with many -- arguments, redundant tests and confusing messages. function chainprocs.chainsub(head,start,stop,kind,chainname,currentcontext,lookuphash,lookuplist,chainlookupname) logwarning("%s: a direct call to chainsub cannot happen",cref(kind,chainname,chainlookupname)) return head, start, false end function chainmores.chainsub(head,start,stop,kind,chainname,currentcontext,lookuphash,lookuplist,chainlookupname,n) logprocess("%s: a direct call to chainsub cannot happen",cref(kind,chainname,chainlookupname)) return head, start, false end -- The reversesub is a special case, which is why we need to store the replacements -- in a bit weird way. There is no lookup and the replacement comes from the lookup -- itself. It is meant mostly for dealing with Urdu. function chainprocs.reversesub(head,start,stop,kind,chainname,currentcontext,lookuphash,replacements) local char = getchar(start) local replacement = replacements[char] if replacement then if trace_singles then logprocess("%s: single reverse replacement of %s by %s",cref(kind,chainname),gref(char),gref(replacement)) end resetinjection(start) setfield(start,"char",replacement) return head, start, true else return head, start, false end end --[[ldx--This chain stuff is somewhat tricky since we can have a sequence of actions to be applied: single, alternate, multiple or ligature where ligature can be an invalid one in the sense that it will replace multiple by one but not neccessary one that looks like the combination (i.e. it is the counterpart of multiple then). For example, the following is valid:
Therefore we we don't really do the replacement here already unless we have the single lookup case. The efficiency of the replacements can be improved by deleting as less as needed but that would also make the code even more messy.
--ldx]]-- -- local function delete_till_stop(head,start,stop,ignoremarks) -- keeps start -- local n = 1 -- if start == stop then -- -- done -- elseif ignoremarks then -- repeat -- start x x m x x stop => start m -- local next = getnext(start) -- if not marks[getchar(next)] then -- local components = getfield(next,"components") -- if components then -- probably not needed -- flush_node_list(components) -- end -- head = delete_node(head,next) -- end -- n = n + 1 -- until next == stop -- else -- start x x x stop => start -- repeat -- local next = getnext(start) -- local components = getfield(next,"components") -- if components then -- probably not needed -- flush_node_list(components) -- end -- head = delete_node(head,next) -- n = n + 1 -- until next == stop -- end -- return head, n -- end --[[ldx--Here we replace start by a single variant.
--ldx]]-- function chainprocs.gsub_single(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname,chainindex) -- todo: marks ? local current = start local subtables = currentlookup.subtables if #subtables > 1 then logwarning("todo: check if we need to loop over the replacements: % t",subtables) end while current do if getid(current) == glyph_code then local currentchar = getchar(current) local lookupname = subtables[1] -- only 1 local replacement = lookuphash[lookupname] if not replacement then if trace_bugs then logwarning("%s: no single hits",cref(kind,chainname,chainlookupname,lookupname,chainindex)) end else replacement = replacement[currentchar] if not replacement or replacement == "" then if trace_bugs then logwarning("%s: no single for %s",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(currentchar)) end else if trace_singles then logprocess("%s: replacing single %s by %s",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(currentchar),gref(replacement)) end resetinjection(current) if check_discretionaries then -- some fonts use a chain lookup to replace e.g. an f in a fi ligature -- and there can be a disc node in between ... the next code tries to catch -- this local next = getnext(current) local prev = getprev(current) -- todo: just remember it above local done = false if next then if getid(next) == disc_code then local subtype = getsubtype(next) if subtype == discretionary_code then setfield(next,"prev",prev) setfield(prev,"next",next) setfield(current,"prev",nil) setfield(current,"next",nil) local replace = getfield(next,"replace") local pre = getfield(next,"pre") local new = copy_node(current) setfield(new,"char",replacement) if replace then setfield(new,"next",replace) setfield(replace,"prev",new) end if pre then setfield(current,"next",pre) setfield(pre,"prev",current) end setfield(next,"replace",new) -- also updates tail setfield(next,"pre",current) -- also updates tail end start = next done = true local next = getnext(start) if next and getid(next) == disc_code then collapse_disc(start,next) end end end if not done and prev then if getid(prev) == disc_code then local subtype = getsubtype(prev) if subtype == discretionary_code then setfield(next,"prev",prev) setfield(prev,"next",next) setfield(current,"prev",nil) setfield(current,"next",nil) local replace = getfield(prev,"replace") local post = getfield(prev,"post") local new = copy_node(current) setfield(new,"char",replacement) if replace then local tail = find_node_tail(replace) setfield(tail,"next",new) setfield(new,"prev",tail) else replace = new end if post then local tail = find_node_tail(post) setfield(tail,"next",current) setfield(current,"prev",tail) else post = current end setfield(prev,"replace",replace) -- also updates tail setfield(prev,"post",post) -- also updates tail start = prev done = true end end end if not done then setfield(current,"char",replacement) end else setfield(current,"char",replacement) end end end return head, start, true elseif current == stop then break else current = getnext(current) end end return head, start, false end chainmores.gsub_single = chainprocs.gsub_single --[[ldx--Here we replace start by a sequence of new glyphs.
--ldx]]-- function chainprocs.gsub_multiple(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) -- local head, n = delete_till_stop(head,start,stop) local startchar = getchar(start) local subtables = currentlookup.subtables local lookupname = subtables[1] local replacements = lookuphash[lookupname] if not replacements then if trace_bugs then logwarning("%s: no multiple hits",cref(kind,chainname,chainlookupname,lookupname)) end else replacements = replacements[startchar] if not replacements or replacement == "" then if trace_bugs then logwarning("%s: no multiple for %s",cref(kind,chainname,chainlookupname,lookupname),gref(startchar)) end else if trace_multiples then logprocess("%s: replacing %s by multiple characters %s",cref(kind,chainname,chainlookupname,lookupname),gref(startchar),gref(replacements)) end return multiple_glyphs(head,start,replacements,currentlookup.flags[1]) end end return head, start, false end chainmores.gsub_multiple = chainprocs.gsub_multiple --[[ldx--Here we replace start by new glyph. First we delete the rest of the match.
--ldx]]-- -- char_1 mark_1 -> char_x mark_1 (ignore marks) -- char_1 mark_1 -> char_x -- to be checked: do we always have just one glyph? -- we can also have alternates for marks -- marks come last anyway -- are there cases where we need to delete the mark function chainprocs.gsub_alternate(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) local current = start local subtables = currentlookup.subtables local value = featurevalue == true and tfmdata.shared.features[kind] or featurevalue while current do if getid(current) == glyph_code then -- is this check needed? local currentchar = getchar(current) local lookupname = subtables[1] local alternatives = lookuphash[lookupname] if not alternatives then if trace_bugs then logwarning("%s: no alternative hit",cref(kind,chainname,chainlookupname,lookupname)) end else alternatives = alternatives[currentchar] if alternatives then local choice, comment = get_alternative_glyph(current,alternatives,value,trace_alternatives) if choice then if trace_alternatives then logprocess("%s: replacing %s by alternative %a to %s, %s",cref(kind,chainname,chainlookupname,lookupname),gref(char),choice,gref(choice),comment) end resetinjection(start) setfield(start,"char",choice) else if trace_alternatives then logwarning("%s: no variant %a for %s, %s",cref(kind,chainname,chainlookupname,lookupname),value,gref(char),comment) end end elseif trace_bugs then logwarning("%s: no alternative for %s, %s",cref(kind,chainname,chainlookupname,lookupname),gref(currentchar),comment) end end return head, start, true elseif current == stop then break else current = getnext(current) end end return head, start, false end chainmores.gsub_alternate = chainprocs.gsub_alternate --[[ldx--When we replace ligatures we use a helper that handles the marks. I might change this function (move code inline and handle the marks by a separate function). We assume rather stupid ligatures (no complex disc nodes).
--ldx]]-- function chainprocs.gsub_ligature(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname,chainindex) local startchar = getchar(start) local subtables = currentlookup.subtables local lookupname = subtables[1] local ligatures = lookuphash[lookupname] if not ligatures then if trace_bugs then logwarning("%s: no ligature hits",cref(kind,chainname,chainlookupname,lookupname,chainindex)) end else ligatures = ligatures[startchar] if not ligatures then if trace_bugs then logwarning("%s: no ligatures starting with %s",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(startchar)) end else local s = getnext(start) local discfound = false local last = stop local nofreplacements = 0 local skipmark = currentlookup.flags[1] while s do local id = getid(s) if id == disc_code then if not discfound then discfound = s end if s == stop then break -- okay? or before the disc else s = getnext(s) end else local schar = getchar(s) if skipmark and marks[schar] then -- marks -- if s == stop then -- maybe add this -- break -- else s = getnext(s) -- end else local lg = ligatures[schar] if lg then ligatures, last, nofreplacements = lg, s, nofreplacements + 1 if s == stop then break else s = getnext(s) end else break end end end end local l2 = ligatures.ligature if l2 then if chainindex then stop = last end if trace_ligatures then if start == stop then logprocess("%s: replacing character %s by ligature %s case 3",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(startchar),gref(l2)) else logprocess("%s: replacing character %s upto %s by ligature %s case 4",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(startchar),gref(getchar(stop)),gref(l2)) end end head, start = toligature(kind,lookupname,head,start,stop,l2,currentlookup.flags[1],discfound) return head, start, true, nofreplacements, discfound elseif trace_bugs then if start == stop then logwarning("%s: replacing character %s by ligature fails",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(startchar)) else logwarning("%s: replacing character %s upto %s by ligature fails",cref(kind,chainname,chainlookupname,lookupname,chainindex),gref(startchar),gref(getchar(stop))) end end end end return head, start, false, 0, false end chainmores.gsub_ligature = chainprocs.gsub_ligature function chainprocs.gpos_mark2base(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) local markchar = getchar(start) if marks[markchar] then local subtables = currentlookup.subtables local lookupname = subtables[1] local markanchors = lookuphash[lookupname] if markanchors then markanchors = markanchors[markchar] end if markanchors then local base = getprev(start) -- [glyph] [start=mark] if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then local basechar = getchar(base) if marks[basechar] then while true do base = getprev(base) if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then basechar = getchar(base) if not marks[basechar] then break end else if trace_bugs then logwarning("%s: no base for mark %s",pref(kind,lookupname),gref(markchar)) end return head, start, false end end end local baseanchors = descriptions[basechar].anchors if baseanchors then local baseanchors = baseanchors['basechar'] if baseanchors then local al = anchorlookups[lookupname] for anchor,ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) if trace_marks then logprocess("%s, anchor %s, bound %s: anchoring mark %s to basechar %s => (%p,%p)", cref(kind,chainname,chainlookupname,lookupname),anchor,bound,gref(markchar),gref(basechar),dx,dy) end return head, start, true end end end if trace_bugs then logwarning("%s, no matching anchors for mark %s and base %s",cref(kind,chainname,chainlookupname,lookupname),gref(markchar),gref(basechar)) end end end elseif trace_bugs then logwarning("%s: prev node is no char",cref(kind,chainname,chainlookupname,lookupname)) end elseif trace_bugs then logwarning("%s: mark %s has no anchors",cref(kind,chainname,chainlookupname,lookupname),gref(markchar)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",cref(kind,chainname,chainlookupname),gref(markchar)) end return head, start, false end function chainprocs.gpos_mark2ligature(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) local markchar = getchar(start) if marks[markchar] then local subtables = currentlookup.subtables local lookupname = subtables[1] local markanchors = lookuphash[lookupname] if markanchors then markanchors = markanchors[markchar] end if markanchors then local base = getprev(start) -- [glyph] [optional marks] [start=mark] if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then local basechar = getchar(base) if marks[basechar] then while true do base = getprev(base) if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then basechar = getchar(base) if not marks[basechar] then break end else if trace_bugs then logwarning("%s: no base for mark %s",cref(kind,chainname,chainlookupname,lookupname),markchar) end return head, start, false end end end -- todo: like marks a ligatures hash local index = getligaindex(start) local baseanchors = descriptions[basechar].anchors if baseanchors then local baseanchors = baseanchors['baselig'] if baseanchors then local al = anchorlookups[lookupname] for anchor,ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then ba = ba[index] if ba then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) if trace_marks then logprocess("%s, anchor %s, bound %s: anchoring mark %s to baselig %s at index %s => (%p,%p)", cref(kind,chainname,chainlookupname,lookupname),anchor,a or bound,gref(markchar),gref(basechar),index,dx,dy) end return head, start, true end end end end if trace_bugs then logwarning("%s: no matching anchors for mark %s and baselig %s",cref(kind,chainname,chainlookupname,lookupname),gref(markchar),gref(basechar)) end end end elseif trace_bugs then logwarning("feature %s, lookup %s: prev node is no char",kind,lookupname) end elseif trace_bugs then logwarning("%s: mark %s has no anchors",cref(kind,chainname,chainlookupname,lookupname),gref(markchar)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",cref(kind,chainname,chainlookupname),gref(markchar)) end return head, start, false end function chainprocs.gpos_mark2mark(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) local markchar = getchar(start) if marks[markchar] then -- local markanchors = descriptions[markchar].anchors markanchors = markanchors and markanchors.mark local subtables = currentlookup.subtables local lookupname = subtables[1] local markanchors = lookuphash[lookupname] if markanchors then markanchors = markanchors[markchar] end if markanchors then local base = getprev(start) -- [glyph] [basemark] [start=mark] local slc = getligaindex(start) if slc then -- a rather messy loop ... needs checking with husayni while base do local blc = getligaindex(base) if blc and blc ~= slc then base = getprev(base) else break end end end if base and getid(base) == glyph_code and getfont(base) == currentfont and getsubtype(base)<256 then -- subtype test can go local basechar = getchar(base) local baseanchors = descriptions[basechar].anchors if baseanchors then baseanchors = baseanchors['basemark'] if baseanchors then local al = anchorlookups[lookupname] for anchor,ba in next, baseanchors do if al[anchor] then local ma = markanchors[anchor] if ma then local dx, dy, bound = setmark(start,base,tfmdata.parameters.factor,rlmode,ba,ma,characters[basechar]) if trace_marks then logprocess("%s, anchor %s, bound %s: anchoring mark %s to basemark %s => (%p,%p)", cref(kind,chainname,chainlookupname,lookupname),anchor,bound,gref(markchar),gref(basechar),dx,dy) end return head, start, true end end end if trace_bugs then logwarning("%s: no matching anchors for mark %s and basemark %s",gref(kind,chainname,chainlookupname,lookupname),gref(markchar),gref(basechar)) end end end elseif trace_bugs then logwarning("%s: prev node is no mark",cref(kind,chainname,chainlookupname,lookupname)) end elseif trace_bugs then logwarning("%s: mark %s has no anchors",cref(kind,chainname,chainlookupname,lookupname),gref(markchar)) end elseif trace_bugs then logwarning("%s: mark %s is no mark",cref(kind,chainname,chainlookupname),gref(markchar)) end return head, start, false end function chainprocs.gpos_cursive(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname) local alreadydone = cursonce and getprop(start,a_cursbase) if not alreadydone then local startchar = getchar(start) local subtables = currentlookup.subtables local lookupname = subtables[1] local exitanchors = lookuphash[lookupname] if exitanchors then exitanchors = exitanchors[startchar] end if exitanchors then local done = false if marks[startchar] then if trace_cursive then logprocess("%s: ignoring cursive for mark %s",pref(kind,lookupname),gref(startchar)) end else local nxt = getnext(start) while not done and nxt and getid(nxt) == glyph_code and getfont(nxt) == currentfont and getsubtype(nxt)<256 do local nextchar = getchar(nxt) if marks[nextchar] then -- should not happen (maybe warning) nxt = getnext(nxt) else local entryanchors = descriptions[nextchar] if entryanchors then entryanchors = entryanchors.anchors if entryanchors then entryanchors = entryanchors['centry'] if entryanchors then local al = anchorlookups[lookupname] for anchor, entry in next, entryanchors do if al[anchor] then local exit = exitanchors[anchor] if exit then local dx, dy, bound = setcursive(start,nxt,tfmdata.parameters.factor,rlmode,exit,entry,characters[startchar],characters[nextchar]) if trace_cursive then logprocess("%s: moving %s to %s cursive (%p,%p) using anchor %s and bound %s in rlmode %s",pref(kind,lookupname),gref(startchar),gref(nextchar),dx,dy,anchor,bound,rlmode) end done = true break end end end end end elseif trace_bugs then -- logwarning("%s: char %s is missing in font",pref(kind,lookupname),gref(startchar)) onetimemessage(currentfont,startchar,"no entry anchors",report_fonts) end break end end end return head, start, done else if trace_cursive and trace_details then logprocess("%s, cursive %s is already done",pref(kind,lookupname),gref(getchar(start)),alreadydone) end return head, start, false end end return head, start, false end function chainprocs.gpos_single(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname,chainindex,sequence) -- untested .. needs checking for the new model local startchar = getchar(start) local subtables = currentlookup.subtables local lookupname = subtables[1] local kerns = lookuphash[lookupname] if kerns then kerns = kerns[startchar] -- needed ? if kerns then local dx, dy, w, h = setpair(start,tfmdata.parameters.factor,rlmode,sequence.flags[4],kerns) -- ,characters[startchar]) if trace_kerns then logprocess("%s: shifting single %s by (%p,%p) and correction (%p,%p)",cref(kind,chainname,chainlookupname),gref(startchar),dx,dy,w,h) end end end return head, start, false end chainmores.gpos_single = chainprocs.gpos_single -- okay? -- when machines become faster i will make a shared function function chainprocs.gpos_pair(head,start,stop,kind,chainname,currentcontext,lookuphash,currentlookup,chainlookupname,chainindex,sequence) local snext = getnext(start) if snext then local startchar = getchar(start) local subtables = currentlookup.subtables local lookupname = subtables[1] local kerns = lookuphash[lookupname] if kerns then kerns = kerns[startchar] if kerns then local lookuptype = lookuptypes[lookupname] local prev, done = start, false local factor = tfmdata.parameters.factor while snext and getid(snext) == glyph_code and getfont(snext) == currentfont and getsubtype(snext)<256 do local nextchar = getchar(snext) local krn = kerns[nextchar] if not krn and marks[nextchar] then prev = snext snext = getnext(snext) else if not krn then -- skip elseif type(krn) == "table" then if lookuptype == "pair" then local a, b = krn[2], krn[3] if a and #a > 0 then local startchar = getchar(start) local x, y, w, h = setpair(start,factor,rlmode,sequence.flags[4],a) -- ,characters[startchar]) if trace_kerns then logprocess("%s: shifting first of pair %s and %s by (%p,%p) and correction (%p,%p)",cref(kind,chainname,chainlookupname),gref(startchar),gref(nextchar),x,y,w,h) end end if b and #b > 0 then local startchar = getchar(start) local x, y, w, h = setpair(snext,factor,rlmode,sequence.flags[4],b) -- ,characters[nextchar]) if trace_kerns then logprocess("%s: shifting second of pair %s and %s by (%p,%p) and correction (%p,%p)",cref(kind,chainname,chainlookupname),gref(startchar),gref(nextchar),x,y,w,h) end end else report_process("%s: check this out (old kern stuff)",cref(kind,chainname,chainlookupname)) local a, b = krn[2], krn[6] if a and a ~= 0 then local k = setkern(snext,factor,rlmode,a) if trace_kerns then logprocess("%s: inserting first kern %s between %s and %s",cref(kind,chainname,chainlookupname),k,gref(getchar(prev)),gref(nextchar)) end end if b and b ~= 0 then logwarning("%s: ignoring second kern xoff %s",cref(kind,chainname,chainlookupname),b*factor) end end done = true elseif krn ~= 0 then local k = setkern(snext,factor,rlmode,krn) if trace_kerns then logprocess("%s: inserting kern %s between %s and %s",cref(kind,chainname,chainlookupname),k,gref(getchar(prev)),gref(nextchar)) end done = true end break end end return head, start, done end end end return head, start, false end chainmores.gpos_pair = chainprocs.gpos_pair -- okay? -- what pointer to return, spec says stop -- to be discussed ... is bidi changer a space? -- elseif char == zwnj and sequence[n][32] then -- brrr -- somehow l or f is global -- we don't need to pass the currentcontext, saves a bit -- make a slow variant then can be activated but with more tracing local function show_skip(kind,chainname,char,ck,class) if ck[9] then logwarning("%s: skipping char %s, class %a, rule %a, lookuptype %a, %a => %a",cref(kind,chainname),gref(char),class,ck[1],ck[2],ck[9],ck[10]) else logwarning("%s: skipping char %s, class %a, rule %a, lookuptype %a",cref(kind,chainname),gref(char),class,ck[1],ck[2]) end end local function normal_handle_contextchain(head,start,kind,chainname,contexts,sequence,lookuphash) -- local rule, lookuptype, sequence, f, l, lookups = ck[1], ck[2] ,ck[3], ck[4], ck[5], ck[6] local flags = sequence.flags local done = false local skipmark = flags[1] local skipligature = flags[2] local skipbase = flags[3] local someskip = skipmark or skipligature or skipbase -- could be stored in flags for a fast test (hm, flags could be false !) local markclass = sequence.markclass -- todo, first we need a proper test local skipped = false for k=1,#contexts do local match = true local current = start local last = start local ck = contexts[k] local seq = ck[3] local s = #seq -- f..l = mid string if s == 1 then -- never happens match = getid(current) == glyph_code and getfont(current) == currentfont and getsubtype(current)<256 and seq[1][getchar(current)] else -- maybe we need a better space check (maybe check for glue or category or combination) -- we cannot optimize for n=2 because there can be disc nodes local f, l = ck[4], ck[5] -- current match if f == 1 and f == l then -- current only -- already a hit -- match = true else -- before/current/after | before/current | current/after -- no need to test first hit (to be optimized) if f == l then -- new, else last out of sync (f is > 1) -- match = true else local n = f + 1 last = getnext(last) while n <= l do if last then local id = getid(last) if id == glyph_code then if getfont(last) == currentfont and getsubtype(last)<256 then local char = getchar(last) local ccd = descriptions[char] if ccd then local class = ccd.class if class == skipmark or class == skipligature or class == skipbase or (markclass and class == "mark" and not markclass[char]) then skipped = true if trace_skips then show_skip(kind,chainname,char,ck,class) end last = getnext(last) elseif seq[n][char] then if n < l then last = getnext(last) end n = n + 1 else match = false break end else match = false break end else match = false break end elseif id == disc_code then if check_discretionaries then local replace = getfield(last,"replace") if replace then -- so far we never entered this branch while replace do if seq[n][getchar(replace)] then n = n + 1 replace = getnext(replace) if not replace then break elseif n > l then -- match = false break end else match = false break end end if not match then break elseif check_discretionaries == "trace" then report_chain("check disc action in current") end else last = getnext(last) -- no skipping here end else last = getnext(last) -- no skipping here end else match = false break end else match = false break end end end end -- before if match and f > 1 then local prev = getprev(start) if prev then local n = f-1 while n >= 1 do if prev then local id = getid(prev) if id == glyph_code then if getfont(prev) == currentfont and getsubtype(prev)<256 then -- normal char local char = getchar(prev) local ccd = descriptions[char] if ccd then local class = ccd.class if class == skipmark or class == skipligature or class == skipbase or (markclass and class == "mark" and not markclass[char]) then skipped = true if trace_skips then show_skip(kind,chainname,char,ck,class) end elseif seq[n][char] then n = n -1 else match = false break end else match = false break end else match = false break end elseif id == disc_code then -- the special case: f i where i becomes dottless i .. if check_discretionaries then local replace = getfield(prev,"replace") if replace then -- we seldom enter this branch (e.g. on brill efficient) replace = find_node_tail(replace) local finish = getprev(replace) while replace do if seq[n][getchar(replace)] then n = n - 1 replace = getprev(replace) if not replace or replace == finish then break elseif n < 1 then -- match = false break end else match = false break end end if not match then break elseif check_discretionaries == "trace" then report_chain("check disc action in before") end else -- skip 'm end else -- skip 'm end elseif seq[n][32] then n = n -1 else match = false break end prev = getprev(prev) elseif seq[n][32] then -- somewhat special, as zapfino can have many preceding spaces n = n - 1 else match = false break end end else match = false end end -- after if match and s > l then local current = last and getnext(last) if current then -- removed optimization for s-l == 1, we have to deal with marks anyway local n = l + 1 while n <= s do if current then local id = getid(current) if id == glyph_code then if getfont(current) == currentfont and getsubtype(current)<256 then -- normal char local char = getchar(current) local ccd = descriptions[char] if ccd then local class = ccd.class if class == skipmark or class == skipligature or class == skipbase or (markclass and class == "mark" and not markclass[char]) then skipped = true if trace_skips then show_skip(kind,chainname,char,ck,class) end elseif seq[n][char] then n = n + 1 else match = false break end else match = false break end else match = false break end elseif id == disc_code then if check_discretionaries then local replace = getfield(current,"replace") if replace then -- so far we never entered this branch while replace do if seq[n][getchar(replace)] then n = n + 1 replace = getnext(replace) if not replace then break elseif n > s then break end else match = false break end end if not match then break elseif check_discretionaries == "trace" then report_chain("check disc action in after") end else -- skip 'm end else -- skip 'm end elseif seq[n][32] then -- brrr n = n + 1 else match = false break end current = getnext(current) elseif seq[n][32] then n = n + 1 else match = false break end end else match = false end end end if match then -- ck == currentcontext if trace_contexts then local rule, lookuptype, f, l = ck[1], ck[2], ck[4], ck[5] local char = getchar(start) if ck[9] then logwarning("%s: rule %s matches at char %s for (%s,%s,%s) chars, lookuptype %a, %a => %a", cref(kind,chainname),rule,gref(char),f-1,l-f+1,s-l,lookuptype,ck[9],ck[10]) else logwarning("%s: rule %s matches at char %s for (%s,%s,%s) chars, lookuptype %a", cref(kind,chainname),rule,gref(char),f-1,l-f+1,s-l,lookuptype) end end local chainlookups = ck[6] if chainlookups then local nofchainlookups = #chainlookups -- we can speed this up if needed if nofchainlookups == 1 then local chainlookupname = chainlookups[1] local chainlookup = lookuptable[chainlookupname] if chainlookup then local cp = chainprocs[chainlookup.type] if cp then local ok head, start, ok = cp(head,start,last,kind,chainname,ck,lookuphash,chainlookup,chainlookupname,nil,sequence) if ok then done = true end else logprocess("%s: %s is not yet supported",cref(kind,chainname,chainlookupname),chainlookup.type) end else -- shouldn't happen logprocess("%s is not yet supported",cref(kind,chainname,chainlookupname)) end else local i = 1 while true do if skipped then while true do local char = getchar(start) local ccd = descriptions[char] if ccd then local class = ccd.class if class == skipmark or class == skipligature or class == skipbase or (markclass and class == "mark" and not markclass[char]) then start = getnext(start) else break end else break end end end local chainlookupname = chainlookups[i] local chainlookup = lookuptable[chainlookupname] if not chainlookup then -- okay, n matches, < n replacements i = i + 1 else local cp = chainmores[chainlookup.type] if not cp then -- actually an error logprocess("%s: %s is not yet supported",cref(kind,chainname,chainlookupname),chainlookup.type) i = i + 1 else local ok, n head, start, ok, n = cp(head,start,last,kind,chainname,ck,lookuphash,chainlookup,chainlookupname,i,sequence) -- messy since last can be changed ! if ok then done = true -- skip next one(s) if ligature i = i + (n or 1) else i = i + 1 end end end if i > nofchainlookups then break elseif start then start = getnext(start) else -- weird end end end else local replacements = ck[7] if replacements then head, start, done = chainprocs.reversesub(head,start,last,kind,chainname,ck,lookuphash,replacements) -- sequence else done = quit_on_no_replacement -- can be meant to be skipped / quite inconsistent in fonts if trace_contexts then logprocess("%s: skipping match",cref(kind,chainname)) end end end end end return head, start, done end -- Because we want to keep this elsewhere (an because speed is less an issue) we -- pass the font id so that the verbose variant can access the relevant helper tables. local verbose_handle_contextchain = function(font,...) logwarning("no verbose handler installed, reverting to 'normal'") otf.setcontextchain() return normal_handle_contextchain(...) end otf.chainhandlers = { normal = normal_handle_contextchain, verbose = verbose_handle_contextchain, } function otf.setcontextchain(method) if not method or method == "normal" or not otf.chainhandlers[method] then if handlers.contextchain then -- no need for a message while making the format logwarning("installing normal contextchain handler") end handlers.contextchain = normal_handle_contextchain else logwarning("installing contextchain handler %a",method) local handler = otf.chainhandlers[method] handlers.contextchain = function(...) return handler(currentfont,...) -- hm, get rid of ... end end handlers.gsub_context = handlers.contextchain handlers.gsub_contextchain = handlers.contextchain handlers.gsub_reversecontextchain = handlers.contextchain handlers.gpos_contextchain = handlers.contextchain handlers.gpos_context = handlers.contextchain end otf.setcontextchain() local missing = { } -- we only report once local function logprocess(...) if trace_steps then registermessage(...) end report_process(...) end local logwarning = report_process local function report_missing_cache(typ,lookup) local f = missing[currentfont] if not f then f = { } missing[currentfont] = f end local t = f[typ] if not t then t = { } f[typ] = t end if not t[lookup] then t[lookup] = true logwarning("missing cache for lookup %a, type %a, font %a, name %a",lookup,typ,currentfont,tfmdata.properties.fullname) end end local resolved = { } -- we only resolve a font,script,language pair once -- todo: pass all these 'locals' in a table local lookuphashes = { } setmetatableindex(lookuphashes, function(t,font) local lookuphash = fontdata[font].resources.lookuphash if not lookuphash or not next(lookuphash) then lookuphash = false end t[font] = lookuphash return lookuphash end) -- fonts.hashes.lookups = lookuphashes local autofeatures = fonts.analyzers.features -- was: constants local function initialize(sequence,script,language,enabled) local features = sequence.features if features then local order = sequence.order if order then for i=1,#order do -- local kind = order[i] -- local valid = enabled[kind] if valid then local scripts = features[kind] -- local languages = scripts[script] or scripts[wildcard] if languages and (languages[language] or languages[wildcard]) then return { valid, autofeatures[kind] or false, sequence.chain or 0, kind, sequence } end end end else -- can't happen end end return false end function otf.dataset(tfmdata,font) -- generic variant, overloaded in context local shared = tfmdata.shared local properties = tfmdata.properties local language = properties.language or "dflt" local script = properties.script or "dflt" local enabled = shared.features local res = resolved[font] if not res then res = { } resolved[font] = res end local rs = res[script] if not rs then rs = { } res[script] = rs end local rl = rs[language] if not rl then rl = { -- indexed but we can also add specific data by key } rs[language] = rl local sequences = tfmdata.resources.sequences for s=1,#sequences do local v = enabled and initialize(sequences[s],script,language,enabled) if v then rl[#rl+1] = v end end end return rl end -- elseif id == glue_code then -- if p[5] then -- chain -- local pc = pp[32] -- if pc then -- start, ok = start, false -- p[1](start,kind,p[2],pc,p[3],p[4]) -- if ok then -- done = true -- end -- if start then start = getnext(start) end -- else -- start = getnext(start) -- end -- else -- start = getnext(start) -- end -- there will be a new direction parser (pre-parsed etc) -- less bytecode: 290 -> 254 -- -- attr = attr or false -- -- local a = getattr(start,0) -- if (a == attr and (not attribute or getprop(start,a_state) == attribute)) or (not attribute or getprop(start,a_state) == attribute) then -- -- the action -- end -- assumptions: -- -- * languages that use complex disc nodes -- optimization comes later ... local function kernrun(disc,run) -- we can assume that prev and next are glyphs if trace_kernruns then report_run("kern") -- will be more detailed end -- local prev = getprev(disc) -- todo, keep these in the main loop local next = getnext(disc) -- todo, keep these in the main loop -- local pre = getfield(disc,"pre") if not pre then -- go on elseif prev then local nest = getprev(pre) setfield(pre,"prev",prev) setfield(prev,"next",pre) run(prev,"preinjections") setfield(pre,"prev",nest) setfield(prev,"next",disc) else run(pre,"preinjections") end -- local post = getfield(disc,"post") if not post then -- go on elseif next then local tail = find_node_tail(post) setfield(tail,"next",next) setfield(next,"prev",tail) run(post,"postinjections",tail) setfield(tail,"next",nil) setfield(next,"prev",disc) else run(post,"postinjections") end -- local replace = getfield(disc,"replace") if not replace then -- this should be already done by discfound elseif prev and next then local tail = find_node_tail(replace) local nest = getprev(replace) setfield(replace,"prev",prev) setfield(prev,"next",replace) setfield(tail,"next",next) setfield(next,"prev",tail) run(prev,"replaceinjections",tail) setfield(replace,"prev",nest) setfield(prev,"next",disc) setfield(tail,"next",nil) setfield(next,"prev",disc) elseif prev then local nest = getprev(replace) setfield(replace,"prev",prev) setfield(prev,"next",replace) run(prev,"replaceinjections") setfield(replace,"prev",nest) setfield(prev,"next",disc) elseif next then local tail = find_node_tail(replace) setfield(tail,"next",next) setfield(next,"prev",tail) run(replace,"replaceinjections",tail) setfield(tail,"next",nil) setfield(next,"prev",disc) else run(replace,"replaceinjections") end end -- the if new test might be dangerous as luatex will check / set some tail stuff -- in a temp node local function comprun(disc,run) if trace_compruns then report_run("comp: %s",languages.serializediscretionary(disc)) end -- local pre = getfield(disc,"pre") if pre then local new, done = run(pre) if done then setfield(disc,"pre",new) end end -- local post = getfield(disc,"post") if post then local new, done = run(post) if done then setfield(disc,"post",new) end end -- local replace = getfield(disc,"replace") if replace then local new, done = run(replace) if done then setfield(disc,"replace",new) end end end local function testrun(disc,trun,crun) local next = getnext(disc) if next then local replace = getfield(disc,"replace") if replace then local prev = getprev(disc) if prev then -- only look ahead local tail = find_node_tail(replace) -- local nest = getprev(replace) setfield(tail,"next",next) setfield(next,"prev",tail) if trun(replace,next) then setfield(disc,"replace",nil) -- beware, side effects of nest so first setfield(prev,"next",replace) setfield(replace,"prev",prev) setfield(next,"prev",tail) setfield(tail,"next",next) setfield(disc,"prev",nil) setfield(disc,"next",nil) flush_node_list(disc) return replace -- restart else setfield(tail,"next",nil) setfield(next,"prev",disc) end else -- weird case end else -- no need end else -- weird case end comprun(disc,crun) return next end local function discrun(disc,drun,krun) local next = getnext(disc) local prev = getprev(disc) if trace_discruns then report_run("disc") -- will be more detailed end if next and prev then setfield(prev,"next",next) -- setfield(next,"prev",prev) drun(prev) setfield(prev,"next",disc) -- setfield(next,"prev",disc) end -- local pre = getfield(disc,"pre") if not pre then -- go on elseif prev then local nest = getprev(pre) setfield(pre,"prev",prev) setfield(prev,"next",pre) krun(prev,"preinjections") setfield(pre,"prev",nest) setfield(prev,"next",disc) else krun(pre,"preinjections") end return next end -- todo: maybe run lr and rl stretches local function featuresprocessor(head,font,attr) local lookuphash = lookuphashes[font] -- we can also check sequences here if not lookuphash then return head, false end head = tonut(head) if trace_steps then checkstep(head) end tfmdata = fontdata[font] descriptions = tfmdata.descriptions characters = tfmdata.characters resources = tfmdata.resources marks = resources.marks anchorlookups = resources.lookup_to_anchor lookuptable = resources.lookups lookuptypes = resources.lookuptypes lookuptags = resources.lookuptags currentfont = font rlmode = 0 local sequences = resources.sequences local done = false local datasets = otf.dataset(tfmdata,font,attr) local dirstack = { } -- could move outside function -- We could work on sub start-stop ranges instead but I wonder if there is that -- much speed gain (experiments showed that it made not much sense) and we need -- to keep track of directions anyway. Also at some point I want to play with -- font interactions and then we do need the full sweeps. -- Keeping track of the headnode is needed for devanagari (I generalized it a bit -- so that multiple cases are also covered.) -- todo: retain prev -- We don't goto the next node of a disc node is created so that we can then treat -- the pre, post and replace. It's abit of a hack but works out ok for most cases. -- there can be less subtype and attr checking in the comprun etc helpers for s=1,#datasets do local dataset = datasets[s] featurevalue = dataset[1] -- todo: pass to function instead of using a global local attribute = dataset[2] local chain = dataset[3] -- sequence.chain or 0 local kind = dataset[4] local sequence = dataset[5] -- sequences[s] -- also dataset[5] local rlparmode = 0 local topstack = 0 local success = false local typ = sequence.type local gpossing = typ == "gpos_single" or typ == "gpos_pair" local subtables = sequence.subtables local handler = handlers[typ] if chain < 0 then -- this is a limited case, no special treatments like 'init' etc -- we need to get rid of this slide! probably no longer needed in latest luatex local start = find_node_tail(head) -- slow (we can store tail because there's always a skip at the end): todo while start do local id = getid(start) if id == glyph_code then if getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = a == attr else a = true end if a then local char = getchar(start) for i=1,#subtables do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then -- local lookupmatch = lookupcache[getchar(start)] local lookupmatch = lookupcache[start] if lookupmatch then -- todo: disc? head, start, success = handler(head,start,kind,lookupname,lookupmatch,sequence,lookuphash,i) if success then break end end else report_missing_cache(typ,lookupname) end end if start then start = getprev(start) end else start = getprev(start) end else start = getprev(start) end else start = getprev(start) end end else local ns = #subtables local start = head -- local ? rlmode = 0 -- to be checked ? if ns == 1 then -- happens often local lookupname = subtables[1] local lookupcache = lookuphash[lookupname] if not lookupcache then -- also check for empty cache report_missing_cache(typ,lookupname) else local function c_run(start) -- no need to check for 256 and attr probably also the same local head = start local done = false while start do local id = getid(start) if id ~= glyph_code then -- very unlikely start = getnext(start) elseif getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then local lookupmatch = lookupcache[getchar(start)] if lookupmatch then -- sequence kan weg local ok head, start, ok = handler(head,start,kind,lookupname,lookupmatch,sequence,lookuphash,1) if ok then done = true end end if start then start = getnext(start) end else start = getnext(start) end else return head, false end end if done then success = true -- needed in this subrun? end return head, done end local function t_run(start,stop) while start ~= stop do local id = getid(start) if id == glyph_code and getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then local lookupmatch = lookupcache[getchar(start)] if lookupmatch then -- hm, hyphens can match (tlig) so we need to really check -- if we need more than ligatures we can outline the code and use functions local s = getnext(start) local l = nil while s do local lg = lookupmatch[getchar(s)] if lg then l = lg s = getnext(s) else break end end if l and l.ligature then return true end end end start = getnext(start) else break end end end local function d_run(prev) -- we can assume that prev and next are glyphs local a = getattr(prev,0) if a then a = (a == attr) and (not attribute or getprop(prev,a_state) == attribute) else a = not attribute or getprop(prev,a_state) == attribute end if a then local lookupmatch = lookupcache[getchar(prev)] if lookupmatch then -- sequence kan weg local h, d, ok = handler(head,prev,kind,lookupname,lookupmatch,sequence,lookuphash,1) if ok then done = true success = true end end end end local function k_run(sub,injection,last) local a = getattr(sub,0) if a then a = (a == attr) and (not attribute or getprop(sub,a_state) == attribute) else a = not attribute or getprop(sub,a_state) == attribute end if a then -- sequence kan weg for n in traverse_nodes(sub) do -- only gpos if n == last then break end local id = getid(n) if id == glyph_code then local lookupmatch = lookupcache[getchar(n)] if lookupmatch then local h, d, ok = handler(sub,n,kind,lookupname,lookupmatch,sequence,lookuphash,1,injection) if ok then done = true success = true end end else -- message end end end end while start do local id = getid(start) if id == glyph_code then if getfont(start) == font and getsubtype(start) < 256 then -- why a 256 test ... local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then local char = getchar(start) local lookupmatch = lookupcache[char] if lookupmatch then -- sequence kan weg local ok head, start, ok = handler(head,start,kind,lookupname,lookupmatch,sequence,lookuphash,1) if ok then success = true elseif gpossing and zwnjruns and char == zwnj then discrun(start,d_run) end elseif gpossing and zwnjruns and char == zwnj then discrun(start,d_run) end if start then start = getnext(start) end else start = getnext(start) end else start = getnext(start) end elseif id == disc_code then local discretionary = getsubtype(start) == discretionary_code if gpossing then if discretionary then kernrun(start,k_run) else discrun(start,d_run,k_run) end start = getnext(start) elseif discretionary then if typ == "gsub_ligature" then start = testrun(start,t_run,c_run) else comprun(start,c_run) start = getnext(start) end else start = getnext(start) end elseif id == whatsit_code then -- will be function local subtype = getsubtype(start) if subtype == dir_code then local dir = getfield(start,"dir") if dir == "+TRT" or dir == "+TLT" then topstack = topstack + 1 dirstack[topstack] = dir elseif dir == "-TRT" or dir == "-TLT" then topstack = topstack - 1 end local newdir = dirstack[topstack] if newdir == "+TRT" then rlmode = -1 elseif newdir == "+TLT" then rlmode = 1 else rlmode = rlparmode end if trace_directions then report_process("directions after txtdir %a: parmode %a, txtmode %a, # stack %a, new dir %a",dir,rlparmode,rlmode,topstack,newdir) end elseif subtype == localpar_code then local dir = getfield(start,"dir") if dir == "TRT" then rlparmode = -1 elseif dir == "TLT" then rlparmode = 1 else rlparmode = 0 end -- one might wonder if the par dir should be looked at, so we might as well drop the next line rlmode = rlparmode if trace_directions then report_process("directions after pardir %a: parmode %a, txtmode %a",dir,rlparmode,rlmode) end end start = getnext(start) elseif id == math_code then start = getnext(end_of_math(start)) else start = getnext(start) end end end else local function c_run(start) local head = start local done = false while start do local id = getid(start) if id ~= glyph_code then -- very unlikely start = getnext(start) elseif getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then local char = getchar(start) for i=1,ns do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then -- local lookupmatch = lookupcache[getchar(start)] local lookupmatch = lookupcache[char] if lookupmatch then -- we could move all code inline but that makes things even more unreadable local ok head, start, ok = handler(head,start,kind,lookupname,lookupmatch,sequence,lookuphash,i) if ok then done = true break elseif not start then -- don't ask why ... shouldn't happen break end end else report_missing_cache(typ,lookupname) end end if start then start = getnext(start) end else start = getnext(start) end else return head, false end end if done then success = true end return head, done end local function d_run(prev) local a = getattr(prev,0) if a then a = (a == attr) and (not attribute or getprop(prev,a_state) == attribute) else a = not attribute or getprop(prev,a_state) == attribute end if a then -- brr prev can be disc local char = getchar(prev) for i=1,ns do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then local lookupmatch = lookupcache[char] if lookupmatch then -- we could move all code inline but that makes things even more unreadable local h, d, ok = handler(head,prev,kind,lookupname,lookupmatch,sequence,lookuphash,i) if ok then done = true break end end else report_missing_cache(typ,lookupname) end end end end local function k_run(sub,injection,last) local a = getattr(sub,0) if a then a = (a == attr) and (not attribute or getprop(sub,a_state) == attribute) else a = not attribute or getprop(sub,a_state) == attribute end if a then for n in traverse_nodes(sub) do -- only gpos if n == last then break end local id = getid(n) if id == glyph_code then local char = getchar(n) for i=1,ns do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then local lookupmatch = lookupcache[char] if lookupmatch then local h, d, ok = handler(head,n,kind,lookupname,lookupmatch,sequence,lookuphash,i,injection) if ok then done = true break end end else report_missing_cache(typ,lookupname) end end else -- message end end end end local function t_run(start,stop) while start ~= stop do local id = getid(start) if id == glyph_code and getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then local char = getchar(start) for i=1,ns do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then local lookupmatch = lookupcache[char] if lookupmatch then -- if we need more than ligatures we can outline the code and use functions local s = getnext(start) local l = nil while s do local lg = lookupmatch[getchar(s)] if lg then l = lg s = getnext(s) else break end end if l and l.ligature then return true end end else report_missing_cache(typ,lookupname) end end end start = getnext(start) else break end end end while start do local id = getid(start) if id == glyph_code then if getfont(start) == font and getsubtype(start) < 256 then local a = getattr(start,0) if a then a = (a == attr) and (not attribute or getprop(start,a_state) == attribute) else a = not attribute or getprop(start,a_state) == attribute end if a then for i=1,ns do local lookupname = subtables[i] local lookupcache = lookuphash[lookupname] if lookupcache then local char = getchar(start) local lookupmatch = lookupcache[char] if lookupmatch then -- we could move all code inline but that makes things even more unreadable local ok head, start, ok = handler(head,start,kind,lookupname,lookupmatch,sequence,lookuphash,i) if ok then success = true break elseif not start then -- don't ask why ... shouldn't happen break elseif gpossing and zwnjruns and char == zwnj then discrun(start,d_run) end elseif gpossing and zwnjruns and char == zwnj then discrun(start,d_run) end else report_missing_cache(typ,lookupname) end end if start then start = getnext(start) end else start = getnext(start) end else start = getnext(start) end elseif id == disc_code then local discretionary = getsubtype(start) == discretionary_code if gpossing then if discretionary then kernrun(start,k_run) else discrun(start,d_run,k_run) end start = getnext(start) elseif discretionary then if typ == "gsub_ligature" then start = testrun(start,t_run,c_run) else comprun(start,c_run) start = getnext(start) end else start = getnext(start) end elseif id == whatsit_code then local subtype = getsubtype(start) if subtype == dir_code then local dir = getfield(start,"dir") if dir == "+TRT" or dir == "+TLT" then topstack = topstack + 1 dirstack[topstack] = dir elseif dir == "-TRT" or dir == "-TLT" then topstack = topstack - 1 end local newdir = dirstack[topstack] if newdir == "+TRT" then rlmode = -1 elseif newdir == "+TLT" then rlmode = 1 else rlmode = rlparmode end if trace_directions then report_process("directions after txtdir %a: parmode %a, txtmode %a, # stack %a, new dir %a",dir,rlparmode,rlmode,topstack,newdir) end elseif subtype == localpar_code then local dir = getfield(start,"dir") if dir == "TRT" then rlparmode = -1 elseif dir == "TLT" then rlparmode = 1 else rlparmode = 0 end rlmode = rlparmode if trace_directions then report_process("directions after pardir %a: parmode %a, txtmode %a",dir,rlparmode,rlmode) end end start = getnext(start) elseif id == math_code then start = getnext(end_of_math(start)) else start = getnext(start) end end end end if success then done = true end if trace_steps then -- ? registerstep(head) end end head = tonode(head) return head, done end local function generic(lookupdata,lookupname,unicode,lookuphash) local target = lookuphash[lookupname] if target then target[unicode] = lookupdata else lookuphash[lookupname] = { [unicode] = lookupdata } end end local action = { substitution = generic, multiple = generic, alternate = generic, position = generic, ligature = function(lookupdata,lookupname,unicode,lookuphash) local target = lookuphash[lookupname] if not target then target = { } lookuphash[lookupname] = target end for i=1,#lookupdata do local li = lookupdata[i] local tu = target[li] if not tu then tu = { } target[li] = tu end target = tu end target.ligature = unicode end, pair = function(lookupdata,lookupname,unicode,lookuphash) local target = lookuphash[lookupname] if not target then target = { } lookuphash[lookupname] = target end local others = target[unicode] local paired = lookupdata[1] if others then others[paired] = lookupdata else others = { [paired] = lookupdata } target[unicode] = others end end, } local function prepare_lookups(tfmdata) local rawdata = tfmdata.shared.rawdata local resources = rawdata.resources local lookuphash = resources.lookuphash local anchor_to_lookup = resources.anchor_to_lookup local lookup_to_anchor = resources.lookup_to_anchor local lookuptypes = resources.lookuptypes local characters = tfmdata.characters local descriptions = tfmdata.descriptions -- we cannot free the entries in the descriptions as sometimes we access -- then directly (for instance anchors) ... selectively freeing does save -- much memory as it's only a reference to a table and the slot in the -- description hash is not freed anyway for unicode, character in next, characters do -- we cannot loop over descriptions ! local description = descriptions[unicode] if description then local lookups = description.slookups if lookups then for lookupname, lookupdata in next, lookups do action[lookuptypes[lookupname]](lookupdata,lookupname,unicode,lookuphash) end end local lookups = description.mlookups if lookups then for lookupname, lookuplist in next, lookups do local lookuptype = lookuptypes[lookupname] for l=1,#lookuplist do local lookupdata = lookuplist[l] action[lookuptype](lookupdata,lookupname,unicode,lookuphash) end end end local list = description.kerns if list then for lookup, krn in next, list do -- ref to glyph, saves lookup local target = lookuphash[lookup] if target then target[unicode] = krn else lookuphash[lookup] = { [unicode] = krn } end end end local list = description.anchors if list then for typ, anchors in next, list do -- types if typ == "mark" or typ == "cexit" then -- or entry? for name, anchor in next, anchors do local lookups = anchor_to_lookup[name] if lookups then for lookup, _ in next, lookups do local target = lookuphash[lookup] if target then target[unicode] = anchors else lookuphash[lookup] = { [unicode] = anchors } end end end end end end end end end end local function split(replacement,original) local result = { } for i=1,#replacement do result[original[i]] = replacement[i] end return result end local valid = { coverage = { chainsub = true, chainpos = true, contextsub = true }, reversecoverage = { reversesub = true }, glyphs = { chainsub = true, chainpos = true }, } local function prepare_contextchains(tfmdata) local rawdata = tfmdata.shared.rawdata local resources = rawdata.resources local lookuphash = resources.lookuphash local lookuptags = resources.lookuptags local lookups = rawdata.lookups if lookups then for lookupname, lookupdata in next, rawdata.lookups do local lookuptype = lookupdata.type if lookuptype then local rules = lookupdata.rules if rules then local format = lookupdata.format local validformat = valid[format] if not validformat then report_prepare("unsupported format %a",format) elseif not validformat[lookuptype] then -- todo: dejavu-serif has one (but i need to see what use it has) report_prepare("unsupported format %a, lookuptype %a, lookupname %a",format,lookuptype,lookuptags[lookupname]) else local contexts = lookuphash[lookupname] if not contexts then contexts = { } lookuphash[lookupname] = contexts end local t, nt = { }, 0 for nofrules=1,#rules do local rule = rules[nofrules] local current = rule.current local before = rule.before local after = rule.after local replacements = rule.replacements local sequence = { } local nofsequences = 0 -- Eventually we can store start, stop and sequence in the cached file -- but then less sharing takes place so best not do that without a lot -- of profiling so let's forget about it. if before then for n=1,#before do nofsequences = nofsequences + 1 sequence[nofsequences] = before[n] end end local start = nofsequences + 1 for n=1,#current do nofsequences = nofsequences + 1 sequence[nofsequences] = current[n] end local stop = nofsequences if after then for n=1,#after do nofsequences = nofsequences + 1 sequence[nofsequences] = after[n] end end if sequence[1] then -- Replacements only happen with reverse lookups as they are single only. We -- could pack them into current (replacement value instead of true) and then -- use sequence[start] instead but it's somewhat ugly. nt = nt + 1 t[nt] = { nofrules, lookuptype, sequence, start, stop, rule.lookups, replacements } for unic, _ in next, sequence[start] do local cu = contexts[unic] if not cu then contexts[unic] = t end end end end end else -- no rules end else report_prepare("missing lookuptype for lookupname %a",lookuptags[lookupname]) end end end end -- we can consider lookuphash == false (initialized but empty) vs lookuphash == table local function featuresinitializer(tfmdata,value) if true then -- value then -- beware we need to use the topmost properties table local rawdata = tfmdata.shared.rawdata local properties = rawdata.properties if not properties.initialized then local starttime = trace_preparing and os.clock() local resources = rawdata.resources resources.lookuphash = resources.lookuphash or { } prepare_contextchains(tfmdata) prepare_lookups(tfmdata) properties.initialized = true if trace_preparing then report_prepare("preparation time is %0.3f seconds for %a",os.clock()-starttime,tfmdata.properties.fullname) end end end end registerotffeature { name = "features", description = "features", default = true, initializers = { position = 1, node = featuresinitializer, }, processors = { node = featuresprocessor, } } -- This can be used for extra handlers, but should be used with care! otf.handlers = handlers