Merge branch 'experimental' of phi-gamma/luaotfload into phi-gamma-experimental

Conflicts:
	mkluatexfontdb.lua
	otfl-basics-gen.lua

1 files changed, 559 insertions, 310 deletions

diff --git a/otfl-font-nms.lua b/otfl-font-nms.lua
index 094ebec..c987c3a 100644
--- a/otfl-font-nms.lua
+++ b/otfl-font-nms.lua
@@ -1,56 +1,107 @@
 if not modules then modules = { } end modules ['font-nms'] = {
-    version   = 1.002,
+    version   = 2.2,
     comment   = "companion to luaotfload.lua",
     author    = "Khaled Hosny and Elie Roux",
     copyright = "Luaotfload Development Team",
     license   = "GNU GPL v2"
 }
 
+--- Luatex builtins
+local load                    = load
+local next                    = next
+local pcall                   = pcall
+local require                 = require
+local tonumber                = tonumber
+
+local iolines                 = io.lines
+local ioopen                  = io.open
+local kpseexpand_path         = kpse.expand_path
+local mathabs                 = math.abs
+local mathmin                 = math.min
+local stringfind              = string.find
+local stringformat            = string.format
+local stringgmatch            = string.gmatch
+local stringgsub              = string.gsub
+local stringlower             = string.lower
+local stringsub               = string.sub
+local stringupper             = string.upper
+local tableconcat             = table.concat
+local tablecopy               = table.copy
+local tablesort               = table.sort
+local tabletofile             = table.tofile
+local texiowrite_nl           = texio.write_nl
+local utf8gsub                = unicode.utf8.gsub
+local utf8lower               = unicode.utf8.lower
+
+--- these come from Lualibs/Context
+local dirglob                 = dir.glob
+local dirmkdirs               = dir.mkdirds
+local filebasename            = file.basename
+local filecollapsepath        = file.collapsepath
+local fileextname             = file.extname
+local filejoin                = file.join
+local filereplacesuffix       = file.replacesuffix
+local filesplitpath           = file.splitpath
+local stringis_empty          = string.is_empty
+local stringsplit             = string.split
+local stringstrip             = string.strip
+local tableappend             = table.append
+local tabletohash             = table.tohash
+
+--- the font loader namespace is “fonts”, same as in Context
 fonts                = fonts       or { }
 fonts.names          = fonts.names or { }
 
 local names          = fonts.names
 local names_dir      = "luatex-cache/generic/names"
-names.version        = 2.010 -- not the same as in context
+names.version        = 2.2
 names.data           = nil
 names.path           = {
     basename = "otfl-names.lua",
-    dir      = file.join(kpse.expand_var("$TEXMFVAR"), names_dir),
+    dir      = filejoin(kpse.expand_var("$TEXMFVAR"), names_dir),
 }
 
-local success = pcall(require, "luatexbase.modutils")
-if success then
-   success = pcall(luatexbase.require_module, "lualatex-platform", "2011/03/30")
-end
-local get_installed_fonts
-if success then
-   get_installed_fonts = lualatex.platform.get_installed_fonts
-else
-   function get_installed_fonts()
-   end
-end
 
-local splitpath, expandpath = file.split_path, kpse.expand_path
-local glob, basename        = dir.glob, file.basename
-local extname               = file.extname
-local upper, lower, format  = string.upper, string.lower, string.format
-local gsub, match, rpadd    = string.gsub, string.match, string.rpadd
-local gmatch, sub, find     = string.gmatch, string.sub, string.find
-local utfgsub               = unicode.utf8.gsub
-
-local trace_short    = false --tracing adapted to rebuilding of the database inside a document
-local trace_search   = false --trackers.register("names.search",   function(v) trace_search   = v end)
-local trace_loading  = false --trackers.register("names.loading",  function(v) trace_loading  = v end)
-
-local function sanitize(str)
-    if str then
-        return utfgsub(lower(str), "[^%a%d]", "")
-    else
-        return str -- nil
+---- <FIXME>
+---
+--- these lines load some binary module called “lualatex-platform”
+--- that doesn’t appear to build with Lua 5.2. I’m going ahead and
+--- disable it for the time being until someone clarifies what it
+--- is supposed to do and whether we should care to fix it.
+---
+--local success = pcall(require, "luatexbase.modutils")
+--if success then
+--   success = pcall(luatexbase.require_module,
+--                   "lualatex-platform", "2011/03/30")
+--    print(success)
+--end
+
+--local get_installed_fonts
+--if success then
+--   get_installed_fonts = lualatex.platform.get_installed_fonts
+--else
+--   function get_installed_fonts()
+--   end
+--end
+---- </FIXME>
+
+local get_installed_fonts = nil
+
+--[[doc--
+Auxiliary functions
+--doc]]--
+
+
+local report = logs.names_report
+
+local sanitize_string = function (str)
+    if str ~= nil then
+        return utf8gsub(utf8lower(str), "[^%a%d]", "")
     end
+    return nil
 end
 
-local function fontnames_init()
+local fontnames_init = function ( )
     return {
         mappings  = { },
         status    = { },
@@ -58,47 +109,143 @@ local function fontnames_init()
     }
 end
 
-local function make_name(path)
-    return file.replacesuffix(path, "lua"), file.replacesuffix(path, "luc")
+local make_name = function (path)
+    return filereplacesuffix(path, "lua"), filereplacesuffix(path, "luc")
 end
 
