From d16a93579dfec03a0dab4281b45f63d877fc4c88 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Fri, 26 Apr 2013 22:33:37 +0200 Subject: install the new file: lookup in luaotfload.lua --- luaotfload-database.lua | 35 +++++++++++++++++++++-------------- luaotfload-features.lua | 17 +++++++++++------ luaotfload.dtx | 15 +++++++++++++-- 3 files changed, 45 insertions(+), 22 deletions(-) diff --git a/luaotfload-database.lua b/luaotfload-database.lua index 4980766..576971e 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -230,6 +230,8 @@ local load_lua_file = function (path) end --- define locals in scope +local crude_file_lookup +local crude_file_lookup_verbose local find_closest local flush_cache local font_fullinfo @@ -290,8 +292,12 @@ do end --- chain: barenames -> [fullnames ->] basenames -> findfile -local crude_file_lookup_verbose = function (data, filename) - local mappings = data.mappings + +--- string -> (string * bool | int) +crude_file_lookup_verbose = function (filename) + if not names.data then names.data = names_reload() end + local data = names.data + local mappings = data.mappings local found --- look up in db first ... @@ -336,7 +342,11 @@ local crude_file_lookup_verbose = function (data, filename) return false end -local crude_file_lookup = function (data, filename) +--- string -> (string * bool | int) +crude_file_lookup = function (filename) + if not names.data then names.data = names_reload() end + local data = names.data + local mappings = data.mappings local found = data.barenames[filename] -- or data.fullnames[filename] or data.basenames[filename] @@ -470,6 +480,7 @@ local resolvers = { fonts.definers.resolve = resolvers[config.luaotfload.resolver] --fonts.definers.resolve = resolvers.cached +fonts.definers.resolve = resolvers.dummy --[[doc-- @@ -513,12 +524,6 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con if not fonts_loaded then names.data = load_names() end local data = names.data - if specification.lookup == "file" then - local found = crude_file_lookup(data, specification.name) - --local found = crude_file_lookup_verbose(data, specification.name) - if found then return found[1], found[2], true end - end - local name = sanitize_string(specification.name) local style = sanitize_string(specification.style) or "regular" @@ -1380,11 +1385,13 @@ scan_external_dir = function (dir) end --- export functionality to the namespace “fonts.names” -names.flush_cache = flush_cache -names.load = load_names -names.save = save_names -names.scan = scan_external_dir -names.update = update_names +names.flush_cache = flush_cache +names.load = load_names +names.save = save_names +names.scan = scan_external_dir +names.update = update_names +names.crude_file_lookup = crude_file_lookup +names.crude_file_lookup_verbose = crude_file_lookup_verbose names.resolve = resolve --- replace the resolver from luatex-fonts names.resolvespec = resolve diff --git a/luaotfload-features.lua b/luaotfload-features.lua index 78f8256..0171dba 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -163,7 +163,7 @@ local set_default_features = function (speclist) return speclist end -local function issome () feature_list.lookup = 'name' end +local function issome () feature_list.lookup = 'file' end local function isfile () feature_list.lookup = 'file' end local function isname () feature_list.lookup = 'name' end local function thename(s) feature_list.name = s end @@ -180,7 +180,8 @@ local spaces = P(" ")^0 local namespec = (1-S("/:("))^1 local filespec = (R("az", "AZ") * P(":"))^-1 * (1-S(":("))^1 local stylespec = spaces * P("/") * (((1-P(":"))^0)/isstyle) * spaces -local filename = (P("file:")/isfile * (filespec/thename)) + (P("[") * P(true)/isname * (((1-P("]"))^0)/thename) * P("]")) +local filename = (P("file:")/isfile * (filespec/thename)) + + (P("[") * P(true)/isname * (((1-P("]"))^0)/thename) * P("]")) local fontname = (P("name:")/isname * (namespec/thename)) + P(true)/issome * (namespec/thename) local sometext = (R("az","AZ","09") + S("+-.,"))^1 local truevalue = P("+") * spaces * (sometext/istrue) @@ -216,10 +217,12 @@ local function colonized(specification) -- xetex mode specification.name = feature_list.name feature_list.name = nil end - if feature_list.lookup then - specification.lookup = feature_list.lookup - feature_list.lookup = nil - end + --- this test overwrites valid file: requests for xetex bracket + --- syntax +-- if feature_list.lookup then +-- specification.lookup = feature_list.lookup +-- feature_list.lookup = nil +-- end if feature_list.sub then specification.sub = feature_list.sub feature_list.sub = nil @@ -229,6 +232,8 @@ local function colonized(specification) -- xetex mode feature_list.mode = fonts.mode end specification.features.normal = fonts.handlers.otf.features.normalize(feature_list) + --inspect(specification) + --os.exit() return specification end diff --git a/luaotfload.dtx b/luaotfload.dtx index 18e01d8..8b3616a 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -1328,7 +1328,7 @@ add_to_callback("find_vf_file", loadmodule"lib-dir.lua" --- required by luaofload-database.lua loadmodule"override.lua" --- “luat-ovr” -logs.set_loglevel(0) +logs.set_loglevel(config.luaotfload.loglevel or 2) % \end{macrocode} % \CONTEXT does not support ofm, these lines were added in order to make it @@ -1365,8 +1365,19 @@ loadmodule"colors.lua" --- “font-clr” % % \begin{macrocode} +--- below lines already (2013-04-25) lead to warnings by +--- the font loader +--fonts.definers.resolvers.file = function (specification) +-- specification.name = fonts.names.resolve('', '', specification) +--end + fonts.definers.resolvers.file = function (specification) - specification.name = fonts.names.resolve('', '', specification) + --inspect(specification) + if specification.lookup == "file" then + local found = fonts.names.crude_file_lookup(specification.name) + --local found = fonts.names.crude_file_lookup_verbose(specification.name) + specification.name = found[1] + end end % \end{macrocode} -- cgit v1.2.3 From 4821fad2ff58fa8c4fbee58cbb6fe5353e047613 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 01:45:34 +0200 Subject: Import new font request parser addressing https://github.com/phi-gamma/luaotfload/issues/4 incomplete for now, only handles file: and name: requests --- luaotfload-features.lua | 327 ++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 274 insertions(+), 53 deletions(-) diff --git a/luaotfload-features.lua b/luaotfload-features.lua index 0171dba..cd639b6 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -26,7 +26,7 @@ function fonts.definers.getspecification(str) return "", str, "", ":", str end -local feature_list = { } +local old_feature_list = { } local report = logs.names_report @@ -64,20 +64,23 @@ local isstyle = function (request) for _,v in next, request do local stylename = supported[v] if stylename then - feature_list.style = stylename + old_feature_list.style = stylename elseif stringfind(v, "^s=") then --- after all, we want everything after the second byte ... local val = stringsub(v, 3) - feature_list.optsize = val + old_feature_list.optsize = val elseif stylename == false then report("log", 0, - "load font", "unsupported font option: %s", v) + "load", "unsupported font option: %s", v) elseif not stringis_empty(v) then - feature_list.style = stringgsub(v, "[^%a%d]", "") + old_feature_list.style = stringgsub(v, "[^%a%d]", "") end end end +--- TODO an option to dump the default features for a script would make +--- a nice addition to luaotfload-tool + local defaults = { dflt = { "ccmp", "locl", "rlig", "liga", "clig", @@ -131,17 +134,22 @@ defaults.tibt = defaults.khmr defaults.lao = defaults.thai +--[[doc-- +Which features are active by default depends on the script requested. +--doc]]-- + --- (string, string) dict -> (string, string) dict local set_default_features = function (speclist) + speclist = speclist or { } local script = speclist.script or "dflt" - report("log", 0, "load font", + report("log", 0, "load", "auto-selecting default features for script: %s", script) local requested = defaults[script] if not requested then - report("log", 0, "load font", + report("log", 0, "load", "no defaults for script “%s”, falling back to “dflt”", script) requested = defaults.dflt @@ -149,9 +157,7 @@ local set_default_features = function (speclist) for i=1, #requested do local feat = requested[i] - if speclist[feat] ~= false then - speclist[feat] = true - end + if speclist[feat] ~= false then speclist[feat] = true end end for feat, state in next, global_defaults do @@ -163,14 +169,15 @@ local set_default_features = function (speclist) return speclist end -local function issome () feature_list.lookup = 'file' end -local function isfile () feature_list.lookup = 'file' end -local function isname () feature_list.lookup = 'name' end -local function thename(s) feature_list.name = s end -local function issub (v) feature_list.sub = v end -local function istrue (s) feature_list[s] = true end -local function isfalse(s) feature_list[s] = false end -local function iskey (k,v) feature_list[k] = v end +-- --[==[obsolete-- +local function issome () old_feature_list.lookup = 'name' end +local function isfile () old_feature_list.lookup = 'file' end +local function isname () old_feature_list.lookup = 'name' end +local function thename(s) old_feature_list.name = s end +local function issub (v) old_feature_list.sub = v end +local function istrue (s) old_feature_list[s] = true end +local function isfalse(s) old_feature_list[s] = false end +local function iskey (k,v) old_feature_list[k] = v end local P, S, R, C = lpeg.P, lpeg.S, lpeg.R, lpeg.C @@ -191,54 +198,268 @@ local somevalue = sometext/istrue local subvalue = P("(") * (C(P(1-S("()"))^1)/issub) * P(")") -- for Kim local option = spaces * (keyvalue + falsevalue + truevalue + somevalue) * spaces local options = P(":") * spaces * (P(";")^0 * option)^0 -local pattern = (filename + fontname) * subvalue^0 * stylespec^0 * options^0 - -local function colonized(specification) -- xetex mode - feature_list = { } - lpeg.match(pattern,specification.specification) - feature_list = set_default_features(feature_list) - if feature_list.style then - specification.style = feature_list.style - feature_list.style = nil +local oldsyntax = (filename + fontname) * subvalue^0 * stylespec^0 * options^0 + +--- to be annihilated +local function old_behavior (specification) -- xetex mode + old_feature_list = { } + lpeg.match(oldsyntax,specification.specification) + old_feature_list = set_default_features(old_feature_list) + if old_feature_list.style then + specification.style = old_feature_list.style + old_feature_list.style = nil end - if feature_list.optsize then - specification.optsize = feature_list.optsize - feature_list.optsize = nil + if old_feature_list.optsize then + specification.optsize = old_feature_list.optsize + old_feature_list.optsize = nil end - if feature_list.name then - if resolvers.findfile(feature_list.name, "tfm") then - feature_list.lookup = "file" - feature_list.name = file.addsuffix(feature_list.name, "tfm") - elseif resolvers.findfile(feature_list.name, "ofm") then - feature_list.lookup = "file" - feature_list.name = file.addsuffix(feature_list.name, "ofm") + if old_feature_list.name then + if resolvers.findfile(old_feature_list.name, "tfm") then + old_feature_list.lookup = "file" + old_feature_list.name = file.addsuffix(old_feature_list.name, "tfm") + elseif resolvers.findfile(old_feature_list.name, "ofm") then + old_feature_list.lookup = "file" + old_feature_list.name = file.addsuffix(old_feature_list.name, "ofm") end - specification.name = feature_list.name - feature_list.name = nil + specification.name = old_feature_list.name + old_feature_list.name = nil end --- this test overwrites valid file: requests for xetex bracket --- syntax --- if feature_list.lookup then --- specification.lookup = feature_list.lookup --- feature_list.lookup = nil --- end - if feature_list.sub then - specification.sub = feature_list.sub - feature_list.sub = nil + if old_feature_list.lookup then + specification.lookup = old_feature_list.lookup + old_feature_list.lookup = nil end - if not feature_list.mode then + if old_feature_list.sub then + specification.sub = old_feature_list.sub + old_feature_list.sub = nil + end + if not old_feature_list.mode then -- if no mode is set, use our default - feature_list.mode = fonts.mode + old_feature_list.mode = fonts.mode end - specification.features.normal = fonts.handlers.otf.features.normalize(feature_list) - --inspect(specification) - --os.exit() + specification.features.normal = fonts.handlers.otf.features.normalize(old_feature_list) return specification end -fonts.definers.registersplit(":",colonized,"cryptic") -fonts.definers.registersplit("", colonized,"more cryptic") -- catches \font\text=[names] +--fonts.definers.registersplit(":",old_behavior,"cryptic") +--fonts.definers.registersplit("", old_behavior,"more cryptic") -- catches \font\text=[names] +--obsolete]==]-- + +----------------------------------------------------------------------- +--- request syntax parser 2.2 +----------------------------------------------------------------------- +--- the luaotfload font request syntax (see manual) +--- has a canonical form: +--- +--- \font=:: +--- +--- where +--- is the control sequence that activates the font +--- is either “file” or “name”, determining the lookup +--- is either a file name (no path) or a font +--- name, depending on the lookup +--- is a list of switches or options, separated by +--- semicolons or commas; a switch is of the form “+” foo +--- or “-” foo, options are of the form lhs “=” rhs +--- +--- however, to ensure backward compatibility we also have +--- support for Xetex-style requests. +--- +--- for the Xetex emulation see: +--- · The XeTeX Reference Guide by Will Robertson, 2011 +--- · The XeTeX Companion by Michel Goosens, 2010 +--- · About XeTeX by Jonathan Kew, 2005 +--- +--- +--- caueat emptor. +--- the request is parsed into one of **four** different +--- lookup categories: the regular ones, file and name, +--- as well as the Xetex compatibility ones, path and anon. +--- (maybe a better choice of identifier would be “ambig”.) +--- +--- according to my reconstruction, the correct chaining +--- of the lookups for each category is as follows: +--- +--- | File -> ( db/filename lookup; +--- db/basename lookup; +--- kpse.find_file() ) +--- | Name -> ( names.resolve() ) +--- | Path -> ( db/filename lookup; +--- db/basename lookup; +--- kpse.find_file(); +--- fullpath lookup ) +--- | Anon -> ( names.resolve(); (* most general *) +--- db/filename lookup; +--- db/basename lookup; +--- kpse.find_file(); +--- fullpath lookup ) +--- +--- the database should be generated only if the chain has +--- been completed, and then only once. +--- +--- caching of successful lookups is essential. we need +--- an additional subtable "cached" in the database. it +--- should be nil’able by issuing fontdbutil --flush or +--- something. if a cache miss is followed by a successful +--- lookup, then it will be counted as new addition to the +--- cache. we also need a config option to ignore caching. +--- +--- also everything has to be finished by tomorrow at noon. +--- +----------------------------------------------------------------------- + + +local stringlower = string.lower + +local toboolean = function (s) + if s == "true" then return true end + if s == "false" then return false end +--if s == "yes" then return true end --- Context style +--if s == "no" then return false end + return s +end + +local lpegmatch = lpeg.match +local P, S, R = lpeg.P, lpeg.S, lpeg.R +local C, Cc, Cf, Cg, Cs, Ct + = lpeg.C, lpeg.Cc, lpeg.Cf, lpeg.Cg, lpeg.Cs, lpeg.Ct + +--- terminals and low-level classes ----------------------------------- +--- note we could use the predefined ones from lpeg.patterns +local dot = P"." +local colon = P":" +local featuresep = S",;" +local slash = P"/" +local equals = P"=" +local lbrk, rbrk = P"[", P"]" + +local spacing = S" \t\v" +local ws = spacing^0 + +local digit = R"09" +local alpha = R("az", "AZ") +local anum = alpha + digit +local decimal = digit^1 * (dot * digit^0)^-1 + +--- modifiers --------------------------------------------------------- +--[[doc-- + The slash notation: called “modifiers” (Kew) or “font options” + (Robertson, Goosens) + we only support the shorthands for italic / bold / bold italic + shapes, the rest is ignored. +--doc]]-- +local style_modifier = (P"BI" + P"IB" + P"bi" + P"ib" + S"biBI") + / stringlower +local other_modifier = P"S=" * decimal --- optical size; unsupported + + P"AAT" + P"aat" --- apple stuff; unsupported + + P"ICU" + P"icu" --- not applicable + + P"GR" + P"gr" --- sil stuff; unsupported +local garbage_modifier = ((1 - colon - slash)^0 * Cc(false)) +local modifier = slash * (other_modifier --> ignore + + Cs(style_modifier) --> collect + + garbage_modifier) --> warn +local modifier_list = Cg(Ct(modifier^0), "modifiers") + +--- lookups ----------------------------------------------------------- +local fontname = C((1-S"/:(")^1) --- like luatex-fonts +local prefixed = P"name:" * ws * Cg(fontname, "name") + + P"file:" * ws * Cg(fontname, "file") +local unprefixed = Cg(fontname, "anon") +local path_lookup = lbrk * Cg(C((1-rbrk)^1), "path") * rbrk + +--- features ---------------------------------------------------------- +local field = (anum + S"+-.")^1 --- sic! +--- assignments are “lhs=rhs” +--- switches are “+key” | “-key” +local assignment = C(field) * ws * equals * ws * (field / toboolean) +local switch = P"+" * ws * C(field) * Cc(true) + + P"-" * ws * C(field) * Cc(false) + + C(field) * Cc(true) -- catch crap +local feature_expr = ws * Cg(assignment + switch) * ws +local feature_list = Cf(Ct"" + * feature_expr + * (featuresep * feature_expr)^0 + , rawset) + * featuresep^-1 + +--- top-level rules --------------------------------------------------- +--- \font\foo=: +local features = Cg(feature_list, "features") +local specification = (prefixed + unprefixed) * modifier_list^-1 +local font_request = Ct(path_lookup * (colon^-1 * features)^-1 + + specification * (colon * features)^-1) + +-- lpeg.print(font_request) +--- new parser: 632 rules +--- old parser: 230 rules + +local import_values = { + --- That’s what the 1.x parser did, not quite as graciously, + --- with an array of branch expressions. + "style", "optsize", "lookup", "sub" --[[‽]], "mode", +} + +local handle_name = function (specification, raw) + --- FIXME only file: and name: atm + local name = raw.file or raw.name + local lookup + --- why is this here? + --- TODO should we keep this, check if it applies only to tfm and + --- ofm, and test formats by a defined list! + if resolvers.findfile(name, "tfm") then + lookup = "file" + name = file.addsuffix(name, "tfm") + elseif resolvers.findfile(name, "ofm") then + lookup = "file" + name = file.addsuffix(name, "ofm") + end + return name, lookup +end + +--- spec -> spec +local handle_request = function (specification) + local request = lpegmatch(font_request, + specification.specification) + request.features = set_default_features(request.features) + + local name, lookup = handle_name(specification, request) + if name then + specification.name = name + specification.lookup = lookup or specification.lookup + end + + for n=1, #import_values do + local feat = import_values[n] + local newvalue = request.features[feat] + if newvalue then + specification[feat] = request.features[feat] + request.features[feat] = nil + end + end + --- The next line sets the “rand” feature to “random”; I haven’t + --- investigated it any further (luatex-fonts-ext), so it will + --- just stay here. + specification.features.normal + = fonts.handlers.otf.features.normalize(request.features) + return specification +end + +local compare_requests = function (spec) + local old = old_behavior(spec) + local new = handle_request(spec) + return new +end + +fonts.definers.registersplit(":", compare_requests, "cryptic") +fonts.definers.registersplit("", compare_requests, "more cryptic") -- catches \font\text=[names] + +--fonts.definers.registersplit(":", handle_request, "cryptic") +--fonts.definers.registersplit("", handle_request, "more cryptic") -- catches \font\text=[names] + +--fonts.definers.registersplit(":",old_behavior,"cryptic") +--fonts.definers.registersplit("", old_behavior,"more cryptic") -- catches \font\text=[names] --- TODO below section is literally the same in luatex-fonts-def --- why is it here? -- cgit v1.2.3 From a1ab3fe5a146cf741d517be62985b97268de624b Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 12:59:51 +0200 Subject: add fallback for specification name --- luaotfload-database.lua | 12 ++++++------ luaotfload-features.lua | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/luaotfload-database.lua b/luaotfload-database.lua index 576971e..b678f51 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -437,7 +437,7 @@ local cached_resolver = function (specification) if not names.data then names.data = load_names() end local request_cache = names.data.request_cache local request = specification.specification - report("info", 4, "cache", + report("log", 4, "cache", "looking for “%s” in cache ...", request) local found = names.data.request_cache[request] @@ -449,7 +449,7 @@ local cached_resolver = function (specification) end return specification end - report("info", 4, "cache", "not cached; resolving") + report("log", 4, "cache", "not cached; resolving") --- first we resolve normally ... local resolved_spec = normal_resolver(specification) @@ -459,7 +459,7 @@ local cached_resolver = function (specification) local f = cache_fields[i] entry[f] = resolved_spec[f] end - report("info", 4, "cache", "new entry: %s", request) + report("log", 4, "cache", "new entry: %s", request) names.data.request_cache[request] = entry --- obviously, the updated cache needs to be stored. @@ -467,7 +467,7 @@ local cached_resolver = function (specification) --- whenever the cache is updated. --- TODO this should trigger a save only once the --- document is compiled (finish_pdffile callback?) - report("info", 5, "cache", "saving updated cache") + report("log", 5, "cache", "saving updated cache") save_names() return resolved_spec end @@ -480,7 +480,7 @@ local resolvers = { fonts.definers.resolve = resolvers[config.luaotfload.resolver] --fonts.definers.resolve = resolvers.cached -fonts.definers.resolve = resolvers.dummy +--fonts.definers.resolve = resolvers.dummy --[[doc-- @@ -1268,7 +1268,7 @@ local function get_os_dirs() local os_dirs = {} for _,p in next, {"/usr/local/etc/fonts/fonts.conf", "/etc/fonts/fonts.conf"} do if lfs.isfile(p) then - read_fonts_conf(p, os_dirs, passed_paths) + paths = read_fonts_conf(p, os_dirs, passed_paths) end end return os_dirs diff --git a/luaotfload-features.lua b/luaotfload-features.lua index cd639b6..f3d9158 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -401,9 +401,9 @@ local import_values = { "style", "optsize", "lookup", "sub" --[[‽]], "mode", } -local handle_name = function (specification, raw) +local handle_name = function (specname, raw) --- FIXME only file: and name: atm - local name = raw.file or raw.name + local name = raw.file or raw.name or specname local lookup --- why is this here? --- TODO should we keep this, check if it applies only to tfm and @@ -424,7 +424,7 @@ local handle_request = function (specification) specification.specification) request.features = set_default_features(request.features) - local name, lookup = handle_name(specification, request) + local name, lookup = handle_name(specification.name, request) if name then specification.name = name specification.lookup = lookup or specification.lookup -- cgit v1.2.3 From 996ba6a5014fc546c8e8c769a259b9adaf2090dc Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 13:34:58 +0200 Subject: add prelimiary anon: and path: resolvers --- luaotfload-features.lua | 23 +++++++++++++++++++---- luaotfload.dtx | 30 ++++++++++++++++++++++++++++-- 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/luaotfload-features.lua b/luaotfload-features.lua index f3d9158..c939a3f 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -401,7 +401,7 @@ local import_values = { "style", "optsize", "lookup", "sub" --[[‽]], "mode", } -local handle_name = function (specname, raw) +local handle_tfmofm = function (specname, raw) --- FIXME only file: and name: atm local name = raw.file or raw.name or specname local lookup @@ -418,13 +418,28 @@ local handle_name = function (specname, raw) return name, lookup end +local lookup_types = { "anon", "file", "name", "path" } + +local select_lookup = function (request) + for i=1, #lookup_types do + local lookup = lookup_types[i] + local value = request[lookup] + if value then + return lookup, value + end + end +end + --- spec -> spec local handle_request = function (specification) - local request = lpegmatch(font_request, - specification.specification) + local request = lpegmatch(font_request, + specification.specification) + local lookup, name = select_lookup(request) request.features = set_default_features(request.features) - local name, lookup = handle_name(specification.name, request) + --- FIXME what to do about tfm/ofm?? + --local name, lookup = handle_tfmofm(specification.name, request) + if name then specification.name = name specification.lookup = lookup or specification.lookup diff --git a/luaotfload.dtx b/luaotfload.dtx index 8b3616a..ead0773 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -1371,8 +1371,10 @@ loadmodule"colors.lua" --- “font-clr” -- specification.name = fonts.names.resolve('', '', specification) --end -fonts.definers.resolvers.file = function (specification) - --inspect(specification) +local resolvers = fonts.definers.resolvers +local formats = fonts.formats + +resolvers.file = function (specification) if specification.lookup == "file" then local found = fonts.names.crude_file_lookup(specification.name) --local found = fonts.names.crude_file_lookup_verbose(specification.name) @@ -1380,6 +1382,30 @@ fonts.definers.resolvers.file = function (specification) end end +--- TODO rewrite this according to the syntax spec +resolvers.anon = function (specification) + local resolved, subfontno = fonts.names.resolve(nil, nil, specification) + if resolved then --- we follow fonts-def to some extent + specification.resolved = resolved + specification.sub = subfontno + local suffix = file.suffix(resolved) + if formats[suffix] then + specification.forced = suffix + specification.name = file.removesuffix(resolved) + else + specification.name = resolved + end + else + resolvers.file(specification) + end +end + +--- TODO rewrite this according to the syntax spec +resolvers.path = function (specification) + local found = fonts.names.crude_file_lookup(specification.name) + specification.name = found[1] +end + % \end{macrocode} % We create a callback for patching fonts on the fly, to be used by other % packages. -- cgit v1.2.3 From 2a4159410151fa9c99adaf56071a370bcb261ac1 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 16:03:16 +0200 Subject: add test for ttc subfont loading --- tests/pln-subfont-1.tex | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 tests/pln-subfont-1.tex diff --git a/tests/pln-subfont-1.tex b/tests/pln-subfont-1.tex new file mode 100644 index 0000000..4877682 --- /dev/null +++ b/tests/pln-subfont-1.tex @@ -0,0 +1,12 @@ +\ifdefined\directlua\input luaotfload.sty\fi + +\directlua{ + inspect(fontloader.info"cambria.ttc") +} + +\font\subfontone="file:cambria.ttc(0)" at 42pt +\font\subfonttwo="file:cambria.ttc(1)" at 42pt + +\subfontone foo bar baz \endgraf +\subfonttwo foo bar baz \endgraf +\bye -- cgit v1.2.3 From 98147cdc664312aa287a46a6d64c0e8fa86ebdbc Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 16:04:05 +0200 Subject: add the subfont selector patter into new syntax (hidden goodie?) --- luaotfload-features.lua | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/luaotfload-features.lua b/luaotfload-features.lua index c939a3f..08414f6 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -384,10 +384,28 @@ local feature_list = Cf(Ct"" , rawset) * featuresep^-1 +--- other ------------------------------------------------------------- +--- This rule is present in the original parser. It sets the “sub” +--- field of the specification which allows addressing a specific +--- font inside a TTC container. Neither in Luatex-Fonts nor in +--- Luaotfload is this documented, so we might as well silently drop +--- it. However, as backward compatibility is one of our prime goals we +--- just insert it here and leave it undocumented until someone cares +--- to ask. (Note: afair subfonts are numbered, but this rule matches a +--- string; I won’t mess with it though until someone reports a +--- problem.) +--- local subvalue = P("(") * (C(P(1-S("()"))^1)/issub) * P(")") -- for Kim +--- Who’s Kim? +--- Note to self: subfonts apparently start at index 0. Tested with +--- Cambria.ttc that includes “Cambria Math” at 0 and “Cambria” at 1. +--- Other values cause luatex to segfault. +local subfont = P"(" * Cg((1 - S"()")^1, "sub") * P")" --- top-level rules --------------------------------------------------- --- \font\foo=: local features = Cg(feature_list, "features") -local specification = (prefixed + unprefixed) * modifier_list^-1 +local specification = (prefixed + unprefixed) + * subfont^-1 + * modifier_list^-1 local font_request = Ct(path_lookup * (colon^-1 * features)^-1 + specification * (colon * features)^-1) @@ -449,6 +467,7 @@ local handle_request = function (specification) local feat = import_values[n] local newvalue = request.features[feat] if newvalue then + print(feat, newvalue) specification[feat] = request.features[feat] request.features[feat] = nil end @@ -467,11 +486,11 @@ local compare_requests = function (spec) return new end -fonts.definers.registersplit(":", compare_requests, "cryptic") -fonts.definers.registersplit("", compare_requests, "more cryptic") -- catches \font\text=[names] +--fonts.definers.registersplit(":", compare_requests, "cryptic") +--fonts.definers.registersplit("", compare_requests, "more cryptic") -- catches \font\text=[names] ---fonts.definers.registersplit(":", handle_request, "cryptic") ---fonts.definers.registersplit("", handle_request, "more cryptic") -- catches \font\text=[names] +fonts.definers.registersplit(":", handle_request, "cryptic") +fonts.definers.registersplit("", handle_request, "more cryptic") -- catches \font\text=[names] --fonts.definers.registersplit(":",old_behavior,"cryptic") --fonts.definers.registersplit("", old_behavior,"more cryptic") -- catches \font\text=[names] -- cgit v1.2.3 From 74ebd14b94432c9de82614627454dfa3bfcb9de0 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 16:39:26 +0200 Subject: add lookups ``file:``, ``path:``, ``name:``, and ``anon:`` --- fontdbutil.lua | 2 +- luaotfload-database.lua | 4 +-- luaotfload.dtx | 86 ++++++++++++++++++++++++++++++++----------------- 3 files changed, 60 insertions(+), 32 deletions(-) diff --git a/fontdbutil.lua b/fontdbutil.lua index 1aa99d0..af9e23c 100755 --- a/fontdbutil.lua +++ b/fontdbutil.lua @@ -28,7 +28,7 @@ string.quoted = string.quoted or function (str) return string.format("%q",str) end -dofile(loader_path) +require(loader_path) --[[doc-- Depending on how the script is called we change its behavior. diff --git a/luaotfload-database.lua b/luaotfload-database.lua index b678f51..eb8271d 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -295,7 +295,7 @@ end --- string -> (string * bool | int) crude_file_lookup_verbose = function (filename) - if not names.data then names.data = names_reload() end + if not names.data then names.data = load_names() end local data = names.data local mappings = data.mappings local found @@ -344,7 +344,7 @@ end --- string -> (string * bool | int) crude_file_lookup = function (filename) - if not names.data then names.data = names_reload() end + if not names.data then names.data = load_names() end local data = names.data local mappings = data.mappings local found = data.barenames[filename] diff --git a/luaotfload.dtx b/luaotfload.dtx index ead0773..0584f07 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -1014,11 +1014,12 @@ local luatexbase = luatexbase local type, next = type, next local setmetatable = setmetatable +local find_file = kpse.find_file +local lfsisfile = lfs.isfile local stringfind = string.find -local stringsub = string.sub -local stringmatch = string.match local stringformat = string.format -local find_file = kpse.find_file +local stringmatch = string.match +local stringsub = string.sub local add_to_callback, create_callback = luatexbase.add_to_callback, luatexbase.create_callback @@ -1363,47 +1364,74 @@ loadmodule"colors.lua" --- “font-clr” % is understood. % Until then it is considered a kludge, like the hack below. % +% Relying on the \verb|name:| resolver for everything has been the source +% of permanent trouble with the database. +% With the introduction of the new syntax parser we now have enough +% granularity to distinguish between the \XETEX emulation layer and the +% genuine \verb|name:| and \verb|file:| lookups of \LUATEX-Fonts. +% Another benefit is that we can now easily plug in or replace new lookup +% behaviors if necessary. +% +% The name resolver remains untouched, but it calls +% \luafunction{fonts.names.resolve()} internally anyways (see +% \fileent{luaotfload-database.lua}). +% % \begin{macrocode} ---- below lines already (2013-04-25) lead to warnings by ---- the font loader ---fonts.definers.resolvers.file = function (specification) --- specification.name = fonts.names.resolve('', '', specification) ---end - local resolvers = fonts.definers.resolvers local formats = fonts.formats +% \end{macrocode} +% \identifier{luaotfload} promises easy access to system fonts. +% Without additional precautions, this cannot be achieved by +% \identifier{kpathsea} alone, because it searches only the +% \fileent{texmf} directories by default. +% Although it is possible for \identifier{kpathsea} to include extra +% paths by adding them to the \verb|OSFONTDIR| environment variable, +% this is still short of the goal »\emphasis{it just works!}«. +% When building the font database \identifier{luaotfload} scans +% system font directories anyways, so we already have all the +% information for looking sytem fonts. +% With the release version 2.2 the file names are indexed in the database +% as well and we are ready to resolve \verb|file:| lookups this way. +% Thus we no longer need to call the \identifier{kpathsea} library in +% most cases when looking up font files, only when generating the database. +% +% \begin{macrocode} resolvers.file = function (specification) + --- how would we go about allowing subfonts (ttc)? if specification.lookup == "file" then local found = fonts.names.crude_file_lookup(specification.name) - --local found = fonts.names.crude_file_lookup_verbose(specification.name) specification.name = found[1] end end --- TODO rewrite this according to the syntax spec -resolvers.anon = function (specification) - local resolved, subfontno = fonts.names.resolve(nil, nil, specification) - if resolved then --- we follow fonts-def to some extent - specification.resolved = resolved - specification.sub = subfontno - local suffix = file.suffix(resolved) - if formats[suffix] then - specification.forced = suffix - specification.name = file.removesuffix(resolved) - else - specification.name = resolved - end - else - resolvers.file(specification) - end -end +% \end{macrocode} +% We classify as \verb|anon:| those requests that have neither a +% prefix nor brackets. According to Khaled\footnote{% +% \url{https://github.com/phi-gamma/luaotfload/issues/4#issuecomment-17090553}. +% } +% they are the \XETEX equivalent of a \verb|name:| request, so we will be +% treating them as such. +% +% \begin{macrocode} ---- TODO rewrite this according to the syntax spec +resolvers.anon = resolvers.name + +% \end{macrocode} +% Prior to version 2.2, \identifier{luaotfload} did not distinguish +% \verb|file:| and \verb|path:| lookups, causing complications with the +% resolver. +% Now we test if the requested name is an absolute path in the file +% system, otherwise we fall back to the \verb|file:| lookup. +% +% \begin{macrocode} resolvers.path = function (specification) - local found = fonts.names.crude_file_lookup(specification.name) - specification.name = found[1] + local exists, _ = lfsisfile(specification.name) + if not exists then -- resort to file: lookup + resolvers.file(specification) + end end % \end{macrocode} -- cgit v1.2.3 From 189085f9a7212320183d5fed0c4aa31df1602d5f Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 19:08:11 +0200 Subject: catch tfm/ofm before db update; remove ``kpse.lookup()`` as criterion for resolved font --- fontdbutil.lua | 12 +++++-- luaotfload-database.lua | 84 ++++++++++++++++++++++--------------------------- luaotfload-features.lua | 37 ---------------------- luaotfload.dtx | 51 +++++++++++++++++++++++------- 4 files changed, 86 insertions(+), 98 deletions(-) diff --git a/fontdbutil.lua b/fontdbutil.lua index af9e23c..470d282 100755 --- a/fontdbutil.lua +++ b/fontdbutil.lua @@ -276,14 +276,20 @@ actions.query = function (job) optsize = 0, } - local foundname, _whatever, success = + local foundname, subfont, success = fonts.names.resolve(nil, nil, tmpspec) if success then logs.names_report(false, 1, "resolve", "Font “%s” found!", query) - logs.names_report(false, 1, - "resolve", "Resolved file name “%s”", foundname) + if subfont then + logs.names_report(false, 1, "resolve", + "Resolved file name “%s”, subfont nr. “%s”", + foundname, subfont) + else + logs.names_report(false, 1, + "resolve", "Resolved file name “%s”", foundname) + end if job.show_info then show_font_info(foundname) end diff --git a/luaotfload-database.lua b/luaotfload-database.lua index eb8271d..e5065bd 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -291,7 +291,7 @@ do end end ---- chain: barenames -> [fullnames ->] basenames -> findfile +local type1_formats = { "tfm", "ofm", } --- string -> (string * bool | int) crude_file_lookup_verbose = function (filename) @@ -320,26 +320,19 @@ crude_file_lookup_verbose = function (filename) if found and mappings[found] then found = mappings[found].filename report("info", 0, "db", - "crude file lookup: req=%s; hit=bare; ret=%s", + "crude file lookup: req=%s; hit=base; ret=%s", filename, found[1]) return found end - --- now look for tfm et al.; will be superseded by proper - --- format lookup - found = resolvers.findfile(filename, "tfm") - if found then - report("info", 0, "db", - "crude file lookup: req=tfm; hit=bare; ret=%s", found) - return { found, false } - end - found = resolvers.findfile(filename, "ofm") - if found then - report("info", 0, "db", - "crude file lookup: req=ofm; hit=bare; ret=%s", found) - return { found, false } + --- ofm and tfm + for i=1, #type1_formats do + local format = type1_formats[i] + if resolvers.findfile(filename, format) then + return { file.addsuffix(filename, format), false }, format + end end - return false + return { filename, false }, nil end --- string -> (string * bool | int) @@ -354,11 +347,13 @@ crude_file_lookup = function (filename) found = data.mappings[found] if found then return found.filename end end - found = resolvers.findfile(filename, "tfm") - if found then return { found, false } end - found = resolvers.findfile(filename, "ofm") - if found then return { found, false } end - return false + for i=1, #type1_formats do + local format = type1_formats[i] + if resolvers.findfile(filename, format) then + return { file.addsuffix(filename, format), false }, format + end + end + return { filename, false }, nil end --[[doc-- @@ -644,13 +639,14 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con end if #found == 1 then - if kpselookup(found[1].filename[1]) then - report("log", 0, "resolve", - "font family='%s', subfamily='%s' found: %s", - name, style, found[1].filename[1] - ) - return found[1].filename[1], found[1].filename[2], true - end + --- Since we do the file resolving ourselves, we don’t need the + --- kpathsea lookup here any longer. + --- “found” is really synonymous with “registered in the db”. + report("log", 0, "resolve", + "font family='%s', subfamily='%s' found: %s", + name, style, found[1].filename[1] + ) + return found[1].filename[1], found[1].filename[2], true 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 @@ -665,13 +661,11 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con least = difference end end - if kpselookup(closest.filename[1]) then - report("log", 0, "resolve", - "font family='%s', subfamily='%s' found: %s", - name, style, closest.filename[1] - ) - return closest.filename[1], closest.filename[2], true - end + report("log", 0, "resolve", + "font family='%s', subfamily='%s' found: %s", + name, style, closest.filename[1] + ) + return closest.filename[1], closest.filename[2], true elseif found.fallback then return found.fallback.filename[1], found.fallback.filename[2], true end @@ -680,7 +674,7 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con if not fonts_reloaded then --- last straw: try reloading the database return reload_db( - "unresoled font name: “" .. name .. "”", + "unresolved font name: “" .. name .. "”", resolve, nil, nil, specification ) end @@ -737,9 +731,7 @@ find_closest = function (name, limit) local name = sanitize_string(name) limit = limit or fuzzy_limit - if not fonts_loaded then - names.data = load_names() - end + if not fonts_loaded then names.data = load_names() end local data = names.data @@ -866,10 +858,10 @@ font_fullinfo = function (filename, subfont, texmf) tfmdata.fontname = metadata.fontname tfmdata.fullname = metadata.fullname tfmdata.familyname = metadata.familyname - tfmdata.filename = { - texmf and filebasename(filename) or filename, - subfont - } + if texmf then + filename = filebasename(filename) + end + tfmdata.filename = { filename, subfont } tfmdata.weight = metadata.pfminfo.weight tfmdata.width = metadata.pfminfo.width tfmdata.slant = metadata.italicangle @@ -1328,9 +1320,9 @@ update_names = function (fontnames, force) read_blacklist() local scanned, new - scanned, new = scan_texmf_fonts(fontnames, newfontnames) - n_scanned = n_scanned + scanned - n_new = n_new + new +-- scanned, new = scan_texmf_fonts(fontnames, newfontnames) +-- n_scanned = n_scanned + scanned +-- n_new = n_new + new scanned, new = scan_os_fonts(fontnames, newfontnames) n_scanned = n_scanned + scanned diff --git a/luaotfload-features.lua b/luaotfload-features.lua index 08414f6..de7ff3f 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -419,23 +419,6 @@ local import_values = { "style", "optsize", "lookup", "sub" --[[‽]], "mode", } -local handle_tfmofm = function (specname, raw) - --- FIXME only file: and name: atm - local name = raw.file or raw.name or specname - local lookup - --- why is this here? - --- TODO should we keep this, check if it applies only to tfm and - --- ofm, and test formats by a defined list! - if resolvers.findfile(name, "tfm") then - lookup = "file" - name = file.addsuffix(name, "tfm") - elseif resolvers.findfile(name, "ofm") then - lookup = "file" - name = file.addsuffix(name, "ofm") - end - return name, lookup -end - local lookup_types = { "anon", "file", "name", "path" } local select_lookup = function (request) @@ -455,9 +438,6 @@ local handle_request = function (specification) local lookup, name = select_lookup(request) request.features = set_default_features(request.features) - --- FIXME what to do about tfm/ofm?? - --local name, lookup = handle_tfmofm(specification.name, request) - if name then specification.name = name specification.lookup = lookup or specification.lookup @@ -467,7 +447,6 @@ local handle_request = function (specification) local feat = import_values[n] local newvalue = request.features[feat] if newvalue then - print(feat, newvalue) specification[feat] = request.features[feat] request.features[feat] = nil end @@ -495,22 +474,6 @@ fonts.definers.registersplit("", handle_request, "more cryptic") -- catches \fo --fonts.definers.registersplit(":",old_behavior,"cryptic") --fonts.definers.registersplit("", old_behavior,"more cryptic") -- catches \font\text=[names] ---- TODO below section is literally the same in luatex-fonts-def ---- why is it here? ---function fonts.definers.applypostprocessors(tfmdata) --- local postprocessors = tfmdata.postprocessors --- if postprocessors then --- for i=1,#postprocessors do --- local extrahash = postprocessors[i](tfmdata) -- after scaling etc --- if type(extrahash) == "string" and extrahash ~= "" then --- -- e.g. a reencoding needs this --- extrahash = string.gsub(lower(extrahash),"[^a-z]","-") --- tfmdata.properties.fullname = format("%s-%s",tfmdata.properties.fullname,extrahash) --- end --- end --- end --- return tfmdata ---end ---[[ end included font-ltx.lua ]] --[[doc-- diff --git a/luaotfload.dtx b/luaotfload.dtx index 0584f07..722a8d2 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -1378,8 +1378,9 @@ loadmodule"colors.lua" --- “font-clr” % % \begin{macrocode} -local resolvers = fonts.definers.resolvers -local formats = fonts.formats +local request_resolvers = fonts.definers.resolvers +local formats = fonts.formats +formats.ofm = "type1" % \end{macrocode} % \identifier{luaotfload} promises easy access to system fonts. @@ -1398,15 +1399,13 @@ local formats = fonts.formats % most cases when looking up font files, only when generating the database. % % \begin{macrocode} -resolvers.file = function (specification) - --- how would we go about allowing subfonts (ttc)? - if specification.lookup == "file" then - local found = fonts.names.crude_file_lookup(specification.name) - specification.name = found[1] - end +request_resolvers.file = function (specification) + --local found = fonts.names.crude_file_lookup(specification.name) + local found = fonts.names.crude_file_lookup_verbose(specification.name) + specification.name = found[1] + --if format then specification.forced = format end end ---- TODO rewrite this according to the syntax spec % \end{macrocode} % We classify as \verb|anon:| those requests that have neither a % prefix nor brackets. According to Khaled\footnote{% @@ -1417,7 +1416,35 @@ end % % \begin{macrocode} -resolvers.anon = resolvers.name +--request_resolvers.anon = request_resolvers.name + +% \end{macrocode} +% There is one drawback, though. +% This syntax is also used for requesting fonts in \identifier{Type1} +% (\abbrev{tfm}, \abbrev{ofm}) format. +% These are essentially \verb|file:| lookups and must be caught before +% the \verb|name:| resolver kicks in, lest they cause the database to +% update. +% Even if we were to require the \verb|file:| prefix for all +% \identifier{Type1} requests, tests have shown that certain fonts still +% include further fonts (e.~g. \fileent{omlgcb.ofm} will ask for +% \fileent{omsecob.tfm}) \emphasis{using the old syntax}. +% For this reason, we introduce an extra check with an early return. +% +% \begin{macrocode} +local type1_formats = { "tfm", "ofm", } + +request_resolvers.anon = function (specification) + local name = specification.name + for i=1, #type1_formats do + local format = type1_formats[i] + if resolvers.findfile(name, format) then + specification.name = file.addsuffix(name, format) + return + end + end + request_resolvers.name(specification) +end % \end{macrocode} % Prior to version 2.2, \identifier{luaotfload} did not distinguish @@ -1427,10 +1454,10 @@ resolvers.anon = resolvers.name % system, otherwise we fall back to the \verb|file:| lookup. % % \begin{macrocode} -resolvers.path = function (specification) +request_resolvers.path = function (specification) local exists, _ = lfsisfile(specification.name) if not exists then -- resort to file: lookup - resolvers.file(specification) + request_resolvers.file(specification) end end -- cgit v1.2.3 From 1c8a1d0a59de24f0d1f456c4fad29024e00ef23b Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Sun, 28 Apr 2013 19:13:56 +0200 Subject: test for file existence again, but try with ``lfs.isfile()`` first --- luaotfload-database.lua | 33 ++++++++++++++++++++------------- 1 file changed, 20 insertions(+), 13 deletions(-) diff --git a/luaotfload-database.lua b/luaotfload-database.lua index e5065bd..8caa35b 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -25,6 +25,7 @@ local kpseexpand_path = kpse.expand_path local kpseexpand_var = kpse.expand_var local kpselookup = kpse.lookup local kpsereadable_file = kpse.readable_file +local lfsisfile = lfs.isfile local mathabs = math.abs local mathmin = math.min local stringfind = string.find @@ -639,14 +640,15 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con end if #found == 1 then - --- Since we do the file resolving ourselves, we don’t need the - --- kpathsea lookup here any longer. --- “found” is really synonymous with “registered in the db”. - report("log", 0, "resolve", - "font family='%s', subfamily='%s' found: %s", - name, style, found[1].filename[1] - ) - return found[1].filename[1], found[1].filename[2], true + local filename = found[1].filename[1] + if lfsisfile(filename) or kpselookup(filename) then + report("log", 0, "resolve", + "font family='%s', subfamily='%s' found: %s", + name, style, filename + ) + return filename, found[1].filename[2], true + 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 @@ -661,13 +663,18 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con least = difference end end - report("log", 0, "resolve", - "font family='%s', subfamily='%s' found: %s", - name, style, closest.filename[1] - ) - return closest.filename[1], closest.filename[2], true + local filename = closest.filename[1] + if lfsisfile(filename) or kpselookup(filename) then + report("log", 0, "resolve", + "font family='%s', subfamily='%s' found: %s", + name, style, filename + ) + return filename, closest.filename[2], true + end elseif found.fallback then - return found.fallback.filename[1], found.fallback.filename[2], true + return found.fallback.filename[1], + found.fallback.filename[2], + true end --- no font found so far -- cgit v1.2.3 From 09765c22460ee4aa3e2fbe5cf1af54aa3106e6a5 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 10:55:49 +0200 Subject: [doc] add font request syntax description MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For convenience it’s a notational bastard of BNF and ISO EBNF. I couldn’t find a package for typesetting the latter, and with my limited understanding of LaTeX I couldn’t have written one within an acceptable time. Anyways, I don’t think anybody will be confused by this. --- luaotfload.dtx | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 77 insertions(+), 2 deletions(-) diff --git a/luaotfload.dtx b/luaotfload.dtx index 722a8d2..957dea1 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -160,6 +160,8 @@ and the derived files \renewcommand\partname{Part}%% gets rid of the stupid “file” heading +\usepackage{syntax}%% bnf for font request syntax + \VerbatimFootnotes \begin{document} \DocInput{luaotfload.dtx}% @@ -256,8 +258,81 @@ and the derived files % % \noindent % The curly brackets are optional and escape the spaces in the enclosed -% font name (alternatively, double quotes serve the same purpose). -% The individual parts of the syntax are: +% font name. +% Alternatively, double quotes serve the same purpose. +% A selection of individual parts of the syntax are discussed below; +% for a more formal description see figure \ref{font-syntax}. +% +% \begin{figure}[b] +% \setlength\grammarparsep{12pt plus 2pt minus 2pt} +% \setlength\grammarindent{5cm} +% \begingroup +% \small +% \begin{grammar} +% ::= `\\font', {\sc csname}, `=', , [ ] ; +% +% ::= `at', {\sc dimension} ; +% +% ::= `"', `"' +% \alt `{', `}' +% \alt ; +% +% ::= , [`:', ] +% \alt `[', `]', [ [`:'], ] ; +% +% ::= , [ ], \{ \} +% \alt , \{ \} ; +% +% ::= `file:', +% \alt `name:', ; +% +% ::= \{ \} ; +% +% ::= \{ \} ; +% +% ::= {\sc tfmname} | ; +% +% ::= \{ {\sc all_characters} - `]' \} ; +% +% ::= `/', (`i' | `b' | `bi' | `ib') ; +% +% ::= `(', \{ {\sc digit} \}, `)' ; +% +% ::= , \{ `;', \} ; +% +% ::= {\sc feature_id}, `=', {\sc feature_value} +% \alt , {\sc feature_id} ; +% +% ::= `+' | `-' ; +% +% ::= {\sc all_characters} - ( `(' | `/' | `:' ) ; +% \end{grammar} +% \endgroup +% \caption{Font request syntax. +% Braces or double quotes around the +% \emphasis{specification} rule will +% preserve whitespace in file names. +% In addition to the font style modifiers +% (\emphasis{slash-notation}) given above, there +% are others that are recognized but will be silently +% ignored: {\ttfamily aat}, +% {\ttfamily icu}, and +% {\ttfamily gr}. +% The special terminals are: +% {\sc feature\textunderscore id} for a valid font +% feature name and +% {\sc feature\textunderscore value} for the corresponding +% value. +% {\sc tfmname} is the name of a \abbrev{tfm} file. +% {\sc digit} again refers to bytes 48--57, and +% {\sc all\textunderscore characters} to all byte values. +% {\sc csname} and {\sc dimension} are the \TEX concepts.} +% \label{font-syntax} +% \end{figure} +% +% %(* braces around the specification will preserve whitespace *) +% %(* file lookups do not allow paths *) +% %(* others like `aat', `icu', and `gr' are silently ignored *) % % \paragraph{Prefix} % -- cgit v1.2.3 From 2adc02056a47717a8f9fee7a48e62ab5cf50c9c8 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 12:07:37 +0200 Subject: add test file for tfm --- tests/pln-tfm.tex | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 tests/pln-tfm.tex diff --git a/tests/pln-tfm.tex b/tests/pln-tfm.tex new file mode 100644 index 0000000..26fa738 --- /dev/null +++ b/tests/pln-tfm.tex @@ -0,0 +1,8 @@ +\ifdefined\directlua\input luaotfload.sty \fi +%% TFM’s can be loaded with a file: request ... +\font\antykwatorunska="file:rm-anttr" +%% or with an anonymous request, like in þe olde TeX: +\font\antykwatorunskabcap=ec-anttbcap +\antykwatorunska foo bar +\antykwatorunskabcap baz xyzzy +\bye -- cgit v1.2.3 From be7d5713a125033d686d97a38910cb5af62f9093 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 12:51:52 +0200 Subject: [doc] describe the various font requests --- luaotfload.dtx | 184 +++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 145 insertions(+), 39 deletions(-) diff --git a/luaotfload.dtx b/luaotfload.dtx index 957dea1..abc737c 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -130,6 +130,8 @@ and the derived files \setsansfont[Ligatures=TeX,Scale=MatchLowercase]{Iwona Medium} %setmathfont{XITS Math} +\usepackage{hologo} + \newcommand\TEX {\TeX\xspace} \newcommand\LUA {Lua\xspace} \newcommand\PDFTEX {pdf\TeX\xspace} @@ -246,15 +248,15 @@ and the derived files % % \section{Loading Fonts} % -% \identifier{luaotfload} supports an extended font loading syntax: +% \identifier{luaotfload} supports an extended font request syntax: % -% \begin{center} +% \begin{quote} % |\font\foo={|% % \meta{prefix}|:|% % \meta{font name}|:|% % \meta{font features}|}|% % \meta{\TEX font features} -% \end{center} +% \end{quote} % % \noindent % The curly brackets are optional and escape the spaces in the enclosed @@ -330,45 +332,93 @@ and the derived files % \label{font-syntax} % \end{figure} % -% %(* braces around the specification will preserve whitespace *) -% %(* file lookups do not allow paths *) -% %(* others like `aat', `icu', and `gr' are silently ignored *) -% -% \paragraph{Prefix} -% -% The \meta{prefix} is either |file:| or |name:|. -% It determines whether the font loader should interpret the request as a -% file name or font name, respectively, which again influences how it -% will attempt to locate the font. -% The prefix can be omitted, in which case |name:| is assumed. -% -%% \iffalse%% how am i supposed to friggin comment stuff in a dtx??? -%% TODO -%% it would appear that the next paragraph is incorrect; I get -%% name: lookups regardless unless the font file is actually -%% in CWD -%% \fi -%% For compatibility with \XETEX, surrounding the \meta{font name} with -%% square brackets is synonymous to using the |file:| prefix. +% \subsection{Prefix -- the \identifier{luaotfload}\space Way} % +% In \identifier{luaotfload}, the canonical syntax for font requests +% requires a \emphasis{prefix}: +% \begin{quote} +% |\font\fontname=|\meta{prefix}|:|\meta{fontname}\dots +% \end{quote} +% where \meta{prefix} is either \verb|file:| or \verb|name:|. +% It determines whether the font loader should interpret the request as +% a \emphasis{file name} or +% \emphasis{font name}, respectively, +% which again influences how it will attempt to locate the font. +% Examples for font names are +% “Latin Modern Italic”, +% “GFS Bodoni Rg”, and +% “PT Serif Caption” +% -- they are the human readable identifiers +% usually listed in drop-down menus and the like. % In order for fonts installed both in system locations and in your % \fileent{texmf} to be accessible by font name, \identifier{luaotfload} must % first collect the metadata included in the files. -% Please refer to section ~\ref{sec:fontdb} below for instructions on how to +% Please refer to section~\ref{sec:fontdb} below for instructions on how to % create the database. % -% \paragraph{Font name} +% File names are whatever your file system allows them to be, except +% that that they may not contain the characters +% \verb|(|, +% \verb|:|, and +% \verb|/|. +% As obvious from the last exception, the \verb|file:| lookup will +% not process paths to the font location -- only those +% files found when generating the database are addressable this way. +% Continue below in the \XETEX section if you need to load your fonts +% by path. +% The file names corresponding to the example font names above are +% \fileent{lmroman12-italic.otf}, +% \fileent{GFSBodoni.otf}, and +% \fileent{PTZ56F.ttf}. +% +% \subsection{\hologo{XeTeX} Compatibility Layer} +% +% In addition to the regular prefixed requests, \identifier{luaotfload} +% accepts loading fonts the \XETEX way. +% There are again two modes: bracketed and unbracketed. +% A bracketed request looks as follows. % -% The \meta{font name} can be either a font filename or actual font -% name based on the \meta{prefix} as mentioned above. +% \begin{quote} +% |\font\fontname=[|\meta{path to file}|]| +% \end{quote} % -% A filename request may optionally include the absolute path to the font file, -% allowing for fonts outside the standard locations to be loaded as well. -% If no path is specified, then \identifier{kpathsea} is used to locate the -% font (which will typically be in the \fileent{texmf} tree or the -% current directory). +% \noindent +% Inside the square brackets, every character except for a closing +% bracket is permitted, allowing for specifying paths to a font file. +% Naturally, path-less file names are equally valid and processed the +% same way as an ordinary \verb|file:| lookup. % -% \subparagraph{Examples for loading by file name} +% \begin{quote} +% |\font\fontname=|\meta{font name} \dots +% \end{quote} +% +% Unbracketed (or, for lack of a better word: \emphasis{anonymous}) +% font requests resemble the conventional \TEX syntax. +% However, they have a broader spectrum of possible interpretations: +% before anything else, \identifier{luaotfload} attempts to load a +% traditional \TEX Font Metric (\abbrev{tfm} or \abbrev{ofm}). +% If this fails, it performs a \verb|name:| lookup, which itself will +% fall back to a \verb|file:| lookup if no database entry matches +% \meta{font name}. +% +% Furthermore, \identifier{luaotfload} supports the slashed (shorthand) +% font style notation from \XETEX. +% +% \begin{quote} +% |\font\fontname=|\meta{font name}|/|\meta{modifier}\dots +% \end{quote} +% +% \noindent +% Currently, four style modifiers are supported: +% \verb|i| for italic shape, +% \verb|b| for bold weight, +% \verb|bi| or \verb|ib| for the combination of both. +% Other “slashed” modifiers are too specific to the \XETEX engine and +% have no meaning in \LUATEX. +% +% \subsection{Examples} +% +% \subsubsection{Loading by File Name} % % For example, conventional \abbrev{type1} font can be loaded with a \verb|file:| % request like so: @@ -380,8 +430,11 @@ and the derived files % \end{quote} % % The \OpenType version of Janusz Nowacki’s font \emphasis{Antykwa -% Półtawskiego} (in \TEX Live) in its condensed variant can be loaded as -% follows: +% Półtawskiego}\footnote{% +% \url{http://jmn.pl/antykwa-poltawskiego/}, also available in +% in \TEX Live. +% } +% in its condensed variant can be loaded as follows: % % \begin{quote} % \begin{verbatim} @@ -399,7 +452,7 @@ and the derived files % \end{verbatim} % \end{quote} % -% \subparagraph{Examples for loading by font name} +% \subsubsection{Loading by Font Name} % % The \verb|name:| lookup does not depend on cryptic filenames: % @@ -435,9 +488,62 @@ and the derived files % \end{verbatim} % \end{quote} % -% \paragraph{Font features} +% \subsubsection{Modifiers} +% +% If the entire \emphasis{Iwona} family\footnote{% +% \url{http://jmn.pl/kurier-i-iwona/}, +% also in \TEX Live. +% } +% is installed in some location accessible by \identifier{luaotfload}, +% the regular shape can be loaded as follows: +% +% \begin{quote} +% \begin{verbatim} +% \font\iwona=Iwona at 20pt +% \end{verbatim} +% \end{quote} +% +% \noindent +% To load the most common of the other styles, the slash notation can +% be employed as shorthand: +% +% \begin{quote} +% \begin{verbatim} +% \font\iwonaitalic =Iwona/i at 20pt +% \font\iwonabold =Iwona/b at 20pt +% \font\iwonabolditalic=Iwona/bi at 20pt +% \end{verbatim} +% \end{quote} +% +% \noindent +% which is equivalent to these full names: +% +% \begin{quote} +% \begin{verbatim} +% \font\iwonaitalic ="Iwona Italic" at 20pt +% \font\iwonabold ="Iwona Bold" at 20pt +% \font\iwonabolditalic="Iwona BoldItalic" at 20pt +% \end{verbatim} +% \end{quote} +% +% \section{Font features} +% +% \emphasis{Font features} are the second to last component in the +% general scheme for font requests: +% +% \begin{quote} +% |\font\foo={|% +% \meta{prefix}|:|% +% \meta{font name}|:|% +% \meta{font features}|}|% +% \meta{\TEX font features} +% \end{quote} +% +% \noindent +% If style modifiers are present (\XETEX style), they must precede \meta{font +% features}. % -% \meta{font features} is semicolon-separated list of feature +% The element \meta{font features} is a semicolon-separated list of feature % tags\footnote{% % Cf. \url{http://www.microsoft.com/typography/otspec/featurelist.htm}. % } @@ -1078,7 +1184,7 @@ luaotfload.prefer_merge = config.luaotfload.prefer_merge or true luaotfload.module = { name = "luaotfload", version = 2.2, - date = "2013/04/15", + date = "2013/04/29", description = "OpenType layout system.", author = "Elie Roux & Hans Hagen", copyright = "Elie Roux", -- cgit v1.2.3 From 1a76cea6357f50d7dae752765173af335ba95beb Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 13:57:35 +0200 Subject: add handler for XeTeX slashed notation --- luaotfload-database.lua | 2 -- luaotfload-features.lua | 35 +++++++++++++++++++++++++++++++++++ tests/pln-subfont-1.tex | 6 +++--- 3 files changed, 38 insertions(+), 5 deletions(-) diff --git a/luaotfload-database.lua b/luaotfload-database.lua index 8caa35b..4aa966a 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -562,8 +562,6 @@ resolve = function (_,_,specification) -- the 1st two parameters are used by Con local found = { } local synonym_set = style_synonyms.set for _,face in next, data.mappings do - --- TODO we really should store those in dedicated - --- .sanitized field local family, subfamily, fullname, psname, fontname, pfullname local facenames = face.sanitized diff --git a/luaotfload-features.lua b/luaotfload-features.lua index de7ff3f..b11bf22 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -431,6 +431,35 @@ local select_lookup = function (request) end end +local supported = { + b = "bold", + i = "italic", + bi = "bolditalic", + aat = false, + icu = false, + gr = false, +} + +local handle_slashed = function (modifiers) + local style, optsize + for i=1, #modifiers do + local mod = modifiers[i] + if supported[mod] then + style = supported[mod] + --elseif stringfind(v, "^s=") then + elseif stringsub(v, 1, 2) == "s=" then + local val = stringsub(v, 3) + optsize = val + elseif stylename == false then + report("log", 0, + "load", "unsupported font option: %s", v) + elseif not stringis_empty(v) then + style = stringgsub(v, "[^%a%d]", "") + end + end + return style, optsize +end + --- spec -> spec local handle_request = function (specification) local request = lpegmatch(font_request, @@ -443,6 +472,11 @@ local handle_request = function (specification) specification.lookup = lookup or specification.lookup end + if request.modifiers then + local style, optsize = handle_slashed(request.modifiers) + specification.style, specification.optsize = style, optsize + end + for n=1, #import_values do local feat = import_values[n] local newvalue = request.features[feat] @@ -451,6 +485,7 @@ local handle_request = function (specification) request.features[feat] = nil end end + --- The next line sets the “rand” feature to “random”; I haven’t --- investigated it any further (luatex-fonts-ext), so it will --- just stay here. diff --git a/tests/pln-subfont-1.tex b/tests/pln-subfont-1.tex index 4877682..fb8e1e7 100644 --- a/tests/pln-subfont-1.tex +++ b/tests/pln-subfont-1.tex @@ -1,12 +1,12 @@ \ifdefined\directlua\input luaotfload.sty\fi - +%% This requires the Cambria fonts from MS. \directlua{ inspect(fontloader.info"cambria.ttc") } - +%% Here we load both subfonts in the collection +%% with the not-quite documented subfont syntax. \font\subfontone="file:cambria.ttc(0)" at 42pt \font\subfonttwo="file:cambria.ttc(1)" at 42pt - \subfontone foo bar baz \endgraf \subfonttwo foo bar baz \endgraf \bye -- cgit v1.2.3 From 19164c39c9f98d9e51a13d5d698f575879f3dfee Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 14:48:12 +0200 Subject: add examples for XeTeX notation and lookup caching --- tests/pln-request-4-slashed.tex | 12 ++++++++++++ tests/pln-request-5-cached.tex | 17 +++++++++++++++++ 2 files changed, 29 insertions(+) create mode 100644 tests/pln-request-4-slashed.tex create mode 100644 tests/pln-request-5-cached.tex diff --git a/tests/pln-request-4-slashed.tex b/tests/pln-request-4-slashed.tex new file mode 100644 index 0000000..5e7d99e --- /dev/null +++ b/tests/pln-request-4-slashed.tex @@ -0,0 +1,12 @@ +\ifdefined\directlua\input luaotfload.sty\fi +\font\iwona =iwona at 20pt +\font\iwonabold =iwona/b at 20pt +\font\iwonaitalic =iwona/i at 20pt +\font\iwonabolditalic =iwona/bi at 20pt + +\def\test{foo bar baz \endgraf} +{\iwona \test} +{\iwonabold \test} +{\iwonaitalic \test} +{\iwonabolditalic \test} +\bye diff --git a/tests/pln-request-5-cached.tex b/tests/pln-request-5-cached.tex new file mode 100644 index 0000000..437b20d --- /dev/null +++ b/tests/pln-request-5-cached.tex @@ -0,0 +1,17 @@ +\ifdefined\directlua + \directlua{config = config or { luaotfload = { } } + config.luaotfload.resolver = "cached" } + \input luaotfload.sty +\fi + +\font\iwona =name:iwona at 20pt +\font\iwonabold =name:iwona/b at 20pt +\font\iwonaitalic =name:iwona/i at 20pt +\font\iwonabolditalic =name:iwona/bi at 20pt + +\def\test{foo bar baz \endgraf} +{\iwona \test} +{\iwonabold \test} +{\iwonaitalic \test} +{\iwonabolditalic \test} +\bye -- cgit v1.2.3 From e79f34d859d48be485589f19fc6905afa5872a53 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 29 Apr 2013 14:52:53 +0200 Subject: only cache ``name:`` lookups --- luaotfload-database.lua | 72 +++++++++++++++--------------------------- luaotfload-features.lua | 3 +- luaotfload.dtx | 18 ++--------- tests/pln-request-5-cached.tex | 3 +- 4 files changed, 32 insertions(+), 64 deletions(-) diff --git a/luaotfload-database.lua b/luaotfload-database.lua index 4aa966a..abf06a2 100644 --- a/luaotfload-database.lua +++ b/luaotfload-database.lua @@ -240,6 +240,7 @@ local load_names local read_fonts_conf local reload_db local resolve +local resolve_cached local save_names local scan_external_dir local update_names @@ -380,22 +381,6 @@ TODO: 9) ??? n) PROFIT!!! ---doc]]-- - ---- the resolver is called after the font request is parsed ---- this is where we insert the cache -local normal_resolver = fonts.definers.resolve -local dummy_resolver = function (specification) - --- this ensures that the db is always loaded - --- before a lookup occurs - if not names.data then names.data = load_names() end - --inspect(specification) - local resolved = normal_resolver(specification) - --inspect(resolved) - return resolved -end - ---[[doc-- The name lookup requires both the “name” and some other keys, so we’ll concatenate them. The spec is modified in place (ugh), so we’ll have to catalogue what @@ -428,33 +413,29 @@ We’ll just cache a deep copy of the entire spec as it leaves the resolver, lest we want to worry if we caught all the details. --doc]]-- ---- spec -> spec -local cached_resolver = function (specification) +--- 'a -> 'a -> table -> (string * int|boolean * boolean) +resolve_cached = function (_, _, specification) if not names.data then names.data = load_names() end local request_cache = names.data.request_cache local request = specification.specification - report("log", 4, "cache", - "looking for “%s” in cache ...", + report("log", 4, "cache", "looking for “%s” in cache ...", request) + local found = names.data.request_cache[request] + + --- case 1) cache positive ---------------------------------------- if found then --- replay fields from cache hit report("info", 4, "cache", "found!") - for i=1, #cache_fields do - local f = cache_fields[i] - if found[f] then specification[f] = found[f] end - end - return specification + return found[1], found[2], true end report("log", 4, "cache", "not cached; resolving") + --- case 2) cache negative ---------------------------------------- --- first we resolve normally ... - local resolved_spec = normal_resolver(specification) - --- ... then we add the fields to the cache - local entry = { } - for i=1, #cache_fields do - local f = cache_fields[i] - entry[f] = resolved_spec[f] - end + local filename, subfont, success = resolve(nil, nil, specification) + if not success then return filename, subfont, false end + --- ... then we add the fields to the cache ... ... + local entry = { filename, subfont } report("log", 4, "cache", "new entry: %s", request) names.data.request_cache[request] = entry @@ -463,21 +444,13 @@ local cached_resolver = function (specification) --- whenever the cache is updated. --- TODO this should trigger a save only once the --- document is compiled (finish_pdffile callback?) + --- TODO we should speed up writing by separating + --- the cache from the db report("log", 5, "cache", "saving updated cache") save_names() - return resolved_spec + return filename, subfont, true end -local resolvers = { - dummy = dummy_resolver, - normal = normal_resolver, - cached = cached_resolver, -} - -fonts.definers.resolve = resolvers[config.luaotfload.resolver] ---fonts.definers.resolve = resolvers.cached ---fonts.definers.resolve = resolvers.dummy - --[[doc-- Luatex-fonts, the font-loader package luaotfload imports, comes with @@ -1390,9 +1363,16 @@ names.update = update_names names.crude_file_lookup = crude_file_lookup names.crude_file_lookup_verbose = crude_file_lookup_verbose -names.resolve = resolve --- replace the resolver from luatex-fonts -names.resolvespec = resolve -names.find_closest = find_closest +--- replace the resolver from luatex-fonts +if config.luaotfload.resolver == "cached" then + report("info", 0, "cache", "caching of name: lookups active") + names.resolve = resolve_cached + names.resolvespec = resolve_cached +else + names.resolve = resolve + names.resolvespec = resolve +end +names.find_closest = find_closest --- dummy required by luatex-fonts (cf. luatex-fonts-syn.lua) diff --git a/luaotfload-features.lua b/luaotfload-features.lua index b11bf22..6cbfdf4 100644 --- a/luaotfload-features.lua +++ b/luaotfload-features.lua @@ -416,7 +416,8 @@ local font_request = Ct(path_lookup * (colon^-1 * features)^-1 local import_values = { --- That’s what the 1.x parser did, not quite as graciously, --- with an array of branch expressions. - "style", "optsize", "lookup", "sub" --[[‽]], "mode", + -- "style", "optsize",--> from slashed notation; handled otherwise + "lookup", "sub" --[[‽]], "mode", } local lookup_types = { "anon", "file", "name", "path" } diff --git a/luaotfload.dtx b/luaotfload.dtx index abc737c..6392c64 100644 --- a/luaotfload.dtx +++ b/luaotfload.dtx @@ -540,8 +540,8 @@ and the derived files % \end{quote} % % \noindent -% If style modifiers are present (\XETEX style), they must precede \meta{font -% features}. +% If style modifiers are present (\XETEX style), they must precede +% \meta{font features}. % % The element \meta{font features} is a semicolon-separated list of feature % tags\footnote{% @@ -1532,19 +1532,6 @@ loadmodule"database.lua" --- “font-nms” loadmodule"colors.lua" --- “font-clr” % \end{macrocode} -% This hack makes fonts called with file method found by fonts.names.resolve -% instead of just trying to find them with \identifier{kpse}. -% It is necessary in cases when font files are not reachable by -% \identifier{kpse} but present in the database, a quite common case -% under Linux. -% -% As of 2013-04-24 we have a workaround in the resolver that handles -% \verb|file:| lookups diverted this way. -% It requires some overhead due to additional extra data saved in the -% names database, and might vanish entirely once the font request syntax -% is understood. -% Until then it is considered a kludge, like the hack below. -% % Relying on the \verb|name:| resolver for everything has been the source % of permanent trouble with the database. % With the introduction of the new syntax parser we now have enough @@ -1715,7 +1702,6 @@ local patch_defined_font = function (specification, size, id) if type(tfmdata) == "table" then call_callback("luaotfload.patch_font", tfmdata) end - -- inspect(table.keys(tfmdata)) return tfmdata end diff --git a/tests/pln-request-5-cached.tex b/tests/pln-request-5-cached.tex index 437b20d..8ba4a5e 100644 --- a/tests/pln-request-5-cached.tex +++ b/tests/pln-request-5-cached.tex @@ -1,6 +1,7 @@ \ifdefined\directlua \directlua{config = config or { luaotfload = { } } - config.luaotfload.resolver = "cached" } + config.luaotfload.resolver = "cached" + config.luaotfload.loglevel = 5 } \input luaotfload.sty \fi -- cgit v1.2.3