1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
if not modules then modules = { } end modules ['font-def'] = {
version = 1.001,
comment = "companion to font-ini.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
license = "see context related readme files"
}
-- We can overload some of the definers.functions so we don't local them.
local format, gmatch, match, find, lower, gsub = string.format, string.gmatch, string.match, string.find, string.lower, string.gsub
local tostring, next = tostring, next
local lpegmatch = lpeg.match
local allocate = utilities.storage.allocate
local trace_defining = false trackers .register("fonts.defining", function(v) trace_defining = v end)
local directive_embedall = false directives.register("fonts.embedall", function(v) directive_embedall = v end)
trackers.register("fonts.loading", "fonts.defining", "otf.loading", "afm.loading", "tfm.loading")
trackers.register("fonts.all", "fonts.*", "otf.*", "afm.*", "tfm.*")
local report_defining = logs.reporter("fonts","defining")
--[[ldx--
<p>Here we deal with defining fonts. We do so by intercepting the
default loader that only handles <l n='tfm'/>.</p>
--ldx]]--
local fonts = fonts
local fontdata = fonts.hashes.identifiers
local readers = fonts.readers
local definers = fonts.definers
local specifiers = fonts.specifiers
local constructors = fonts.constructors
local fontgoodies = fonts.goodies
readers.sequence = allocate { 'otf', 'ttf', 'afm', 'tfm', 'lua' } -- dfont ttc
local variants = allocate()
specifiers.variants = variants
definers.methods = definers.methods or { }
local internalized = allocate() -- internal tex numbers (private)
local loadedfonts = constructors.loadedfonts
local designsizes = constructors.designsizes
-- not in generic (some day I'll make two defs, one for context, one for generic)
local resolvefile = fontgoodies and fontgoodies.filenames and fontgoodies.filenames.resolve or function(s) return s end
--[[ldx--
<p>We hardly gain anything when we cache the final (pre scaled)
<l n='tfm'/> table. But it can be handy for debugging, so we no
longer carry this code along. Also, we now have quite some reference
to other tables so we would end up with lots of catches.</p>
--ldx]]--
--[[ldx--
<p>We can prefix a font specification by <type>name:</type> or
<type>file:</type>. The first case will result in a lookup in the
synonym table.</p>
<typing>
[ name: | file: ] identifier [ separator [ specification ] ]
</typing>
<p>The following function split the font specification into components
and prepares a table that will move along as we proceed.</p>
--ldx]]--
-- beware, we discard additional specs
--
-- method:name method:name(sub) method:name(sub)*spec method:name*spec
-- name name(sub) name(sub)*spec name*spec
-- name@spec*oeps
local splitter, splitspecifiers = nil, "" -- not so nice
local P, C, S, Cc = lpeg.P, lpeg.C, lpeg.S, lpeg.Cc
local left = P("(")
local right = P(")")
local colon = P(":")
local space = P(" ")
definers.defaultlookup = "file"
local prefixpattern = P(false)
local function addspecifier(symbol)
splitspecifiers = splitspecifiers .. symbol
local method = S(splitspecifiers)
local lookup = C(prefixpattern) * colon
local sub = left * C(P(1-left-right-method)^1) * right
local specification = C(method) * C(P(1)^1)
local name = C((1-sub-specification)^1)
splitter = P((lookup + Cc("")) * name * (sub + Cc("")) * (specification + Cc("")))
end
local function addlookup(str,default)
prefixpattern = prefixpattern + P(str)
end
definers.addlookup = addlookup
addlookup("file")
addlookup("name")
addlookup("spec")
local function getspecification(str)
return lpegmatch(splitter,str)
end
definers.getspecification = getspecification
function definers.registersplit(symbol,action,verbosename)
addspecifier(symbol)
variants[symbol] = action
if verbosename then
variants[verbosename] = action
end
end
local function makespecification(specification,lookup,name,sub,method,detail,size)
size = size or 655360
if not lookup or lookup == "" then
lookup = definers.defaultlookup
end
if trace_defining then
report_defining("specification %a, lookup %a, name %a, sub %a, method %a, detail %a",
specification, lookup, name, sub, method, detail)
end
local t = {
lookup = lookup, -- forced type
specification = specification, -- full specification
size = size, -- size in scaled points or -1000*n
name = name, -- font or filename
sub = sub, -- subfont (eg in ttc)
method = method, -- specification method
detail = detail, -- specification
resolved = "", -- resolved font name
forced = "", -- forced loader
features = { }, -- preprocessed features
}
return t
end
definers.makespecification = makespecification
function definers.analyze(specification, size)
-- can be optimized with locals
local lookup, name, sub, method, detail = getspecification(specification or "")
return makespecification(specification, lookup, name, sub, method, detail, size)
end
--[[ldx--
<p>We can resolve the filename using the next function:</p>
--ldx]]--
definers.resolvers = definers.resolvers or { }
local resolvers = definers.resolvers
-- todo: reporter
function resolvers.file(specification)
local name = resolvefile(specification.name) -- catch for renames
local suffix = file.suffix(name)
if fonts.formats[suffix] then
specification.forced = suffix
specification.name = file.removesuffix(name)
else
specification.name = name -- cna be resolved
end
end
function resolvers.name(specification)
local resolve = fonts.names.resolve
if resolve then
local resolved, sub = resolve(specification.name,specification.sub,specification) -- we pass specification for overloaded versions
if resolved then
specification.resolved = resolved
specification.sub = sub
local suffix = file.suffix(resolved)
if fonts.formats[suffix] then
specification.forced = suffix
specification.name = file.removesuffix(resolved)
else
specification.name = resolved
end
end
else
resolvers.file(specification)
end
end
function resolvers.spec(specification)
local resolvespec = fonts.names.resolvespec
if resolvespec then
local resolved, sub = resolvespec(specification.name,specification.sub,specification) -- we pass specification for overloaded versions
if resolved then
specification.resolved = resolved
specification.sub = sub
specification.forced = file.suffix(resolved)
specification.name = file.removesuffix(resolved)
end
else
resolvers.name(specification)
end
end
function definers.resolve(specification)
if not specification.resolved or specification.resolved == "" then -- resolved itself not per se in mapping hash
local r = resolvers[specification.lookup]
if r then
r(specification)
end
end
if specification.forced == "" then
specification.forced = nil
else
specification.forced = specification.forced
end
specification.hash = lower(specification.name .. ' @ ' .. constructors.hashfeatures(specification))
if specification.sub and specification.sub ~= "" then
specification.hash = specification.sub .. ' @ ' .. specification.hash
end
return specification
end
--[[ldx--
<p>The main read function either uses a forced reader (as determined by
a lookup) or tries to resolve the name using the list of readers.</p>
<p>We need to cache when possible. We do cache raw tfm data (from <l
n='tfm'/>, <l n='afm'/> or <l n='otf'/>). After that we can cache based
on specificstion (name) and size, that is, <l n='tex'/> only needs a number
for an already loaded fonts. However, it may make sense to cache fonts
before they're scaled as well (store <l n='tfm'/>'s with applied methods
and features). However, there may be a relation between the size and
features (esp in virtual fonts) so let's not do that now.</p>
<p>Watch out, here we do load a font, but we don't prepare the
specification yet.</p>
--ldx]]--
-- very experimental:
function definers.applypostprocessors(tfmdata)
local postprocessors = tfmdata.postprocessors
if postprocessors then
local properties = tfmdata.properties
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 = gsub(lower(extrahash),"[^a-z]","-")
properties.fullname = format("%s-%s",properties.fullname,extrahash)
end
end
end
return tfmdata
end
-- function definers.applypostprocessors(tfmdata)
-- return tfmdata
-- end
local function checkembedding(tfmdata)
local properties = tfmdata.properties
local embedding
if directive_embedall then
embedding = "full"
elseif properties and properties.filename and constructors.dontembed[properties.filename] then
embedding = "no"
else
embedding = "subset"
end
if properties then
properties.embedding = embedding
else
tfmdata.properties = { embedding = embedding }
end
tfmdata.embedding = embedding
end
function definers.loadfont(specification)
local hash = constructors.hashinstance(specification)
local tfmdata = loadedfonts[hash] -- hashes by size !
if not tfmdata then
local forced = specification.forced or ""
if forced ~= "" then
local reader = readers[lower(forced)]
tfmdata = reader and reader(specification)
if not tfmdata then
report_defining("forced type %a of %a not found",forced,specification.name)
end
else
local sequence = readers.sequence -- can be overloaded so only a shortcut here
for s=1,#sequence do
local reader = sequence[s]
if readers[reader] then -- we skip not loaded readers
if trace_defining then
report_defining("trying (reader sequence driven) type %a for %a with file %a",reader,specification.name,specification.filename)
end
tfmdata = readers[reader](specification)
if tfmdata then
break
else
specification.filename = nil
end
end
end
end
if tfmdata then
tfmdata = definers.applypostprocessors(tfmdata)
checkembedding(tfmdata) -- todo: general postprocessor
loadedfonts[hash] = tfmdata
designsizes[specification.hash] = tfmdata.parameters.designsize
end
end
if not tfmdata then
report_defining("font with asked name %a is not found using lookup %a",specification.name,specification.lookup)
end
return tfmdata
end
local function checkvirtual(tfmdata)
-- begin of experiment: we can use { "slot", 0, number } in virtual fonts
local fonts = tfmdata.fonts
local selfid = font.nextid()
if fonts and #fonts > 0 then
for i=1,#fonts do
if fonts[i][2] == 0 then
fonts[i][2] = selfid
end
end
else
tfmdata.fonts = { "id", selfid }
end
-- end of experiment
end
function constructors.readanddefine(name,size) -- no id -- maybe a dummy first
local specification = definers.analyze(name,size)
local method = specification.method
if method and variants[method] then
specification = variants[method](specification)
end
specification = definers.resolve(specification)
local hash = constructors.hashinstance(specification)
local id = definers.registered(hash)
if not id then
local tfmdata = definers.loadfont(specification)
if tfmdata then
checkvirtual(tfmdata) -- experiment, will become obsolete when slots can selfreference
id = font.define(tfmdata)
definers.register(tfmdata,id)
else
id = 0 -- signal
end
end
return fontdata[id], id
end
--[[ldx--
<p>So far the specifiers. Now comes the real definer. Here we cache
based on id's. Here we also intercept the virtual font handler. Since
it evolved stepwise I may rewrite this bit (combine code).</p>
In the previously defined reader (the one resulting in a <l n='tfm'/>
table) we cached the (scaled) instances. Here we cache them again, but
this time based on id. We could combine this in one cache but this does
not gain much. By the way, passing id's back to in the callback was
introduced later in the development.</p>
--ldx]]--
local lastdefined = nil -- we don't want this one to end up in s-tra-02
local internalized = { }
function definers.current() -- or maybe current
return lastdefined
end
function definers.registered(hash)
local id = internalized[hash]
return id, id and fontdata[id]
end
function definers.register(tfmdata,id)
if tfmdata and id then
local hash = tfmdata.properties.hash
if not internalized[hash] then
internalized[hash] = id
if trace_defining then
report_defining("registering font, id %s, hash %a",id,hash)
end
fontdata[id] = tfmdata
end
end
end
function definers.read(specification,size,id) -- id can be optional, name can already be table
statistics.starttiming(fonts)
if type(specification) == "string" then
specification = definers.analyze(specification,size)
end
local method = specification.method
if method and variants[method] then
specification = variants[method](specification)
end
specification = definers.resolve(specification)
local hash = constructors.hashinstance(specification)
local tfmdata = definers.registered(hash) -- id
if tfmdata then
if trace_defining then
report_defining("already hashed: %s",hash)
end
else
tfmdata = definers.loadfont(specification) -- can be overloaded
if tfmdata then
if trace_defining then
report_defining("loaded and hashed: %s",hash)
end
tfmdata.properties.hash = hash
if id then
definers.register(tfmdata,id)
end
else
if trace_defining then
report_defining("not loaded and hashed: %s",hash)
end
end
end
lastdefined = tfmdata or id -- todo ! ! ! ! !
if not tfmdata then -- or id?
report_defining( "unknown font %a, loading aborted",specification.name)
elseif trace_defining and type(tfmdata) == "table" then
local properties = tfmdata.properties or { }
local parameters = tfmdata.parameters or { }
report_defining("using %s font with id %a, name %a, size %a, bytes %a, encoding %a, fullname %a, filename %a",
properties.format, id, properties.name, parameters.size, properties.encodingbytes,
properties.encodingname, properties.fullname, file.basename(properties.filename))
end
statistics.stoptiming(fonts)
return tfmdata
end
function font.getfont(id)
return fontdata[id] -- otherwise issues
end
--[[ldx--
<p>We overload the <l n='tfm'/> reader.</p>
--ldx]]--
callbacks.register('define_font', definers.read, "definition of fonts (tfmdata preparation)")
|