[fontloader] reorganize under the new import scheme

For better orientation, the fontloader tree now contains two
subdirectories into which files have been reorganized:

The two files required at runtime for the fontloader and luaotfload-tool
are:

      × ``fontloader-basics-gen.lua``
      × ``fontloader-fontloader.lua``

They are now kept in the ``src/fontloader/runtime/`` subdirectory.

All other files from upstream are now located in
``src/fontloader/misc``. This includes a number of files that have not
yet been part of Luaotfload. Currently, the *misc* set of files is not
packaged along with Luaotfload. This may change in the future when there
is an option to switch the merged fontloader for its constituent files,
or even for upstream.

1 files changed, 491 insertions, 0 deletions

diff --git a/src/fontloader/misc/fontloader-mplib.lua b/src/fontloader/misc/fontloader-mplib.lua
new file mode 100644
index 0000000..c6628ac
--- /dev/null
+++ b/src/fontloader/misc/fontloader-mplib.lua
@@ -0,0 +1,491 @@
+if not modules then modules = { } end modules ['luatex-mplib'] = {
+    version   = 1.001,
+    comment   = "companion to luatex-mplib.tex",
+    author    = "Hans Hagen & Taco Hoekwater",
+    copyright = "ConTeXt Development Team",
+    license   = "public domain",
+}
+
+--[[ldx--
+<p>This module is a stripped down version of libraries that are used
+by <l n='context'/>. It can be used in other macro packages and/or
+serve as an example. Embedding in a macro package is upto others and
+normally boils down to inputting <t>supp-mpl.tex</t>.</p>
+--ldx]]--
+
+if metapost and metapost.version then
+
+    --[[ldx--
+    <p>Let's silently quit and make sure that no one loads it
+    manually in <l n='context'/>.</p>
+    --ldx]]--
+
+else
+
+    local format, concat, abs, match = string.format, table.concat, math.abs, string.match
+
+    local mplib = require ('mplib')
+    local kpse  = require ('kpse')
+
+    --[[ldx--
+    <p>We create a namespace and some variables to it. If a namespace is
+    already defined it wil not be initialized. This permits hooking
+    in code beforehand.</p>
+
+    <p>We don't make a format automatically. After all, distributions
+    might have their own preferences and normally a format (mem) file will
+    have some special place in the <l n='tex'/> tree. Also, there can already
+    be format files, different memort settings and other nasty pitfalls that
+    we don't want to interfere with. If you want, you can define a function
+    <t>metapost.make(name,mem_name) that does the job.</t></p>
+    --ldx]]--
+
+    metapost          = metapost or { }
+    metapost.version  = 1.00
+    metapost.showlog  = metapost.showlog or false
+    metapost.lastlog  = ""
+
+    --[[ldx--
+    <p>A few helpers, taken from <t>l-file.lua</t>.</p>
+    --ldx]]--
+
+    local file = file or { }
+
+    function file.replacesuffix(filename, suffix)
+        return (string.gsub(filename,"%.[%a%d]+$","")) .. "." .. suffix
+    end
+
+    function file.stripsuffix(filename)
+        return (string.gsub(filename,"%.[%a%d]+$",""))
+    end
+
+    --[[ldx--
+    <p>We use the <l n='kpse'/> library unless a finder is already
+    defined.</p>
+    --ldx]]--
+
+    local mpkpse = kpse.new("luatex","mpost")
+
+    metapost.finder = metapost.finder or function(name, mode, ftype)
+        if mode == "w" then
+            return name
+        else
+            return mpkpse:find_file(name,ftype)
+        end
+    end
+
+    --[[ldx--
+    <p>You can use your own reported if needed, as long as it handles multiple
+    arguments and formatted strings.</p>
+    --ldx]]--
+
+    metapost.report = metapost.report or function(...)
+        texio.write(format("<mplib: %s>",format(...)))
+    end
+
+    --[[ldx--
+    <p>The rest of this module is not documented. More info can be found in the
+    <l n='luatex'/> manual, articles in user group journals and the files that
+    ship with <l n='context'/>.</p>
+    --ldx]]--
+
+    function metapost.resetlastlog()
+        metapost.lastlog = ""
+    end
+
+    local mplibone = tonumber(mplib.version()) <= 1.50
+
+    if mplibone then
+
+        metapost.make = metapost.make or function(name,mem_name,dump)
+            local t = os.clock()
+            local mpx = mplib.new {
+                ini_version = true,
+                find_file = metapost.finder,
+                job_name = file.stripsuffix(name)
+            }
+            mpx:execute(string.format("input %s ;",name))
+            if dump then
+                mpx:execute("dump ;")
+                metapost.report("format %s made and dumped for %s in %0.3f seconds",mem_name,name,os.clock()-t)
+            else
+                metapost.report("%s read in %0.3f seconds",name,os.clock()-t)
+            end
+            return mpx
+        end
+
+        function metapost.load(name)
+            local mem_name = file.replacesuffix(name,"mem")
+            local mpx = mplib.new {
+                ini_version = false,
+                mem_name = mem_name,
+                find_file = metapost.finder
+            }
+            if not mpx and type(metapost.make) == "function" then
+                -- when i have time i'll locate the format and dump
+                mpx = metapost.make(name,mem_name)
+            end
+            if mpx then
+                metapost.report("using format %s",mem_name,false)
+                return mpx, nil
+            else
+                return nil, { status = 99, error = "out of memory or invalid format" }
+            end
+        end
+
+    else
+
+        local preamble = [[
+            boolean mplib ; mplib := true ;
+            let dump = endinput ;
+            input %s ;
+        ]]
+
+        metapost.make = metapost.make or function()
+        end
+
+        function metapost.load(name)
+            local mpx = mplib.new {
+                ini_version = true,
+                find_file = metapost.finder,
+            }
+            local result
+            if not mpx then
+                result = { status = 99, error = "out of memory"}
+            else
+                result = mpx:execute(format(preamble, file.replacesuffix(name,"mp")))
+            end
+            metapost.reporterror(result)
+            return mpx, result
+        end
+
+    end
+
+    function metapost.unload(mpx)
+        if mpx then
+            mpx:finish()
+        end
+    end
+
+    function metapost.reporterror(result)
+        if not result then
+            metapost.report("mp error: no result object returned")
+        elseif result.status > 0 then
+            local t, e, l = result.term, result.error, result.log
+            if t then
+                metapost.report("mp terminal: %s",t)
+            end
+            if e then
+                metapost.report("mp error: %s", e)
+            end
+            if not t and not e and l then
+                metapost.lastlog = metapost.lastlog .. "\n " .. l
+                metapost.report("mp log: %s",l)
+            else
+                metapost.report("mp error: unknown, no error, terminal or log messages")
+            end
+        else
+            return false
+        end
+        return true
+    end
+
+    function metapost.process(mpx, data)
+        local converted, result = false, {}
+        mpx = metapost.load(mpx)
+        if mpx and data then
+            local result = mpx:execute(data)
+            if not result then
+                metapost.report("mp error: no result object returned")
+            elseif result.status > 0 then
+                metapost.report("mp error: %s",(result.term or "no-term") .. "\n" .. (result.error or "no-error"))
+            elseif metapost.showlog then
+                metapost.lastlog = metapost.lastlog .. "\n" .. result.term
+                metapost.report("mp info: %s",result.term or "no-term")
+            elseif result.fig then
+                converted = metapost.convert(result)
+            else
+                metapost.report("mp error: unknown error, maybe no beginfig/endfig")
+            end
+        else
+           metapost.report("mp error: mem file not found")
+        end
+        return converted, result
+    end
+
+    local function getobjects(result,figure,f)
+        return figure:objects()
+    end
+
+    function metapost.convert(result, flusher)
+        metapost.flush(result, flusher)
+        return true -- done
+    end
+
+    --[[ldx--
+    <p>We removed some message and tracing code. We might even remove the flusher</p>
+    --ldx]]--
+
+    local function pdf_startfigure(n,llx,lly,urx,ury)
+        tex.sprint(format("\\startMPLIBtoPDF{%s}{%s}{%s}{%s}",llx,lly,urx,ury))
+    end
+
+    local function pdf_stopfigure()
+        tex.sprint("\\stopMPLIBtoPDF")
+    end
+
+    function pdf_literalcode(fmt,...) -- table
+        tex.sprint(format("\\MPLIBtoPDF{%s}",format(fmt,...)))
+    end
+
+    function pdf_textfigure(font,size,text,width,height,depth)
+        text = text:gsub(".","\\hbox{%1}") -- kerning happens in metapost
+        tex.sprint(format("\\MPLIBtextext{%s}{%s}{%s}{%s}{%s}",font,size,text,0,-( 7200/ 7227)/65536*depth))
+    end
+
+    local bend_tolerance = 131/65536
+
+    local rx, sx, sy, ry, tx, ty, divider = 1, 0, 0, 1, 0, 0, 1
+
+    local function pen_characteristics(object)
+        local t = mplib.pen_info(object)
+        rx, ry, sx, sy, tx, ty = t.rx, t.ry, t.sx, t.sy, t.tx, t.ty
+        divider = sx*sy - rx*ry
+        return not (sx==1 and rx==0 and ry==0 and sy==1 and tx==0 and ty==0), t.width
+    end
+
+    local function concat(px, py) -- no tx, ty here
+        return (sy*px-ry*py)/divider,(sx*py-rx*px)/divider
+    end
+
+    local function curved(ith,pth)
+        local d = pth.left_x - ith.right_x
+        if abs(ith.right_x - ith.x_coord - d) <= bend_tolerance and abs(pth.x_coord - pth.left_x - d) <= bend_tolerance then
+            d = pth.left_y - ith.right_y
+            if abs(ith.right_y - ith.y_coord - d) <= bend_tolerance and abs(pth.y_coord - pth.left_y - d) <= bend_tolerance then
+                return false
+            end
+        end
+        return true
+    end
+
+    local function flushnormalpath(path,open)
+        local pth, ith
+        for i=1,#path do
+            pth = path[i]
+            if not ith then
+                pdf_literalcode("%f %f m",pth.x_coord,pth.y_coord)
+            elseif curved(ith,pth) then
+                pdf_literalcode("%f %f %f %f %f %f c",ith.right_x,ith.right_y,pth.left_x,pth.left_y,pth.x_coord,pth.y_coord)
+            else
+                pdf_literalcode("%f %f l",pth.x_coord,pth.y_coord)
+            end
+            ith = pth
+        end
+        if not open then
+            local one = path[1]
+            if curved(pth,one) then
+                pdf_literalcode("%f %f %f %f %f %f c",pth.right_x,pth.right_y,one.left_x,one.left_y,one.x_coord,one.y_coord )
+            else
+                pdf_literalcode("%f %f l",one.x_coord,one.y_coord)
+            end
+        elseif #path == 1 then
+            -- special case .. draw point
+            local one = path[1]
+            pdf_literalcode("%f %f l",one.x_coord,one.y_coord)
+        end
+        return t
+    end
+
+    local function flushconcatpath(path,open)
+        pdf_literalcode("%f %f %f %f %f %f cm", sx, rx, ry, sy, tx ,ty)
+        local pth, ith
+        for i=1,#path do
+            pth = path[i]
+            if not ith then
+               pdf_literalcode("%f %f m",concat(pth.x_coord,pth.y_coord))
+            elseif curved(ith,pth) then
+                local a, b = concat(ith.right_x,ith.right_y)
+                local c, d = concat(pth.left_x,pth.left_y)
+                pdf_literalcode("%f %f %f %f %f %f c",a,b,c,d,concat(pth.x_coord, pth.y_coord))
+            else
+               pdf_literalcode("%f %f l",concat(pth.x_coord, pth.y_coord))
+            end
+            ith = pth
+        end
+        if not open then
+            local one = path[1]
+            if curved(pth,one) then
+                local a, b = concat(pth.right_x,pth.right_y)
+                local c, d = concat(one.left_x,one.left_y)
+                pdf_literalcode("%f %f %f %f %f %f c",a,b,c,d,concat(one.x_coord, one.y_coord))
+            else
+                pdf_literalcode("%f %f l",concat(one.x_coord,one.y_coord))
+            end
+        elseif #path == 1 then
+            -- special case .. draw point
+            local one = path[1]
+            pdf_literalcode("%f %f l",concat(one.x_coord,one.y_coord))
+        end
+        return t
+    end
+
+    --[[ldx--
+    <p>Support for specials has been removed.</p>
+    --ldx]]--
+
+    function metapost.flush(result,flusher)
+        if result then
+            local figures = result.fig
+            if figures then
+                for f=1, #figures do
+                    metapost.report("flushing figure %s",f)
+                    local figure = figures[f]
+                    local objects = getobjects(result,figure,f)
+                    local fignum = tonumber(match(figure:filename(),"([%d]+)$") or figure:charcode() or 0)
+                    local miterlimit, linecap, linejoin, dashed = -1, -1, -1, false
+                    local bbox = figure:boundingbox()
+                    local llx, lly, urx, ury = bbox[1], bbox[2], bbox[3], bbox[4] -- faster than unpack
+                    if urx < llx then
+                        -- invalid
+                        pdf_startfigure(fignum,0,0,0,0)
+                        pdf_stopfigure()
+                    else
+                        pdf_startfigure(fignum,llx,lly,urx,ury)
+                        pdf_literalcode("q")
+                        if objects then
+                            for o=1,#objects do
+                                local object = objects[o]
+                                local objecttype = object.type
+                                if objecttype == "start_bounds" or objecttype == "stop_bounds" then
+                                    -- skip
+                                elseif objecttype == "start_clip" then
+                                    pdf_literalcode("q")
+                                    flushnormalpath(object.path,t,false)
+                                    pdf_literalcode("W n")
+                                elseif objecttype == "stop_clip" then
+                                    pdf_literalcode("Q")
+                                    miterlimit, linecap, linejoin, dashed = -1, -1, -1, false
+                                elseif objecttype == "special" then
+                                    -- not supported
+                                elseif objecttype == "text" then
+                                    local ot = object.transform -- 3,4,5,6,1,2
+                                    pdf_literalcode("q %f %f %f %f %f %f cm",ot[3],ot[4],ot[5],ot[6],ot[1],ot[2])
+                                    pdf_textfigure(object.font,object.dsize,object.text,object.width,object.height,object.depth)
+                                    pdf_literalcode("Q")
+                                else
+                                    local cs = object.color
+                                    if cs and #cs > 0 then
+                                        pdf_literalcode(metapost.colorconverter(cs))
+                                    end
+                                    local ml = object.miterlimit
+                                    if ml and ml ~= miterlimit then
+                                        miterlimit = ml
+                                        pdf_literalcode("%f M",ml)
+                                    end
+                                    local lj = object.linejoin
+                                    if lj and lj ~= linejoin then
+                                        linejoin = lj
+                                        pdf_literalcode("%i j",lj)
+                                    end
+                                    local lc = object.linecap
+                                    if lc and lc ~= linecap then
+                                        linecap = lc
+                                        pdf_literalcode("%i J",lc)
+                                    end
+                                    local dl = object.dash
+                                    if dl then
+                                        local d = format("[%s] %i d",concat(dl.dashes or {}," "),dl.offset)
+                                        if d ~= dashed then
+                                            dashed = d
+                                            pdf_literalcode(dashed)
+                                        end
+                                    elseif dashed then
+                                       pdf_literalcode("[] 0 d")
+                                       dashed = false
+                                    end
+                                    local path = object.path
+                                    local transformed, penwidth = false, 1
+                                    local open = path and path[1].left_type and path[#path].right_type
+                                    local pen = object.pen
+                                    if pen then
+                                       if pen.type == 'elliptical' then
+                                            transformed, penwidth = pen_characteristics(object) -- boolean, value
+                                            pdf_literalcode("%f w",penwidth)
+                                            if objecttype == 'fill' then
+                                                objecttype = 'both'
+                                            end
+                                       else -- calculated by mplib itself
+                                            objecttype = 'fill'
+                                       end
+                                    end
+                                    if transformed then
+                                        pdf_literalcode("q")
+                                    end
+                                    if path then
+                                        if transformed then
+                                            flushconcatpath(path,open)
+                                        else
+                                            flushnormalpath(path,open)
+                                        end
+                                        if objecttype == "fill" then
+                                            pdf_literalcode("h f")
+                                        elseif objecttype == "outline" then
+                                            pdf_literalcode((open and "S") or "h S")
+                                        elseif objecttype == "both" then
+                                            pdf_literalcode("h B")
+                                        end
+                                    end
+                                    if transformed then
+                                        pdf_literalcode("Q")
+                                    end
+                                    local path = object.htap
+                                    if path then
+                                        if transformed then
+                                            pdf_literalcode("q")
+                                        end
+                                        if transformed then
+                                            flushconcatpath(path,open)
+                                        else
+                                            flushnormalpath(path,open)
+                                        end
+                                        if objecttype == "fill" then
+                                            pdf_literalcode("h f")
+                                        elseif objecttype == "outline" then
+                                            pdf_literalcode((open and "S") or "h S")
+                                        elseif objecttype == "both" then
+                                            pdf_literalcode("h B")
+                                        end
+                                        if transformed then
+                                            pdf_literalcode("Q")
+                                        end
+                                    end
+                                    if cr then
+                                        pdf_literalcode(cr)
+                                    end
+                                end
+                           end
+                        end
+                        pdf_literalcode("Q")
+                        pdf_stopfigure()
+                    end
+                end
+            end
+        end
+    end
+
+    function metapost.colorconverter(cr)
+        local n = #cr
+        if n == 4 then
+            local c, m, y, k = cr[1], cr[2], cr[3], cr[4]
+            return format("%.3f %.3f %.3f %.3f k %.3f %.3f %.3f %.3f K",c,m,y,k,c,m,y,k), "0 g 0 G"
+        elseif n == 3 then
+            local r, g, b = cr[1], cr[2], cr[3]
+            return format("%.3f %.3f %.3f rg %.3f %.3f %.3f RG",r,g,b,r,g,b), "0 g 0 G"
+        else
+            local s = cr[1]
+            return format("%.3f g %.3f G",s,s), "0 g 0 G"
+        end
+    end
+
+end