[*] move source files to ./src

1 files changed, 0 insertions, 3445 deletions

diff --git a/luaotfload-database.lua b/luaotfload-database.lua
deleted file mode 100644
index 4b2d201..0000000
--- a/luaotfload-database.lua
+++ /dev/null
@@ -1,3445 +0,0 @@
-if not modules then modules = { } end modules ['luaotfload-database'] = {
-    version   = "2.5",
-    comment   = "companion to luaotfload-main.lua",
-    author    = "Khaled Hosny, Elie Roux, Philipp Gesang",
-    copyright = "Luaotfload Development Team",
-    license   = "GNU GPL v2.0"
-}
-
---[[doc--
-
-    Some statistics:
-
-        a) TL 2012,     mkluatexfontdb --force
-        b) v2.4,        luaotfload-tool --update --force
-        c) v2.4,        luaotfload-tool --update --force --formats=+afm,pfa,pfb
-        d) Context,     mtxrun --script fonts --reload --force
-
-    (Keep in mind that Context does index fewer fonts since it
-    considers only the contents of the minimals tree, not the
-    tex live one!)
-
-                time (m:s)       peak VmSize (kB)
-            a     1:19              386 018
-            b     0:37              715 797
-            c     2:27            1 017 674
-            d     0:44            1 082 313
-
-    Most of the increase in memory consumption from version 1.x to 2.2+
-    can be attributed to the move from single-pass to a multi-pass
-    approach to building the index: Information is first gathered from
-    all reachable fonts and only afterwards processed, classified and
-    discarded.  Also, there is a good deal of additional stuff kept in
-    the database now: two extra tables for file names and font families
-    have been added, making font lookups more efficient while improving
-    maintainability of the code.
-
---doc]]--
-
-local lpeg                     = require "lpeg"
-local P, Cc, lpegmatch         = lpeg.P, lpeg.Cc, lpeg.match
-
-local parsers                  = luaotfload.parsers
-local read_fonts_conf          = parsers.read_fonts_conf
-local stripslashes             = parsers.stripslashes
-local splitcomma               = parsers.splitcomma
-
-local log                      = luaotfload.log
-local report                   = log.report
-local report_status            = log.names_status
-local report_status_start      = log.names_status_start
-local report_status_stop       = log.names_status_stop
-
-
---- Luatex builtins
-local load                     = load
-local next                     = next
-local require                  = require
-local tonumber                 = tonumber
-local unpack                   = table.unpack
-
-local fontloaderinfo           = fontloader.info
-local fontloaderclose          = fontloader.close
-local fontloaderopen           = fontloader.open
------ fontloaderto_table       = fontloader.to_table
-local gzipopen                 = gzip.open
-local iolines                  = io.lines
-local ioopen                   = io.open
-local iopopen                  = io.popen
-local kpseexpand_path          = kpse.expand_path
-local kpsefind_file            = kpse.find_file
-local kpselookup               = kpse.lookup
-local kpsereadable_file        = kpse.readable_file
-local lfsattributes            = lfs.attributes
-local lfschdir                 = lfs.chdir
-local lfscurrentdir            = lfs.currentdir
-local lfsdir                   = lfs.dir
-local mathabs                  = math.abs
-local mathmin                  = math.min
-local osgetenv                 = os.getenv
-local osgettimeofday           = os.gettimeofday
-local osremove                 = os.remove
-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 tablesort                = table.sort
-local utf8gsub                 = unicode.utf8.gsub
-local utf8lower                = unicode.utf8.lower
-local utf8len                  = unicode.utf8.len
-local zlibcompress             = zlib.compress
-
---- these come from Lualibs/Context
-local filebasename             = file.basename
-local filecollapsepath         = file.collapsepath or file.collapse_path
-local filedirname              = file.dirname
-local fileextname              = file.extname
-local fileiswritable           = file.iswritable
-local filejoin                 = file.join
-local filenameonly             = file.nameonly
-local filereplacesuffix        = file.replacesuffix
-local filesplitpath            = file.splitpath or file.split_path
-local filesuffix               = file.suffix
-local getwritablepath          = caches.getwritablepath
-local lfsisdir                 = lfs.isdir
-local lfsisfile                = lfs.isfile
-local lfsmkdirs                = lfs.mkdirs
-local lpegsplitat              = lpeg.splitat
-local stringis_empty           = string.is_empty
-local stringsplit              = string.split
-local stringstrip              = string.strip
-local tableappend              = table.append
-local tablecontains            = table.contains
-local tablecopy                = table.copy
-local tablefastcopy            = table.fastcopy
-local tabletofile              = table.tofile
-local tabletohash              = table.tohash
-local tableserialize           = table.serialize
-local runasscript              = caches == nil
---- the font loader namespace is “fonts”, same as in Context
---- we need to put some fallbacks into place for when running
---- as a script
-fonts                          = fonts          or { }
-fonts.names                    = fonts.names    or { }
-fonts.definers                 = fonts.definers or { }
-
-local luaotfloadconfig         = config.luaotfload --- always present
-luaotfloadconfig.resolver      = luaotfloadconfig.resolver or "normal"
-luaotfloadconfig.formats       = luaotfloadconfig.formats  or "otf,ttf,ttc,dfont"
-luaotfloadconfig.strip         = luaotfloadconfig.strip == true
-
---- this option allows for disabling updates
---- during a TeX run
-luaotfloadconfig.update_live   = luaotfloadconfig.update_live ~= false
-luaotfloadconfig.compress      = luaotfloadconfig.compress ~= false
-
-local names                    = fonts.names
-local name_index               = nil --> upvalue for names.data
-local lookup_cache             = nil --> for names.lookups
-names.version                  = 2.5
-names.data                     = nil      --- contains the loaded database
-names.lookups                  = nil      --- contains the lookup cache
-
-names.path                     = { index = { }, lookups = { } }
-names.path.globals             = {
-    prefix                     = "", --- writable_path/names_dir
-    names_dir                  = luaotfloadconfig.names_dir or "names",
-    index_file                 = luaotfloadconfig.index_file
-                              or "luaotfload-names.lua",
-    lookups_file               = "luaotfload-lookup-cache.lua",
-}
-
---- string -> (string * string)
-local make_luanames = function (path)
-    return filereplacesuffix(path, "lua"),
-           filereplacesuffix(path, "luc")
-end
-
---- The “termwidth” value is only considered when printing
---- short status messages, e.g. when building the database
---- online.
-if not luaotfloadconfig.termwidth then
-    local tw = 79
-    if not (    os.type == "windows" --- Assume broken terminal.
-            or osgetenv "TERM" == "dumb")
-    then
-        local p = iopopen "tput cols"
-        if p then
-            result = tonumber (p:read "*all")
-            p:close ()
-            if result then
-                tw = result
-            else
-                report ("log", 2, "db", "tput returned non-number.")
-            end
-        else
-            report ("log", 2, "db", "Shell escape disabled or tput executable missing.")
-            report ("log", 2, "db", "Assuming 79 cols terminal width.")
-        end
-    end
-    luaotfloadconfig.termwidth = tw
-end
-
-local format_precedence = {
-    "otf",   "ttc", "ttf",
-    "dfont", "afm", "pfb",
-    "pfa",
-}
-
-local location_precedence = {
-    "local", "system", "texmf",
-}
-
-local set_location_precedence = function (precedence)
-    location_precedence = precedence
-end
-
---[[doc--
-    We use the functions in the cache.* namespace that come with the
-    fontloader (see luat-basics-gen). it’s safe to use for the most part
-    since most checks and directory creations are already done. It
-    uses TEXMFCACHE or TEXMFVAR as starting points.
-
-    There is one quirk, though: ``getwritablepath()`` will always
-    assume that files in subdirectories of the cache tree are writable.
-    It gives no feedback at all if it fails to open a file in write
-    mode. This may cause trouble when the index or lookup cache were
-    created by different user.
---doc]]--
-
-if not runasscript then
-    local globals   = names.path.globals
-    local names_dir = globals.names_dir
-
-    prefix = getwritablepath (names_dir, "")
-    if not prefix then
-        luaotfload.error
-            ("Impossible to find a suitable writeable cache...")
-    else
-        prefix = lpegmatch (stripslashes, prefix)
-        report ("log", 0, "db",
-                "Root cache directory is %s.", prefix)
-    end
-
-    globals.prefix     = prefix
-    local lookup_path  = names.path.lookups
-    local index        = names.path.index
-    local lookups_file = filejoin (prefix, globals.lookups_file)
-    local index_file   = filejoin (prefix, globals.index_file)
-    lookup_path.lua, lookup_path.luc = make_luanames (lookups_file)
-    index.lua, index.luc     = make_luanames (index_file)
-else --- running as script, inject some dummies
-    caches = { }
-    local dummy_function = function () end
-    log   = { report                = dummy_function,
-              report_status         = dummy_function,
-              report_status_start   = dummy_function,
-              report_status_stop    = dummy_function, }
-end
-
-
---[[doc--
-Auxiliary functions
---doc]]--
-
---- fontnames contain all kinds of garbage; as a precaution we
---- lowercase and strip them of non alphanumerical characters
-
---- string -> string
-
-local invalidchars = "[^%a%d]"
-
-local sanitize_fontname = function (str)
-    if str ~= nil then
-        str = utf8gsub (utf8lower (str), invalidchars, "")
-        return str
-    end
-    return nil
-end
-
-local sanitize_fontnames = function (rawnames)
-    local result = { }
-    for category, namedata in next, rawnames do
-
-        if type (namedata) == "string" then
-            result [category] = utf8gsub (utf8lower (namedata),
-                                          invalidchars,
-                                          "")
-        else
-            local target = { }
-            for field, name in next, namedata do
-                target [field] = utf8gsub (utf8lower (name),
-                                        invalidchars,
-                                        "")
-            end
-            result [category] = target
-        end
-    end
-    return result
-end
-
-local find_files_indeed
-find_files_indeed = function (acc, dirs, filter)
-    if not next (dirs) then --- done
-        return acc
-    end
-
-    local pwd   = lfscurrentdir ()
-    local dir   = dirs[#dirs]
-    dirs[#dirs] = nil
-
-    if lfschdir (dir) then
-        lfschdir (pwd)
-
-        local newfiles = { }
-        for ent in lfsdir (dir) do
-            if ent ~= "." and ent ~= ".." then
-                local fullpath = dir .. "/" .. ent
-                if filter (fullpath) == true then
-                    if lfsisdir (fullpath) then
-                        dirs[#dirs+1] = fullpath
-                    elseif lfsisfile (fullpath) then
-                        newfiles[#newfiles+1] = fullpath
-                    end
-                end
-            end
-        end
-        return find_files_indeed (tableappend (acc, newfiles),
-                                  dirs, filter)
-    end
-    --- could not cd into, so we skip it
-    return find_files_indeed (acc, dirs, filter)
-end
-
-local dummyfilter = function () return true end
-
---- the optional filter function receives the full path of a file
---- system entity. a filter applies if the first argument it returns is
---- true.
-
---- string -> function? -> string list
-local find_files = function (root, filter)
-    if lfsisdir (root) then
-        return find_files_indeed ({}, { root }, filter or dummyfilter)
-    end
-end
-
-
---[[doc--
-This is a sketch of the luaotfload db:
-
-    type dbobj = {
-        families    : familytable;
-        files       : filemap;
-        status      : filestatus;
-        mappings    : fontentry list;
-        meta        : metadata;
-        names       : namedata; // TODO: check for relevance after db is finalized
-    }
-    and familytable = {
-        local  : (format, familyentry) hash; // specified with include dir
-        texmf  : (format, familyentry) hash;
-        system : (format, familyentry) hash;
-    }
-    and familyentry = {
-        regular     : sizes;
-        italic      : sizes;
-        bold        : sizes;
-        bolditalic  : sizes;
-    }
-    and sizes = {
-        default : int;              // points into mappings or names
-        optical : (int, int) list;  // design size -> index entry
-    }
-    and metadata = {
-        formats     : string list; // { "otf", "ttf", "ttc", "dfont" }
-        statistics  : TODO;
-        version     : float;
-    }
-    and filemap = {
-        base : {
-            local  : (string, int) hash; // basename -> idx
-            system : (string, int) hash;
-            texmf  : (string, int) hash;
-        };
-        bare : {
-            local  : (string, (string, int) hash) hash; // location -> (barename -> idx)
-            system : (string, (string, int) hash) hash;
-            texmf  : (string, (string, int) hash) hash;
-        };
-        full : (int, string) hash; // idx -> full path
-    }
-    and fontentry = {
-        barename    : string;
-        familyname  : string;
-        filename    : string;
-        fontname    : string; // <- metadata
-        fullname    : string; // <- metadata
-        sanitized   : {
-            family         : string;
-            fontstyle_name : string; // <- new in 2.4
-            fontname       : string; // <- metadata
-            fullname       : string; // <- namedata.names
-            metafamily     : string;
-            pfullname      : string;
-            prefmodifiers  : string;
-            psname         : string;
-            subfamily      : string;
-        };
-        size         : int list;
-        slant        : int;
-        subfont      : int;
-        location     : local | system | texmf;
-        weight       : int;
-        width        : int;
-        units_per_em : int;         // mainly 1000, but also 2048 or 256
-    }
-    and filestatus = (string,       // fullname
-                      { index       : int list; // pointer into mappings
-                        timestamp   : int;      }) dict
-
-beware that this is a reconstruction and may be incomplete.
-
-mtx-fonts has in names.tma:
-
-    type names = {
-        cache_uuid    : uuid;
-        cache_version : float;
-        datastate     : uuid list;
-        fallbacks     : (filetype, (basename, int) hash) hash;
-        families      : (basename, int list) hash;
-        files         : (filename, fullname) hash;
-        indices       : (fullname, int) hash;
-        mappings      : (filetype, (basename, int) hash) hash;
-        names         : ? (empty hash) ?;
-        rejected      : (basename, int) hash;
-        specifications: fontentry list;
-    }
-    and fontentry = {
-        designsize    : int;
-        familyname    : string;
-        filename      : string;
-        fontname      : string;
-        format        : string;
-        fullname      : string;
-        maxsize       : int;
-        minsize       : int;
-        modification  : int;
-        rawname       : string;
-        style         : string;
-        subfamily     : string;
-        variant       : string;
-        weight        : string;
-        width         : string;
-    }
-
---doc]]--
-
-local initialize_namedata = function (formats) --- returns dbobj
-    return {
-        --families        = { },
-        status          = { }, -- was: status; map abspath -> mapping
-        mappings        = { }, -- TODO: check if still necessary after rewrite
-        names           = { },
---      files           = { }, -- created later
-        meta            = {
-            formats    = formats,
-            statistics = { },
-            version    = names.version,
-        },
-    }
-end
-
---[[doc--
-
-    Since Luaotfload does not depend on the lualibs anymore we
-    have to put our own small wrappers for the gzip library in
-    place.
-
-    load_gzipped -- Read and decompress and entire gzipped file.
-    Returns the uncompressed content as a string.
-
---doc]]--
-
-local load_gzipped = function (filename)
-    local gh = gzipopen (filename,"rb")
-    if gh then
-        local data = gh:read "*all"
-        gh:close ()
-        return data
-    end
-end
-
---[[doc--
-
-    save_gzipped -- Compress and write a string to file. The return
-    value is the number of bytes written. Zlib parameters are: best
-    compression and default strategy.
-
---doc]]--
-
-local save_gzipped = function (filename, data)
-    local gh = gzipopen (filename, "wb9")
-    if gh then
-        gh:write (data)
-        local bytes = gh:seek ()
-        gh:close ()
-        return bytes
-    end
-end
-
---- 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.
-
---- string -> (string * table)
-local load_lua_file = function (path)
-    local foundname = filereplacesuffix (path, "luc")
-    local code      = nil
-
-    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 --- probe gzipped file
-        foundname = filereplacesuffix (path, "lua.gz")
-        local chunk = load_gzipped (foundname)
-        if chunk then
-            code = load (chunk, "t")
-        end
-    end
-
-    if not code then return nil, nil end
-    return foundname, code ()
-end
-
---- define locals in scope
-local crude_file_lookup
-local crude_file_lookup_verbose
-local find_closest
-local flush_lookup_cache
-local ot_fullinfo
-local t1_fullinfo
-local load_names
-local load_lookups
-local read_blacklist
-local reload_db
-local resolve_name
-local resolve_cached
-local resolve_fullpath
-local save_names
-local save_lookups
-local update_names
-local get_font_filter
-local set_font_filter
-
---- state of the database
-local fonts_reloaded = false
-local fonts_read     = 0
-
---- limit output when approximate font matching (luaotfload-tool -F)
-local fuzzy_limit = 1 --- display closest only
-
---- bool? -> dbobj
-load_names = function (dry_run)
-    local starttime = osgettimeofday ()
-    local foundname, data = load_lua_file (names.path.index.lua)
-
-    if data then
-        report ("both", 2, "db",
-                "Font names database loaded", "%s", foundname)
-        report ("info", 3, "db", "Loading took %0.f ms.",
-                1000 * (osgettimeofday () - starttime))
-
-        local db_version, nms_version
-        if data.meta then
-            db_version = data.meta.version
-        else
-            --- Compatibility branch; the version info used to be
-            --- stored in the table root which is why updating from
-            --- an earlier index version broke.
-            db_version = data.version or -42 --- invalid
-        end
-        nms_version = names.version
-        if db_version ~= nms_version then
-            report ("both", 0, "db",
-                    [[Version mismatch; expected %4.3f, got %4.3f.]],
-                    nms_version, db_version)
-            if not fonts_reloaded then
-                report ("both", 0, "db", [[Force rebuild.]])
-                data = update_names ({ }, true, false)
-                if not data then
-                    report ("both", 0, "db",
-                            "Database creation unsuccessful.")
-                end
-            end
-        end
-    else
-        report ("both", 0, "db",
-                [[Font names database not found, generating new one.]])
-        report ("both", 0, "db",
-                [[This can take several minutes; please be patient.]])
-        data = update_names (initialize_namedata (get_font_filter ()),
-                             nil, dry_run)
-        if not data then
-            report ("both", 0, "db", "Database creation unsuccessful.")
-        end
-    end
-    return data
-end
-
---- unit -> unit
-load_lookups = function ( )
-    local foundname, data = load_lua_file(names.path.lookups.lua)
-    if data then
-        report("both", 3, "cache",
-               "Lookup cache loaded from %s.", foundname)
-    else
-        report("both", 1, "cache",
-               "No lookup cache, creating empty.")
-        data = { }
-    end
-    lookup_cache = data
-end
-
-local regular_synonym = {
-    book    = "r",
-    normal  = "r",
-    plain   = "r",
-    regular = "r",
-    roman   = "r",
-}
-
-local italic_synonym = {
-    oblique = true,
-    slanted = true,
-    italic  = true,
-}
-
-local style_category = {
-    regular     = "r",
-    bold        = "b",
-    bolditalic  = "bi",
-    italic      = "i",
-    r           = "regular",
-    b           = "bold",
-    bi          = "bolditalic",
-    i           = "italic",
-}
-
-local type1_formats = { "tfm", "ofm", }
-
-local dummy_findfile = resolvers.findfile -- from basics-gen
-
---- filemap -> string -> string -> (string | bool)
-local verbose_lookup = function (data, kind, filename)
-    local found = data[kind][filename]
-    if found ~= nil then
-        found = data.full[found]
-        if found == nil then --> texmf
-            report("info", 0, "db",
-                "Crude file lookup: req=%s; hit=%s => kpse.",
-                filename, kind)
-            found = dummy_findfile(filename)
-        else
-            report("info", 0, "db",
-                "Crude file lookup: req=%s; hit=%s; ret=%s.",
-                filename, kind, found)
-        end
-        return found
-    end
-    return false
-end
-
---- string -> (string * string * bool)
-crude_file_lookup_verbose = function (filename)
-    if not name_index then name_index = load_names() end
-    local mappings  = name_index.mappings
-    local files     = name_index.files
-    local found
-
-    --- look up in db first ...
-    found = verbose_lookup(files, "bare", filename)
-    if found then
-        return found, nil, true
-    end
-    found = verbose_lookup(files, "base", filename)
-    if found then
-        return found, nil, true
-    end
-
-    --- ofm and tfm, returns pair
-    for i=1, #type1_formats do
-        local format = type1_formats[i]
-        if resolvers.findfile(filename, format) then
-            return file.addsuffix(filename, format), format, true
-        end
-    end
-    return filename, nil, false
-end
-
-local lookup_filename = function (filename)
-    if not name_index then name_index = load_names () end
-    local files    = name_index.files
-    local basedata = files.base
-    local baredata = files.bare
-    for i = 1, #location_precedence do
-        local location = location_precedence [i]
-        local basenames = basedata [location]
-        local barenames = baredata [location]
-        local idx
-        if basenames ~= nil then
-            idx = basenames [filename]
-            if idx then
-                goto done
-            end
-        end
-        if barenames ~= nil then
-            for j = 1, #format_precedence do
-                local format  = format_precedence [j]
-                local filemap = barenames [format]
-                if filemap then
-                    idx = barenames [format] [filename]
-                    if idx then
-                        break
-                    end
-                end
-            end
-        end
-::done::
-        if idx then
-            return files.full [idx]
-        end
-    end
-end
-
---- string -> (string * string * bool)
-crude_file_lookup = function (filename)
-    local found = lookup_filename (filename)
-
-    if not found then
-        found = dummy_findfile(filename)
-    end
-
-    if found then
-        return found, nil, true
-    end
-
-    for i=1, #type1_formats do
-        local format = type1_formats[i]
-        if resolvers.findfile(filename, format) then
-            return file.addsuffix(filename, format), format, true
-        end
-    end
-
-    return filename, nil, false
-end
-
---[[doc--
-Existence of the resolved file name is verified differently depending
-on whether the index entry has a texmf flag set.
---doc]]--
-
-local get_font_file = function (index)
-    local entry = name_index.mappings [index]
-    if not entry then
-        return false
-    end
-    local basename = entry.basename
-    if entry.location == "texmf" then
-        if kpselookup(basename) then
-            return true, basename, entry.subfont
-        end
-    else --- system, local
-        local fullname = name_index.files.full [index]
-        if lfsisfile (fullname) then
-            return true, basename, entry.subfont
-        end
-    end
-    return false
-end
-
---[[doc--
-We need to verify if the result of a cached lookup actually exists in
-the texmf or filesystem. Again, due to the schizoprenic nature of the
-font managment we have to check both the system path and the texmf.
---doc]]--
-
-local verify_font_file = function (basename)
-    local path = resolve_fullpath (basename)
-    if path and lfsisfile(path) then
-        return true
-    end
-    if kpsefind_file(basename) then
-        return true
-    end
-    return false
-end
-
---[[doc--
-Lookups can be quite costly, more so the less specific they are.
-Even if we find a matching font eventually, the next time the
-user compiles Eir document E will have to stand through the delay
-again.
-Thus, some caching of results -- even between runs -- is in order.
-We’ll just store successful name: lookups in a separate cache file.
-
-type lookup_cache = (string, (string * num)) dict
-
-The spec is expected to be modified in place (ugh), so we’ll have to
-catalogue what fields actually influence its behavior.
-
-Idk what the “spec” resolver is for.
-
-        lookup      inspects            modifies
-        ----------  -----------------   ---------------------------
-        file:       name                forced, name
-        name:[*]    name, style, sub,   resolved, sub, name, forced
-                    optsize, size
-        spec:       name, sub           resolved, sub, name, forced
-
-[*] name: contains both the name resolver from luatex-fonts and
-    resolve_name() below
-
-From my reading of font-def.lua, what a resolver does is
-basically rewrite the “name” field of the specification record
-with the resolution.
-Also, the fields “resolved”, “sub”, “force” etc. influence the outcome.
-
---doc]]--
-
-local concat_char = "#"
-local hash_fields = {
-    --- order is important
-    "specification", "style", "sub", "optsize", "size",
-}
-local n_hash_fields = #hash_fields
-
---- spec -> string
-local hash_request = function (specification)
-    local key = { } --- segments of the hash
-    for i=1, n_hash_fields do
-        local field = specification[hash_fields[i]]
-        if field then
-            key[#key+1] = field
-        end
-    end
-    return tableconcat(key, concat_char)
-end
-
---- 'a -> 'a -> table -> (string * int|boolean * boolean)
-resolve_cached = function (specification)
-    if not lookup_cache then load_lookups () end
-    local request = hash_request(specification)
-    report("both", 4, "cache", "Looking for %q in cache ...",
-           request)
-
-    local found = lookup_cache [request]
-
-    --- case 1) cache positive ----------------------------------------
-    if found then --- replay fields from cache hit
-        report("info", 4, "cache", "Found!")
-        local basename = found[1]
-        --- check the presence of the file in case it’s been removed
-        local success = verify_font_file (basename)
-        if success == true then
-            return basename, found[2], true
-        end
-        report("both", 4, "cache", "Cached file not found; resolving again.")
-    else
-        report("both", 4, "cache", "Not cached; resolving.")
-    end
-
-    --- case 2) cache negative ----------------------------------------
-    --- first we resolve normally ...
-    local filename, subfont = resolve_name (specification)
-    if not filename then
-        return nil, nil
-    end
-    --- ... then we add the fields to the cache ... ...
-    local entry = { filename, subfont }
-    report("both", 4, "cache", "New entry: %s.", request)
-    lookup_cache [request] = entry
-
-    --- obviously, the updated cache needs to be stored.
-    --- TODO this should trigger a save only once the
-    ---      document is compiled (finish_pdffile callback?)
-    report("both", 5, "cache", "Saving updated cache.")
-    local success = save_lookups ()
-    if not success then --- sad, but not critical
-        report("both", 0, "cache", "Error writing cache.")
-    end
-    return filename, subfont
-end
-
---- this used to be inlined; with the lookup cache we don’t
---- have to be parsimonious wrt function calls anymore
---- “found” is the match accumulator
-local add_to_match = function (found, size, face)
-
-    local continue = true
-
-    local optsize = face.size
-
-    if optsize and next (optsize) then
-        local dsnsize, maxsize, minsize
-        dsnsize = optsize[1]
-        maxsize = optsize[2]
-        minsize = optsize[3]
-
-        if size ~= nil
-        and (dsnsize == size or (size > minsize and size <= maxsize))
-        then
-            found[1] = face
-            continue = false ---> break
-        else
-            found[#found+1] = face
-        end
-    else
-        found[1] = face
-        continue = false ---> break
-    end
-
-    return found, continue
-end
-
-local choose_closest = function (distances)
-    local closest = 2^51
-    local match
-    for i = 1, #distances do
-        local d, index = unpack (distances [i])
-        if d < closest then
-            closest = d
-            match   = index
-        end
-    end
-    return match
-end
-
---[[doc--
-
-    choose_size -- Pick a font face of appropriate size from the list
-    of family members with matching style. There are three categories:
-
-        1. exact matches: if there is a face whose design size equals
-           the asked size, it is returned immediately and no further
-           candidates are inspected.
-
-        2. range matches: of all faces in whose design range the
-           requested size falls the one whose center the requested
-           size is closest to is returned.
-
-        3. out-of-range matches: of all other faces (i. e. whose range
-           is above or below the asked size) the one is chosen whose
-           boundary (upper or lower) is closest to the requested size.
-
-        4. default matches: if no design size or a design size of zero
-           is requested, the face with the default size is returned.
-
---doc]]--
-
---- int * int * int * int list -> int -> int
-local choose_size = function (sizes, askedsize)
-    local mappings = name_index.mappings
-    local match    = sizes.default
-    local exact
-    local inrange  = { } --- distance * index list
-    local norange  = { } --- distance * index list
-    local fontname, subfont
-    if askedsize ~= 0 then
-        --- firstly, look for an exactly matching design size or
-        --- matching range
-        for i = 1, #sizes do
-            local dsnsize, high, low, index = unpack (sizes [i])
-            if dsnsize == askedsize then
-                --- exact match, this is what we were looking for
-                exact = index
-                goto skip
-            elseif askedsize < low then
-                --- below range, add to the norange table
-                local d = low - askedsize
-                norange [#norange + 1] = { d, index }
-            elseif askedsize > high then
-                --- beyond range, add to the norange table
-                local d = askedsize - high
-                norange [#norange + 1] = { d, index }
-            else
-                --- range match
-                local d = ((low + high) / 2) - askedsize
-                if d < 0 then
-                    d = -d
-                end
-                inrange [#inrange + 1] = { d, index }
-            end
-        end
-    end
-::skip::
-    if exact then
-        match = exact
-    elseif #inrange > 0 then
-        match = choose_closest (inrange)
-    elseif #norange > 0 then
-        match = choose_closest (norange)
-    end
-    return match
-end
-
---[[doc--
-
-    resolve_familyname -- Query the families table for an entry
-    matching the specification.
-    The parameters “name” and “style” are pre-sanitized.
-
---doc]]--
---- spec -> string -> string -> int -> string * int
-local resolve_familyname = function (specification, name, style, askedsize)
-    local families   = name_index.families
-    local mappings   = name_index.mappings
-    local candidates = nil
-    --- arrow code alert
-    for i = 1, #location_precedence do
-        local location = location_precedence [i]
-        local locgroup = families [location]
-        for j = 1, #format_precedence do
-            local format       = format_precedence [j]
-            local fmtgroup     = locgroup [format]
-            if fmtgroup then
-                local familygroup  = fmtgroup [name]
-                if familygroup then
-                    local stylegroup = familygroup [style]
-                    if stylegroup then --- suitable match
-                        candidates = stylegroup
-                        goto done
-                    end
-                end
-            end
-        end
-    end
-    if true then
-        return nil, nil
-    end
-::done::
-    index = choose_size (candidates, askedsize)
-    local success, resolved, subfont = get_font_file (index)
-    if not success then
-        return nil, nil
-    end
-    report ("info", 2, "db", "Match found: %s(%d).",
-            resolved, subfont or 0)
-    return resolved, subfont
-end
-
-local resolve_fontname = function (specification, name, style)
-    local mappings    = name_index.mappings
-    local fallback    = nil
-    local lastresort  = nil
-    style = style_category [style]
-    for i = 1, #mappings do
-        local face = mappings [i]
-        local prefmodifiers = face.prefmodifiers
-        local subfamily     = face.subfamily
-        if     face.fontname   == name
-            or face.splainname == name
-            or face.fullname   == name
-            or face.psname     == name
-        then
-            return face.basename, face.subfont
-        elseif face.familyname == name then
-            if prefmodifiers == style
-                or subfamily == style
-            then
-                fallback = face
-            elseif regular_synonym [prefmodifiers]
-                or regular_synonym [subfamily]
-            then
-                lastresort = face
-            end
-        elseif face.metafamily == name
-            and (regular_synonym [prefmodifiers]
-                 or regular_synonym [subfamily])
-        then
-            lastresort = face
-        end
-    end
-    if fallback then
-        return fallback.basename, fallback.subfont
-    end
-    if lastresort then
-        return lastresort.basename, lastresort.subfont
-    end
-    return nil, nil
-end
-
---[[doc--
-
-    resolve_name -- Perform a name: lookup. This first queries the
-    font families table and, if there is no match for the spec, the
-    font names table.
-    The return value is a pair consisting of the file name and the
-    subfont index if appropriate..
-
-    the request specification has the fields:
-
-      · features: table
-        · normal: set of { ccmp clig itlc kern liga locl mark mkmk rlig }
-        · ???
-      · forced:   string
-      · lookup:   "name"
-      · method:   string
-      · name:     string
-      · resolved: string
-      · size:     int
-      · specification: string (== <lookup> ":" <name>)
-      · sub:      string
-
-    The “size” field deserves special attention: if its value is
-    negative, then it actually specifies a scalefactor of the
-    design size of the requested font. This happens e.g. if a font is
-    requested without an explicit “at size”. If the font is part of a
-    larger collection with different design sizes, this complicates
-    matters a bit: Normally, the resolver prefers fonts that have a
-    design size as close as possible to the requested size. If no
-    size specified, then the design size is implied. But which design
-    size should that be? Xetex appears to pick the “normal” (unmarked)
-    size: with Adobe fonts this would be the one that is neither
-    “caption” nor “subhead” nor “display” &c ... For fonts by Adobe this
-    seems to be the one that does not receive a “prefmodifiers” field.
-    (IOW Adobe uses the “prefmodifiers” field to encode the design size
-    in more or less human readable format.) However, this is not true
-    of LM and EB Garamond. As this matters only where there are
-    multiple design sizes to a given font/style combination, we put a
-    workaround in place that chooses that unmarked version.
-
-    The first return value of “resolve_name” is the file name of the
-    requested font (string). It can be passed to the fullname resolver
-    get_font_file().
-    The second value is either “false” or an integer indicating the
-    subfont index in a TTC.
-
---doc]]--
-
---- table -> string * (int | bool)
-resolve_name = function (specification)
-    local resolved, subfont
-    if not name_index then name_index = load_names () end
-    local name      = sanitize_fontname (specification.name)
-    local style     = sanitize_fontname (specification.style) or "r"
-    local askedsize = specification.optsize
-
-    if askedsize then
-        askedsize = tonumber (askedsize)
-    else
-        askedsize = specification.size
-        if askedsize and askedsize >= 0 then
-            askedsize = askedsize / 65536
-        else
-            askedsize = 0
-        end
-    end
-
-    resolved, subfont = resolve_familyname (specification,
-                                            name,
-                                            style,
-                                            askedsize)
-    if not resolved then
-        resolved, subfont = resolve_fontname (specification,
-                                              name,
-                                              style)
-    end
-    if not resolved then
-        resolved = specification.name, false
-    end
-
-    if not resolved then
-        if not fonts_reloaded then
-            return reload_db ("Font not found.",
-                              resolve_name,
-                              specification)
-        end
-    end
-    return resolved, subfont
-end
-
-resolve_fullpath = function (fontname, ext) --- getfilename()
-    if not name_index then name_index = load_names () end
-    local files = name_index.files
-    local basedata = files.base
-    local baredata = files.bare
-    for i = 1, #location_precedence do
-        local location = location_precedence [i]
-        local basenames = basedata [location]
-        local idx
-        if basenames ~= nil then
-            idx = basenames [fontname]
-        end
-        if ext then
-            local barenames = baredata [location] [ext]
-            if not idx and barenames ~= nil then
-                idx = barenames [fontname]
-            end
-        end
-        if idx then
-            return files.full [idx]
-        end
-    end
-    return ""
-end
-
---- when reload is triggered we update the database
---- and then re-run the caller with the arg list
-
---- string -> ('a -> 'a) -> 'a list -> 'a
-reload_db = function (why, caller, ...)
-    local namedata  = name_index
-    local formats   = tableconcat (namedata.meta.formats, ",")
-
-    report ("both", 1, "db",
-            "Reload initiated (formats: %s); reason: %q.",
-            formats, why)
-
-    set_font_filter (formats)
-    namedata = update_names (namedata, false, false)
-
-    if namedata then
-        fonts_reloaded = true
-        name_index = namedata
-        return caller (...)
-    end
-
-    report ("both", 0, "db", "Database update unsuccessful.")
-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
-
---- string -> int -> bool
-find_closest = function (name, limit)
-    local name     = sanitize_fontname (name)
-    limit          = limit or fuzzy_limit
-
-    if not name_index then name_index = load_names () end
-    if not name_index or type (name_index) ~= "table" then
-        if not fonts_reloaded then
-            return reload_db("no database", find_closest, name)
-        end
-        return false
-    end
-
-    local by_distance   = { } --- (int, string list) dict
-    local distances     = { } --- int list
-    local cached        = { } --- (string, int) dict
-    local mappings      = name_index.mappings
-    local n_fonts       = #mappings
-
-    for n = 1, n_fonts do
-        local current    = mappings[n]
-        --[[
-            This is simplistic but surpisingly fast.
-            Matching is performed against the “fullname” field
-            of a db record in preprocessed form. We then store the
-            raw “fullname” at its edit distance.
-            We should probably do some weighting over all the
-            font name categories as well as whatever agrep
-            does.
-        --]]
-        local fullname  = current.plainname
-        local sfullname = current.fullname
-        local dist      = cached[sfullname]--- maybe already calculated
-
-        if not dist then
-            dist = iterative_levenshtein(name, sfullname)
-            cached[sfullname] = 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
-
-    --- 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 \"%s\": %s\n    "
-                   .. tableconcat (namelst, "\n    "),
-                   name, dist)
-        end
-
-        return true
-    end
-    return false
-end --- find_closest()
-
---[[doc--
-
-    load_font_file -- Safely open a font file. See
-    <http://www.ntg.nl/pipermail/ntg-context/2013/075885.html>
-    regarding the omission of ``fontloader.close()``.
-
-    TODO --   check if fontloader.info() is ready for prime in 0.78+
-         --   fields /tables needed:
-                    -- names
-                    -- postscriptname
-                    -- validation_state
-                    -- ..
-
---doc]]--
-
-local load_font_file = function (filename, subfont)
-    local rawfont, _msg = fontloaderopen (filename, subfont)
-    if not rawfont then
-        report ("log", 1, "db", "ERROR: failed to open %s.", filename)
-        return
-    end
-    return rawfont
-end
-
---- rawdata -> (int * int * int | bool)
-
-local get_size_info = function (metadata)
-    local design_size         = metadata.design_size
-    local design_range_top    = metadata.design_range_top
-    local design_range_bottom = metadata.design_range_bottom
-
-    local fallback_size = design_size         ~= 0 and design_size
-                       or design_range_bottom ~= 0 and design_range_bottom
-                       or design_range_top    ~= 0 and design_range_top
-
-    if fallback_size then
-        design_size         = (design_size         or fallback_size) / 10
-        design_range_top    = (design_range_top    or fallback_size) / 10
-        design_range_bottom = (design_range_bottom or fallback_size) / 10
-        return {
-            design_size, design_range_top, design_range_bottom,
-        }
-    end
-
-    return false
-end
-
-local get_english_names = function (metadata)
-    local names = metadata.names
-    local english_names
-
-    if names then
-        --inspect(names)
-        for _, raw_namedata in next, names do
-            if raw_namedata.lang == "English (US)" then
-                return raw_namedata.names
-            end
-        end
-    end
-
-    -- no (English) names table, probably a broken font
-    report("both", 3, "db",
-            "%s: missing or broken English names table.", basename)
-    return { fontname = metadata.fontname,
-             fullname = metadata.fullname, }
-end
-
---[[--
-    In case of broken PS names we set some dummies. However, we cannot
-    directly modify the font data as returned by fontloader.open() because
-    it is a userdata object.
-
-    For this reason we copy what is necessary whilst keeping the table
-    structure the same as in the tfmdata.
---]]--
-local get_raw_info = function (metadata, basename)
-    local fullname
-    local fontname
-    local psname
-
-    local validation_state = metadata.validation_state
-    if validation_state
-        and tablecontains (validation_state, "bad_ps_fontname")
-    then
-        --- Broken names table, e.g. avkv.ttf with UTF-16 strings;
-        --- we put some dummies in place like the fontloader
-        --- (font-otf.lua) does.
-        report("both", 3, "db",
-               "%s has invalid postscript font names, using dummies.",
-               basename)
-        fontname = "bad-fontname-" .. basename
-        fullname = "bad-fullname-" .. basename
-    else
-        fontname = metadata.fontname
-        fullname = metadata.fullname
-    end
-
-    return {
-        familyname          = metadata.familyname,
-        fontname            = fontname,
-        fontstyle_name      = metadata.fontstyle_name,
-        fullname            = fullname,
-        italicangle         = metadata.italicangle,
-        names               = metadata.names,
-        pfminfo             = metadata.pfminfo,
-        units_per_em        = metadata.units_per_em,
-        version             = metadata.version,
-        design_size         = metadata.design_size,
-        design_range_top    = metadata.design_range_top,
-        design_range_bottom = metadata.design_range_bottom,
-    }
-end
-
-local organize_namedata = function (rawinfo,
-                                    english_names,
-                                    basename,
-                                    info)
-    local default_name = english_names.compatfull
-                      or english_names.fullname
-                      or english_names.postscriptname
-                      or rawinfo.fullname
-                      or rawinfo.fontname
-                      or info.fullname
-                      or info.fontname
-    local default_family = english_names.preffamily
-                        or english_names.family
-                        or rawinfo.familyname
-                        or info.familyname
---    local default_modifier = english_names.prefmodifiers
---                          or english_names.subfamily
-    local fontnames = {
-        --- see
-        --- https://developer.apple.com/fonts/TTRefMan/RM06/Chap6name.html
-        --- http://www.microsoft.com/typography/OTSPEC/name.htm#NameIDs
-        english = {
-            --- where a “compatfull” field is given, the value of “fullname” is
-            --- either identical or differs by separating the style
-            --- with a hyphen and omitting spaces. (According to the
-            --- spec, “compatfull” is “Macintosh only”.)
-            --- Of the three “fullname” fields, this one appears to be the one
-            --- with the entire name given in a legible,
-            --- non-abbreviated fashion, for most fonts at any rate.
-            --- However, in some fonts (e.g. CMU) all three fields are
-            --- identical.
-            fullname      = --[[ 18 ]] english_names.compatfull
-                         or --[[  4 ]] english_names.fullname
-                         or default_name,
-            --- we keep both the “preferred family” and the “family”
-            --- values around since both are valid but can turn out
-            --- quite differently, e.g. with Latin Modern:
-            ---     preffamily: “Latin Modern Sans”,
-            ---     family:     “LM Sans 10”
-            preffamily    = --[[ 16 ]] english_names.preffamilyname,
-            family        = --[[  1 ]] english_names.family or default_family,
-            prefmodifiers = --[[ 17 ]] english_names.prefmodifiers,
-            subfamily     = --[[  2 ]] english_names.subfamily,
-            psname        = --[[  6 ]] english_names.postscriptname,
-        },
-
-        metadata = {
-            fullname      = rawinfo.fullname,
-            fontname      = rawinfo.fontname,
-            familyname    = rawinfo.familyname,
-        },
-
-        info = {
-            fullname      = info.fullname,
-            familyname    = info.familyname,
-            fontname      = info.fontname,
-        },
-    }
-
-    -- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size
-    if rawinfo.fontstyle_name then
-        --- not present in all fonts, often differs from the preferred
-        --- subfamily as well as subfamily fields, e.g. with
-        --- LMSans10-BoldOblique:
-        ---     subfamily:      “Bold Italic”
-        ---     prefmodifiers:  “10 Bold Oblique”
-        ---     fontstyle_name: “Bold Oblique”
-        for _, name in next, rawinfo.fontstyle_name do
-            if name.lang == 1033 then --- I hate magic numbers
-                fontnames.fontstyle_name = name.name
-            end
-        end
-    end
-
-    return {
-        sanitized     = sanitize_fontnames (fontnames),
-        fontname      = rawinfo.fontname,
-        fullname      = rawinfo.fullname,
-        familyname    = rawinfo.familyname,
-    }
-end
-
-
-local dashsplitter = lpegsplitat "-"
-
-local split_fontname = function (fontname)
-    --- sometimes the style hides in the latter part of the
-    --- fontname, separated by a dash, e.g. “Iwona-Regular”,
-    --- “GFSSolomos-Regular”
-    local splitted = { lpegmatch (dashsplitter, fontname) }
-    if next (splitted) then
-        return sanitize_fontname (splitted [#splitted])
-    end
-end
-
-local organize_styledata = function (fontname,
-                                     metadata,
-                                     english_names,
-                                     info)
-    local pfminfo   = metadata.pfminfo
-    local names     = metadata.names
-
-    return {
-    --- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size
-        size            = get_size_info (metadata),
-        weight          = pfminfo.weight or 400,
-        split           = split_fontname (fontname),
-        width           = pfminfo.width,
-        italicangle     = metadata.italicangle,
-    --- this is for querying, see www.ntg.nl/maps/40/07.pdf for details
-        units_per_em    = metadata.units_per_em,
-        version         = metadata.version,
-    }
-end
-
---[[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]]--
-
---- string -> int -> bool -> string -> fontentry
-
-ot_fullinfo = function (filename,
-                        subfont,
-                        location,
-                        basename,
-                        format,
-                        info)
-
-    local metadata = load_font_file (filename, subfont)
-    if not metadata then
-        return nil
-    end
-
-    local rawinfo = get_raw_info (metadata, basename)
-    --- Closing the file manually is a tad faster and more memory
-    --- efficient than having it closed by the gc
-    fontloaderclose (metadata)
-
-    local english_names = get_english_names (rawinfo)
-    local namedata      = organize_namedata (rawinfo,
-                                             english_names,
-                                             basename,
-                                             info)
-    local style         = organize_styledata (namedata.fontname,
-                                              rawinfo,
-                                              english_names,
-                                              info)
-
-    local res = {
-        file            = { base        = basename,
-                            full        = filename,
-                            subfont     = subfont,
-                            location    = location or "system" },
-        format          = format,
-        names           = namedata,
-        style           = style,
-        version         = rawinfo.version,
-    }
-    return res
-end
-
---[[doc--
-
-    Type1 font inspector. In comparison with OTF, PFB’s contain a good
-    deal less name fields which makes it tricky in some parts to find a
-    meaningful representation for the database.
-
-    Good read: http://www.adobe.com/devnet/font/pdfs/5004.AFM_Spec.pdf
-
---doc]]--
-
---- string -> int -> bool -> string -> fontentry
-
-t1_fullinfo = function (filename, _subfont, location, basename, format)
-    local sanitized
-    local metadata      = load_font_file (filename)
-    local fontname      = metadata.fontname
-    local fullname      = metadata.fullname
-    local familyname    = metadata.familyname
-    local italicangle   = metadata.italicangle
-    local splitstyle    = split_fontname (fontname)
-    local style         = ""
-    local weight
-
-    sanitized = sanitize_fontnames ({
-        fontname        = fontname,
-        psname          = fullname,
-        pfullname       = fullname,
-        metafamily      = family,
-        familyname      = familyname,
-        weight          = metadata.weight, --- string identifier
-        prefmodifiers   = style,
-    })
-
-    weight = sanitized.weight
-
-    if weight == "bold" then
-        style = weight
-    end
-
-    if italicangle ~= 0 then
-        style = style .. "italic"
-    end
-
-    return {
-        basename         = basename,
-        fullpath         = filename,
-        subfont          = false,
-        location         = location or "system",
-        format           = format,
-        fullname         = sanitized.fullname,
-        fontname         = sanitized.fontname,
-        familyname       = sanitized.familyname,
-        plainname        = fullname,
-        splainname       = sanitized.fullname,
-        psname           = sanitized.fontname,
-        version          = metadata.version,
-        size             = false,
-        splitstyle       = splitstyle,
-        fontstyle_name   = style ~= "" and style or weight,
-        weight           = metadata.pfminfo.weight or 400,
-        italicangle      = italicangle,
-    }
-end
-
-local loaders = {
-    dfont   = ot_fullinfo,
-    otf     = ot_fullinfo,
-    ttc     = ot_fullinfo,
-    ttf     = ot_fullinfo,
-
-    pfb     = t1_fullinfo,
-    pfa     = t1_fullinfo,
-}
-
---- not side-effect free!
-
-local compare_timestamps = function (fullname,
-                                     currentstatus,
-                                     currententrystatus,
-                                     currentmappings,
-                                     targetstatus,
-                                     targetentrystatus,
-                                     targetmappings)
-
-    local currenttimestamp = currententrystatus
-                         and currententrystatus.timestamp
-    local targettimestamp  = lfsattributes (fullname, "modification")
-
-    if targetentrystatus ~= nil
-    and targetentrystatus.timestamp == targettimestamp then
-        report ("log", 3, "db", "Font %q already read.", fullname)
-        return false
-    end
-
-    targetentrystatus.timestamp = targettimestamp
-    targetentrystatus.index     = targetentrystatus.index or { }
-
-    if  currenttimestamp == targettimestamp
-    and not targetentrystatus.index [1]
-    then
-        --- copy old namedata into new
-
-        for _, currentindex in next, currententrystatus.index do
-
-            local targetindex   = #targetentrystatus.index
-            local fullinfo      = currentmappings [currentindex]
-            local location      = #targetmappings + 1
-
-            targetmappings [location]                 = fullinfo
-            targetentrystatus.index [targetindex + 1] = location
-        end
-
-        report ("log", 3, "db", "Font %q already indexed.", fullname)
-
-        return false
-    end
-
-    return true
-end
-
-local insert_fullinfo = function (fullname,
-                                  basename,
-                                  n_font,
-                                  loader,
-                                  format,
-                                  location,
-                                  targetmappings,
-                                  targetentrystatus,
-                                  info)
-
-    local subfont
-    if n_font ~= false then
-        subfont = n_font - 1
-    else
-        subfont = false
-        n_font  = 1
-    end
-
-    local fullinfo = loader (fullname, subfont,
-                             location, basename,
-                             format, info)
-
-    if not fullinfo then
-        return false
-    end
-
-    local index = targetentrystatus.index [n_font]
-
-    if not index then
-        index = #targetmappings + 1
-    end
-
-    targetmappings [index]            = fullinfo
-    targetentrystatus.index [n_font]  = index
-
-    return true
-end
-
-
-
---- we return true if the font is new or re-indexed
---- string -> dbobj -> dbobj -> bool
-
-local read_font_names = function (fullname,
-                                  currentnames,
-                                  targetnames,
-                                  location)
-
-    local targetmappings        = targetnames.mappings
-    local targetstatus          = targetnames.status --- by full path
-    local targetentrystatus     = targetstatus [fullname]
-
-    if targetentrystatus == nil then
-        targetentrystatus        = { }
-        targetstatus [fullname]  = targetentrystatus
-    end
-
-    local currentmappings       = currentnames.mappings
-    local currentstatus         = currentnames.status
-    local currententrystatus    = currentstatus [fullname]
-
-    local basename              = filebasename (fullname)
-    local barename              = filenameonly (fullname)
-    local entryname             = fullname
-
-    if location == "texmf" then
-        entryname = basename
-    end
-
-    --- 1) skip if blacklisted
-
-    if names.blacklist[fullname] or names.blacklist[basename] then
-        report("log", 2, "db",
-               "Ignoring blacklisted font %q.", fullname)
-        return false
-    end
-
-    --- 2) skip if known with same timestamp
-
-    if not compare_timestamps (fullname,
-                               currentstatus,
-                               currententrystatus,
-                               currentmappings,
-                               targetstatus,
-                               targetentrystatus,
-                               targetmappings)
-    then
-        return false
-    end
-
-    --- 3) new font; choose a loader, abort if unknown
-
-    local format    = stringlower (filesuffix (basename))
-    local loader    = loaders [format] --- ot_fullinfo, t1_fullinfo
-
-    if not loader then
-        report ("both", 0, "db",
-                "Unknown format: %q, skipping.", format)
-        return false
-    end
-
-    --- 4) get basic info, abort if fontloader can’t read it
-
-    local info = fontloaderinfo (fullname)
-
-    if not info then
-        report ("log", 1, "db",
-                "Failed to read basic information from %q", basename)
-        return false
-    end
-
-
-    --- 5) check for subfonts and process each of them
-
-    if type (info) == "table" and #info > 1 then --- ttc
-
-        local success = false --- true if at least one subfont got read
-
-        for n_font = 1, #info do
-            if insert_fullinfo (fullname, basename, n_font,
-                                loader, format, location,
-                                targetmappings, targetentrystatus,
-                                info)
-            then
-                success = true
-            end
-        end
-
-        return success
-    end
-
-    return insert_fullinfo (fullname, basename, false,
-                            loader, format, location,
-                            targetmappings, targetentrystatus,
-                            info)
-end
-
-local path_normalize
-do
-    --- os.type and os.name are constants so we
-    --- choose a normalization function in advance
-    --- instead of testing with every call
-    local os_type, os_name = os.type, os.name
-    local filecollapsepath = filecollapsepath
-    local lfsreadlink      = lfs.readlink
-
-    --- windows and dos
-    if os_type == "windows" or os_type == "msdos" then
-        --- ms platfom specific stuff
-        path_normalize = function (path)
-            path = stringgsub(path, '\\', '/')
-            path = stringlower(path)
-            path = filecollapsepath(path)
-            return path
-        end
---[[doc--
-    The special treatment for cygwin was removed with a patch submitted
-    by Ken Brown.
-    Reference: http://cygwin.com/ml/cygwin/2013-05/msg00006.html
---doc]]--
-
-    else -- posix
-        path_normalize = function (path)
-            local dest = lfsreadlink(path)
-            if dest then
-                if kpsereadable_file(dest) then
-                    path = dest
-                elseif kpsereadable_file(filejoin(filedirname(path), dest)) then
-                    path = filejoin(file.dirname(path), dest)
-                else
-                    -- broken symlink?
-                end
-            end
-            path = filecollapsepath(path)
-            return path
-        end
-    end
-end
-
-fonts.path_normalize = path_normalize
-
-names.blacklist = { }
-
-local blacklist   = names.blacklist
-local p_blacklist --- prefixes of dirs
-
---- string list -> string list
-local collapse_prefixes = function (lst)
-    --- avoid redundancies in blacklist
-    if #lst < 2 then
-        return lst
-    end
-
-    tablesort(lst)
-    local cur = lst[1]
-    local result = { cur }
-    for i=2, #lst do
-        local elm = lst[i]
-        if stringsub(elm, 1, #cur) ~= cur then
-            --- different prefix
-            cur = elm
-            result[#result+1] = cur
-        end
-    end
-    return result
-end
-
---- string list -> string list -> (string, bool) hash_t
-local create_blacklist = function (blacklist, whitelist)
-    local result = { }
-    local dirs   = { }
-
-    report("info", 2, "db", "Blacklisting %d files and directories.",
-           #blacklist)
-    for i=1, #blacklist do
-        local entry = blacklist[i]
-        if lfsisdir(entry) then
-            dirs[#dirs+1] = entry
-        else
-            result[blacklist[i]] = true
-        end
-    end
-
-    report("info", 2, "db", "Whitelisting %d files.", #whitelist)
-    for i=1, #whitelist do
-        result[whitelist[i]] = nil
-    end
-
-    dirs = collapse_prefixes(dirs)
-
-    --- build the disjunction of the blacklisted directories
-    for i=1, #dirs do
-        local p_dir = P(dirs[i])
-        if p_blacklist then
-            p_blacklist = p_blacklist + p_dir
-        else
-            p_blacklist = p_dir
-        end
-    end
-
-    if p_blacklist == nil then
-        --- always return false
-        p_blacklist = Cc(false)
-    end
-
-    return result
-end
-
---- unit -> unit
-read_blacklist = function ()
-    local files = {
-        kpselookup ("luaotfload-blacklist.cnf",
-                    {all=true, format="tex"})
-    }
-    local blacklist = { }
-    local whitelist = { }
-
-    if files and type(files) == "table" then
-        for _, path in next, files do
-            for line in iolines (path) do
-                line = stringstrip(line) -- to get rid of lines like " % foo"
-                local first_chr = stringsub(line, 1, 1)
-                if first_chr == "%" or stringis_empty(line) then
-                    -- comment or empty line
-                elseif first_chr == "-" then
-                    report ("both", 3, "db",
-                            "Whitelisted file %q via %q.",
-                            line, path)
-                    whitelist[#whitelist+1] = stringsub(line, 2, -1)
-                else
-                    local cmt = stringfind(line, "%%")
-                    if cmt then
-                        line = stringsub(line, 1, cmt - 1)
-                    end
-                    line = stringstrip(line)
-                    report ("both", 3, "db",
-                            "Blacklisted file %q via %q.",
-                            line, path)
-                    blacklist[#blacklist+1] = line
-                end
-            end
-        end
-    end
-    names.blacklist = create_blacklist(blacklist, whitelist)
-end
-
-local p_font_filter
-
-do
-    local current_formats = { }
-
-    local extension_pattern = function (list)
-        local pat
-        for i=#list, 1, -1 do
-            local e = list[i]
-            if not pat then
-                pat = P(e)
-            else
-                pat = pat + P(e)
-            end
-        end
-        pat = pat * P(-1)
-        return (1 - pat)^1 * pat
-    end
-
-    --- small helper to adjust the font filter pattern (--formats
-    --- option)
-
-    set_font_filter = function (formats)
-
-        if not formats or type (formats) ~= "string" then
-            return
-        end
-
-        if stringsub (formats, 1, 1) == "+" then -- add
-            formats = lpegmatch (splitcomma, stringsub (formats, 2))
-            if formats then
-                current_formats = tableappend (current_formats, formats)
-            end
-        elseif stringsub (formats, 1, 1) == "-" then -- add
-            formats = lpegmatch (splitcomma, stringsub (formats, 2))
-            if formats then
-                local newformats = { }
-                for i = 1, #current_formats do
-                    local fmt     = current_formats[i]
-                    local include = true
-                    for j = 1, #formats do
-                        if current_formats[i] == formats[j] then
-                            include = false
-                            goto skip
-                        end
-                    end
-                    newformats[#newformats+1] = fmt
-                    ::skip::
-                end
-                current_formats = newformats
-            end
-        else -- set
-            formats = lpegmatch (splitcomma, formats)
-            if formats then
-                current_formats = formats
-            end
-        end
-
-        p_font_filter = extension_pattern (current_formats)
-    end
-
-    get_font_filter = function (formats)
-        return tablefastcopy (current_formats)
-    end
-
-    --- initialize
-    set_font_filter (luaotfloadconfig.formats)
-end
-
-local process_dir_tree
-process_dir_tree = function (acc, dirs)
-    if not next (dirs) then --- done
-        return acc
-    end
-
-    local pwd   = lfscurrentdir ()
-    local dir   = dirs[#dirs]
-    dirs[#dirs] = nil
-
-    if lfschdir (dir) then
-        lfschdir (pwd)
-
-        local newfiles = { }
-        local blacklist = names.blacklist
-        for ent in lfsdir (dir) do
-            --- filter right away
-            if ent ~= "." and ent ~= ".." and not blacklist[ent] then
-                local fullpath = dir .. "/" .. ent
-                if lfsisdir (fullpath)
-                and not lpegmatch (p_blacklist, fullpath)
-                then
-                    dirs[#dirs+1] = fullpath
-                elseif lfsisfile (fullpath) then
-                    ent = stringlower (ent)
-
-                    if lpegmatch (p_font_filter, ent) then
-                        if filesuffix (ent) == "afm" then
-                            --- fontloader.open() will load the afm
-                            --- iff both files are in the same directory
-                            local pfbpath = filereplacesuffix
-                                                    (fullpath, "pfb")
-                            if lfsisfile (pfbpath) then
-                                newfiles[#newfiles+1] = pfbpath
-                            end
-                        else
-                            newfiles[#newfiles+1] = fullpath
-                        end
-                    end
-
-                end
-            end
-        end
-        return process_dir_tree (tableappend (acc, newfiles), dirs)
-    end
-    --- cannot cd; skip
-    return process_dir_tree (acc, dirs)
-end
-
-local process_dir = function (dir)
-    local pwd = lfscurrentdir ()
-    if lfschdir (dir) then
-        lfschdir (pwd)
-
-        local files = { }
-        local blacklist = names.blacklist
-        for ent in lfsdir (dir) do
-            if ent ~= "." and ent ~= ".." and not blacklist[ent] then
-                local fullpath = dir .. "/" .. ent
-                if lfsisfile (fullpath) then
-                    ent = stringlower (ent)
-                    if lpegmatch (p_font_filter, ent)
-                    then
-                        if filesuffix (ent) == "afm" then
-                            --- fontloader.open() will load the afm
-                            --- iff both files are in the same
-                            --- directory
-                            local pfbpath = filereplacesuffix
-                                                    (fullpath, "pfb")
-                            if lfsisfile (pfbpath) then
-                                files[#files+1] = pfbpath
-                            end
-                        else
-                            files[#files+1] = fullpath
-                        end
-                    end
-                end
-            end
-        end
-        return files
-    end
-    return { }
-end
-
---- string -> bool -> string list
-local find_font_files = function (root, recurse)
-    if lfsisdir (root) then
-        if recurse == true then
-            return process_dir_tree ({}, { root })
-        else --- kpathsea already delivered the necessary subdirs
-            return process_dir (root)
-        end
-    end
-end
-
---- truncate_string -- Cut the first part of a string to fit it
---- into a given terminal width. The parameter “restrict” (int)
---- indicates the number of characters already consumed on the
---- line.
-local truncate_string = function (str, restrict)
-    local tw  = luaotfloadconfig.termwidth
-    local wd  = tw - restrict
-    local len = utf8len (str)
-    if wd - len < 0 then
-        --- combined length exceeds terminal,
-        str = ".." .. stringsub(str, len - wd + 2)
-    end
-    return str
-end
-
---[[doc--
-
-    scan_dir() scans a directory and populates the list of fonts
-    with all the fonts it finds.
-
-        · dirname       : name of the directory to scan
-        · currentnames  : current font db object
-        · targetnames   : font db object to fill
-        · dry_run       : don’t touch anything
-
---doc]]--
-
---- string -> dbobj -> dbobj -> bool -> bool -> (int * int)
-
-local scan_dir = function (dirname, currentnames, targetnames,
-                           dry_run, location)
-    if lpegmatch (p_blacklist, dirname) then
-        report ("both", 4, "db",
-                "Skipping blacklisted directory %s.", dirname)
-        --- ignore
-        return 0, 0
-    end
-    local found = find_font_files (dirname, location ~= "texmf")
-    if not found then
-        report ("both", 4, "db",
-                "No such directory: %q; skipping.", dirname)
-        return 0, 0
-    end
-    report ("both", 4, "db", "Scanning directory %s.", dirname)
-
-    local n_new         = 0   --- total of fonts collected
-    local n_found       = #found
-    local max_fonts     = luaotfloadconfig.max_fonts
-
-    report ("both", 4, "db", "%d font files detected.", n_found)
-    for j=1, n_found do
-        if max_fonts and fonts_read >= max_fonts then
-            break
-        end
-
-        local fullname = found[j]
-        fullname = path_normalize(fullname)
-        local new
-
-        if dry_run == true then
-            local truncated = truncate_string (fullname, 43)
-            report ("log", 2, "db",
-                    "Would have been loading %s.", fullname)
-            report_status ("term", "db",
-                           "Would have been loading %s", truncated)
-        else
-            local truncated = truncate_string (fullname, 32)
-            report ("log", 2, "db", "Loading font %s.", fullname)
-            report_status ("term", "db", "Loading font %s", truncated)
-            local new = read_font_names (fullname, currentnames,
-                                         targetnames, texmf)
-            if new == true then
-                fonts_read = fonts_read + 1
-                n_new = n_new + 1
-            end
-        end
-    end
-    report ("both", 4, "db", "Done. %d fonts indexed in %q.",
-            n_found, dirname)
-    return n_found, n_new
-end
-
---- string list -> string list
-local filter_out_pwd = function (dirs)
-    local result = { }
-    local pwd = path_normalize (lpegmatch (stripslashes,
-                                           lfscurrentdir ()))
-    for i = 1, #dirs do
-        --- better safe than sorry
-        local dir = path_normalize (lpegmatch (stripslashes, dirs[i]))
-        if not (dir == "." or dir == pwd) then
-            result[#result+1] = dir
-        end
-    end
-    return result
-end
-
-local path_separator = ostype == "windows" and ";" or ":"
-
---[[doc--
-
-    scan_texmf_fonts() scans all fonts in the texmf tree through the
-    kpathsea variables OPENTYPEFONTS and TTFONTS of texmf.cnf.
-    The current working directory comes as “.” (texlive) or absolute
-    path (miktex) and will always be filtered out.
-
---doc]]--
-
---- dbobj -> dbobj -> bool? -> (int * int)
-
-local scan_texmf_fonts = function (currentnames, targetnames, dry_run)
-
-    local n_scanned, n_new, fontdirs = 0, 0
-    local osfontdir = kpseexpand_path "$OSFONTDIR"
-
-    if stringis_empty (osfontdir) then
-        report ("info", 1, "db", "Scanning TEXMF fonts...")
-    else
-        report ("info", 1, "db", "Scanning TEXMF and OS fonts...")
-        if log.get_loglevel () > 3 then
-            local osdirs = filesplitpath (osfontdir)
-            report ("info", 0, "db",
-                    "$OSFONTDIR has %d entries:", #osdirs)
-            for i = 1, #osdirs do
-                report ("info", 0, "db", "[%d] %s", i, osdirs[i])
-            end
-        end
-    end
-
-    fontdirs = kpseexpand_path "$OPENTYPEFONTS"
-    fontdirs = fontdirs .. path_separator .. kpseexpand_path "$TTFONTS"
-    fontdirs = fontdirs .. path_separator .. kpseexpand_path "$T1FONTS"
-
-    if not stringis_empty (fontdirs) then
-        local tasks = filter_out_pwd (filesplitpath (fontdirs))
-        report ("info", 3, "db",
-                "Initiating scan of %d directories.", #tasks)
-        report_status_start (2, 4)
-        for _, d in next, tasks do
-            local found, new = scan_dir (d, currentnames, targetnames,
-                                         dry_run, "texmf")
-            n_scanned = n_scanned + found
-            n_new     = n_new     + new
-        end
-        report_status_stop ("term", "db", "Scanned %d files, %d new.", n_scanned, n_new)
-    end
-
-    return n_scanned, n_new
-end
-
---- TODO stuff those paths into some writable table
---- unit -> string list
-local function get_os_dirs ()
-    if os.name == 'macosx' then
-        return {
-            filejoin(kpseexpand_path('~'), "Library/Fonts"),
-            "/Library/Fonts",
-            "/System/Library/Fonts",
-            "/Network/Library/Fonts",
-        }
-    elseif os.type == "windows" or os.type == "msdos" then
-        local windir = osgetenv("WINDIR")
-        return { filejoin(windir, 'Fonts') }
-    else
-        local fonts_conves = { --- plural, much?
-            "/usr/local/etc/fonts/fonts.conf",
-            "/etc/fonts/fonts.conf",
-        }
-        local os_dirs = read_fonts_conf(fonts_conves, find_files)
-        return os_dirs
-    end
-    return {}
-end
-
---[[doc--
-
-    scan_os_fonts() scans the OS fonts through
-      - fontconfig for Unix (reads the fonts.conf file[s] and scans the
-        directories)
-      - a static set of directories for Windows and MacOSX
-
-    **NB**: If $OSFONTDIR is nonempty, as it appears to be by default
-            on Windows setups, the system fonts will have already been
-            processed while scanning the TEXMF. Thus, this function is
-            never called.
-
---doc]]--
-
---- dbobj -> dbobj -> bool? -> (int * int)
-local scan_os_fonts = function (currentnames,
-                                targetnames,
-                                dry_run)
-
-    local n_scanned, n_new = 0, 0
-    report ("info", 1, "db", "Scanning OS fonts...")
-    report ("info", 2, "db",
-            "Searching in static system directories...")
-
-    report_status_start (2, 4)
-    for _, d in next, get_os_dirs () do
-        local found, new = scan_dir (d, currentnames,
-                                     targetnames, dry_run)
-        n_scanned = n_scanned + found
-        n_new     = n_new     + new
-    end
-    report_status_stop ("term", "db", "Scanned %d files, %d new.", n_scanned, n_new)
-
-    return n_scanned, n_new
-end
-
---- unit -> (bool, lookup_cache)
-flush_lookup_cache = function ()
-    lookup_cache = { }
-    collectgarbage "collect"
-    return true, lookup_cache
-end
-
-
---- fontentry list -> filemap
-
-local generate_filedata = function (mappings)
-
-    report ("both", 2, "db", "Creating filename map.")
-
-    local nmappings  = #mappings
-
-    local files  = {
-        bare = {
-            ["local"]   = { },
-            system      = { }, --- mapped to mapping format -> index in full
-            texmf       = { }, --- mapped to mapping format -> “true”
-        },
-        base = {
-            ["local"]   = { },
-            system      = { }, --- mapped to index in “full”
-            texmf       = { }, --- set; all values are “true”
-        },
-        full = { }, --- non-texmf
-    }
-
-    local base = files.base
-    local bare = files.bare
-    local full = files.full
-
-    local conflicts = {
-        basenames = 0,
-        barenames = 0,
-    }
-
-    for index = 1, nmappings do
-        local entry    = mappings [index]
-
-        local filedata = entry.file
-        local format
-        local location
-        local fullpath
-        local basename
-        local barename
-        local subfont
-
-        if filedata then --- new entry
-            format   = entry.format   --- otf, afm, ...
-            location = filedata.location --- texmf, system, ...
-            fullpath = filedata.full
-            basename = filedata.base
-            barename = filenameonly (fullpath)
-            subfont  = filedata.subfont
-        else
-            format   = entry.format   --- otf, afm, ...
-            location = entry.location --- texmf, system, ...
-            fullpath = entry.fullpath
-            basename = entry.basename
-            barename = filenameonly (fullpath)
-            subfont  = entry.subfont
-        end
-
-        entry.index    = index
-
-        --- 1) add to basename table
-
-        local inbase = base [location] --- no format since the suffix is known
-
-        if inbase then
-            local present = inbase [basename]
-            if present then
-                report ("both", 4, "db",
-                        "Conflicting basename: %q already indexed \z
-                         in category %s, ignoring.",
-                        barename, location)
-                conflicts.basenames = conflicts.basenames + 1
-
-                --- track conflicts per font
-                local conflictdata = entry.conflicts
-
-                if not conflictdata then
-                    entry.conflicts = { basename = present }
-                else -- some conflicts already detected
-                    conflictdata.basename = present
-                end
-
-            else
-                inbase [basename] = index
-            end
-        else
-            inbase = { basename = index }
-            base [location] = inbase
-        end
-
-        --- 2) add to barename table
-
-        local inbare = bare [location] [format]
-
-        if inbare then
-            local present = inbare [barename]
-            if present then
-                report ("both", 4, "db",
-                        "Conflicting barename: %q already indexed \z
-                         in category %s/%s, ignoring.",
-                        barename, location, format)
-                conflicts.barenames = conflicts.barenames + 1
-
-                --- track conflicts per font
-                local conflictdata = entry.conflicts
-
-                if not conflictdata then
-                    entry.conflicts = { barename = present }
-                else -- some conflicts already detected
-                    conflictdata.barename = present
-                end
-
-            else
-                inbare [barename] = index
-            end
-        else
-            inbare = { [barename] = index }
-            bare [location] [format] = inbare
-        end
-
-        --- 3) add to fullpath map
-
-        full [index] = fullpath
-    end
-
-    return files
-end
-
-local pick_style
-local check_regular
-
-do
-    local splitfontname = lpeg.splitat "-"
-
-    local choose_exact = function (field)
-        --- only clean matches, without guessing
-        if italic_synonym [field] then
-            return "i"
-        end
-
-        if field == "bold" then
-            return "b"
-        end
-
-        if field == "bolditalic" or field == "boldoblique" then
-            return "bi"
-        end
-
-        return false
-    end
-
-    pick_style = function (fontstyle_name,
-                           prefmodifiers,
-                           subfamily,
-                           splitstyle)
-        local style
-        if fontstyle_name then
-            style = choose_exact (fontstyle_name)
-        end
-        if not style then
-            if prefmodifiers then
-                style = choose_exact (prefmodifiers)
-            elseif subfamily then
-                style = choose_exact (subfamily)
-            end
-        end
-        return style
-    end
-
-    pick_fallback_style = function (italicangle, weight)
-        --- more aggressive, but only to determine bold faces
-        if weight > 500 then --- bold spectrum matches
-            if italicangle == 0 then
-                return tostring (weight)
-            else
-                return tostring (weight) .. "i"
-            end
-        end
-        return false
-    end
-
-    --- we use only exact matches here since there are constructs
-    --- like “regularitalic” (Cabin, Bodoni Old Fashion)
-
-    check_regular = function (fontstyle_name,
-                              prefmodifiers,
-                              subfamily,
-                              splitstyle,
-                              italicangle,
-                              weight)
-
-        if fontstyle_name then
-            return regular_synonym [fontstyle_name]
-        elseif prefmodifiers then
-            return regular_synonym [prefmodifiers]
-        elseif subfamily then
-            return regular_synonym [subfamily]
-        elseif splitstyle then
-            return regular_synonym [splitstyle]
-        elseif italicangle == 0 and weight == 400 then
-            return true
-        end
-
-        return nil
-    end
-end
-
-local pull_values = function (entry)
-    local file              = entry.file
-    local names             = entry.names
-    local style             = entry.style
-    local sanitized         = names.sanitized
-    local english           = sanitized.english
-    local info              = sanitized.info
-    local metadata          = sanitized.metadata
-
-    --- pull file info ...
-    entry.basename          = file.base
-    entry.fullpath          = file.full
-    entry.location          = file.location
-    entry.subfont           = file.subfont
-
-    --- pull name info ...
-    entry.psname            = english.psname
-    entry.fontname          = info.fontname or metadata.fontname
-    entry.fullname          = english.fullname or info.fullname
-    entry.splainname        = metadata.fullname
-    entry.prefmodifiers     = english.prefmodifiers
-    local metafamily        = metadata.familyname
-    local familyname        = english.preffamily or english.family
-    entry.familyname        = familyname
-    if familyname ~= metafamily then
-        entry.metafamily    = metadata.familyname
-    end
-    entry.fontstyle_name    = sanitized.fontstyle_name
-    entry.plainname         = names.fullname
-    entry.subfamily         = english.subfamily
-
-    --- pull style info ...
-    entry.italicangle       = style.italicangle
-    entry.size              = style.size
-    entry.splitstyle        = style.split
-    entry.weight            = style.weight
-
-    if luaotfloadconfig.strip == true then
-        entry.file  = nil
-        entry.names = nil
-        entry.style = nil
-    end
-end
-
-local add_family = function (name, subtable, modifier, entry)
-    if not name then --- probably borked font
-        return
-    end
-    local familytable = subtable [name]
-    if not familytable then
-        familytable = { }
-        subtable [name] = familytable
-    end
-
-    local size = entry.size
-
-    familytable [#familytable + 1] = {
-        index    = entry.index,
-        modifier = modifier,
-    }
-end
-
-local get_subtable = function (families, entry)
-    local location  = entry.location
-    local format    = entry.format
-    local subtable  = families [location] [format]
-    if not subtable then
-        subtable  = { }
-        families [location] [format] = subtable
-    end
-    return subtable
-end
-
-local collect_families = function (mappings)
-
-    report ("info", 2, "db", "Analyzing families.")
-
-    local families = {
-        ["local"]  = { },
-        system     = { },
-        texmf      = { },
-    }
-
-    for i = 1, #mappings do
-
-        local entry = mappings [i]
-
-        if entry.file then
-            pull_values (entry)
-        end
-
-        local subtable          = get_subtable (families, entry)
-
-        local familyname        = entry.familyname
-        local metafamily        = entry.metafamily
-        local fontstyle_name    = entry.fontstyle_name
-        local prefmodifiers     = entry.prefmodifiers
-        local subfamily         = entry.subfamily
-
-        local weight            = entry.weight
-        local italicangle       = entry.italicangle
-        local splitstyle        = entry.splitstyle
-
-        local modifier          = pick_style (fontstyle_name,
-                                              prefmodifiers,
-                                              subfamily,
-                                              splitstyle)
-
-        if not modifier then --- regular, exact only
-            modifier = check_regular (fontstyle_name,
-                                      prefmodifiers,
-                                      subfamily,
-                                      splitstyle,
-                                      italicangle,
-                                      weight)
-        end
-
-        if modifier then
-            add_family (familyname, subtable, modifier, entry)
-            --- registering the metafamilies is unreliable within the
-            --- same table as identifiers might interfere with an
-            --- unmarked style that lacks a metafamily, e.g.
-            ---
-            ---         iwona condensed regular ->
-            ---                     family:     iwonacond
-            ---                     metafamily: iwona
-            ---         iwona regular ->
-            ---                     family:     iwona
-            ---                     metafamily: ø
-            ---
-            --- Both would be registered as under the same family,
-            --- i.e. “iwona”, and depending on the loading order
-            --- the query “name:iwona” can resolve to the condensed
-            --- version instead of the actual unmarked one. The only
-            --- way around this would be to introduce a separate
-            --- table for metafamilies and do fallback queries on it.
-            --- At the moment this is not pressing enough to justify
-            --- further increasing the index size, maybe if need
-            --- arises from the user side.
---            if metafamily and metafamily ~= familyname then
---                add_family (metafamily, subtable, modifier, entry)
---            end
-        elseif weight > 500 then -- in bold spectrum
-            modifier = pick_fallback_style (italicangle, weight)
-            if modifier then
-                add_family (familyname, subtable, modifier, entry)
-            end
-        end
-    end
-
-    collectgarbage "collect"
-    return families
-end
-
---[[doc--
-
-    add_bold_spectrum -- For not-quite-bold faces, determine whether
-    they can fill in for a missing bold face slot in a matching family.
-
-    Some families like Lucida do not contain real bold / bold italic
-    members. Instead, they have semibold variants at weight 600 which
-    we must add in a separate pass.
-
---doc]]--
-
-local bold_spectrum_low  = 501 --- 500 is medium, 900 heavy/black
-local bold_weight        = 700
-local style_categories   = { "r", "b", "i", "bi" }
-local bold_categories    = {      "b",      "bi" }
-
-local group_modifiers = function (mappings, families)
-    report ("info", 2, "db", "Analyzing shapes, weights, and styles.")
-    for location, location_data in next, families do
-        for format, format_data in next, location_data do
-            for familyname, collected in next, format_data do
-                local styledata = { } --- will replace the “collected” table
-                --- First, fill in the ordinary style data that
-                --- fits neatly into the four relevant modifier
-                --- categories.
-                for _, modifier in next, style_categories do
-                    local entries
-                    for key, info in next, collected do
-                        if info.modifier == modifier then
-                            if not entries then
-                                entries = { }
-                            end
-                            local index = info.index
-                            local entry = mappings [index]
-                            local size  = entry.size
-                            if size then
-                                entries [#entries + 1] = {
-                                    size [1],
-                                    size [2],
-                                    size [3],
-                                    index,
-                                }
-                            else
-                                entries.default = index
-                            end
-                            collected [key] = nil
-                        end
-                        styledata [modifier] = entries
-                    end
-                end
-
-                --- At this point the family set may still lack
-                --- entries for bold or bold italic. We will fill
-                --- those in using the modifier with the numeric
-                --- weight that is closest to bold (700).
-                if next (collected) then --- there are uncategorized entries
-                    for _, modifier in next, bold_categories do
-                        if not styledata [modifier] then
-                            local closest
-                            local minimum = 2^51
-                            for key, info in next, collected do
-                                local info_modifier = tonumber (info.modifier) and "b" or "bi"
-                                if modifier == info_modifier then
-                                    local index  = info.index
-                                    local entry  = mappings [index]
-                                    local weight = entry.weight
-                                    local diff   = weight < 700 and 700 - weight or weight - 700
-                                    if diff < minimum then
-                                        minimum = diff
-                                        closest = weight
-                                    end
-                                end
-                            end
-                            if closest then
-                                --- We know there is a substitute face for the modifier.
-                                --- Now we scan the list again to extract the size data
-                                --- in case the shape is available at multiple sizes.
-                                local entries = { }
-                                for key, info in next, collected do
-                                    local info_modifier = tonumber (info.modifier) and "b" or "bi"
-                                    if modifier == info_modifier then
-                                        local index  = info.index
-                                        local entry  = mappings [index]
-                                        local size   = entry.size
-                                        if entry.weight == closest then
-                                            if size then
-                                                entries [#entries + 1] =  {
-                                                    size [1],
-                                                    size [2],
-                                                    size [3],
-                                                    index,
-                                                }
-                                            else
-                                                entries.default = index
-                                            end
-                                        end
-                                    end
-                                end
-                                styledata [modifier] = entries
-                            end
-                        end
-                    end
-                end
-                format_data [familyname] = styledata
-            end
-        end
-    end
-    return families
-end
-
-local cmp_sizes = function (a, b)
-    return a [1] < b [1]
-end
-
-local order_design_sizes = function (families)
-
-    report ("info", 2, "db", "Ordering design sizes.")
-
-    for location, data in next, families do
-        for format, data in next, data do
-            for familyname, data in next, data do
-                for style, data in next, data do
-                    tablesort (data, cmp_sizes)
-                end
-            end
-        end
-    end
-
-    return families
-end
-
-local retrieve_namedata = function (currentnames,
-                                    targetnames,
-                                    dry_run,
-                                    n_rawnames,
-                                    n_newnames)
-
-    local rawnames, new = scan_texmf_fonts (currentnames,
-                                            targetnames,
-                                            dry_run)
-
-    n_rawnames    = n_rawnames + rawnames
-    n_newnames    = n_newnames + new
-
-    rawnames, new = scan_os_fonts (currentnames, targetnames, dry_run)
-
-    n_rawnames    = n_rawnames + rawnames
-    n_newnames    = n_newnames + new
-
-    return n_rawnames, n_newnames
-end
-
-
---- dbobj -> stats
-
-local collect_statistics = function (mappings)
-    local sum_dsnsize, n_dsnsize = 0, 0
-
-    local fullname, family, families = { }, { }, { }
-    local subfamily, prefmodifiers, fontstyle_name = { }, { }, { }
-
-    local addtohash = function (hash, item)
-        if item then
-            local times = hash [item]
-            if times then
-                hash [item] = times + 1
-            else
-                hash [item] = 1
-            end
-        end
-    end
-
-    local appendtohash = function (hash, key, value)
-        if key and value then
-            local entry = hash [key]
-            if entry then
-                entry [#entry + 1] = value
-            else
-                hash [key] = { value }
-            end
-        end
-    end
-
-    local addtoset = function (hash, key, value)
-        if key and value then
-            local set = hash [key]
-            if set then
-                set [value] = true
-            else
-                hash [key] = { [value] = true }
-            end
-        end
-    end
-
-    local setsize = function (set)
-        local n = 0
-        for _, _ in next, set do
-            n = n + 1
-        end
-        return n
-    end
-
-    local hashsum = function (hash)
-        local n = 0
-        for _, m in next, hash do
-            n = n + m
-        end
-        return n
-    end
-
-    for _, entry in next, mappings do
-        local style        = entry.style
-        local names        = entry.names.sanitized
-        local englishnames = names.english
-
-        addtohash (fullname,        englishnames.fullname)
-        addtohash (family,          englishnames.family)
-        addtohash (subfamily,       englishnames.subfamily)
-        addtohash (prefmodifiers,   englishnames.prefmodifiers)
-        addtohash (fontstyle_name,  names.fontstyle_name)
-
-        addtoset (families, englishnames.family, englishnames.fullname)
-
-        local sizeinfo = entry.style.size
-        if sizeinfo then
-            sum_dsnsize = sum_dsnsize + sizeinfo [1]
-            n_dsnsize = n_dsnsize + 1
-        end
-    end
-
-    --inspect (families)
-
-    local n_fullname = setsize (fullname)
-    local n_family   = setsize (family)
-
-    if log.get_loglevel () > 1 then
-        local pprint_top = function (hash, n, set)
-
-            local freqs = { }
-            local items = { }
-
-            for item, value in next, hash do
-                if set then
-                    freq = setsize (value)
-                else
-                    freq = value
-                end
-                local ifreq = items [freq]
-                if ifreq then
-                    ifreq [#ifreq + 1] = item
-                else
-                    items [freq] = { item }
-                    freqs [#freqs + 1] = freq
-                end
-            end
-
-            tablesort (freqs)
-
-            local from = #freqs
-            local to   = from - (n - 1)
-            if to < 1 then
-                to = 1
-            end
-
-            for i = from, to, -1 do
-                local freq     = freqs [i]
-                local itemlist = items [freq]
-
-                if type (itemlist) == "table" then
-                    itemlist = tableconcat (itemlist, ", ")
-                end
-
-                report ("both", 0, "db",
-                        "       · %4d × %s.",
-                        freq, itemlist)
-            end
-        end
-
-        report ("both", 0, "", "~~~~ font index statistics ~~~~")
-        report ("both", 0, "db",
-                "   · Collected %d fonts (%d names) in %d families.",
-                #mappings, n_fullname, n_family)
-        pprint_top (families, 4, true)
-
-        report ("both", 0, "db",
-                "   · %d different “subfamily” kinds.",
-                setsize (subfamily))
-        pprint_top (subfamily, 4)
-
-        report ("both", 0, "db",
-                "   · %d different “prefmodifiers” kinds.",
-                setsize (prefmodifiers))
-        pprint_top (prefmodifiers, 4)
-
-        report ("both", 0, "db",
-                "   · %d different “fontstyle_name” kinds.",
-                setsize (fontstyle_name))
-        pprint_top (fontstyle_name, 4)
-    end
-
-    local mean_dsnsize = 0
-    if n_dsnsize > 0 then
-        mean_dsnsize = sum_dsnsize / n_dsnsize
-    end
-
-    return {
-        mean_dsnsize = mean_dsnsize,
-        names = {
-            fullname = n_fullname,
-            families = n_family,
-        },
---        style = {
---            subfamily = subfamily,
---            prefmodifiers = prefmodifiers,
---            fontstyle_name = fontstyle_name,
---        },
-    }
-end
-
---- force:      dictate rebuild from scratch
---- dry_dun:    don’t write to the db, just scan dirs
-
---- dbobj? -> bool? -> bool? -> dbobj
-update_names = function (currentnames, force, dry_run)
-
-    local targetnames
-
-    if luaotfloadconfig.update_live == false then
-        report ("info", 2, "db",
-                "Skipping database update.")
-        --- skip all db updates
-        return currentnames or name_index
-    end
-
-    local starttime                 = osgettimeofday ()
-    local n_rawnames, n_newnames    = 0, 0
-
-    --[[
-    The main function, scans everything
-    - “targetnames” is the final table to return
-    - force is whether we rebuild it from scratch or not
-    ]]
-    report("both", 1, "db", "Updating the font names database"
-                         .. (force and " forcefully." or "."))
-
-    --- pass 1 get raw data: read font files (normal case) or reuse
-    --- information present in index
-
-    if luaotfloadconfig.skip_read == true then
-        --- the difference to a “dry run” is that we don’t search
-        --- for font files entirely. we also ignore the “force”
-        --- parameter since it concerns only the font files.
-        report ("info", 2, "db",
-                "Ignoring font files, reusing old data.")
-        currentnames = load_names (false)
-        targetnames  = currentnames
-    else
-        if force then
-            currentnames = initialize_namedata (get_font_filter ())
-        else
-            if not currentnames then
-                currentnames = load_names (dry_run)
-            end
-            if currentnames.meta.version ~= names.version then
-                report ("both", 1, "db", "No font names database or old "
-                                    .. "one found; generating new one.")
-                currentnames = initialize_namedata (get_font_filter ())
-            end
-        end
-
-        targetnames = initialize_namedata (get_font_filter ())
-
-        read_blacklist ()
-
-        local n_raw, n_new= retrieve_namedata (currentnames,
-                                               targetnames,
-                                               dry_run,
-                                               n_rawnames,
-                                               n_newnames)
-        report ("info", 3, "db",
-                "Scanned %d font files; %d new entries.",
-                n_rawnames, n_newnames)
-    end
-
-    --- pass 2 (optional): collect some stats about the raw font info
-    if luaotfloadconfig.statistics == true then
-        targetnames.meta.statistics = collect_statistics
-                                            (targetnames.mappings)
-    end
-
-    --- we always generate the file lookup tables because
-    --- non-texmf entries are redirected there and the mapping
-    --- needs to be 100% consistent
-
-    --- pass 3: build filename table
-    targetnames.files       = generate_filedata (targetnames.mappings)
-
-    --- pass 4: build family lookup table
-    targetnames.families    = collect_families  (targetnames.mappings)
-
-    --- pass 5: arrange style and size info
-    targetnames.families    = group_modifiers (targetnames.mappings,
-                                               targetnames.families)
-
-    --- pass 6: order design size tables
-    targetnames.families    = order_design_sizes (targetnames.families)
-
-
-    report ("info", 3, "db",
-            "Rebuilt in %0.f ms.",
-            1000 * (osgettimeofday () - starttime))
-    name_index = targetnames
-
-    if dry_run ~= true then
-
-        save_names ()
-
-        local success, _lookups = flush_lookup_cache ()
-        if success then
-            local success = save_lookups ()
-            if success then
-                report ("info", 2, "cache",
-                                   "Lookup cache emptied.")
-                return targetnames
-            end
-        end
-    end
-    return targetnames
-end
-
---- unit -> bool
-save_lookups = function ( )
-    local path    = names.path.lookups
-    local luaname, lucname = path.lua, path.luc
-    if fileiswritable (luaname) and fileiswritable (lucname) then
-        tabletofile (luaname, lookup_cache, true)
-        osremove (lucname)
-        caches.compile (lookup_cache, luaname, lucname)
-        --- double check ...
-        if lfsisfile (luaname) and lfsisfile (lucname) then
-            report ("both", 3, "cache", "Lookup cache saved.")
-            return true
-        end
-        report ("info", 0, "cache", "Could not compile lookup cache.")
-        return false
-    end
-    report ("info", 0, "cache", "Lookup cache file not writable.")
-    if not fileiswritable (luaname) then
-        report ("info", 0, "cache", "Failed to write %s.", luaname)
-    end
-    if not fileiswritable (lucname) then
-        report ("info", 0, "cache", "Failed to write %s.", lucname)
-    end
-    return false
-end
-
---- save_names() is usually called without the argument
---- dbobj? -> bool
-save_names = function (currentnames)
-    if not currentnames then
-        currentnames = name_index
-    end
-    local path = names.path.index
-    local luaname, lucname = path.lua, path.luc
-    if fileiswritable (luaname) and fileiswritable (lucname) then
-        osremove (lucname)
-        local gzname = luaname .. ".gz"
-        if luaotfloadconfig.compress then
-            local serialized = tableserialize (currentnames, true)
-            save_gzipped (gzname, serialized)
-            caches.compile (currentnames, "", lucname)
-        else
-            tabletofile (luaname, currentnames, true)
-            caches.compile (currentnames, luaname, lucname)
-        end
-        report ("info", 2, "db", "Font index saved at ...")
-        local success = false
-        if lfsisfile (luaname) then
-            report ("info", 2, "db", "Text: " .. luaname)
-            success = true
-        end
-        if lfsisfile (gzname) then
-            report ("info", 2, "db", "Gzip: " .. gzname)
-            success = true
-        end
-        if lfsisfile (lucname) then
-            report ("info", 2, "db", "Byte: " .. lucname)
-            success = true
-        end
-        if success then
-            return true
-        else
-            report ("info", 0, "db", "Could not compile font index.")
-            return false
-        end
-    end
-    report ("info", 0, "db", "Index file not writable")
-    if not fileiswritable (luaname) then
-        report ("info", 0, "db", "Failed to write %s.", luaname)
-    end
-    if not fileiswritable (lucname) then
-        report ("info", 0, "db", "Failed to write %s.", lucname)
-    end
-    return false
-end
-
---[[doc--
-
-    Below set of functions is modeled after mtx-cache.
-
---doc]]--
-
---- string -> string -> string list -> string list -> string list -> unit
-local print_cache = function (category, path, luanames, lucnames, rest)
-    local report_indeed = function (...)
-        report("info", 0, "cache", ...)
-    end
-    report_indeed("Luaotfload cache: %s", category)
-    report_indeed("location: %s", path)
-    report_indeed("[raw]       %4i", #luanames)
-    report_indeed("[compiled]  %4i", #lucnames)
-    report_indeed("[other]     %4i", #rest)
-    report_indeed("[total]     %4i", #luanames + #lucnames + #rest)
-end
-
---- string -> string -> string list -> bool -> bool
-local purge_from_cache = function (category, path, list, all)
-    report("info", 1, "cache", "Luaotfload cache: %s %s",
-        (all and "erase" or "purge"), category)
-    report("info", 1, "cache", "location: %s",path)
-    local n = 0
-    for i=1,#list do
-        local filename = list[i]
-        if stringfind(filename,"luatex%-cache") then -- safeguard
-            if all then
-                report("info", 5, "cache", "Removing %s.", filename)
-                osremove(filename)
-                n = n + 1
-            else
-                local suffix = filesuffix(filename)
-                if suffix == "lua" then
-                    local checkname = file.replacesuffix(
-                        filename, "lua", "luc")
-                    if lfsisfile(checkname) then
-                        report("info", 5, "cache", "Removing %s.", filename)
-                        osremove(filename)
-                        n = n + 1
-                    end
-                end
-            end
-        end
-    end
-    report("info", 1, "cache", "Removed lua files : %i", n)
-    return true
-end
-
---- string -> string list -> int -> string list -> string list -> string list ->
----     (string list * string list * string list * string list)
-local collect_cache collect_cache = function (path, all, n, luanames,
-                                              lucnames, rest)
-    if not all then
-        local all = find_files (path)
-
-        local luanames, lucnames, rest = { }, { }, { }
-        return collect_cache(nil, all, 1, luanames, lucnames, rest)
-    end
-
-    local filename = all[n]
-    if filename then
-        local suffix = filesuffix(filename)
-        if suffix == "lua" then
-            luanames[#luanames+1] = filename
-        elseif suffix == "luc" then
-            lucnames[#lucnames+1] = filename
-        else
-            rest[#rest+1] = filename
-        end
-        return collect_cache(nil, all, n+1, luanames, lucnames, rest)
-    end
-    return luanames, lucnames, rest, all
-end
-
-local getwritablecachepath = function ( )
-    --- fonts.handlers.otf doesn’t exist outside a Luatex run,
-    --- so we have to improvise
-    local writable = getwritablepath (luaotfloadconfig.cache_dir)
-    if writable then
-        return writable
-    end
-end
-
-local getreadablecachepaths = function ( )
-    local readables = caches.getreadablepaths
-                        (luaotfloadconfig.cache_dir)
-    local result    = { }
-    if readables then
-        for i=1, #readables do
-            local readable = readables[i]
-            if lfsisdir (readable) then
-                result[#result+1] = readable
-            end
-        end
-    end
-    return result
-end
-
---- unit -> unit
-local purge_cache = function ( )
-    local writable_path = getwritablecachepath ()
-    local luanames, lucnames, rest = collect_cache(writable_path)
-    if log.get_loglevel() > 1 then
-        print_cache("writable path", writable_path, luanames, lucnames, rest)
-    end
-    local success = purge_from_cache("writable path", writable_path, luanames, false)
-    return success
-end
-
---- unit -> unit
-local erase_cache = function ( )
-    local writable_path = getwritablecachepath ()
-    local luanames, lucnames, rest, all = collect_cache(writable_path)
-    if log.get_loglevel() > 1 then
-        print_cache("writable path", writable_path, luanames, lucnames, rest)
-    end
-    local success = purge_from_cache("writable path", writable_path, all, true)
-    return success
-end
-
-local separator = function ( )
-    report("info", 0, string.rep("-", 67))
-end
-
---- unit -> unit
-local show_cache = function ( )
-    local readable_paths = getreadablecachepaths ()
-    local writable_path  = getwritablecachepath ()
-    local luanames, lucnames, rest = collect_cache(writable_path)
-
-    separator ()
-    print_cache ("writable path", writable_path,
-                 luanames, lucnames, rest)
-    texio.write_nl""
-    for i=1,#readable_paths do
-        local readable_path = readable_paths[i]
-        if readable_path ~= writable_path then
-            local luanames, lucnames = collect_cache (readable_path)
-            print_cache ("readable path",
-                         readable_path, luanames, lucnames, rest)
-        end
-    end
-    separator()
-    return true
-end
-
------------------------------------------------------------------------
---- export functionality to the namespace “fonts.names”
------------------------------------------------------------------------
-
-names.scan_dir                    = scan_dir
-names.set_font_filter             = set_font_filter
-names.flush_lookup_cache          = flush_lookup_cache
-names.save_lookups                = save_lookups
-names.load                        = load_names
-names.data                        = function () return name_index end
-names.save                        = save_names
-names.update                      = update_names
-names.crude_file_lookup           = crude_file_lookup
-names.crude_file_lookup_verbose   = crude_file_lookup_verbose
-names.read_blacklist              = read_blacklist
-names.sanitize_fontname           = sanitize_fontname
-names.getfilename                 = resolve_fullpath
-names.set_location_precedence     = set_location_precedence
-
---- font cache
-names.purge_cache    = purge_cache
-names.erase_cache    = erase_cache
-names.show_cache     = show_cache
-
---- replace the resolver from luatex-fonts
-if luaotfloadconfig.resolver == "cached" then
-    report("both", 2, "cache", "Caching of name: lookups active.")
-    names.resolvespec  = resolve_cached
-    names.resolve_name = resolve_cached
-else
-    names.resolvespec  = resolve_name
-    names.resolve_name = resolve_name
-end
-
-names.find_closest = find_closest
-
--- for testing purpose
-names.read_fonts_conf = read_fonts_conf
-
--- vim:tw=71:sw=4:ts=4:expandtab