ConTeXT 2012.05.23 10:30 and a patch for texmfcnf in ConTeXt MKIV

git-svn-id: svn://tug.org/texlive/trunk@26593 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 1 insertions, 167 deletions

diff --git a/Master/texmf-dist/tex/generic/context/luatex/luatex-fonts-merged.lua b/Master/texmf-dist/tex/generic/context/luatex/luatex-fonts-merged.lua
index 47863dd99af..94c92644085 100644
--- a/Master/texmf-dist/tex/generic/context/luatex/luatex-fonts-merged.lua
+++ b/Master/texmf-dist/tex/generic/context/luatex/luatex-fonts-merged.lua
@@ -1,6 +1,6 @@
 -- merged file : luatex-fonts-merged.lua
 -- parent file : luatex-fonts.lua
--- merge date  : 05/22/12 16:12:31
+-- merge date  : 05/23/12 10:30:18
 
 do -- begin closure to overcome local limits and interference
 
@@ -11000,172 +11000,6 @@ local function split(replacement,original)
     return result
 end
 
--- not shared as we hook into lookups now
-
---~ local function uncover_1(covers,result) -- multiple covers
---~     local nofresults = #result
---~     for n=1,#covers do
---~         nofresults = nofresults + 1
---~         local u = { }
---~         local c = covers[n]
---~         for i=1,#c do
---~             u[c[i]] = true
---~         end
---~         result[nofresults] = u
---~     end
---~ end
-
---~ local function uncover_2(covers,result) -- single covers (turned into multiple with n=1)
---~     local nofresults = #result
---~     for n=1,#covers do
---~         nofresults = nofresults + 1
---~         result[nofresults] = { [covers[n]] = true }
---~     end
---~ end
-
---~ local function uncover_1(covers,result) -- multiple covers
---~     local nofresults = #result
---~     for n=1,#covers do
---~         nofresults = nofresults + 1
---~         result[nofresults] = covers[n]
---~     end
---~ end
-
---~ local function prepare_contextchains(tfmdata)
---~     local rawdata    = tfmdata.shared.rawdata
---~     local resources  = rawdata.resources
---~     local lookuphash = resources.lookuphash
---~     local lookups    = rawdata.lookups
---~     if lookups then
---~         for lookupname, lookupdata in next, rawdata.lookups do
---~             local lookuptype = lookupdata.type
---~             if not lookuptype then
---~                 report_prepare("missing lookuptype for %s",lookupname)
---~             else -- => lookuphash[lookupname][unicode]
---~                 local rules = lookupdata.rules
---~                 if rules then
---~                     local fmt = lookupdata.format
---~                  -- if fmt == "coverage" then
---~                     if fmt == "coverage" or fmt == "glyphs" then
---~                         if lookuptype ~= "chainsub" and lookuptype ~= "chainpos" then
---~                             -- todo: dejavu-serif has one (but i need to see what use it has)
---~                             report_prepare("unsupported coverage %s for %s",lookuptype,lookupname)
---~                         else
---~                             local contexts = lookuphash[lookupname]
---~                             if not contexts then
---~                                 contexts = { }
---~                                 lookuphash[lookupname] = contexts
---~                             end
---~                             local t, nt = { }, 0
---~                             for nofrules=1,#rules do -- does #rules>1 happen often?
---~                                 local rule     = rules[nofrules]
---~                                 local current  = rule.current
---~                                 local before   = rule.before
---~                                 local after    = rule.after
---~                                 local sequence = { }
---~                                 if before then
---~                                     uncover_1(before,sequence)
---~                                 end
---~                                 local start = #sequence + 1
---~                                 uncover_1(current,sequence)
---~                                 local stop = #sequence
---~                                 if after then
---~                                     uncover_1(after,sequence)
---~                                 end
---~                                 if sequence[1] then
---~                                     nt = nt + 1
---~                                     t[nt] = { nofrules, lookuptype, sequence, start, stop, rule.lookups }
---~                                     for unic, _ in next, sequence[start] do
---~                                         local cu = contexts[unic]
---~                                         if not cu then
---~                                             contexts[unic] = t
---~                                         end
---~                                     end
---~                                 end
---~                             end
---~                         end
---~                     elseif fmt == "reversecoverage" then -- we could combine both branches (only dufference is replacements)
---~                         if lookuptype ~= "reversesub" then
---~                             report_prepare("unsupported reverse coverage %s for %s",lookuptype,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     = { }
---~                                 if before then
---~                                     uncover_1(before,sequence)
---~                                 end
---~                                 local start = #sequence + 1
---~                                 uncover_1(current,sequence)
---~                                 local stop = #sequence
---~                                 if after then
---~                                     uncover_1(after,sequence)
---~                                 end
---~                                 if sequence[1] then
---~                                     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
---~                  -- elseif fmt == "glyphs" then --maybe just make then before = { fore } and share with coverage
---~                  --     if lookuptype ~= "chainsub" and lookuptype ~= "chainpos" then
---~                  --         report_prepare("unsupported coverage %s for %s",lookuptype,lookupname)
---~                  --     else
---~                  --         local contexts = lookuphash[lookupname]
---~                  --         if not contexts then
---~                  --             contexts = { }
---~                  --             lookuphash[lookupname] = contexts
---~                  --         end
---~                  --         local t, nt = { }, 0
---~                  --         for nofrules=1,#rules do -- we can make glyphs a special case (less tables)
---~                  --             local rule     = rules[nofrules]
---~                  --             local current  = rule.names
---~                  --             local before   = rule.fore
---~                  --             local after    = rule.back
---~                  --             local sequence = { }
---~                  --             if before then
---~                  --                 uncover_1(before,sequence)
---~                  --             end
---~                  --             local start = #sequence + 1
---~                  --             uncover_1(current,sequence)
---~                  --             local stop = #sequence
---~                  --             if after then
---~                  --                 uncover_1(after,sequence)
---~                  --             end
---~                  --             if sequence then
---~                  --                 nt = nt + 1
---~                  --                 t[nt] = { nofrules, lookuptype, sequence, start, stop, rule.lookups }
---~                  --                 for unic, _ in next, sequence[start] do
---~                  --                     local cu = contexts[unic]
---~                  --                     if not cu then
---~                  --                         contexts[unic] = t
---~                  --                     end
---~                  --                 end
---~                  --             end
---~                  --         end
---~                  --     end
---~                     end
---~                 end
---~             end
---~         end
---~     end
---~ end
-
 local valid = {
     coverage        = { chainsub = true, chainpos = true, contextsub = true },
     reversecoverage = { reversesub = true },