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