-local function load_names()
-    local path = file.join(names.path.dir, names.path.basename)
-    local luaname, lucname = make_name(path)
-    local foundname
-    local data
-    if file.isreadable(lucname) then
-        data = dofile(lucname)
-	foundname = lucname
-    elseif file.isreadable(luaname) then
-        data = dofile(luaname)
-	foundname = luaname
+--- When loading a lua file we try its binary complement first, which
+--- is assumed to be located at an identical path, carrying the suffix
+--- .luc.
+
+local code_cache = { }
+
+--- string -> (string * table)
+local load_lua_file = function (path)
+    local code = code_cache[path]
+    if code then return path, code() end
+
+    local foundname = filereplacesuffix(path, "luc")
+
+    local fh = ioopen(foundname, "rb") -- try bin first
+    if fh then
+        local chunk = fh:read"*all"
+        fh:close()
+        code = load(chunk, "b")
     end
+
+    if not code then --- fall back to text file
+        foundname = filereplacesuffix(path, "lua")
+        fh = ioopen(foundname, "rb")
+        if fh then
+            local chunk = fh:read"*all"
+            fh:close()
+            code = load(chunk, "t")
+        end
+    end
+
+    if not code then return nil, nil end
+
+    code_cache[path] = code --- insert into memo
+    return foundname, code()
+end
+
+--- define locals in scope
+local find_closest
+local font_fullinfo
+local load_names
+local read_fonts_conf
+local reload_db
+local resolve
+local save_names
+local scan_external_dir
+local update_names
+
+load_names = function ( )
+    local path            = filejoin(names.path.dir, names.path.basename)
+    local foundname, data = load_lua_file(path)
+
     if data then
-        logs.info("Font names database loaded", "%s", foundname)
+        report("info", 0, "Font names database loaded", "%s", foundname)
     else
