From 655ab8e887944e82c48d4d5c1745e00c771dbae0 Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 22 Apr 2013 15:03:17 +0200 Subject: remove luaotfload.lua from repo the version in luaotfload.dtx is authoritative as of now; I apologize in advance for every time I forget to merge back changes into the dtx ;-) --- luaotfload.lua | 457 --------------------------------------------------------- 1 file changed, 457 deletions(-) delete mode 100644 luaotfload.lua diff --git a/luaotfload.lua b/luaotfload.lua deleted file mode 100644 index f11218e..0000000 --- a/luaotfload.lua +++ /dev/null @@ -1,457 +0,0 @@ -module("luaotfload", package.seeall) - -luaotfload.module = { - name = "luaotfload", - version = 2.2, - date = "2013/04/15", - description = "OpenType layout system.", - author = "Elie Roux & Hans Hagen", - copyright = "Elie Roux", - license = "CC0" -} - -local luatexbase = luatexbase - -local type, next = type, next -local stringfind = string.find -local stringsub = string.sub -local stringmatch = string.match -local stringformat = string.format -local find_file = kpse.find_file - -local add_to_callback, create_callback = - luatexbase.add_to_callback, luatexbase.create_callback -local reset_callback, call_callback = - luatexbase.reset_callback, luatexbase.call_callback - -local dummy_function = function () end - -_G.luaotfload = _G.luaotfload or { } -local luaotfload = _G.luaotfload - ---[[doc-- -No final decision has been made on how to handle font definition. At -the moment, there are three candidates: The \identifier{generic} -callback as hard-coded in the font loader, the \identifier{old} -wrapper, and a simplified version of the latter (\identifier{patch}) -that does nothing besides applying font patches. ---doc]]-- - -luaotfload.font_definer = "patch" --- | “generic” | “old” - -local error, warning, info, log = - luatexbase.provides_module(luaotfload.module) - ---[[doc-- -This is a necessary initalization in order not to rebuild an existing -font. -Maybe 600 should be replaced by \texmacro{pdfpkresolution} %% (why?) -or \luafunction{texconfig.pk_dpi} (and it should be replaced -dynamically), but we don't have access (yet) to the -\identifier{texconfig} table, so we let it be 600. -Anyway, it does still work fine even if \texmacro{pdfpkresolution} is -changed. ---doc]]-- - -kpse.init_prog("", 600, "/") - ---[[doc-- -We set the minimum version requirement for \LUATEX to v0.74, as it was -the first version to include version 5.2 of the \LUA interpreter. ---doc]]-- - -local luatex_version = 74 - -if tex.luatexversion < luatex_version then - warning("LuaTeX v%.2f is old, v%.2f is recommended.", - tex.luatexversion/100, - luatex_version /100) -end - ---[[doc-- -\subsection{Module loading} - -We load the files imported from \CONTEXT with this function. -It automatically prepends the prefix \fileent{otfl-} to its argument, -so we can refer to the files with their actual \CONTEXT name. ---doc]]-- - -local fl_prefix = "otfl" -- “luatex” for luatex-plain -local loadmodule = function (name) - local tofind = fl_prefix .."-"..name - local found = find_file(tofind,"tex") - if found then - log("loading file %s.", found) - dofile(found) - else - error("file %s not found.", tofind) - end -end - ---[[doc-- -Virtual fonts are resolved via a callback. -\luafunction{find_vf_file} derives the name of the virtual font file -from the filename. -(NB: \CONTEXT handles this likewise in \fileent{font-vf.lua}.) ---doc]]-- -local Cs, P, lpegmatch = lpeg.Cs, lpeg.P, lpeg.match - -local p_dot, p_slash = P".", P"/" -local p_suffix = (p_dot * (1 - p_dot - p_slash)^1 * P(-1)) / "" -local p_removesuffix = Cs((p_suffix + 1)^1) - -local find_vf_file = function (name) - local fullname = find_file(name, "ovf") - if not fullname then - --fullname = find_file(file.removesuffix(name), "ovf") - fullname = find_file(lpegmatch(p_removesuffix, name), "ovf") - end - if fullname then - log("loading virtual font file %s.", fullname) - end - return fullname -end - ---[[doc-- - -\subsection{Preparing the Font Loader} -We treat the fontloader as a black box so behavior is consistent -between formats. -The wrapper file is \fileent{otfl-fonts.lua} which we imported from -\href{http://standalone.contextgarden.net/current/context/experimental/tex/generic/context/luatex/}{\LUATEX-Plain}. -It has roughly two purposes: - -\begin{enumerate} - - \item insert the functionality required for fontloader; and - - \item put it in place via the respective callbacks. - -\end{enumerate} - -How the first step is executed depends on the presence on the -\emphasis{merged font loader code}. -In \identifier{luaotfload} this is contained in the file -\fileent{otfl-fonts-merged.lua}. -If this file cannot be found, the original libraries from \CONTEXT of -which the merged code was composed are loaded instead. - -Hans provides two global tables to control the font loader: - - \begin{itemize} - \item \luafunction{generic_context}: - encapsulation mechanism, callback functions - \item \luafunction{non generic_context}: - customized code insertion - \end{itemize} - - -With \luafunction{non_generic_context} we can tailor the font loader -insertion to our file naming habits (key \luafunction{load_before}). -Additionally, \luafunction{skip_loading} can be unset to force loading -of the original libraries as though the merged code was absent. -Another key, \luafunction{load_after} is called at the time when the -font loader is actually inserted. -In combination with the option \luafunction{no_callbacks_yet} in -\luafunction{generic_context}, we can insert our own, -\identifier{luatexbase}-style callback handling here. ---doc]]-- -if not _G. generic_context then _G. generic_context = { } end -if not _G.non_generic_context then _G.non_generic_context = { } end - -local generic_context = generic_context -local non_generic_context =non_generic_context - -generic_context.no_callbacks_yet = true - -_G.non_generic_context = { luatex_fonts = { - load_before = "otfl-fonts-merged.lua", - -- load_after = nil, --- TODO, this is meant for callbacks - skip_loading = true, -}} - ---[[doc-- -In its raw form, the font loader will write to the terminal quite -liberally, not using the proper channels (loggers) even of \CONTEXT. -To make it behave we temporarily replace two functions from the -\luafunction{texio} library with wrappers that redirect output to the -log. -Just in case Hans decides to call \luafunction{texio.write*} with the -optional target parameter (which he doesn’t at the moment), we catch the -first argument and skip it where appropriate. -The originals are backed up and restored after loading -\fileent{otfl-fonts.lua}. - -Should we decide to do our own packaging (we’re capable of that -anyways), this will most likely become unnecessary. ---doc]]-- - -local normal_write, normal_write_nl = texio.write, texio.write_nl - -local log_template = "luaotfload: %s" -local fake_write = function (first, rest) - if first == "log" or first == "term" then -- ignore - normal_write("log", stringformat(log_template, rest)) - else - normal_write("log", stringformat(log_template, first)) - end -end -local fake_write_nl = function (first, rest) - if first == "log" or first == "term" then -- ignore - normal_write_nl("log", stringformat(log_template, rest)) - else - normal_write_nl("log", stringformat(log_template, first, rest)) - end -end -texio.write, texio.write_nl = fake_write, fake_write_nl - ---[[doc-- -The imported font loader will call \luafunction{callback.register} once -while reading \fileent{font-def.lua}. -This is unavoidable unless we modify the imported files, but harmless -if we make it call a dummy instead. ---doc]]-- - -local trapped_register = callback.register -callback.register = dummy_function - ---[[doc-- -Now that things are sorted out we can finally load the fontloader. ---doc]]-- - -loadmodule"fonts.lua" - ---[[doc-- -Here we restore the original \luafunction{texio} functions. ---doc]]-- -texio.write, texio.write_nl = normal_write, normal_write_nl - ---[[doc-- -By default, the fontloader requires a number of \emphasis{private -attributes} for internal use. -These must be kept consistent with the attribute handling methods as -provided by \identifier{luatexbase}. -Our strategy is to override the function that allocates new attributes -before we initialize the font loader, making it a wrapper around -\luafunction{luatexbase.new_attribute}.\footnote{% - Many thanks, again, to Hans Hagen for making this part - configurable! -} -The attribute identifiers are prefixed “\fileent{otfl@}” to -avoid name clashes. ---doc]]-- - -do - local new_attribute = luatexbase.new_attribute - local the_attributes = luatexbase.attributes - - _G.attributes = _G.attributes or { } - - _G.attributes.private = function (name) - local attr = "otfl@" .. name - local number = the_attributes[attr] - if not number then - number = new_attribute(attr) - end - return number - end -end - ---[[doc-- - -\subsection{Callbacks} - -After the fontloader is ready we can restore the callback trap from -\identifier{luatexbase}. ---doc]]-- - -callback.register = trapped_register - ---[[doc-- -We do our own callback handling with the means provided by luatexbase. - -Note: \luafunction{pre_linebreak_filter} and \luafunction{hpack_filter} -are coupled in \CONTEXT in the concept of \emphasis{node processor}. ---doc]]-- - -add_to_callback("pre_linebreak_filter", - generic_context.callback_pre_linebreak_filter, - "luaotfload.node_processor", - 1) -add_to_callback("hpack_filter", - generic_context.callback_hpack_filter, - "luaotfload.node_processor", - 1) -add_to_callback("find_vf_file", - find_vf_file, "luaotfload.find_vf_file") - -loadmodule"font-otc.lua" -- TODO check what we can drop from otfl-features -loadmodule"lib-dir.lua" -- required by font-nms -loadmodule"luat-ovr.lua" - -if fonts and fonts.readers.tfm then - -------------------------------------------------------------------- - --- OFM; read this first - -------------------------------------------------------------------- - --- I can’t quite make out whether this is still relevant - --- as those ofm fonts always fail, even in the 2011 version - --- (mktexpk: don't know how to create bitmap font for omarabb.ofm) - --- the font loader appears to read ofm like tfm so if this - --- hack was supposed achieve that, we should excise it anyways - fonts.readers.ofm = fonts.readers.tfm - fonts.handlers.ofm = fonts.handlers.tfm --- empty anyways - fonts.formats.ofm = fonts.formats.tfm --- “type1” - --- fonts.readers.sequence[#fonts.readers.sequence+1] = "ofm" - -------------------------------------------------------------------- -end - ---[[doc-- - -Now we load the modules written for \identifier{luaotfload}. - ---doc]]-- -loadmodule"font-pfb.lua" --- new in 2.0, added 2011 -loadmodule"font-nms.lua" -loadmodule"font-clr.lua" -loadmodule"font-ltx.lua" --- new in 2.0, added 2011 - ---[[doc-- - -We create a callback for patching fonts on the fly, to be used by other -packages. -It initially contains the empty function that we are going to override -below. - ---doc]]-- - -create_callback("luaotfload.patch_font", "simple", dummy_function) - ---[[doc-- - -This is a wrapper for the imported font loader. -As of 2013, everything it does appear to be redundand, so we won’t use -it unless somebody points out a cogent reason. -Nevertheless, it has been adapted to work with the current structure of -font data objects and will stay here for reference / until breakage is -reported. - -\emphasis{TODO} -This one also enables patching fonts. -The current fontloader apparently comes with a dedicated mechanism for -that already: enhancers. -How those work remains to be figured out. - ---doc]]-- -local define_font_wrapper = function (...) - --- we use “tfmdata” (not “fontdata”) for consistency with the - --- font loader - local tfmdata = fonts.definers.read(...) - if type(tfmdata) == "table" and tfmdata.shared then - local metadata = tfmdata.shared.rawdata.metadata - local mathdata = metadata.math --- do all fonts have this field? - if mathdata then - local mathconstants = { } --- why new hash, not modify in place? - local units_per_em = metadata.units_per_em - local size = tfmdata.size - for k,v in next, mathdata do - --- afaics this is alread taken care of by - --- definers.read - if stringfind(k, "Percent") then - -- keep percent values as is - print(k,v) - mathconstants[k] = v - else - mathconstants[k] = v / units_per_em * size - end - end - --- for \overwithdelims - --- done by definers.read as well - mathconstants.FractionDelimiterSize = 1.01 * size - --- fontloader has 2.4 × size - mathconstants.FractionDelimiterDisplayStyleSize = 2.39 * size - tfmdata.MathConstants = mathconstants - end - call_callback("luaotfload.patch_font", tfmdata) - end - return tfmdata -end - ---[[doc-- - -\subsection{\CONTEXT override} - -We provide a simplified version of the original font definition -callback. - ---doc]]-- - -local read_font_file = fonts.definers.read -local patch_defined_font = function (...) - local tfmdata = read_font_file(...)-- spec -> size -> id -> tmfdata - if type(tfmdata) == "table" then - call_callback("luaotfload.patch_font", tfmdata) - end - -- inspect(table.keys(tfmdata)) - return tfmdata -end - -caches.compilemethod = "both" - -reset_callback("define_font") - ---[[doc-- -Finally we register the callbacks ---doc]]-- - -if luaotfload.font_definer == "old" then - add_to_callback("define_font", - define_font_wrapper, - "luaotfload.define_font", - 1) -elseif luaotfload.font_definer == "generic" then - add_to_callback("define_font", - generic_context.callback_define_font, - "luaotfload.define_font", - 1) -elseif luaotfload.font_definer == "patch" then - add_to_callback("define_font", - patch_defined_font, - "luaotfload.define_font", - 1) -end - ---[[todo-- ---- The manual promises coercion of the file: lookup if ---- the asked name is enclosed in brackets. ---- A couple things make me doubt that this is the case: ---- ---- 1) there doesn’t appear to be code for these cases ---- 2) the brackets remain part of the file name ---- 3) we still get calls to names.resolve which ---- ignores the “lookup” field of the spec it gets ---- ---- For this reason here is some code that a) coerces ---- file: lookups in these cases and b) strips the brackets ---- from the file name. As we *still* get name: lookups even ---- though this code is active I’ll just leave it here ---- for reference, ineffective as it is. -do - local getspecification, makespecification = - fonts.definers.getspecification, fonts.definers.makespecification - - local analyze = function (specification, size) - local lookup, name, sub, method, detail = getspecification(specification or "") - local filename = stringmatch(name, "^%[(.*)%]$") - if filename then - lookup = "file" --> coerce file: - name = filename --> remove brackets - end - return makespecification(specification, lookup, name, sub, method, detail, size) - end - fonts.definers.analyze = analyze -end ---]]-- - -loadmodule"features.lua" - --- vim:tw=71:sw=4:ts=4:expandtab -- cgit v1.2.3 From 4f0774100b6000784cf29bcc8677e63a3169f21a Mon Sep 17 00:00:00 2001 From: Philipp Gesang Date: Mon, 22 Apr 2013 15:15:22 +0200 Subject: =?UTF-8?q?migrate=20files=20from=20=E2=80=98otfl=E2=80=99=20to=20?= =?UTF-8?q?=E2=80=98luaotfload=E2=80=99=20prefix?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- luaotfload-basics-gen.lua | 296 ++ luaotfload-basics-nod.lua | 95 + luaotfload-blacklist.cnf | 23 + luaotfload-features.lua | 110 + luaotfload-font-clr.lua | 187 + luaotfload-font-ltx.lua | 205 + luaotfload-font-nms.lua | 1049 +++++ luaotfload-font-otc.lua | 333 ++ luaotfload-font-pfb.lua | 24 + luaotfload-fonts-cbk.lua | 68 + luaotfload-fonts-def.lua | 97 + luaotfload-fonts-enc.lua | 28 + luaotfload-fonts-ext.lua | 272 ++ luaotfload-fonts-lua.lua | 33 + luaotfload-fonts-tfm.lua | 38 + luaotfload-fonts.lua | 253 + luaotfload-lib-dir.lua | 449 ++ luaotfload-luat-ovr.lua | 81 + luaotfload-merged.lua | 11041 ++++++++++++++++++++++++++++++++++++++++++++ otfl-basics-gen.lua | 296 -- otfl-basics-nod.lua | 95 - otfl-blacklist.cnf | 23 - otfl-features.lua | 110 - otfl-font-clr.lua | 187 - otfl-font-ltx.lua | 205 - otfl-font-nms.lua | 1049 ----- otfl-font-otc.lua | 333 -- otfl-font-pfb.lua | 24 - otfl-fonts-cbk.lua | 68 - otfl-fonts-def.lua | 97 - otfl-fonts-enc.lua | 28 - otfl-fonts-ext.lua | 272 -- otfl-fonts-lua.lua | 33 - otfl-fonts-merged.lua | 11041 -------------------------------------------- otfl-fonts-tfm.lua | 38 - otfl-fonts.lua | 253 - otfl-lib-dir.lua | 449 -- otfl-luat-ovr.lua | 80 - 38 files changed, 14682 insertions(+), 14681 deletions(-) create mode 100644 luaotfload-basics-gen.lua create mode 100644 luaotfload-basics-nod.lua create mode 100644 luaotfload-blacklist.cnf create mode 100644 luaotfload-features.lua create mode 100644 luaotfload-font-clr.lua create mode 100644 luaotfload-font-ltx.lua create mode 100644 luaotfload-font-nms.lua create mode 100644 luaotfload-font-otc.lua create mode 100644 luaotfload-font-pfb.lua create mode 100644 luaotfload-fonts-cbk.lua create mode 100644 luaotfload-fonts-def.lua create mode 100644 luaotfload-fonts-enc.lua create mode 100644 luaotfload-fonts-ext.lua create mode 100644 luaotfload-fonts-lua.lua create mode 100644 luaotfload-fonts-tfm.lua create mode 100644 luaotfload-fonts.lua create mode 100644 luaotfload-lib-dir.lua create mode 100644 luaotfload-luat-ovr.lua create mode 100644 luaotfload-merged.lua delete mode 100644 otfl-basics-gen.lua delete mode 100644 otfl-basics-nod.lua delete mode 100644 otfl-blacklist.cnf delete mode 100644 otfl-features.lua delete mode 100644 otfl-font-clr.lua delete mode 100644 otfl-font-ltx.lua delete mode 100644 otfl-font-nms.lua delete mode 100644 otfl-font-otc.lua delete mode 100644 otfl-font-pfb.lua delete mode 100644 otfl-fonts-cbk.lua delete mode 100644 otfl-fonts-def.lua delete mode 100644 otfl-fonts-enc.lua delete mode 100644 otfl-fonts-ext.lua delete mode 100644 otfl-fonts-lua.lua delete mode 100644 otfl-fonts-merged.lua delete mode 100644 otfl-fonts-tfm.lua delete mode 100644 otfl-fonts.lua delete mode 100644 otfl-lib-dir.lua delete mode 100644 otfl-luat-ovr.lua diff --git a/luaotfload-basics-gen.lua b/luaotfload-basics-gen.lua new file mode 100644 index 0000000..727086e --- /dev/null +++ b/luaotfload-basics-gen.lua @@ -0,0 +1,296 @@ +if not modules then modules = { } end modules ['luat-basics-gen'] = { + version = 1.100, + comment = "companion to luatex-*.tex", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} + +if context then + texio.write_nl("fatal error: this module is not for context") + os.exit() +end + +local dummyfunction = function() end +----- dummyreporter = function(c) return function(...) texio.write_nl(c .. " : " .. string.format(...)) end end +local dummyreporter = function(c) return function(...) texio.write_nl(c .. " : " .. string.formatters(...)) end end + +statistics = { + register = dummyfunction, + starttiming = dummyfunction, + stoptiming = dummyfunction, + elapsedtime = nil, +} + +directives = { + register = dummyfunction, + enable = dummyfunction, + disable = dummyfunction, +} + +trackers = { + register = dummyfunction, + enable = dummyfunction, + disable = dummyfunction, +} + +experiments = { + register = dummyfunction, + enable = dummyfunction, + disable = dummyfunction, +} + +storage = { -- probably no longer needed + register = dummyfunction, + shared = { }, +} + +logs = { + new = dummyreporter, + reporter = dummyreporter, + messenger = dummyreporter, + report = dummyfunction, +} + +callbacks = { + register = function(n,f) return callback.register(n,f) end, + +} + +utilities = { + storage = { + allocate = function(t) return t or { } end, + mark = function(t) return t or { } end, + }, +} + +characters = characters or { + data = { } +} + +-- we need to cheat a bit here + +texconfig.kpse_init = true + +resolvers = resolvers or { } -- no fancy file helpers used + +local remapper = { + otf = "opentype fonts", + ttf = "truetype fonts", + ttc = "truetype fonts", + dfont = "truetype fonts", -- "truetype dictionary", + cid = "cid maps", + cidmap = "cid maps", + fea = "font feature files", + pfa = "type1 fonts", -- this is for Khaled, in ConTeXt we don't use this! + pfb = "type1 fonts", -- this is for Khaled, in ConTeXt we don't use this! +} + +function resolvers.findfile(name,fileformat) + name = string.gsub(name,"\\","/") + if not fileformat or fileformat == "" then + fileformat = file.suffix(name) + if fileformat == "" then + fileformat = "tex" + end + end + fileformat = string.lower(fileformat) + fileformat = remapper[fileformat] or fileformat + local found = kpse.find_file(name,fileformat) + if not found or found == "" then + found = kpse.find_file(name,"other text files") + end + return found +end + +-- function resolvers.findbinfile(name,fileformat) +-- if not fileformat or fileformat == "" then +-- fileformat = file.suffix(name) +-- end +-- return resolvers.findfile(name,(fileformat and remapper[fileformat]) or fileformat) +-- end + +resolvers.findbinfile = resolvers.findfile + +function resolvers.resolve(s) + return s +end + +function resolvers.unresolve(s) + return s +end + +-- Caches ... I will make a real stupid version some day when I'm in the +-- mood. After all, the generic code does not need the more advanced +-- ConTeXt features. Cached data is not shared between ConTeXt and other +-- usage as I don't want any dependency at all. Also, ConTeXt might have +-- different needs and tricks added. + +--~ containers.usecache = true + +caches = { } + +local writable, readables = nil, { } + +if not caches.namespace or caches.namespace == "" or caches.namespace == "context" then + caches.namespace = 'generic' +end + +do + + local cachepaths = kpse.expand_path('$TEXMFCACHE') or "" + + if cachepaths == "" then + cachepaths = kpse.expand_path('$TEXMFVAR') + end + + if cachepaths == "" then + cachepaths = kpse.expand_path('$VARTEXMF') + end + + if cachepaths == "" then + cachepaths = "." + end + + cachepaths = string.split(cachepaths,os.type == "windows" and ";" or ":") + + for i=1,#cachepaths do + if file.is_writable(cachepaths[i]) then + writable = file.join(cachepaths[i],"luatex-cache") + lfs.mkdir(writable) + writable = file.join(writable,caches.namespace) + lfs.mkdir(writable) + break + end + end + + for i=1,#cachepaths do + if file.is_readable(cachepaths[i]) then + readables[#readables+1] = file.join(cachepaths[i],"luatex-cache",caches.namespace) + end + end + + if not writable then + texio.write_nl("quiting: fix your writable cache path") + os.exit() + elseif #readables == 0 then + texio.write_nl("quiting: fix your readable cache path") + os.exit() + elseif #readables == 1 and readables[1] == writable then + texio.write(string.format("(using cache: %s)",writable)) + else + texio.write(string.format("(using write cache: %s)",writable)) + texio.write(string.format("(using read cache: %s)",table.concat(readables, " "))) + end + +end + +function caches.getwritablepath(category,subcategory) + local path = file.join(writable,category) + lfs.mkdir(path) + path = file.join(path,subcategory) + lfs.mkdir(path) + return path +end + +function caches.getreadablepaths(category,subcategory) + local t = { } + for i=1,#readables do + t[i] = file.join(readables[i],category,subcategory) + end + return t +end + +local function makefullname(path,name) + if path and path ~= "" then + name = "temp-" .. name -- clash prevention + return file.addsuffix(file.join(path,name),"lua"), file.addsuffix(file.join(path,name),"luc") + end +end + +function caches.is_writable(path,name) + local fullname = makefullname(path,name) + return fullname and file.is_writable(fullname) +end + +function caches.loaddata(paths,name) + for i=1,#paths do + local data = false + local luaname, lucname = makefullname(paths[i],name) + if lucname and lfs.isfile(lucname) then -- maybe also check for size + texio.write(string.format("(load luc: %s)",lucname)) + data = loadfile(lucname) + if data then + data = data() + end + if data then + return data + else + texio.write(string.format("(loading failed: %s)",lucname)) + end + end + if luaname and lfs.isfile(luaname) then + texio.write(string.format("(load lua: %s)",luaname)) + data = loadfile(luaname) + if data then + data = data() + end + if data then + return data + end + end + end +end + +function caches.savedata(path,name,data) + local luaname, lucname = makefullname(path,name) + if luaname then + texio.write(string.format("(save: %s)",luaname)) + table.tofile(luaname,data,true,{ reduce = true }) + if lucname and type(caches.compile) == "function" then + os.remove(lucname) -- better be safe + texio.write(string.format("(save: %s)",lucname)) + caches.compile(data,luaname,lucname) + end + end +end + +-- According to KH os.execute is not permitted in plain/latex so there is +-- no reason to use the normal context way. So the method here is slightly +-- different from the one we have in context. We also use different suffixes +-- as we don't want any clashes (sharing cache files is not that handy as +-- context moves on faster.) +-- +-- Beware: serialization might fail on large files (so maybe we should pcall +-- this) in which case one should limit the method to luac and enable support +-- for execution. + +caches.compilemethod = "both" + +function caches.compile(data,luaname,lucname) + local done = false + if caches.compilemethod == "luac" or caches.compilemethod == "both" then + done = os.spawn("texluac -o " .. string.quoted(lucname) .. " -s " .. string.quoted(luaname)) == 0 + end + if not done and (caches.compilemethod == "dump" or caches.compilemethod == "both") then + local d = io.loaddata(luaname) + if not d or d == "" then + d = table.serialize(data,true) -- slow + end + if d and d ~= "" then + local f = io.open(lucname,'w') + if f then + local s + if _G["loadstring"] then s=loadstring(d) else s=load(d) end + f:write(string.dump(s)) + f:close() + end + end + end +end + +-- + +function table.setmetatableindex(t,f) + setmetatable(t,{ __index = f }) +end diff --git a/luaotfload-basics-nod.lua b/luaotfload-basics-nod.lua new file mode 100644 index 0000000..151d98a --- /dev/null +++ b/luaotfload-basics-nod.lua @@ -0,0 +1,95 @@ +if not modules then modules = { } end modules ['luatex-fonts-nod'] = { + version = 1.001, + comment = "companion to luatex-fonts.lua", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} + +if context then + texio.write_nl("fatal error: this module is not for context") + os.exit() +end + +-- Don't depend on code here as it is only needed to complement the +-- font handler code. + +-- Attributes: + +if tex.attribute[0] ~= 0 then + + texio.write_nl("log","!") + texio.write_nl("log","! Attribute 0 is reserved for ConTeXt's font feature management and has to be") + texio.write_nl("log","! set to zero. Also, some attributes in the range 1-255 are used for special") + texio.write_nl("log","! purposes so setting them at the TeX end might break the font handler.") + texio.write_nl("log","!") + + tex.attribute[0] = 0 -- else no features + +end + +attributes = { } +attributes.unsetvalue = -0x7FFFFFFF + +local numbers, last = { }, 127 + +function attributes.private(name) + local number = numbers[name] + if not number then + if last < 255 then + last = last + 1 + end + number = last + numbers[name] = number + end + return number +end + +-- Nodes: + +nodes = { } +nodes.pool = { } +nodes.handlers = { } + +local nodecodes = { } for k,v in next, node.types () do nodecodes[string.gsub(v,"_","")] = k end +local whatcodes = { } for k,v in next, node.whatsits() do whatcodes[string.gsub(v,"_","")] = k end +local glyphcodes = { [0] = "character", "glyph", "ligature", "ghost", "left", "right" } + +nodes.nodecodes = nodecodes +nodes.whatcodes = whatcodes +nodes.whatsitcodes = whatcodes +nodes.glyphcodes = glyphcodes + +local free_node = node.free +local remove_node = node.remove +local new_node = node.new + +nodes.handlers.protectglyphs = node.protect_glyphs +nodes.handlers.unprotectglyphs = node.unprotect_glyphs + +function nodes.remove(head, current, free_too) + local t = current + head, current = remove_node(head,current) + if t then + if free_too then + free_node(t) + t = nil + else + t.next, t.prev = nil, nil + end + end + return head, current, t +end + +function nodes.delete(head,current) + return nodes.remove(head,current,true) +end + +nodes.before = node.insert_before +nodes.after = node.insert_after + +function nodes.pool.kern(k) + local n = new_node("kern",1) + n.kern = k + return n +end diff --git a/luaotfload-blacklist.cnf b/luaotfload-blacklist.cnf new file mode 100644 index 0000000..771649b --- /dev/null +++ b/luaotfload-blacklist.cnf @@ -0,0 +1,23 @@ +% Takes ages to load +LastResort.ttf % a MacOSX font, but also available for free from unicode.org + +% Mac OS X TTC fonts, this list need to be filtered out +% luatex bug fixed? +% /Library/Fonts/AmericanTypewriter.ttc +% /Library/Fonts/Baskerville.ttc +% /Library/Fonts/Chalkboard.ttc +% /Library/Fonts/Cochin.ttc +% /Library/Fonts/Copperplate.ttc +% /Library/Fonts/Didot.ttc +% /Library/Fonts/Futura.ttc +% /Library/Fonts/GillSans.ttc +% /Library/Fonts/Hoefler Text.ttc +% /Library/Fonts/MarkerFelt.ttc +% /Library/Fonts/Optima.ttc +% /Library/Fonts/Papyrus.ttc +% /Library/Fonts/STHeiti Medium.ttc +% /System/Library/Fonts/AquaKana.ttc +% /System/Library/Fonts/HelveticaNeue.ttc +% /System/Library/Fonts/LucidaGrande.ttc +% /System/Library/Fonts/Menlo.ttc +% /System/Library/Fonts/STHeiti Light.ttc diff --git a/luaotfload-features.lua b/luaotfload-features.lua new file mode 100644 index 0000000..aae0515 --- /dev/null +++ b/luaotfload-features.lua @@ -0,0 +1,110 @@ +--[[doc-- +Taken from the most recent branch of luaotfload. +--doc]]-- +local addotffeature = fonts.handlers.otf.addfeature +local registerotffeature = fonts.handlers.otf.features.register + +local everywhere = { ["*"] = { ["*"] = true } } + +local tlig = { + { + type = "substitution", + features = everywhere, + data = { + [0x0022] = 0x201D, -- quotedblright + [0x0027] = 0x2019, -- quoteleft + [0x0060] = 0x2018, -- quoteright + }, + flags = { }, + }, + { + type = "ligature", + features = everywhere, + data = { + [0x2013] = {0x002D, 0x002D}, -- endash + [0x2014] = {0x002D, 0x002D, 0x002D}, -- emdash + [0x201C] = {0x2018, 0x2018}, -- quotedblleft + [0x201D] = {0x2019, 0x2019}, -- quotedblright + [0x201E] = {0x002C, 0x002C}, -- quotedblbase + [0x00A1] = {0x0021, 0x2018}, -- exclamdown + [0x00BF] = {0x003F, 0x2018}, -- questiondown + }, + flags = { }, + }, + { + type = "ligature", + features = everywhere, + data = { + [0x201C] = {0x0060, 0x0060}, -- quotedblleft + [0x201D] = {0x0027, 0x0027}, -- quotedblright + [0x00A1] = {0x0021, 0x0060}, -- exclamdown + [0x00BF] = {0x003F, 0x0060}, -- questiondown + }, + flags = { }, + }, +} + +addotffeature("tlig", tlig) +addotffeature("trep", { }) -- empty, all in tlig now +local anum_arabic = { + [0x0030] = 0x0660, + [0x0031] = 0x0661, + [0x0032] = 0x0662, + [0x0033] = 0x0663, + [0x0034] = 0x0664, + [0x0035] = 0x0665, + [0x0036] = 0x0666, + [0x0037] = 0x0667, + [0x0038] = 0x0668, + [0x0039] = 0x0669, +} + +local anum_persian = { + [0x0030] = 0x06F0, + [0x0031] = 0x06F1, + [0x0032] = 0x06F2, + [0x0033] = 0x06F3, + [0x0034] = 0x06F4, + [0x0035] = 0x06F5, + [0x0036] = 0x06F6, + [0x0037] = 0x06F7, + [0x0038] = 0x06F8, + [0x0039] = 0x06F9, +} + +local function valid(data) + local features = data.resources.features + if features then + for k, v in next, features do + for k, v in next, v do + if v.arab then + return true + end + end + end + end +end + +local anum_specification = { + { + type = "substitution", + features = { arab = { far = true, urd = true, snd = true } }, + data = anum_persian, + flags = { }, + valid = valid, + }, + { + type = "substitution", +features = { arab = { ["*"] = true } }, + data = anum_arabic, + flags = { }, + valid = valid, + }, +} + +addotffeature("anum",anum_specification) + +registerotffeature { + name = 'anum', + description = 'arabic digits', +} diff --git a/luaotfload-font-clr.lua b/luaotfload-font-clr.lua new file mode 100644 index 0000000..439fd7c --- /dev/null +++ b/luaotfload-font-clr.lua @@ -0,0 +1,187 @@ +if not modules then modules = { } end modules ['font-clr'] = { + version = 1.001, + comment = "companion to font-otf.lua (font color)", + author = "Khaled Hosny and Elie Roux", + copyright = "Luaotfload Development Team", + license = "GPL" +} + +local newnode = node.new +local nodetype = node.id +local traverse_nodes = node.traverse +local insert_node_before = node.insert_before +local insert_node_after = node.insert_after + +local stringformat = string.format +local stringgsub = string.gsub +local stringfind = string.find + +local otffeatures = fonts.constructors.newfeatures("otf") +local ids = fonts.hashes.identifiers +local registerotffeature = otffeatures.register + +local function setcolor(tfmdata,value) + local sanitized + local properties = tfmdata.properties + + if value then + value = tostring(value) + if #value == 6 or #value == 8 then + sanitized = value + elseif #value == 7 then + _, _, sanitized = stringfind(value, "(......)") + elseif #value > 8 then + _, _, sanitized = stringfind(value, "(........)") + else + -- broken color code ignored, issue a warning? + end + end + + if sanitized then + tfmdata.properties.color = sanitized + add_color_callback() + end +end + +registerotffeature { + name = "color", + description = "color", + initializers = { + base = setcolor, + node = setcolor, + } +} + +local function hex2dec(hex,one) + if one then + return stringformat("%.1g", tonumber(hex, 16)/255) + else + return stringformat("%.3g", tonumber(hex, 16)/255) + end +end + +local res + +local function pageresources(a) + local res2 + if not res then + res = "/TransGs1<>" + end + res2 = stringformat("/TransGs%s<>", a, a, a) + res = stringformat("%s%s", res, stringfind(res, res2) and "" or res2) +end + +local function hex_to_rgba(hex) + local r, g, b, a, push, pop, res3 + if hex then + if #hex == 6 then + _, _, r, g, b = stringfind(hex, '(..)(..)(..)') + elseif #hex == 8 then + _, _, r, g, b, a = stringfind(hex, '(..)(..)(..)(..)') + a = hex2dec(a,true) + pageresources(a) + end + else + return nil + end + r = hex2dec(r) + g = hex2dec(g) + b = hex2dec(b) + if a then + push = stringformat('/TransGs%g gs %s %s %s rg', a, r, g, b) + pop = '0 g /TransGs1 gs' + else + push = stringformat('%s %s %s rg', r, g, b) + pop = '0 g' + end + return push, pop +end + +local glyph = nodetype('glyph') +local hlist = nodetype('hlist') +local vlist = nodetype('vlist') +local whatsit = nodetype('whatsit') +local pgi = nodetype('page_insert') +local sbox = nodetype('sub_box') + +local function lookup_next_color(head) + for n in traverse_nodes(head) do + if n.id == glyph then + if ids[n.font] and ids[n.font].properties and ids[n.font].properties.color then + return ids[n.font].properties.color + else + return -1 + end + elseif n.id == vlist or n.id == hlist or n.id == sbox then + local r = lookup_next_color(n.list) + if r == -1 then + return -1 + elseif r then + return r + end + elseif n.id == whatsit or n.id == pgi then + return -1 + end + end + return nil +end + +local function node_colorize(head, current_color, next_color) + for n in traverse_nodes(head) do + if n.id == hlist or n.id == vlist or n.id == sbox then + local next_color_in = lookup_next_color(n.next) or next_color + n.list, current_color = node_colorize(n.list, current_color, next_color_in) + elseif n.id == glyph then + local tfmdata = ids[n.font] + if tfmdata and tfmdata.properties and tfmdata.properties.color then + if tfmdata.properties.color ~= current_color then + local pushcolor = hex_to_rgba(tfmdata.properties.color) + local push = newnode(whatsit, 8) + push.mode = 1 + push.data = pushcolor + head = insert_node_before(head, n, push) + current_color = tfmdata.properties.color + end + local next_color_in = lookup_next_color (n.next) or next_color + if next_color_in ~= tfmdata.properties.color then + local _, popcolor = hex_to_rgba(tfmdata.properties.color) + local pop = newnode(whatsit, 8) + pop.mode = 1 + pop.data = popcolor + head = insert_node_after(head, n, pop) + current_color = nil + end + end + end + end + return head, current_color +end + +local function font_colorize(head) + -- check if our page resources existed in the previous run + -- and remove it to avoid duplicating it later + if res then + local r = "/ExtGState<<"..res..">>" + tex.pdfpageresources = stringgsub(tex.pdfpageresources, r, "") + end + local h = node_colorize(head, nil, nil) + -- now append our page resources + if res and stringfind(res, "%S") then -- test for non-empty string + local r = "/ExtGState<<"..res..">>" + tex.pdfpageresources = tex.pdfpageresources..r + end + return h +end + +local color_callback_activated = 0 + +function add_color_callback() + if color_callback_activated == 0 then + luatexbase.add_to_callback( + "pre_output_filter", font_colorize, "luaotfload.colorize") + color_callback_activated = 1 + end +end + +-- vim:tw=71:sw=4:ts=4:expandtab + diff --git a/luaotfload-font-ltx.lua b/luaotfload-font-ltx.lua new file mode 100644 index 0000000..afc8621 --- /dev/null +++ b/luaotfload-font-ltx.lua @@ -0,0 +1,205 @@ +if not modules then modules = { } end modules ['font-ltx'] = { + version = 1.001, + comment = "companion to luatex-*.tex", + author = "Hans Hagen, PRAGMA-ADE, Hasselt NL", + copyright = "PRAGMA ADE / ConTeXt Development Team", + license = "see context related readme files" +} +--- where have all the comments gone? + +local fonts = fonts + +-- A bit of tuning for definitions. + +fonts.constructors.namemode = "specification" -- somehow latex needs this (changed name!) => will change into an overload + +-- tricky: we sort of bypass the parser and directly feed all into +-- the sub parser + +function fonts.definers.getspecification(str) + return "", str, "", ":", str +end + +-- the generic name parser (different from context!) + +local feature_list = { } + +local report = logs.names_report + +--- ugh TODO use lpeg instead +local function isstyle(s) + local style = string.lower(s):split("/") + for _,v in next, style do + if v == "b" then + feature_list.style = "bold" + elseif v == "i" then + feature_list.style = "italic" + elseif v == "bi" or v == "ib" then + feature_list.style = "bolditalic" + elseif v:find("^s=") then + feature_list.optsize = v:split("=")[2] + elseif v == "aat" or v == "icu" or v == "gr" then + report("log", 0, + "load font", "unsupported font option: %s", v) + elseif not v:is_empty() then + feature_list.style = v:gsub("[^%a%d]", "") + end + end +end + +local defaults = { + dflt = { + "ccmp", "locl", "rlig", "liga", "clig", + "kern", "mark", "mkmk", 'itlc', + }, + arab = { + "ccmp", "locl", "isol", "fina", "fin2", + "fin3", "medi", "med2", "init", "rlig", + "calt", "liga", "cswh", "mset", "curs", + "kern", "mark", "mkmk", + }, + deva = { + "ccmp", "locl", "init", "nukt", "akhn", + "rphf", "blwf", "half", "pstf", "vatu", + "pres", "blws", "abvs", "psts", "haln", + "calt", "blwm", "abvm", "dist", "kern", + "mark", "mkmk", + }, + khmr = { + "ccmp", "locl", "pref", "blwf", "abvf", + "pstf", "pres", "blws", "abvs", "psts", + "clig", "calt", "blwm", "abvm", "dist", + "kern", "mark", "mkmk", + }, + thai = { + "ccmp", "locl", "liga", "kern", "mark", + "mkmk", + }, + hang = { + "ccmp", "ljmo", "vjmo", "tjmo", + }, +} + +defaults.beng = defaults.deva +defaults.guru = defaults.deva +defaults.gujr = defaults.deva +defaults.orya = defaults.deva +defaults.taml = defaults.deva +defaults.telu = defaults.deva +defaults.knda = defaults.deva +defaults.mlym = defaults.deva +defaults.sinh = defaults.deva + +defaults.syrc = defaults.arab +defaults.mong = defaults.arab +defaults.nko = defaults.arab + +defaults.tibt = defaults.khmr + +defaults.lao = defaults.thai + +local function set_default_features(script) + local features + local script = script or "dflt" + report("log", 0, "load font", + "auto-selecting default features for script: %s", + script) + if defaults[script] then + features = defaults[script] + else + features = defaults["dflt"] + end + for _,v in next, features do + if feature_list[v] ~= false then + feature_list[v] = true + end + end +end + +local function issome () feature_list.lookup = 'name' 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 + +local P, S, R, C = lpeg.P, lpeg.S, lpeg.R, lpeg.C + +local spaces = P(" ")^0 +--local namespec = (1-S("/:("))^0 -- was: (1-S("/: ("))^0 +--[[phg-- this prevents matching of absolute paths as file names --]]-- +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 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) +local falsevalue = P("-") * spaces * (sometext/isfalse) +local keyvalue = P("+") + (C(sometext) * spaces * P("=") * spaces * C(sometext))/iskey +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) + set_default_features(feature_list.script) + if feature_list.style then + specification.style = feature_list.style + feature_list.style = nil + end + if feature_list.optsize then + specification.optsize = feature_list.optsize + 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") + end + + 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 + if feature_list.sub then + specification.sub = feature_list.sub + feature_list.sub = nil + end + if not feature_list.mode then + -- if no mode is set, use our default + feature_list.mode = fonts.mode + end + specification.features.normal = fonts.handlers.otf.features.normalize(feature_list) + return specification +end + +fonts.definers.registersplit(":",colonized,"cryptic") +fonts.definers.registersplit("", colonized,"more cryptic") -- catches \font\text=[names] + +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 +-- vim:tw=71:sw=4:ts=4:expandtab diff --git a/luaotfload-font-nms.lua b/luaotfload-font-nms.lua new file mode 100644 index 0000000..cec2a54 --- /dev/null +++ b/luaotfload-font-nms.lua @@ -0,0 +1,1049 @@ +if not modules then modules = { } end modules ['font-nms'] = { + version = 2.2, + comment = "companion to luaotfload.lua", + author = "Khaled Hosny and Elie Roux", + copyright = "Luaotfload Development Team", + license = "GNU GPL v2" +} + +--- TODO: if the specification is an absolute filename with a font not in the +--- database, add the font to the database and load it. There is a small +--- difficulty with the filenames of the TEXMF tree that are referenced as +--- relative paths... + +--- 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 kpseexpand_var = kpse.expand_var +local kpselookup = kpse.lookup +local kpsereadable_file = kpse.readable_file +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.mkdirs +local filebasename = file.basename +local filecollapsepath = file.collapsepath +local fileextname = file.extname +local fileiswritable = file.iswritable +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 + +names.version = 2.2 +names.data = nil +names.path = { + basename = "otfl-names.lua", + dir = "", + path = "", +} + +-- We use the cache.* of ConTeXt (see luat-basics-gen), we can +-- use it safely (all checks and directory creations are already done). It +-- uses TEXMFCACHE or TEXMFVAR as starting points. +local writable_path = caches.getwritablepath("names","") +if not writable_path then + error("Impossible to find a suitable writeable cache...") +end +names.path.dir = writable_path +names.path.path = filejoin(writable_path, names.path.basename) + + +---- +--- +--- 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 +---- + +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 fontnames_init = function ( ) + return { + mappings = { }, + status = { }, + version = names.version, + } +end + +local make_name = function (path) + return filereplacesuffix(path, "lua"), filereplacesuffix(path, "luc") +end + +--- When loading a lua file we try its binary complement first, which +--- is assumed to be located at an identical path, carrying the suffix +--- .luc. + +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 foundname, data = load_lua_file(names.path.path) + + if data then + report("info", 1, "db", + "Font names database loaded", "%s", foundname) + else + report("info", 0, "db", + [[Font names database not found, generating new one. + This can take several minutes; please be patient.]]) + data = update_names(fontnames_init()) + save_names(data) + end + return data +end + +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", }, + } + + for category, synonyms in next, style_synonyms.list do + style_synonyms.set[category] = tabletohash(synonyms, true) + end +end + +--- 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 (== ":" ) +--- · 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 + size = tonumber(specification.optsize) + elseif specification.size then + size = specification.size / 65536 + end + + if not fonts_loaded then + names.data = load_names() + fonts_loaded = true + end + + local data = names.data + 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 + --- 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 + dsnsize = optsize[1] and optsize[1] / 10 + -- can be nil + maxsize = optsize[2] and optsize[2] / 10 or dsnsize + minsize = optsize[3] and optsize[3] / 10 or dsnsize + end + if name == family then + if subfamily == style then + if optsize then + if dsnsize == size + or (size > minsize and size <= maxsize) then + found[1] = face + break + else + found[#found+1] = face + end + else + found[1] = face + break + end + elseif synonym_set[style] and + synonym_set[style][subfamily] then + if optsize then + if dsnsize == size + or (size > minsize and size <= maxsize) then + found[1] = face + break + else + found[#found+1] = face + end + else + found[1] = face + break + end + elseif subfamily == "regular" or + synonym_set.regular[subfamily] then + found.fallback = face + end + else + if name == fullname + or name == pfullname + or name == fontname + or name == psname then + if optsize then + if dsnsize == size + or (size > minsize and size <= maxsize) then + found[1] = face + break + else + found[#found+1] = face + end + else + found[1] = face + break + end + end + end + end + if #found == 1 then + if 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 + elseif #found > 1 then + -- we found matching font(s) but not in the requested optical + -- sizes, so we loop through the matches to find the one with + -- least difference from the requested size. + local closest + local least = math.huge -- initial value is infinity + for i,face in next, found do + local dsnsize = face.size[1]/10 + local difference = mathabs(dsnsize-size) + if difference < least then + closest = face + 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 + elseif found.fallback then + return found.fallback.filename[1], found.fallback.filename[2], true + end + --- 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 requested name + --- specification.name is empty with absolute paths, looks + --- like a bug in the specification parser '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 + +--- string -> int -> bool +find_closest = function (name, limit) + local name = sanitize_string(name) + limit = limit or fuzzy_limit + + if not fonts_loaded then + names.data = load_names() + fonts_loaded = true + 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 metadata = fontloader.to_table(rawfont) + fontloader.close(rawfont) + collectgarbage("collect") + -- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size + 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 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 + report("log", 1, "db", "broken font rejected", "%s", basefile) + return + end + 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 + 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 tfmdata +end + +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 basename = filebasename(filename) + local basefile = texmf and basename or filename + if filename then + if names.blacklist[filename] or + names.blacklist[basename] then + report("log", 2, "db", "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]) + if index_status and index_status.timestamp == timestamp then + -- already indexed this run + return + end + + newstatus[basefile] = newstatus[basefile] or { } + newstatus[basefile].timestamp = timestamp + newstatus[basefile].index = newstatus[basefile].index or { } + + if db_timestamp == timestamp and not newstatus[basefile].index[1] then + for _,v in next, status[basefile].index do + local index = #newstatus[basefile].index + newmappings[#newmappings+1] = mappings[v] + newstatus[basefile].index[index+1] = #newmappings + end + report("log", 1, "db", "font already indexed", "%s", basefile) + return + end + local info = fontloader.info(filename) + if info then + if type(info) == "table" and #info > 1 then + for i in next, info do + local fullinfo = font_fullinfo(filename, i-1, texmf) + if not fullinfo then + return + end + local index = newstatus[basefile].index[i] + if newstatus[basefile].index[i] then + index = newstatus[basefile].index[i] + else + index = #newmappings+1 + end + newmappings[index] = fullinfo + newstatus[basefile].index[i] = index + end + else + local fullinfo = font_fullinfo(filename, false, texmf) + if not fullinfo then + return + end + local index + if newstatus[basefile].index[1] then + index = newstatus[basefile].index[1] + else + index = #newmappings+1 + end + newmappings[index] = fullinfo + newstatus[basefile].index[1] = index + end + else + report("log", 1, "db", "failed to load", "%s", basefile) + end + end +end + +local function path_normalize(path) + --[[ + path normalization: + - a\b\c -> a/b/c + - a/../b -> b + - /cygdrive/a/b -> a:/b + - reading symlinks under non-Win32 + - using kpse.readable_file on Win32 + ]] + if os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then + path = 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 kpsereadable_file(dest) then + path = dest + elseif kpsereadable_file(filejoin(file.dirname(path), dest)) then + path = filejoin(file.dirname(path), dest) + else + -- broken symlink? + end + end + end + path = filecollapsepath(path) + return path +end + +fonts.path_normalize = path_normalize + +names.blacklist = { } + +local function read_blacklist() + local files = { + kpselookup("otfl-blacklist.cnf", {all=true, format="tex"}) + } + local blacklist = names.blacklist + local whitelist = { } + + if files and type(files) == "table" then + for _,v in next, files do + 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 + --- this is highly inefficient + line = stringsplit(line, "%")[1] + line = stringstrip(line) + if stringsub(line, 1, 1) == "-" then + whitelist[stringsub(line, 2, -1)] = true + else + report("log", 2, "db", "blacklisted file", "%s", line) + blacklist[line] = true + end + end + end + end + end + for _,fontname in next, whitelist do + blacklist[fontname] = nil + end +end + +local font_extensions = { "otf", "ttf", "ttc", "dfont" } +local font_extensions_set = {} +for key, value in next, font_extensions do + font_extensions_set[value] = true +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. +-- --- what for? why can’t we do this in Lua? +-- 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) + --[[ + This function scans a directory and populates the list of fonts + with all the fonts it finds. + - dirname is the name of the directory to scan + - names is the font database to fill + - texmf is a boolean saying if we are scanning a texmf directory + ]] + local list, found = { }, { } + local nbfound = 0 + report("log", 2, "db", "scanning", "%s", dirname) + for _,i in next, font_extensions do + 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. + report("log", 2, "db", + "fonts found", "%s '%s' fonts found", #found, ext) + nbfound = nbfound + #found + tableappend(list, found) + end + end + report("log", 2, "db", + "fonts found", "%d fonts found in '%s'", nbfound, dirname) + + for _,file in next, list do + file = path_normalize(file) + report("log", 1, "db", + "loading font", "%s", file) + load_font(file, fontnames, newfontnames, texmf) + end +end + +local function scan_texmf_fonts(fontnames, newfontnames) + --[[ + This function scans all fonts in the texmf tree, through kpathsea + variables OPENTYPEFONTS and TTFONTS of texmf.cnf + ]] + if stringis_empty(kpseexpand_path("$OSFONTDIR")) then + report("info", 1, "db", "Scanning TEXMF fonts...") + else + report("info", 1, "db", "Scanning TEXMF and OS fonts...") + end + 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 +end + +--[[ + For the OS fonts, there are several options: + - if OSFONTDIR is set (which is the case under windows by default but + not on the other OSs), it scans it at the same time as the texmf tree, + in the scan_texmf_fonts. + - if not: + - under Windows and Mac OSX, we take a look at some hardcoded directories + - under Unix, we read /etc/fonts/fonts.conf and read the directories in it + + This means that if you have fonts in fancy directories, you need to set them + in OSFONTDIR. +]] + +--- (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. + + 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 fh = ioopen(path) + passed_paths[#passed_paths+1] = path + passed_paths_set = tabletohash(passed_paths, true) + if not fh then + report("log", 2, "db", "cannot open file", "%s", path) + return results + end + local incomments = false + for line in fh:lines() do + while line and line ~= "" do + -- spaghetti code... hmmm... + if incomments then + local tmp = stringfind(line, '-->') --- wtf? + if tmp then + incomments = false + line = stringsub(line, tmp+3) + else + line = nil + end + else + local tmp = stringfind(line, '') --- wtf? - if tmp then - incomments = false - line = stringsub(line, tmp+3) - else - line = nil - end - else - local tmp = stringfind(line, '') --- wtf? + if tmp then + incomments = false + line = stringsub(line, tmp+3) + else + line = nil + end + else + local tmp = stringfind(line, '') --- wtf? - if tmp then - incomments = false - line = stringsub(line, tmp+3) - else - line = nil - end - else - local tmp = stringfind(line, '