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
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
|
if not modules then modules = { } end modules ['font-chk'] = {
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"
}
-- This is kind of old but it makes no real sense to upgrade it to for instance
-- using delayed type 3 fonts in order to be lean and mean and cut'n'paste
-- compliant. When this kicks one needs to fix the choice of fonts anyway! So,
-- instead we just keep the method we use but slightly adapted to the backend
-- of lmtx.
local type, next = type, next
local find, lower, gmatch = string.find, string.lower, string.gmatch
local floor = math.floor
local context = context
local formatters = string.formatters
local bpfactor = number.dimenfactors.bp
local fastcopy = table.fastcopy
local sortedkeys = table.sortedkeys
local sortedhash = table.sortedhash
local contains = table.contains
local report = logs.reporter("fonts")
local report_checking = logs.reporter("fonts","checking")
local allocate = utilities.storage.allocate
local getmacro = tokens.getters.macro
local fonts = fonts
fonts.checkers = fonts.checkers or { }
local checkers = fonts.checkers
local fonthashes = fonts.hashes
local fontdata = fonthashes.identifiers
local fontcharacters = fonthashes.characters
local currentfont = font.current
local definers = fonts.definers
local helpers = fonts.helpers
local addprivate = helpers.addprivate
local hasprivate = helpers.hasprivate
local getprivateslot = helpers.getprivateslot
local getprivatecharornode = helpers.getprivatecharornode
local otffeatures = fonts.constructors.features.otf
local afmfeatures = fonts.constructors.features.afm
local registerotffeature = otffeatures.register
local registerafmfeature = afmfeatures.register
local is_character = characters.is_character
local chardata = characters.data
local tasks = nodes.tasks
local enableaction = tasks.enableaction
local disableaction = tasks.disableaction
local implement = interfaces.implement
local glyph_code = nodes.nodecodes.glyph
local hpack_node = nodes.hpack
local nuts = nodes.nuts
local tonut = nuts.tonut
local isglyph = nuts.isglyph
local setchar = nuts.setchar
local nextglyph = nuts.traversers.glyph
local remove_node = nuts.remove
local insertnodeafter = nuts.insertafter
local insertnodebefore = nuts.insertbefore
local copy_node = nuts.copy
local actions = false
-- to tfmdata.properties ?
local function onetimemessage(font,char,message) -- char == false returns table
local tfmdata = fontdata[font]
local shared = tfmdata.shared
if not shared then
shared = { }
tfmdata.shared = shared
end
local messages = shared.messages
if not messages then
messages = { }
shared.messages = messages
end
local category = messages[message]
if not category then
category = { }
messages[message] = category
end
if char == false then
return sortedkeys(category), category
end
local cc = category[char]
if not cc then
report_checking("char %C in font %a with id %a: %s",char,tfmdata.properties.fullname,font,message)
category[char] = 1
else
category[char] = cc + 1
end
end
fonts.loggers.onetimemessage = onetimemessage
local fakes = {
MissingLowercase = { width = .45, height = .55, depth = .20 },
MissingUppercase = { width = .65, height = .70, depth = .25 },
MissingMark = { width = .15, height = .70, depth = -.50 },
MissingPunctuation = { width = .15, height = .55, depth = .20 },
MissingUnknown = { width = .45, height = .20, depth = 0 },
}
local mapping = allocate {
lu = { "MissingUppercase", "darkred" },
ll = { "MissingLowercase", "darkred" },
lt = { "MissingUppercase", "darkred" },
lm = { "MissingLowercase", "darkred" },
lo = { "MissingLowercase", "darkred" },
mn = { "MissingMark", "darkgreen" },
mc = { "MissingMark", "darkgreen" },
me = { "MissingMark", "darkgreen" },
nd = { "MissingLowercase", "darkblue" },
nl = { "MissingLowercase", "darkblue" },
no = { "MissingLowercase", "darkblue" },
pc = { "MissingPunctuation", "darkcyan" },
pd = { "MissingPunctuation", "darkcyan" },
ps = { "MissingPunctuation", "darkcyan" },
pe = { "MissingPunctuation", "darkcyan" },
pi = { "MissingPunctuation", "darkcyan" },
pf = { "MissingPunctuation", "darkcyan" },
po = { "MissingPunctuation", "darkcyan" },
sm = { "MissingLowercase", "darkmagenta" },
sc = { "MissingLowercase", "darkyellow" },
sk = { "MissingLowercase", "darkyellow" },
so = { "MissingLowercase", "darkyellow" },
}
table.setmetatableindex(mapping, { "MissingUnknown", "darkgray" })
checkers.mapping = mapping
-- We provide access by (private) name for tracing purposes. We also need to make
-- sure the dimensions are known at the lua and tex end. For previous variants see
-- the mkiv files or older lmtx files. I decided to just drop the old stuff here.
function checkers.placeholder(font,char,category)
local category = category or chardata[char].category or "lu" -- todo: unknown
local fakedata = mapping[category] or mapping.lu
local tfmdata = fontdata[font]
local units = tfmdata.parameters.units or 1000
local slant = (tfmdata.parameters.slant or 0)/65536
local scale = units/1000
local rawdata = tfmdata.shared and tfmdata.shared.rawdata
local weight = (rawdata and rawdata.metadata and rawdata.metadata.pfmweight or 400)/400
-- if slant then
-- slant = 0.2
-- end
local specification = {
code = "MissingGlyph",
scale = scale,
slant = slant,
weight = weight,
namespace = font,
shapes = { { shape = fakedata[1], color = fakedata[2] } },
}
fonts.helpers.setmetaglyphs("missing", font, char, specification)
end
function checkers.missing(head)
local lastfont = nil
local characters = nil
local found = nil
local addplaceholder = checkers.placeholder -- so we can overload
if actions.replace or actions.decompose then
for n, char, font in nextglyph, head do
if font ~= lastfont then
lastfont = font
characters = fontcharacters[font]
end
if font > 0 and not characters[char] and is_character[chardata[char].category or "unknown"] then
if actions.decompose then
local c = chardata[char]
if c then
local s = c.specials
if s and (s[1] == "char" or s[1] == "with") then -- with added
local l = #s
if l > 2 then
-- check first
local okay = true
for i=2,l do
if not characters[s[i]] then
okay = false
break
end
end
if okay then
-- we work backward
local o = n -- we're not supposed to change n (lua 5.4+)
onetimemessage(font,char,"missing (decomposed)")
setchar(n,s[l])
for i=l-1,2,-1 do
head, o = insertnodebefore(head,o,copy_node(n))
setchar(o,s[i])
end
goto DONE
end
end
end
end
end
if actions.replace then
onetimemessage(font,char,"missing (replaced)")
local f, c = addplaceholder(font,char)
if f and c then
setchar(n, c, f)
end
goto DONE
end
if actions.remove then
onetimemessage(font,char,"missing (deleted)")
if not found then
found = { n }
else
found[#found+1] = n
end
goto DONE
end
onetimemessage(font,char,"missing (checked)")
::DONE::
end
end
end
if found then
for i=1,#found do
head = remove_node(head,found[i],true)
end
end
return head
end
local relevant = {
"missing (decomposed)",
"missing (replaced)",
"missing (deleted)",
"missing (checked)",
"missing",
}
local function getmissing(id)
if id then
local list = getmissing(currentfont())
if list then
local _, list = next(getmissing(currentfont()))
return list
else
return { }
end
else
local t = { }
for id, d in next, fontdata do
local shared = d.shared
local messages = shared and shared.messages
if messages then
local filename = d.properties.filename
if not filename then
filename = tostring(d)
end
local tf = t[filename] or { }
for i=1,#relevant do
local tm = messages[relevant[i]]
if tm then
for k, v in next, tm do
tf[k] = (tf[k] or 0) + v
end
end
end
if next(tf) then
t[filename] = tf
end
end
end
local l = { }
for k, v in next, t do
l[k] = sortedkeys(v)
end
return l, t
end
end
checkers.getmissing = getmissing
do
local reported = true
callback.register("glyph_not_found",function(font,char)
if font > 0 then
if char > 0 then
onetimemessage(font,char,"missing")
else
-- we have a special case
end
elseif not reported then
report("nullfont is used, maybe no bodyfont is defined")
reported = true
end
end)
local loaded = false
trackers.register("fonts.missing", function(v)
if v then
enableaction("processors","fonts.checkers.missing")
if v == true then
actions = { check = true }
else
actions = utilities.parsers.settings_to_set(v)
if not loaded and actions.replace then
metapost.simple("simplefun",'loadfile("mp-miss.mpxl");')
loaded = true
end
end
else
disableaction("processors","fonts.checkers.missing")
actions = false
end
end)
logs.registerfinalactions(function()
local collected, details = getmissing()
if next(collected) then
for filename, list in sortedhash(details) do
logs.startfilelogging(report,"missing characters",filename)
for u, v in sortedhash(list) do
report("%4i %U %c %s",v,u,u,chardata[u].description)
end
logs.stopfilelogging()
end
if logs.loggingerrors() then
for filename, list in sortedhash(details) do
logs.starterrorlogging(report,"missing characters",filename)
for u, v in sortedhash(list) do
report("%4i %U %c %s",v,u,u,chardata[u].description)
end
logs.stoperrorlogging()
end
end
end
end)
end
-- for the moment here
local function expandglyph(characters,index,done)
done = done or { }
if not done[index] then
local data = characters[index]
if data then
done[index] = true
local d = fastcopy(data)
local n = d.next
if n then
d.next = expandglyph(characters,n,done)
end
local h = d.hvariants
if h then
for i=1,#h do
h[i].glyph = expandglyph(characters,h[i].glyph,done)
end
end
local v = d.vvariants
if v then
for i=1,#v do
v[i].glyph = expandglyph(characters,v[i].glyph,done)
end
end
return d
end
end
end
helpers.expandglyph = expandglyph
-- should not be needed as we add .notdef in the engine
local dummyzero = {
-- width = 0,
-- height = 0,
-- depth = 0,
commands = { { "special", "" } },
}
local function adddummysymbols(tfmdata)
local characters = tfmdata.characters
if not characters[0] then
characters[0] = dummyzero
end
-- if not characters[1] then
-- characters[1] = dummyzero -- test only
-- end
end
local dummies_specification = {
name = "dummies",
description = "dummy symbols",
default = true,
manipulators = {
base = adddummysymbols,
node = adddummysymbols,
}
}
registerotffeature(dummies_specification)
registerafmfeature(dummies_specification)
--
local function addvisualspace(tfmdata)
local spacechar = tfmdata.characters[32]
if spacechar and not spacechar.commands then
local w = spacechar.width
local h = tfmdata.parameters.xheight
-- local h = tfmdata.parameters.xheight / 4 -- could be "visualspace=large" or so
local c = {
width = w,
commands = { { "rule", h, w } },
-- commands = { { "line", w, 5*h, h } },
}
local u = addprivate(tfmdata, "visualspace", c)
end
end
local visualspace_specification = {
name = "visualspace",
description = "visual space",
default = true,
manipulators = {
base = addvisualspace,
node = addvisualspace,
}
}
registerotffeature(visualspace_specification)
registerafmfeature(visualspace_specification)
do
local reference = 88 -- string.byte("X")
local mapping = { ss = "sans", rm = "serif", tt = "mono" }
local order = { "sans", "serif", "mono" }
local fallbacks = { sans = { }, serif = { }, mono = { } }
local function locate(fallbacks,n,f,c)
for i=1,#fallbacks do
local id = fallbacks[i]
if type(id) == "string" then
local fid = definers.define { name = id }
report("using fallback font %!font:name! (id: %i)",fid,fid)
fallbacks[i] = fid
id = fid
end
if type(id) == "number" then
local cid = fontcharacters[id]
if cid[c] then
local fc = fontcharacters[f]
local sc = (fc[reference].height / cid[reference].height) * (n.scale or 1000)
report("character %C in font %!font:name! (id: %i) is taken from fallback font %!font:name! (id: %i)",c,f,f,id,id)
return { id, sc }
end
end
end
return false
end
local cache = table.setmetatableindex("table")
callback.register("missing_character", function(n,f,c)
local cached = cache[f]
local found = cached[c]
if found == nil then
-- we can use fonts.helpers.name(f) but we need the monospace flag anyway so:
local metadata = fontdata[f].shared
if metadata then
metadata = metadata.rawdata
if metadata then
metadata = metadata.metadata
if metadata then
if metadata.monospaced then
found = locate(fallbacks.mono,n,f,c)
if found then
cached[c] = found
goto done
end
end
local fn = lower(metadata.fullname)
for i=1,3 do
local o = order[i]
if find(fn,o) then
found = locate(fallbacks[o],n,f,c)
if found then
cached[c] = found
goto done
end
end
end
end
end
end
found = locate(fallbacks[mapping[getmacro("fontstyle")] or "mono"],n,f,c)
if found then
cached[c] = found
goto done
end
end
::done::
if found then
n.font = found[1]
n.scale = found[2]
end
end)
function definers.registerfallbackfont(style,list)
local l = fallbacks[style]
if l then
for s in gmatch(list,"[^, ]+") do
if not contains(l,s) then
l[#l+1] = s
end
end
end
end
implement {
name = "registerfallbackfont",
public = true,
protected = true,
arguments = { "optional", "optional" },
actions = definers.registerfallbackfont,
}
end
|