-        logs.info([[Font names database not found, generating new one.
+        report("info", 0,
+            [[Font names database not found, generating new one.
              This can take several minutes; please be patient.]])
-        data = names.update(fontnames_init())
-        names.save(data)
+        data = update_names(fontnames_init())
+        save_names(data)
     end
-    texio.write_nl("")
+    texiowrite_nl""
     return data
 end
 
-local synonyms = {
-    regular    = { "normal", "roman", "plain", "book", "medium" },
-    bold       = { "boldregular", "demi", "demibold" },
-    italic     = { "regularitalic", "normalitalic", "oblique", "slanted" },
-    bolditalic = { "boldoblique", "boldslanted", "demiitalic", "demioblique", "demislanted", "demibolditalic" },
-}
+local fuzzy_limit = 1 --- display closest only
+
+local style_synonyms = { set = { } }
+do
+    style_synonyms.list = {
+        regular    = { "normal",        "roman",
+                       "plain",         "book",
+                       "medium", },
+        --- TODO note from Élie Roux
+        --- boldregular was for old versions of Linux Libertine, is it still useful?
+        --- semibold is in new versions of Linux Libertine, but there is also a bold,
+        --- not sure it's useful here...
+        bold       = { "demi",           "demibold",
+                       "semibold",       "boldregular",},
+        italic     = { "regularitalic",  "normalitalic",
+                       "oblique",        "slanted", },
+        bolditalic = { "boldoblique",    "boldslanted",
+                       "demiitalic",     "demioblique",
+                       "demislanted",    "demibolditalic",
+                       "semibolditalic", },
+    }
 
-local loaded   = false
-local reloaded = false
+    for category, synonyms in next, style_synonyms.list do
+        style_synonyms.set[category] = tabletohash(synonyms, true)
+    end
+end
 
-function names.resolve(_,_,specification) -- the 1st two parameters are used by ConTeXt
-    local name  = sanitize(specification.name)
-    local style = sanitize(specification.style) or "regular"
+--- state of the database
+local fonts_loaded   = false
+local fonts_reloaded = false
+
+--[[doc--
+
+Luatex-fonts, the font-loader package luaotfload imports, comes with
+basic file location facilities (see luatex-fonts-syn.lua).
+However, the builtin functionality is too limited to be of more than
+basic use, which is why we supply our own resolver that accesses the
+font database created by the mkluatexfontdb script.
+
+--doc]]--
+
+
+---
+--- the request specification has the fields:
+---
+---   · features: table
+---     · normal: set of { ccmp clig itlc kern liga locl mark mkmk rlig }
+---     · ???
+---   · forced:   string
+---   · lookup:   "name" | "file"
+---   · method:   string
+---   · name:     string
+---   · resolved: string
+---   · size:     int
+---   · specification: string (== <lookup> ":" <name>)
+---   · sub:      string
+---
+--- the return value of “resolve” is the file name of the requested
+--- font
+
+--- 'a -> 'a -> table -> (string * string | bool * bool)
+---
+---     note by phg: I added a third return value that indicates a
+---     successful lookup as this cannot be inferred from the other
+---     values.
+---
+resolve = function (_,_,specification) -- the 1st two parameters are used by ConTeXt
+    local name  = sanitize_string(specification.name)
+    local style = sanitize_string(specification.style) or "regular"
 
     local size
     if specification.optsize then
@@ -107,23 +254,33 @@ function names.resolve(_,_,specification) -- the 1st two parameters are used by
         size = specification.size / 65536
     end
 
-
-    if not loaded then
-        names.data = names.load()
-        loaded     = true
+    if not fonts_loaded then
+        names.data   = load_names()
+        fonts_loaded = true
     end
 
     local data = names.data
-    if type(data) == "table" and data.version == names.version then
+    if type(data) == "table" then
+        local db_version, nms_version = data.version, names.version
+        if data.version ~= names.version then
+            report("log", 0, "db",
+                [[version mismatch; expected %4.3f, got %4.3f]],
+                nms_version, db_version
+            )
+            return reload_db(resolve, nil, nil, specification)
+        end
         if data.mappings then
             local found = { }
+            local synonym_set = style_synonyms.set
             for _,face in next, data.mappings do
-                local family    = sanitize(face.names and face.names.family)
-                local subfamily = sanitize(face.names and face.names.subfamily)
-                local fullname  = sanitize(face.names and face.names.fullname)
-                local psname    = sanitize(face.names and face.names.psname)
-                local fontname  = sanitize(face.fontname)
-                local pfullname = sanitize(face.fullname)
+                --- TODO we really should store those in dedicated
+                --- .sanitized field
+                local family    = sanitize_string(face.names and face.names.family)
+                local subfamily = sanitize_string(face.names and face.names.subfamily)
+                local fullname  = sanitize_string(face.names and face.names.fullname)
+                local psname    = sanitize_string(face.names and face.names.psname)
+                local fontname  = sanitize_string(face.fontname)
+                local pfullname = sanitize_string(face.fullname)
                 local optsize, dsnsize, maxsize, minsize
                 if #face.size > 0 then
                     optsize = face.size
@@ -146,8 +303,8 @@ function names.resolve(_,_,specification) -- the 1st two parameters are used by
                             found[1] = face
                             break
                         end
-                    elseif synonyms[style] and
-                           table.contains(synonyms[style], subfamily) then
+                    elseif synonym_set[style] and
+                           synonym_set[style][subfamily] then
                         if optsize then
                             if dsnsize == size
                             or (size > minsize and size <= maxsize) then
@@ -161,7 +318,7 @@ function names.resolve(_,_,specification) -- the 1st two parameters are used by
                             break
                         end
                     elseif subfamily == "regular" or
-                           table.contains(synonyms.regular, subfamily) then
+                           synonym_set.regular[subfamily] then
                         found.fallback = face
                     end
                 else
@@ -186,10 +343,11 @@ function names.resolve(_,_,specification) -- the 1st two parameters are used by
             end
             if #found == 1 then
                 if kpse.lookup(found[1].filename[1]) then
-                    logs.report("load font",
-                                "font family='%s', subfamily='%s' found: %s",
-                                name, style, found[1].filename[1])
-                    return found[1].filename[1], found[1].filename[2]
+                    report("log", 0, "load font",
+                        "font family='%s', subfamily='%s' found: %s",
+                        name, style, found[1].filename[1]
+                    )
+                    return found[1].filename[1], found[1].filename[2], true
                 end
             elseif #found > 1 then
                 -- we found matching font(s) but not in the requested optical
@@ -199,152 +357,242 @@ function names.resolve(_,_,specification) -- the 1st two parameters are used by
                 local least = math.huge -- initial value is infinity
                 for i,face in next, found do
                     local dsnsize    = face.size[1]/10
-                    local difference = math.abs(dsnsize-size)
+                    local difference = mathabs(dsnsize-size)
                     if difference < least then
                         closest = face
                         least   = difference
                     end
                 end
                 if kpse.lookup(closest.filename[1]) then
-                    logs.report("load font",
-                                "font family='%s', subfamily='%s' found: %s",
-                                name, style, closest.filename[1])
-                    return closest.filename[1], closest.filename[2]
+                    report("log", 0, "load font",
+                        "font family='%s', subfamily='%s' found: %s",
+                        name, style, closest.filename[1]
+                    )
+                    return closest.filename[1], closest.filename[2], true
                 end
             elseif found.fallback then
-                return found.fallback.filename[1], found.fallback.filename[2]
+                return found.fallback.filename[1], found.fallback.filename[2], true
             end
-            -- no font found so far
-            if not reloaded then
-                -- try reloading the database
-                names.data = names.update(names.data)
-                names.save(names.data)
-                reloaded   = true
-                return names.resolve(_,_,specification)
+            --- no font found so far
+            if not fonts_reloaded then
+                --- last straw: try reloading the database
+                return reload_db(resolve, nil, nil, specification)
             else
-                -- else, fallback to filename
-                -- XXX: specification.name is empty with absolute paths, looks
-                -- like a bug in the specification parser
-                return specification.name, false
+                --- else, fallback to requested name
+                --- XXX: specification.name is empty with absolute paths, looks
+                --- like a bug in the specification parser
+                return specification.name, false, false
             end
         end
-    else
-        if not reloaded then
-            names.data = names.update()
-            names.save(names.data)
-            reloaded   = true
-            return names.resolve(_,_,specification)
-        else
-            return specification.name, false
+
+    else --- no db or outdated; reload names and retry
+        if not fonts_reloaded then
+            return reload_db(resolve, nil, nil, specification)
+        else --- unsucessfully reloaded; bail
+            return specification.name, false, false
         end
     end
-end
+end --- resolve()
 
-names.resolvespec = names.resolve
+--- when reload is triggered we update the database
+--- and then re-run the caller with the arg list
 
-function names.set_log_level(level)
-    if level == 2 then
-        trace_loading = true
-    elseif level >= 3 then
-        trace_loading = true
-        trace_search = true
+--- ('a -> 'a) -> 'a list -> 'a
+reload_db = function (caller, ...)
+    report("log", 1, "db", "reload initiated")
+    names.data = update_names()
+    save_names(names.data)
+    fonts_reloaded = true
+    return caller(...)
+end
+
+--- string -> string -> int
+local iterative_levenshtein = function (s1, s2)
+
+  local costs = { }
+  local len1, len2 = #s1, #s2
+
+  for i = 0, len1 do
+    local last = i
+    for j = 0, len2 do
+      if i == 0 then
+        costs[j] = j
+      else
+        if j > 0 then
+          local current = costs[j-1]
+          if stringsub(s1, i, i) ~= stringsub(s2, j, j) then
+            current = mathmin(current, last, costs[j]) + 1
+          end
+          costs[j-1] = last
+          last = current
+        end
+      end
     end
+    if i > 0 then costs[len2] = last end
+  end
+
+  return costs[len2]--- lower right has the distance
 end
 
-local lastislog = 0
+--- string -> int -> bool
+find_closest = function (name, limit)
+    local name     = sanitize_string(name)
+    limit          = limit or fuzzy_limit
 
-local function log(category, fmt, ...)
-    lastislog = 1
-    if fmt then
-        texio.write_nl(format("luaotfload | %s: %s", category, format(fmt, ...)))
-    elseif category then
-        texio.write_nl(format("luaotfload | %s", category))
-    else
-        texio.write_nl(format("luaotfload |"))
+    if not fonts_loaded then
+        names.data = load_names()
+        fonts_loaded     = true
     end
-    io.flush()
-end
 
-logs        = logs or { }
-logs.report = logs.report or log
-logs.info   = logs.info or log
-
-local function font_fullinfo(filename, subfont, texmf)
-    local t = { }
-    local f = fontloader.open(filename, subfont)
-    if not f then
-	    if trace_loading then
-               logs.report("error", "failed to open %s", filename)
-	    end
+    local data = names.data
+
+    if type(data) == "table" then
+        local by_distance   = { } --- (int, string list) dict
+        local distances     = { } --- int list
+        local cached        = { } --- (string, int) dict
+        local mappings      = data.mappings
+        local n_fonts       = #mappings
+
+        for n = 1, n_fonts do
+            local current    = mappings[n]
+            local cnames     = current.names
+            --[[
+                This is simplistic but surpisingly fast.
+                Matching is performed against the “family” name
+                of a db record. We then store its “fullname” at
+                it edit distance.
+                We should probably do some weighting over all the
+                font name categories as well as whatever agrep
+                does.
+            --]]
+            if cnames then
+                local fullname, family = cnames.fullname, cnames.family
+                family = sanitize_string(family)
+
+                local dist = cached[family]--- maybe already calculated
+                if not dist then
+                    dist = iterative_levenshtein(name, family)
+                    cached[family] = dist
+                end
+                local namelst = by_distance[dist]
+                if not namelst then --- first entry
+                    namelst = { fullname }
+                    distances[#distances+1] = dist
+                else --- append
+                    namelst[#namelst+1] = fullname
+                end
+                by_distance[dist] = namelst
+            end
+        end
+
+        --- print the matches according to their distance
+        local n_distances = #distances
+        if n_distances > 0 then --- got some data
+            tablesort(distances)
+            limit = mathmin(n_distances, limit)
+            report(false, 1, "query",
+                    "displaying %d distance levels", limit)
+
+            for i = 1, limit do
+                local dist     = distances[i]
+                local namelst  = by_distance[dist]
+                report(false, 0, "query",
+                    "distance from “" .. name .. "”: " .. dist
+                 .. "\n    " .. tableconcat(namelst, "\n    ")
+                )
+            end
+
+            return true
+        end
+        return false
+    else --- need reload
+        return reload_db(find_closest, name)
+    end
+    return false
+end --- find_closest()
+
+--[[doc--
+The data inside an Opentype font file can be quite heterogeneous.
+Thus in order to get the relevant information, parts of the original
+table as returned by the font file reader need to be relocated.
+--doc]]--
+font_fullinfo = function (filename, subfont, texmf)
+    local tfmdata = { }
+    local rawfont = fontloader.open(filename, subfont)
+    if not rawfont then
+        report("log", 1, "error", "failed to open %s", filename)
         return
     end
-    local m = fontloader.to_table(f)
-    fontloader.close(f)
-    collectgarbage('collect')
+    local metadata = fontloader.to_table(rawfont)
+    fontloader.close(rawfont)
+    collectgarbage("collect")
     -- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size
-    if m.fontstyle_name then
-        for _,v in next, m.fontstyle_name do
-            if v.lang == 1033 then
-                t.fontstyle_name = v.name
+    if metadata.fontstyle_name then
+        for _, name in next, metadata.fontstyle_name do
+            if name.lang == 1033 then --- I hate magic numbers
+                tfmdata.fontstyle_name = name.name
             end
         end
     end
-    if m.names then
-        for _,v in next, m.names do
-            if v.lang == "English (US)" then
-                t.names = {
-                    -- see
-                    -- http://developer.apple.com/textfonts/
-                    -- TTRefMan/RM06/Chap6name.html
-                    fullname = v.names.compatfull     or v.names.fullname,
-                    family   = v.names.preffamilyname or v.names.family,
-                    subfamily= t.fontstyle_name       or v.names.prefmodifiers  or v.names.subfamily,
-                    psname   = v.names.postscriptname
+    if metadata.names then
+        for _, namedata in next, metadata.names do
+            if namedata.lang == "English (US)" then
+                tfmdata.names = {
+                    --- see
+                    --- https://developer.apple.com/fonts/TTRefMan/RM06/Chap6name.html
+                    fullname = namedata.names.compatfull
+                            or namedata.names.fullname,
+                    family   = namedata.names.preffamilyname
+                            or namedata.names.family,
+                    subfamily= tfmdata.fontstyle_name
+                            or namedata.names.prefmodifiers
+                            or namedata.names.subfamily,
+                    psname   = namedata.names.postscriptname
                 }
             end
         end
     else
         -- no names table, propably a broken font
-        if trace_loading then
-            logs.report("broken font rejected", "%s", basefile)
-        end
+        report("log", 1, "broken font rejected", "%s", basefile)
         return
     end
-    t.fontname    = m.fontname
-    t.fullname    = m.fullname
-    t.familyname  = m.familyname
-    t.filename    = { texmf and basename(filename) or filename, subfont }
-    t.weight      = m.pfminfo.weight
-    t.width       = m.pfminfo.width
-    t.slant       = m.italicangle
+    tfmdata.fontname    = metadata.fontname
+    tfmdata.fullname    = metadata.fullname
+    tfmdata.familyname  = metadata.familyname
+    tfmdata.filename    = {
+        texmf and filebasename(filename) or filename,
+        subfont
+    }
+    tfmdata.weight      = metadata.pfminfo.weight
+    tfmdata.width       = metadata.pfminfo.width
+    tfmdata.slant       = metadata.italicangle
     -- don't waste the space with zero values
-    t.size = {
-        m.design_size         ~= 0 and m.design_size         or nil,
-        m.design_range_top    ~= 0 and m.design_range_top    or nil,
-        m.design_range_bottom ~= 0 and m.design_range_bottom or nil,
+    tfmdata.size = {
+        metadata.design_size         ~= 0 and metadata.design_size         or nil,
+        metadata.design_range_top    ~= 0 and metadata.design_range_top    or nil,
+        metadata.design_range_bottom ~= 0 and metadata.design_range_bottom or nil,
     }
-    return t
+    return tfmdata
 end
 
-local function load_font(filename, fontnames, newfontnames, texmf)
+local load_font = function (filename, fontnames, newfontnames, texmf)
     local newmappings = newfontnames.mappings
     local newstatus   = newfontnames.status
     local mappings    = fontnames.mappings
     local status      = fontnames.status
-    local basefile    = texmf and basename(filename) or filename
+    local basename    = filebasename(filename)
+    local basefile    = texmf and basename or filename
     if filename then
         if names.blacklist[filename] or
-           names.blacklist[basename(filename)] then
-            if trace_search then
-                logs.report("ignoring font", "%s", filename)
-            end
+           names.blacklist[basename] then
+            report("log", 2, "ignoring font", "%s", filename)
             return
         end
         local timestamp, db_timestamp
         db_timestamp        = status[basefile] and status[basefile].timestamp
         timestamp           = lfs.attributes(filename, "modification")
 
-        local index_status = newstatus[basefile] or (not texmf and newstatus[basename(filename)])
+        local index_status = newstatus[basefile] or (not texmf and newstatus[basename])
         if index_status and index_status.timestamp == timestamp then
             -- already indexed this run
             return
@@ -360,9 +608,7 @@ local function load_font(filename, fontnames, newfontnames, texmf)
                 newmappings[#newmappings+1]        = mappings[v]
                 newstatus[basefile].index[index+1] = #newmappings
             end
-            if trace_loading then
-                logs.report("font already indexed", "%s", basefile)
-            end
+            report("log", 1, "font already indexed", "%s", basefile)
             return
         end
         local info = fontloader.info(filename)
@@ -397,9 +643,7 @@ local function load_font(filename, fontnames, newfontnames, texmf)
                 newstatus[basefile].index[1] = index
             end
         else
-            if trace_loading then
-               logs.report("failed to load", "%s", basefile)
-            end
+            report("log", 1, "failed to load", "%s", basefile)
         end
     end
 end
@@ -414,23 +658,23 @@ local function path_normalize(path)
         - using kpse.readable_file on Win32
     ]]
     if os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then
-        path = path:gsub('\\', '/')
-        path = path:lower()
-        path = path:gsub('^/cygdrive/(%a)/', '%1:/')
+        path = stringgsub(path, '\\', '/')
+        path = stringlower(path)
+        path = stringgsub(path, '^/cygdrive/(%a)/', '%1:/')
     end
     if os.type ~= "windows" and os.type ~= "msdos" then
         local dest = lfs.readlink(path)
         if dest then
             if kpse.readable_file(dest) then
                 path = dest
-            elseif kpse.readable_file(file.join(file.dirname(path), dest)) then
-                path = file.join(file.dirname(path), dest)
+            elseif kpse.readable_file(filejoin(file.dirname(path), dest)) then
+                path = filejoin(file.dirname(path), dest)
             else
                 -- broken symlink?
             end
         end
     end
-    path = file.collapse_path(path)
+    path = filecollapsepath(path)
     return path
 end
 
@@ -447,20 +691,20 @@ local function read_blacklist()
 
     if files and type(files) == "table" then
         for _,v in next, files do
-            for line in io.lines(v) do
-                line = line:strip() -- to get rid of lines like " % foo"
-                if line:find("^%%") or line:is_empty() then
+            for line in iolines(v) do
+                line = stringstrip(line) -- to get rid of lines like " % foo"
+                local first_chr = stringsub(line, 1, 1) --- faster than find
+                if first_chr == "%" or stringis_empty(line) then
                     -- comment or empty line
                 else
-                    line = line:split("%")[1]
-                    line = line:strip()
-                    if string.sub(line,1,1) == "-" then
-                        whitelist[string.sub(line,2,-1)] = true
+                    --- this is highly inefficient
+                    line = stringsplit(line, "%")[1]
+                    line = stringstrip(line)
+                    if stringsub(line, 1, 1) == "-" then
+                        whitelist[stringsub(line, 2, -1)] = true
                     else
-                      if trace_search then
-                          logs.report("blacklisted file", "%s", line)
-                      end
-                      blacklist[line] = true
+                        report("log", 2, "blacklisted file", "%s", line)
+                        blacklist[line] = true
                     end
                 end
             end
@@ -477,37 +721,34 @@ for key, value in next, font_extensions do
    font_extensions_set[value] = true
 end
 
-local installed_fonts_scanned = false
-
-local function scan_installed_fonts(fontnames, newfontnames)
-   -- Try to query and add font list from operating system.
-   -- This uses the lualatex-platform module.
-   logs.info("Scanning fonts known to operating system...")
-   local fonts = get_installed_fonts()
-   if fonts and #fonts > 0 then
-      installed_fonts_scanned = true
-      if trace_search then
-         logs.report("operating system fonts found", "%d", #fonts)
-      end
-      for key, value in next, fonts do
-         local file = value.path
-         if file then
-            local ext = extname(file)
-            if ext and font_extensions_set[ext] then
-               file = path_normalize(file)
-               if trace_loading then
-                  logs.report("loading font", "%s", file)
-               end
-               load_font(file, fontnames, newfontnames, false)
-            end
-         end
-      end
-   else
-      if trace_search then
-         logs.report("Could not retrieve list of installed fonts")
-      end
-   end
-end
+--local installed_fonts_scanned = false --- ugh
+
+--- we already have scan_os_fonts don’t we?
+
+--local function scan_installed_fonts(fontnames, newfontnames)
+--    --- Try to query and add font list from operating system.
+--    --- This uses the lualatex-platform module.
+--    --- <phg>what for? why can’t we do this in Lua?</phg>
+--    report("info", 0, "Scanning fonts known to operating system...")
+--    local fonts = get_installed_fonts()
+--    if fonts and #fonts > 0 then
+--        installed_fonts_scanned = true
+--        report("log", 2, "operating system fonts found", "%d", #fonts)
+--        for key, value in next, fonts do
+--            local file = value.path
+--            if file then
+--                local ext = fileextname(file)
+--                if ext and font_extensions_set[ext] then
+--                file = path_normalize(file)
+--                    report("log", 1, "loading font", "%s", file)
+--                load_font(file, fontnames, newfontnames, false)
+--                end
+--            end
+--        end
+--    else
+--        report("log", 2, "Could not retrieve list of installed fonts")
+--    end
+--end
 
 local function scan_dir(dirname, fontnames, newfontnames, texmf)
     --[[
@@ -519,30 +760,22 @@ local function scan_dir(dirname, fontnames, newfontnames, texmf)
     ]]
     local list, found = { }, { }
     local nbfound = 0
-    if trace_search then
-        logs.report("scanning", "%s", dirname)
-    end
+    report("log", 2, "scanning", "%s", dirname)
     for _,i in next, font_extensions do
-        for _,ext in next, { i, upper(i) } do
-            found = glob(format("%s/**.%s$", dirname, ext))
+        for _,ext in next, { i, stringupper(i) } do
+            found = dirglob(stringformat("%s/**.%s$", dirname, ext))
             -- note that glob fails silently on broken symlinks, which happens
             -- sometimes in TeX Live.
-            if trace_search then
-                logs.report("fonts found", "%s '%s' fonts found", #found, ext)
-            end
+            report("log", 2, "fonts found", "%s '%s' fonts found", #found, ext)
             nbfound = nbfound + #found
-            table.append(list, found)
+            tableappend(list, found)
         end
     end
-    if trace_search then
-        logs.report("fonts found", "%d fonts found in '%s'", nbfound, dirname)
-    end
+    report("log", 2, "fonts found", "%d fonts found in '%s'", nbfound, dirname)
 
     for _,file in next, list do
         file = path_normalize(file)
-        if trace_loading then
-            logs.report("loading font", "%s", file)
-        end
+        report("log", 1, "loading font", "%s", file)
         load_font(file, fontnames, newfontnames, texmf)
     end
 end
@@ -552,15 +785,15 @@ local function scan_texmf_fonts(fontnames, newfontnames)
     This function scans all fonts in the texmf tree, through kpathsea
     variables OPENTYPEFONTS and TTFONTS of texmf.cnf
     ]]
-    if expandpath("$OSFONTDIR"):is_empty() then
-        logs.info("Scanning TEXMF fonts...")
+    if stringis_empty(kpseexpand_path("$OSFONTDIR")) then
+        report("info", 0, "Scanning TEXMF fonts...")
     else
-        logs.info("Scanning TEXMF and OS fonts...")
+        report("info", 0, "Scanning TEXMF and OS fonts...")
     end
-    local fontdirs = expandpath("$OPENTYPEFONTS"):gsub("^%.", "")
-    fontdirs = fontdirs .. expandpath("$TTFONTS"):gsub("^%.", "")
-    if not fontdirs:is_empty() then
-        for _,d in next, splitpath(fontdirs) do
+    local fontdirs = stringgsub(kpseexpand_path("$OPENTYPEFONTS"), "^%.", "")
+    fontdirs       = fontdirs .. stringgsub(kpseexpand_path("$TTFONTS"), "^%.", "")
+    if not stringis_empty(fontdirs) then
+        for _,d in next, filesplitpath(fontdirs) do
             scan_dir(d, fontnames, newfontnames, true)
         end
     end
@@ -579,101 +812,112 @@ end
   in OSFONTDIR.
 ]]
 
-local function read_fonts_conf(path, results)
+--- (string -> tab -> tab -> tab)
+read_fonts_conf = function (path, results, passed_paths)
     --[[
-    This function parses /etc/fonts/fonts.conf and returns all the dir it finds.
-    The code is minimal, please report any error it may generate.
+    This function parses /etc/fonts/fonts.conf and returns all the dir
+    it finds.  The code is minimal, please report any error it may
+    generate.
+
+    TODO    fonts.conf are some kind of XML so in theory the following
+            is totally inappropriate. Maybe a future version of the
+            lualibs will include the lxml-* files from Context so we
+            can write something presentable instead.
     ]]
-    local f = io.open(path)
-    if not f then
-        if trace_search then
-            logs.report("cannot open file", "%s", path)
-        end
+    local fh = ioopen(path)
+    passed_paths[#passed_paths+1] = path
+    passed_paths_set = tabletohash(passed_paths, true)
+    if not fh then
+        report("log", 2, "cannot open file", "%s", path)
         return results
     end
     local incomments = false
-    for line in f:lines() do
+    for line in fh:lines() do
         while line and line ~= "" do
             -- spaghetti code... hmmm...
             if incomments then
-                local tmp = find(line, '-->')
+                local tmp = stringfind(line, '-->') --- wtf?
                 if tmp then
                     incomments = false
-                    line = sub(line, tmp+3)
+                    line = stringsub(line, tmp+3)
                 else
                     line = nil
                 end
             else
-                local tmp = find(line, '<!--')
+                local tmp = stringfind(line, '<!--')
                 local newline = line
                 if tmp then
                     -- for the analysis, we take everything that is before the
                     -- comment sign
-                    newline = sub(line, 1, tmp-1)
+                    newline = stringsub(line, 1, tmp-1)
                     -- and we loop again with the comment
                     incomments = true
-                    line = sub(line, tmp+4)
+                    line = stringsub(line, tmp+4)
                 else
                     -- if there is no comment start, the block after that will
                     -- end the analysis, we exit the while loop
                     line = nil
                 end
-                for dir in gmatch(newline, '<dir>([^<]+)</dir>') do
+                for dir in stringgmatch(newline, '<dir>([^<]+)</dir>') do
                     -- now we need to replace ~ by kpse.expand_path('~')
-                    if sub(dir, 1, 1) == '~' then
-                        dir = file.join(kpse.expand_path('~'), sub(dir, 2))
+                    if stringsub(dir, 1, 1) == '~' then
+                        dir = filejoin(kpseexpand_path('~'), stringsub(dir, 2))
                     end
                     -- we exclude paths with texmf in them, as they should be
                     -- found anyway
-                    if not find(dir, 'texmf') then
+                    if not stringfind(dir, 'texmf') then
                         results[#results+1] = dir
                     end
                 end
-                for include in gmatch(newline, '<include[^<]*>([^<]+)</include>') do
+                for include in stringgmatch(newline, '<include[^<]*>([^<]+)</include>') do
                     -- include here can be four things: a directory or a file,
                     -- in absolute or relative path.
-                    if sub(include, 1, 1) == '~' then
-                        include = file.join(kpse.expand_path('~'),sub(include, 2))
+                    if stringsub(include, 1, 1) == '~' then
+                        include = filejoin(kpseexpand_path('~'),stringsub(include, 2))
                         -- First if the path is relative, we make it absolute:
                     elseif not lfs.isfile(include) and not lfs.isdir(include) then
-                        include = file.join(file.dirname(path), include)
+                        include = filejoin(file.dirname(path), include)
                     end
-                    if lfs.isfile(include) then
+                    if      lfs.isfile(include)
+                    and     kpse.readable_file(include)
+                    and not passed_paths_set[include]
+                    then
                         -- maybe we should prevent loops here?
                         -- we exclude path with texmf in them, as they should
                         -- be found otherwise
-                        read_fonts_conf(include, results)
+                        read_fonts_conf(include, results, passed_paths)
                     elseif lfs.isdir(include) then
-                        for _,f in next, glob(file.join(include, "*.conf")) do
-                            read_fonts_conf(f, results)
+                        for _,f in next, dirglob(filejoin(include, "*.conf")) do
+                            read_fonts_conf(f, results, passed_paths)
                         end
                     end
                 end
             end
         end
     end
-    f:close()
+    fh:close()
     return results
 end
 
 -- for testing purpose
 names.read_fonts_conf = read_fonts_conf
 
+--- TODO stuff those paths into some writable table
 local function get_os_dirs()
     if os.name == 'macosx' then
         return {
-            file.join(kpse.expand_path('~'), "Library/Fonts"),
+            filejoin(kpseexpand_path('~'), "Library/Fonts"),
             "/Library/Fonts",
             "/System/Library/Fonts",
             "/Network/Library/Fonts",
         }
     elseif os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then
         local windir = os.getenv("WINDIR")
-        return { file.join(windir, 'Fonts') }
-    else
+        return { filejoin(windir, 'Fonts') }
+    else --- TODO what about ~/config/fontconfig/fonts.conf etc?
         for _,p in next, {"/usr/local/etc/fonts/fonts.conf", "/etc/fonts/fonts.conf"} do
             if lfs.isfile(p) then
-                return read_fonts_conf("/etc/fonts/fonts.conf", {})
+                return read_fonts_conf("/etc/fonts/fonts.conf", {}, {})
             end
         end
     end
@@ -686,85 +930,90 @@ local function scan_os_fonts(fontnames, newfontnames)
       - fontcache for Unix (reads the fonts.conf file and scans the directories)
       - a static set of directories for Windows and MacOSX
     ]]
-    logs.info("Scanning OS fonts...")
-    if trace_search then
-        logs.info("Searching in static system directories...")
-    end
+    report("info", 0, "Scanning OS fonts...")
+    report("info", 2, "Searching in static system directories...")
     for _,d in next, get_os_dirs() do
         scan_dir(d, fontnames, newfontnames, false)
     end
 end
 
-local function update_names(fontnames, force)
+update_names = function (fontnames, force)
     --[[
     The main function, scans everything
     - fontnames is the final table to return
     - force is whether we rebuild it from scratch or not
     ]]
-    logs.info("Updating the font names database")
+    report("info", 0, "Updating the font names database")
 
     if force then
         fontnames = fontnames_init()
     else
         if not fontnames then
-            fontnames = names.load()
+            fontnames = load_names()
         end
         if fontnames.version ~= names.version then
             fontnames = fontnames_init()
-            if trace_search then
-                logs.report("No font names database or old one found; "
-                          .."generating new one")
-            end
+            report("log", 0, "No font names database or old one found; "
+                           .."generating new one")
         end
     end
     local newfontnames = fontnames_init()
     read_blacklist()
-    installed_font_scanned = false
-    scan_installed_fonts(fontnames, newfontnames)
+    --installed_fonts_scanned = false
+    --scan_installed_fonts(fontnames, newfontnames) --- see fixme above
     scan_texmf_fonts(fontnames, newfontnames)
-    if not installed_fonts_scanned and expandpath("$OSFONTDIR"):is_empty() then
+    --if  not installed_fonts_scanned
+    --and stringis_empty(kpseexpand_path("$OSFONTDIR"))
+    if stringis_empty(kpseexpand_path("$OSFONTDIR"))
+    then
         scan_os_fonts(fontnames, newfontnames)
     end
     return newfontnames
 end
 
-local function save_names(fontnames)
+save_names = function (fontnames)
     local path  = names.path.dir
     if not lfs.isdir(path) then
-        dir.mkdirs(path)
+        dirmkdirs(path)
     end
-    path = file.join(path, names.path.basename)
+    path = filejoin(path, names.path.basename)
     if file.iswritable(path) then
         local luaname, lucname = make_name(path)
-        table.tofile(luaname, fontnames, true)
+        tabletofile(luaname, fontnames, true)
         caches.compile(fontnames,luaname,lucname)
-        logs.info("Font names database saved")
+        report("info", 0, "Font names database saved")
         return path
     else
-        logs.info("Failed to save names database")
+        report("info", 0, "Failed to save names database")
         return nil
     end
 end
 
-local function scan_external_dir(dir)
+scan_external_dir = function (dir)
     local old_names, new_names
-    if loaded then
+    if fonts_loaded then
         old_names = names.data
     else
-        old_names = names.load()
-        loaded    = true
+        old_names = load_names()
+        fonts_loaded    = true
     end
-    new_names = table.copy(old_names)
+    new_names = tablecopy(old_names)
     scan_dir(dir, old_names, new_names)
     names.data = new_names
 end
 
+--- export functionality to the namespace “fonts.names”
 names.scan   = scan_external_dir
 names.load   = load_names
 names.update = update_names
 names.save   = save_names
 
--- dummy
-function fonts.names.getfilename(askedname,suffix)  -- only supported in mkiv
-    return ""
-end
+names.resolve      = resolve --- replace the resolver from luatex-fonts
+names.resolvespec  = resolve
+names.find_closest = find_closest
+
+--- dummy required by luatex-fonts (cf. luatex-fonts-syn.lua)
+
+fonts.names.getfilename = function (askedname,suffix) return "" end
+
+-- vim:tw=71:sw=4:ts=4:expandtab