import legacy files

1 files changed, 705 insertions, 0 deletions

diff --git a/luaotfload-legacy-database.lua b/luaotfload-legacy-database.lua
new file mode 100644
index 0000000..2edb615
--- /dev/null
+++ b/luaotfload-legacy-database.lua
@@ -0,0 +1,705 @@
+if not modules then modules = { } end modules ['font-nms'] = {
+    version   = "old",
+    comment   = "companion to luaotfload.lua",
+    author    = "Khaled Hosny and Elie Roux",
+    copyright = "Luaotfload Development Team",
+    license   = "GNU GPL v2"
+}
+
+fonts                = fonts       or { }
+fonts.names          = fonts.names or { }
+
+local names          = fonts.names
+local names_dir      = "luatex-cache/generic/names"
+names.version        = "old" -- not the same as in context
+names.data           = nil
+names.path           = {
+    basename  = "otfl-names.lua", --- different from current
+    localdir  = file.join(kpse.expand_var("$TEXMFVAR"),    names_dir),
+    systemdir = file.join(kpse.expand_var("$TEXMFSYSVAR"), names_dir),
+}
+
+
+local splitpath, expandpath = file.split_path, kpse.expand_path
+local glob, basename        = dir.glob, file.basename
+local upper, lower, format  = string.upper, string.lower, string.format
+local gsub, match, rpadd    = string.gsub, string.match, string.rpadd
+local gmatch, sub, find     = string.gmatch, string.sub, string.find
+local utfgsub               = unicode.utf8.gsub
+
+local trace_short    = false --tracing adapted to rebuilding of the database inside a document
+local trace_search   = false --trackers.register("names.search",   function(v) trace_search   = v end)
+local trace_loading  = false --trackers.register("names.loading",  function(v) trace_loading  = v end)
+
+local function sanitize(str)
+    if str then
+        return utfgsub(lower(str), "[^%a%d]", "")
+    else
+        return str -- nil
+    end
+end
+
+local function fontnames_init()
+    return {
+        mappings  = { },
+        status    = { },
+        version   = names.version,
+    }
+end
+
+local function load_names()
+    local localpath  = file.join(names.path.localdir, names.path.basename)
+    local systempath = file.join(names.path.systemdir, names.path.basename)
+    local kpsefound  = kpse.find_file(names.path.basename)
+    local foundname
+    local data
+    if kpsefound and file.isreadable(kpsefound) then
+        data = dofile(kpsefound)
+	foundname = kpsefound
+    elseif file.isreadable(localpath)  then
+        data = dofile(localpath)
+	foundname = localpath
+    elseif file.isreadable(systempath) then
+        data = dofile(systempath)
+	foundname = systempath
+    end
+    if data then
+        logs.info("Font names database loaded: " .. foundname)
+    else
+        logs.info([[Font names database not found, generating new one.
+             This can take several minutes; please be patient.]])
+        data = names.update(fontnames_init())
+        names.save(data)
+    end
+    return data
+end
+
+local synonyms = {
+    regular    = { "normal", "roman", "plain", "book", "medium" },
+    -- boldregular was for old versions of Linux Libertine, is it still useful?
+    -- semibold is in new versions of Linux Libertine, but there is also a bold,
+    -- not sure it's useful here...
+    bold       = { "demi", "demibold", "semibold", "boldregular" },
+    italic     = { "regularitalic", "normalitalic", "oblique", "slanted" },
+    bolditalic = { "boldoblique", "boldslanted", "demiitalic", "demioblique", "demislanted", "demibolditalic", "semibolditalic" },
+}
+
+local loaded   = false
+local reloaded = false
+
+function names.resolve(specification)
+    local name  = sanitize(specification.name)
+    local style = sanitize(specification.style) or "regular"
+
+    local size
+    if specification.optsize then
+        size = tonumber(specification.optsize)
+    elseif specification.size then
+        size = specification.size / 65536
+    end
+
+
+    if not loaded then
+        names.data = names.load()
+        loaded     = true
+    end
+
+    local data = names.data
+    if type(data) == "table" and data.version == names.version then
+        if data.mappings then
+            local found = { }
+            for _,face in next, data.mappings do
+                local family    = sanitize(face.names.family)
+                local subfamily = sanitize(face.names.subfamily)
+                local fullname  = sanitize(face.names.fullname)
+                local psname    = sanitize(face.names.psname)
+                local fontname  = sanitize(face.fontname)
+                local pfullname = sanitize(face.fullname)
+                local optsize, dsnsize, maxsize, minsize
+                if #face.size > 0 then
+                    optsize = face.size
+                    dsnsize = optsize[1] and optsize[1] / 10
+                    -- can be nil
+                    maxsize = optsize[2] and optsize[2] / 10 or dsnsize
+                    minsize = optsize[3] and optsize[3] / 10 or dsnsize
+                end
+                if name == family then
+                    if subfamily == style then
+                        if optsize then
+                            if dsnsize == size
+                            or (size > minsize and size <= maxsize) then
+                                found[1] = face
+                                break
+                            else
+                                found[#found+1] = face
+                            end
+                        else
+                            found[1] = face
+                            break
+                        end
+                    elseif synonyms[style] and
+                           table.contains(synonyms[style], subfamily) then
+                        if optsize then
+                            if dsnsize == size
+                            or (size > minsize and size <= maxsize) then
+                                found[1] = face
+                                break
+                            else
+                                found[#found+1] = face
+                            end
+                        else
+                            found[1] = face
+                            break
+                        end
+                    elseif subfamily == "regular" or
+                           table.contains(synonyms.regular, subfamily) then
+                        found.fallback = face
+                    elseif name == fullname
+                    or name == pfullname
+                    or name == fontname
+                    or name == psname then
+                        if optsize then
+                            if dsnsize == size
+                            or (size > minsize and size <= maxsize) then
+                                found[1] = face
+                                break
+                            else
+                                found[#found+1] = face
+                            end
+                        else
+                            found[1] = face
+                            break
+                        end
+                    end
+                else
+                    if name == fullname
+                    or name == pfullname
+                    or name == fontname
+                    or name == psname then
+                        if optsize then
+                            if dsnsize == size
+                            or (size > minsize and size <= maxsize) then
+                                found[1] = face
+                                break
+                            else
+                                found[#found+1] = face
+                            end
+                        else
+                            found[1] = face
+                            break
+                        end
+                    end
+                end
+            end
+            if #found == 1 then
+                if kpse.lookup(found[1].filename[1]) then
+                    logs.report("load font",
+                                "font family='%s', subfamily='%s' found: %s",
+                                name, style, found[1].filename[1])
+                    return found[1].filename[1], found[1].filename[2]
+                end
+            elseif #found > 1 then
+                -- we found matching font(s) but not in the requested optical
+                -- sizes, so we loop through the matches to find the one with
+                -- least difference from the requested size.
+                local closest
+                local least = math.huge -- initial value is infinity
+                for i,face in next, found do
+                    local dsnsize    = face.size[1]/10
+                    local difference = math.abs(dsnsize-size)
+                    if difference < least then
+                        closest = face
+                        least   = difference
+                    end
+                end
+                if kpse.lookup(closest.filename[1]) then
+                    logs.report("load font",
+                                "font family='%s', subfamily='%s' found: %s",
+                                name, style, closest.filename[1])
+                    return closest.filename[1], closest.filename[2]
+                end
+            elseif found.fallback then
+                return found.fallback.filename[1], found.fallback.filename[2]
+            end
+            -- no font found so far
+            if not reloaded then
+                -- try reloading the database
+                names.data = names.update(names.data)
+                names.save(names.data)
+                reloaded   = true
+                return names.resolve(specification)
+            else
+                -- else, fallback to filename
+                return specification.name, false
+            end
+        end
+    else
+        if not reloaded then
+            names.data = names.update()
+            names.save(names.data)
+            reloaded   = true
+            return names.resolve(specification)
+        else
+            return specification.name, false
+        end
+    end
+end
+
+names.resolvespec = names.resolve
+
+function names.set_log_level(level)
+    if level == 2 then
+        trace_loading = true
+    elseif level >= 3 then
+        trace_loading = true
+        trace_search = true
+    end
+end
+
+local lastislog = 0
+
+local function log(fmt, ...)
+    lastislog = 1
+    texio.write_nl(format("luaotfload | %s", format(fmt,...)))
+    io.flush()
+end
+
+logs        = logs or { }
+logs.report = logs.report or log
+logs.info   = logs.info or log
+
+local function font_fullinfo(filename, subfont, texmf)
+    local t = { }
+    local f = fontloader.open(filename, subfont)
+    if not f then
+	    if trace_loading then
+        	logs.report("error: failed to open %s", filename)
+	    end
+        return
+    end
+    local m = fontloader.to_table(f)
+    fontloader.close(f)
+    collectgarbage('collect')
+    -- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size
+    if m.fontstyle_name then
+        for _,v in next, m.fontstyle_name do
+            if v.lang == 1033 then
+                t.fontstyle_name = v.name
+            end
+        end
+    end
+    if m.names then
+        for _,v in next, m.names do
+            if v.lang == "English (US)" then
+                t.names = {
+                    -- see
+                    -- http://developer.apple.com/textfonts/
+                    -- TTRefMan/RM06/Chap6name.html
+                    fullname = v.names.compatfull     or v.names.fullname,
+                    family   = v.names.preffamilyname or v.names.family,
+                    subfamily= t.fontstyle_name       or v.names.prefmodifiers  or v.names.subfamily,
+                    psname   = v.names.postscriptname
+                }
+            end
+        end
+    else
+        -- no names table, propably a broken font
+        if trace_loading then
+            logs.report("broken font rejected: %s", basefile)
+        end
+        return
+    end
+    t.fontname    = m.fontname
+    t.fullname    = m.fullname
+    t.familyname  = m.familyname
+    t.filename    = { texmf and basename(filename) or filename, subfont }
+    t.weight      = m.pfminfo.weight
+    t.width       = m.pfminfo.width
+    t.slant       = m.italicangle
+    -- don't waste the space with zero values
+    t.size = {
+        m.design_size         ~= 0 and m.design_size         or nil,
+        m.design_range_top    ~= 0 and m.design_range_top    or nil,
+        m.design_range_bottom ~= 0 and m.design_range_bottom or nil,
+    }
+    return t
+end
+
+local function load_font(filename, fontnames, newfontnames, texmf)
+    local newmappings = newfontnames.mappings
+    local newstatus   = newfontnames.status
+    local mappings    = fontnames.mappings
+    local status      = fontnames.status
+    local basefile    = texmf and basename(filename) or filename
+    if filename then
+        if table.contains(names.blacklist, filename) or
+           table.contains(names.blacklist, basename(filename)) then
+            if trace_search then
+                logs.report("ignoring font '%s'", filename)
+            end
+            return
+        end
+        local timestamp, db_timestamp
+        db_timestamp        = status[basefile] and status[basefile].timestamp
+        timestamp           = lfs.attributes(filename, "modification")
+
+        local index_status = newstatus[basefile] or (not texmf and newstatus[basename(filename)])
+        if index_status and index_status.timestamp == timestamp then
+            -- already indexed this run
+            return
+        end
+
+        newstatus[basefile] = newstatus[basefile] or { }
+        newstatus[basefile].timestamp = timestamp
+        newstatus[basefile].index     = newstatus[basefile].index or { }
+
+        if db_timestamp == timestamp and not newstatus[basefile].index[1] then
+            for _,v in next, status[basefile].index do
+                local index = #newstatus[basefile].index
+                newmappings[#newmappings+1]        = mappings[v]
+                newstatus[basefile].index[index+1] = #newmappings
+            end
+            if trace_loading then
+                logs.report("font already indexed: %s", basefile)
+            end
+            return
+        end
+        local info = fontloader.info(filename)
+        if info then
+            if type(info) == "table" and #info > 1 then
+                for i in next, info do
+                    local fullinfo = font_fullinfo(filename, i-1, texmf)
+                    if not fullinfo then
+                        return
+                    end
+                    local index = newstatus[basefile].index[i]
+                    if not index then
+                        index = #newmappings+1
+                    end
+                    newmappings[index]           = fullinfo
+                    newstatus[basefile].index[i] = index
+                end
+            else
+                local fullinfo = font_fullinfo(filename, false, texmf)
+                if not fullinfo then
+                    return
+                end
+                local index = newstatus[basefile].index[1]
+                if not index then
+                    index = #newmappings+1
+                end
+                newmappings[index]           = fullinfo
+                newstatus[basefile].index[1] = index
+            end
+        else
+            if trace_loading then
+               logs.report("failed to load %s", basefile)
+            end
+        end
+    end
+end
+
+local function path_normalize(path)
+    --[[
+        path normalization:
+        - a\b\c  -> a/b/c
+        - a/../b -> b
+        - /cygdrive/a/b -> a:/b
+        - reading symlinks under non-Win32
+        - using kpse.readable_file on Win32
+    ]]
+    if os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then
+        path = path:gsub('\\', '/')
+        path = path:lower()
+        path = path:gsub('^/cygdrive/(%a)/', '%1:/')
+    end
+    if os.type ~= "windows" and os.type ~= "msdos" then
+        local dest = lfs.readlink(path)
+        if dest then
+            if kpse.readable_file(dest) then
+                path = dest
+            elseif kpse.readable_file(file.join(file.dirname(path), dest)) then
+                path = file.join(file.dirname(path), dest)
+            else
+                -- broken symlink?
+            end
+        end
+    end
+    path = file.collapse_path(path)
+    return path
+end
+
+fonts.path_normalize = path_normalize
+
+names.blacklist = { }
+
+local function read_blacklist()
+    local files = {
+        kpse.lookup("otfl-blacklist.cnf", {all=true, format="tex"})
+    }
+    local blacklist = names.blacklist
+
+    if files and type(files) == "table" then
+        for _,v in next, files do
+            for line in io.lines(v) do
+                line = line:strip() -- to get rid of lines like " % foo"
+                if line:find("^%%") or line:is_empty() then
+                    -- comment or empty line
+                else
+                    line = line:split("%")[1]
+                    line = line:strip()
+                    if trace_search then
+                        logs.report("blacklisted file: %s", line)
+                    end
+                    blacklist[#blacklist+1] = line
+                end
+            end
+        end
+    end
+end
+
+local font_extensions = { "otf", "ttf", "ttc", "dfont" }
+
+local function scan_dir(dirname, fontnames, newfontnames, texmf)
+    --[[
+    This function scans a directory and populates the list of fonts
+    with all the fonts it finds.
+    - dirname is the name of the directory to scan
+    - names is the font database to fill
+    - texmf is a boolean saying if we are scanning a texmf directory
+    ]]
+    local list, found = { }, { }
+    local nbfound = 0
+    if trace_search then
+        logs.report("scanning '%s'", dirname)
+    end
+    for _,i in next, font_extensions do
+        for _,ext in next, { i, upper(i) } do
+            found = glob(format("%s/**.%s$", dirname, ext))
+            -- note that glob fails silently on broken symlinks, which happens
+            -- sometimes in TeX Live.
+            if trace_search then
+                logs.report("%s '%s' fonts found", #found, ext)
+            end
+            nbfound = nbfound + #found
+            table.append(list, found)
+        end
+    end
+    if trace_search then
+        logs.report("%d fonts found in '%s'", nbfound, dirname)
+    end
+
+    for _,file in next, list do
+        file = path_normalize(file)
+        if trace_loading then
+            logs.report("loading font: %s", file)
+        end
+        load_font(file, fontnames, newfontnames, texmf)
+    end
+end
+
+local function scan_texmf_fonts(fontnames, newfontnames)
+    --[[
+    This function scans all fonts in the texmf tree, through kpathsea
+    variables OPENTYPEFONTS and TTFONTS of texmf.cnf
+    ]]
+    if expandpath("$OSFONTDIR"):is_empty() then
+        logs.info("Scanning TEXMF fonts...")
+    else
+        logs.info("Scanning TEXMF and OS fonts...")
+    end
+    local fontdirs = expandpath("$OPENTYPEFONTS"):gsub("^%.", "")
+    fontdirs = fontdirs .. expandpath("$TTFONTS"):gsub("^%.", "")
+    if not fontdirs:is_empty() then
+        for _,d in next, splitpath(fontdirs) do
+            scan_dir(d, fontnames, newfontnames, true)
+        end
+    end
+end
+
+--[[
+  For the OS fonts, there are several options:
+   - if OSFONTDIR is set (which is the case under windows by default but
+     not on the other OSs), it scans it at the same time as the texmf tree,
+     in the scan_texmf_fonts.
+   - in addition:
+     - under Windows and Mac OSX, we take a look at some hardcoded directories
+     - under Unix, we read /etc/fonts/fonts.conf and read the directories in it
+
+  This means that if you have fonts in fancy directories, you need to set them
+  in OSFONTDIR if they cannot be found by fontconfig.
+]]
+
+local function read_fonts_conf(path, results, passed_paths)
+    --[[
+    This function parses /etc/fonts/fonts.conf and returns all the dir it finds.
+    The code is minimal, please report any error it may generate.
+    ]]
+    local f = io.open(path)
+    table.insert(passed_paths, path)
+    if not f then
+        logs.info("Warning: unable to read "..path.. ", skipping...")
+        return results
+    end
+    local incomments = false
+    for line in f:lines() do
+        while line and line ~= "" do
+            -- spaghetti code... hmmm...
+            if incomments then
+                local tmp = find(line, '-->')
+                if tmp then
+                    incomments = false
+                    line = sub(line, tmp+3)
+                else
+                    line = nil
+                end
+            else
+                local tmp = find(line, '<!--')
+                local newline = line
+                if tmp then
+                    -- for the analysis, we take everything that is before the
+                    -- comment sign
+                    newline = sub(line, 1, tmp-1)
+                    -- and we loop again with the comment
+                    incomments = true
+                    line = sub(line, tmp+4)
+                else
+                    -- if there is no comment start, the block after that will
+                    -- end the analysis, we exit the while loop
+                    line = nil
+                end
+                for dir in gmatch(newline, '<dir>([^<]+)</dir>') do
+                    -- now we need to replace ~ by kpse.expand_path('~')
+                    if sub(dir, 1, 1) == '~' then
+                        dir = file.join(kpse.expand_path('~'), sub(dir, 2))
+                    end
+                    -- we exclude paths with texmf in them, as they should be
+                    -- found anyway
+                    if not find(dir, 'texmf') then
+                        results[#results+1] = dir
+                    end
+                end
+                for include in gmatch(newline, '<include[^<]*>([^<]+)</include>') do
+                    -- include here can be four things: a directory or a file,
+                    -- in absolute or relative path.
+                    if sub(include, 1, 1) == '~' then
+                        include = file.join(kpse.expand_path('~'),sub(include, 2))
+                        -- First if the path is relative, we make it absolute:
+                    elseif not lfs.isfile(include) and not lfs.isdir(include) then
+                        include = file.join(file.dirname(path), include)
+                    end
+                    if lfs.isfile(include) and kpse.readable_file(include) and not table.contains(passed_paths, include) then
+                        -- we exclude path with texmf in them, as they should
+                        -- be found otherwise
+                        read_fonts_conf(include, results, passed_paths)
+                    elseif lfs.isdir(include) then
+                        for _,f in next, glob(file.join(include, "*.conf")) do
+                            if not table.contains(passed_paths, f) then
+                                read_fonts_conf(f, results, passed_paths)
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+    f:close()
+    return results
+end
+
+-- for testing purpose
+names.read_fonts_conf = read_fonts_conf
+
+local function get_os_dirs()
+    if os.name == 'macosx' then
+        return {
+            file.join(kpse.expand_path('~'), "Library/Fonts"),
+            "/Library/Fonts",
+            "/System/Library/Fonts",
+            "/Network/Library/Fonts",
+        }
+    elseif os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then
+        local windir = os.getenv("WINDIR")
+        return { file.join(windir, 'Fonts') }
+    else
+        return read_fonts_conf("/etc/fonts/fonts.conf", {}, {})
+    end
+end
+
+local function scan_os_fonts(fontnames, newfontnames)
+    --[[
+    This function scans the OS fonts through
+      - fontcache for Unix (reads the fonts.conf file and scans the directories)
+      - a static set of directories for Windows and MacOSX
+    ]]
+    logs.info("Scanning OS fonts...")
+    if trace_search then
+        logs.info("Searching in static system directories...")
+    end
+    for _,d in next, get_os_dirs() do
+        scan_dir(d, fontnames, newfontnames, false)
+    end
+end
+
+local function update_names(fontnames, force)
+    --[[
+    The main function, scans everything
+    - fontnames is the final table to return
+    - force is whether we rebuild it from scratch or not
+    ]]
+    logs.info("Updating the font names database:")
+
+    if force then
+        fontnames = fontnames_init()
+    else
+        if not fontnames then
+            fontnames = names.load()
+        end
+        if fontnames.version ~= names.version then
+            fontnames = fontnames_init()
+            if trace_search then
+                logs.report("No font names database or old one found; "
+                          .."generating new one")
+            end
+        end
+    end
+    local newfontnames = fontnames_init()
+    read_blacklist()
+    scan_texmf_fonts(fontnames, newfontnames)
+    scan_os_fonts(fontnames, newfontnames)
+    return newfontnames
+end
+
+local function save_names(fontnames)
+    local savepath  = names.path.localdir
+    if not lfs.isdir(savepath) then
+        dir.mkdirs(savepath)
+    end
+    savepath = file.join(savepath, names.path.basename)
+    if file.iswritable(savepath) then
+        table.tofile(savepath, fontnames, true)
+        logs.info("Font names database saved: %s \n", savepath)
+        return savepath
+    else
+        logs.info("Failed to save names database\n")
+        return nil
+    end
+end
+
+local function scan_external_dir(dir)
+    local old_names, new_names
+    if loaded then
+        old_names = names.data
+    else
+        old_names = names.load()
+        loaded    = true
+    end
+    new_names = table.copy(old_names)
+    scan_dir(dir, old_names, new_names)
+    names.data = new_names
+end
+
+names.scan   = scan_external_dir
+names.load   = load_names
+names.update = update_names
+names.save   = save_names