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
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
|
if not modules then modules = { } end modules ['font-ctx'] = {
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"
}
-- needs a cleanup: merge of replace, lang/script etc
local texsprint, count, texsetcount = tex.sprint, tex.count, tex.setcount
local format, concat, gmatch, match, find, lower, gsub, byte = string.format, table.concat, string.gmatch, string.match, string.find, string.lower, string.gsub, string.byte
local tostring, next, type = tostring, next, type
local lpegmatch = lpeg.match
local round = math.round
local ctxcatcodes = tex.ctxcatcodes
local trace_defining = false trackers.register("fonts.defining", function(v) trace_defining = v end)
local tfm = fonts.tfm
local define = fonts.define
local fontdata = fonts.identifiers
local specify = define.specify
specify.context_setups = specify.context_setups or { }
specify.context_numbers = specify.context_numbers or { }
specify.context_merged = specify.context_merged or { }
specify.synonyms = specify.synonyms or { }
local setups = specify.context_setups
local numbers = specify.context_numbers
local merged = specify.context_merged
local synonyms = specify.synonyms
local triggers = fonts.triggers
--[[ldx--
<p>So far we haven't really dealt with features (or whatever we want
to pass along with the font definition. We distinguish the following
situations:</p>
situations:</p>
<code>
name:xetex like specs
name@virtual font spec
name*context specification
</code>
--ldx]]--
function specify.predefined(specification)
local detail = specification.detail
if detail ~= "" then
-- detail = gsub(detail,"["..define.splitsymbols.."].*$","") -- get rid of *whatever specs and such
if define.methods[detail] then -- since these may be appended at the
specification.features.vtf = { preset = detail } -- tex end by default
end
end
return specification
end
define.register_split("@", specify.predefined)
storage.register("fonts/setups" , define.specify.context_setups , "fonts.define.specify.context_setups" )
storage.register("fonts/numbers", define.specify.context_numbers, "fonts.define.specify.context_numbers")
storage.register("fonts/merged", define.specify.context_merged, "fonts.define.specify.context_merged")
storage.register("fonts/synonyms", define.specify.synonyms, "fonts.define.specify.synonyms")
local normalize_meanings = fonts.otf.meanings.normalize
local settings_to_hash = aux.settings_to_hash
local default_features = fonts.otf.features.default
local function preset_context(name,parent,features) -- currently otf only
if features == "" and find(parent,"=") then
features = parent
parent = ""
end
if features == "" then
features = { }
elseif type(features) == "string" then
features = normalize_meanings(settings_to_hash(features))
else
features = normalize_meanings(features)
end
-- todo: synonyms, and not otf bound
if parent ~= "" then
for p in gmatch(parent,"[^, ]+") do
local s = setups[p]
if s then
for k,v in next, s do
if features[k] == nil then
features[k] = v
end
end
end
end
end
-- these are auto set so in order to prevent redundant definitions
-- we need to preset them (we hash the features and adding a default
-- setting during initialization may result in a different hash)
for k,v in next, triggers do
if features[v] == nil then -- not false !
local vv = default_features[v]
if vv then features[v] = vv end
end
end
-- sparse 'm so that we get a better hash and less test (experimental
-- optimization)
local t = { } -- can we avoid t ?
for k,v in next, features do
if v then t[k] = v end
end
-- needed for dynamic features
local number = (setups[name] and setups[name].number) or 0
if number == 0 then
number = #numbers + 1
numbers[number] = name
end
t.number = number
setups[name] = t
return number, t
end
local function context_number(name) -- will be replaced
local t = setups[name]
if not t then
return 0
elseif t.auto then
local lng = tonumber(tex.language)
local tag = name .. ":" .. lng
local s = setups[tag]
if s then
return s.number or 0
else
local script, language = languages.association(lng)
if t.script ~= script or t.language ~= language then
local s = table.fastcopy(t)
local n = #numbers + 1
setups[tag] = s
numbers[n] = tag
s.number = n
s.script = script
s.language = language
return n
else
setups[tag] = t
return t.number or 0
end
end
else
return t.number or 0
end
end
local function merge_context(currentnumber,extraname,option)
local current = setups[numbers[currentnumber]]
local extra = setups[extraname]
if extra then
local mergedfeatures, mergedname = { }, nil
if option < 0 then
if current then
for k, v in next, current do
if not extra[k] then
mergedfeatures[k] = v
end
end
end
mergedname = currentnumber .. "-" .. extraname
else
if current then
for k, v in next, current do
mergedfeatures[k] = v
end
end
for k, v in next, extra do
mergedfeatures[k] = v
end
mergedname = currentnumber .. "+" .. extraname
end
local number = #numbers + 1
mergedfeatures.number = number
numbers[number] = mergedname
merged[number] = option
setups[mergedname] = mergedfeatures
return number -- context_number(mergedname)
else
return currentnumber
end
end
local function register_context(fontnumber,extraname,option)
local extra = setups[extraname]
if extra then
local mergedfeatures, mergedname = { }, nil
if option < 0 then
mergedname = fontnumber .. "-" .. extraname
else
mergedname = fontnumber .. "+" .. extraname
end
for k, v in next, extra do
mergedfeatures[k] = v
end
local number = #numbers + 1
mergedfeatures.number = number
numbers[number] = mergedname
merged[number] = option
setups[mergedname] = mergedfeatures
return number -- context_number(mergedname)
else
return 0
end
end
specify.preset_context = preset_context
specify.context_number = context_number
specify.merge_context = merge_context
specify.register_context = register_context
local current_font = font.current
local tex_attribute = tex.attribute
local cache = { } -- concat might be less efficient than nested tables
function fonts.withset(name,what)
local zero = tex_attribute[0]
local hash = zero .. "+" .. name .. "*" .. what
local done = cache[hash]
if not done then
done = merge_context(zero,name,what)
cache[hash] = done
end
tex_attribute[0] = done
end
function fonts.withfnt(name,what)
local font = current_font()
local hash = font .. "*" .. name .. "*" .. what
local done = cache[hash]
if not done then
done = register_context(font,name,what)
cache[hash] = done
end
tex_attribute[0] = done
end
function specify.show_context(name)
return setups[name] or setups[numbers[name]] or setups[numbers[tonumber(name)]] or { }
end
local function split_context(features)
return setups[features] or (preset_context(features,"","") and setups[features])
end
specify.split_context = split_context
function specify.context_tostring(name,kind,separator,yes,no,strict,omit) -- not used
return aux.hash_to_string(table.merged(fonts[kind].features.default or {},setups[name] or {}),separator,yes,no,strict,omit)
end
local splitter = lpeg.splitat(",")
function specify.starred(features) -- no longer fallbacks here
local detail = features.detail
if detail and detail ~= "" then
features.features.normal = split_context(detail)
else
features.features.normal = { }
end
return features
end
define.register_split('*',specify.starred)
-- define (two steps)
local P, C, Cc = lpeg.P, lpeg.C, lpeg.Cc
local space = P(" ")
local spaces = space^0
local leftparent = (P"(")
local rightparent = (P")")
local value = C((leftparent * (1-rightparent)^0 * rightparent + (1-space))^1)
local dimension = C((space/"" + P(1))^1)
local rest = C(P(1)^0)
local scale_none = Cc(0)
local scale_at = P("at") * Cc(1) * spaces * dimension -- value
local scale_sa = P("sa") * Cc(2) * spaces * dimension -- value
local scale_mo = P("mo") * Cc(3) * spaces * dimension -- value
local scale_scaled = P("scaled") * Cc(4) * spaces * dimension -- value
local sizepattern = spaces * (scale_at + scale_sa + scale_mo + scale_scaled + scale_none)
local splitpattern = spaces * value * spaces * rest
local specification --
local get_specification = define.get_specification
-- we can make helper macros which saves parsing (but normaly not
-- that many calls, e.g. in mk a couple of 100 and in metafun 3500)
function define.command_1(str)
statistics.starttiming(fonts)
local fullname, size = lpegmatch(splitpattern,str)
local lookup, name, sub, method, detail = get_specification(fullname)
if not name then
logs.report("define font","strange definition '%s'",str)
texsprint(ctxcatcodes,"\\fcglet\\somefontname\\defaultfontfile")
elseif name == "unknown" then
texsprint(ctxcatcodes,"\\fcglet\\somefontname\\defaultfontfile")
else
texsprint(ctxcatcodes,"\\fcxdef\\somefontname{",name,"}")
end
-- we can also use a count for the size
if size and size ~= "" then
local mode, size = lpegmatch(sizepattern,size)
if size and mode then
count.scaledfontmode = mode
texsprint(ctxcatcodes,"\\def\\somefontsize{",size,"}")
else
count.scaledfontmode = 0
texsprint(ctxcatcodes,"\\let\\somefontsize\\empty")
end
elseif true then
-- so we don't need to check in tex
count.scaledfontmode = 2
texsprint(ctxcatcodes,"\\let\\somefontsize\\empty")
else
count.scaledfontmode = 0
texsprint(ctxcatcodes,"\\let\\somefontsize\\empty")
end
specification = define.makespecification(str,lookup,name,sub,method,detail,size)
end
local n = 0
-- we can also move rscale to here (more consistent)
function define.command_2(global,cs,str,size,classfeatures,fontfeatures,classfallbacks,fontfallbacks,mathsize,textsize,relativeid)
if trace_defining then
logs.report("define font","memory usage before: %s",statistics.memused())
end
-- name is now resolved and size is scaled cf sa/mo
local lookup, name, sub, method, detail = get_specification(str or "")
-- asome settings can be overloaded
if lookup and lookup ~= "" then
specification.lookup = lookup
end
if relativeid and relativeid ~= "" then -- experimental hook
local id = tonumber(relativeid) or 0
specification.relativeid = id > 0 and id
end
specification.name = name
specification.size = size
specification.sub = (sub and sub ~= "" and sub) or specification.sub
specification.mathsize = mathsize
specification.textsize = textsize
if detail and detail ~= "" then
specification.method, specification.detail = method or "*", detail
elseif specification.detail and specification.detail ~= "" then
-- already set
elseif fontfeatures and fontfeatures ~= "" then
specification.method, specification.detail = "*", fontfeatures
elseif classfeatures and classfeatures ~= "" then
specification.method, specification.detail = "*", classfeatures
end
if fontfallbacks and fontfallbacks ~= "" then
specification.fallbacks = fontfallbacks
elseif classfallbacks and classfallbacks ~= "" then
specification.fallbacks = classfallbacks
end
local tfmdata = define.read(specification,size) -- id not yet known
if not tfmdata then
logs.report("define font","unable to define %s as \\%s",name,cs)
texsetcount("global","lastfontid",-1)
elseif type(tfmdata) == "number" then
if trace_defining then
logs.report("define font","reusing %s with id %s as \\%s (features: %s/%s, fallbacks: %s/%s)",name,tfmdata,cs,classfeatures,fontfeatures,classfallbacks,fontfallbacks)
end
tex.definefont(global,cs,tfmdata)
-- resolved (when designsize is used):
texsprint(ctxcatcodes,format("\\def\\somefontsize{%isp}",fontdata[tfmdata].size))
texsetcount("global","lastfontid",tfmdata)
else
-- local t = os.clock(t)
local id = font.define(tfmdata)
-- print(name,os.clock()-t)
tfmdata.id = id
define.register(tfmdata,id)
tex.definefont(global,cs,id)
tfm.cleanup_table(tfmdata)
if trace_defining then
logs.report("define font","defining %s with id %s as \\%s (features: %s/%s, fallbacks: %s/%s)",name,id,cs,classfeatures,fontfeatures,classfallbacks,fontfallbacks)
end
-- resolved (when designsize is used):
texsprint(ctxcatcodes,format("\\def\\somefontsize{%isp}",tfmdata.size))
--~ if specification.fallbacks then
--~ fonts.collections.prepare(specification.fallbacks)
--~ end
texsetcount("global","lastfontid",id)
end
if trace_defining then
logs.report("define font","memory usage after: %s",statistics.memused())
end
statistics.stoptiming(fonts)
end
local enable_auto_r_scale = false
experiments.register("fonts.autorscale", function(v)
enable_auto_r_scale = v
end)
local calculate_scale = fonts.tfm.calculate_scale
function fonts.tfm.calculate_scale(tfmtable, scaledpoints, relativeid)
local scaledpoints, delta, units = calculate_scale(tfmtable, scaledpoints, relativeid)
if enable_auto_r_scale and relativeid then -- for the moment this is rather context specific
local relativedata = fontdata[relativeid]
local id_x_height = relativedata and relativedata.parameters and relativedata.parameters.x_height
local tf_x_height = id_x_height and tfmtable.parameters and tfmtable.parameters.x_height * delta
if tf_x_height then
scaledpoints = (id_x_height/tf_x_height) * scaledpoints
delta = scaledpoints/units
end
end
return scaledpoints, delta, units
end
--~ table.insert(readers.sequence,1,'vtf')
--~ function readers.vtf(specification)
--~ if specification.features.vtf and specification.features.vtf.preset then
--~ return tfm.make(specification)
--~ else
--~ return nil
--~ end
--~ end
-- we need a place for this .. outside the generic scope
local dimenfactors = number.dimenfactors
function fonts.dimenfactor(unit,tfmdata)
if unit == "ex" then
return (tfmdata and tfmdata.parameters.x_height) or 655360
elseif unit == "em" then
return (tfmdata and tfmdata.parameters.em_height) or 655360
else
return dimenfactors[unit] or unit
end
end
function fonts.cleanname(name)
texsprint(ctxcatcodes,fonts.names.cleanname(name))
end
local p, f = 1, "%0.1fpt" -- normally this value is changed only once
local stripper = lpeg.patterns.strip_zeros
function fonts.nbfs(amount,precision)
if precision ~= p then
p = precision
f = "%0." .. p .. "fpt"
end
texsprint(ctxcatcodes,lpegmatch(stripper,format(f,amount/65536)))
end
-- for the moment here, this will become a chain of extras that is
-- hooked into the ctx registration (or scaler or ...)
function fonts.set_digit_width(font)
local tfmtable = fontdata[font]
local parameters = tfmtable.parameters
local width = parameters.digitwidth
if not width then
width = round(parameters.quad/2) -- maybe tex.scale
local characters = tfmtable.characters
for i=48,57 do
local wd = round(characters[i].width)
if wd > width then
width = wd
end
end
parameters.digitwidth = width
end
return width
end
fonts.get_digit_width = fonts.set_digit_width
-- soon to be obsolete:
local loaded = { -- prevent loading (happens in cont-sys files)
["original-base.map" ] = true,
["original-ams-base.map" ] = true,
["original-ams-euler.map"] = true,
["original-public-lm.map"] = true,
}
function fonts.map.loadfile(name)
name = file.addsuffix(name,"map")
if not loaded[name] then
pdf.mapfile(name)
loaded[name] = true
end
end
local loaded = { -- prevent double loading
}
function fonts.map.loadline(how,line)
if line then
how = how .. " " .. line
elseif how == "" then
how = "= " .. line
end
if not loaded[how] then
pdf.mapline(how)
loaded[how] = true
end
end
function fonts.map.reset()
pdf.mapfile("")
end
fonts.map.reset() -- resets the default file
-- we need an 'do after the banner hook'
-- pdf.mapfile("mkiv-base.map") -- loads the default file
local nounicode = byte("?")
local function name_to_slot(name) -- maybe some day rawdata
local tfmdata = fonts.ids[font.current()]
local shared = tfmdata and tfmdata.shared
local fntdata = shared and shared.otfdata or shared.afmdata
if fntdata then
local unicode = fntdata.luatex.unicodes[name]
if not unicode then
return nounicode
elseif type(unicode) == "number" then
return unicode
else -- multiple unicodes
return unicode[1]
end
end
return nounicode
end
fonts.name_to_slot = name_to_slot
function fonts.char(n) -- todo: afm en tfm
if type(n) == "string" then
n = name_to_slot(n)
end
if type(n) == "number" then
texsprint(ctxcatcodes,format("\\char%s ",n))
end
end
-- moved from ini:
fonts.color = { } -- dummy in ini
local attribute = attributes.private('color')
local mapping = (attributes and attributes.list[attribute]) or { }
local set_attribute = node.set_attribute
local unset_attribute = node.unset_attribute
function fonts.color.set(n,c)
local mc = mapping[c]
if not mc then
unset_attribute(n,attribute)
else
set_attribute(n,attribute,mc)
end
end
function fonts.color.reset(n)
unset_attribute(n,attribute)
end
-- this will become obsolete:
fonts.otf.name_to_slot = name_to_slot
fonts.afm.name_to_slot = name_to_slot
fonts.otf.char = fonts.char
fonts.afm.char = fonts.char
-- this will change ...
function fonts.show_char_data(n)
local tfmdata = fonts.ids[font.current()]
if tfmdata then
if type(n) == "string" then
n = utf.byte(n)
end
local chr = tfmdata.characters[n]
if chr then
write_nl(format("%s @ %s => U%04X => %s => ",tfmdata.fullname,tfmdata.size,n,utf.char(n)) .. serialize(chr,false))
end
end
end
function fonts.show_font_parameters()
local tfmdata = fonts.ids[font.current()]
if tfmdata then
local parameters, mathconstants = tfmdata.parameters, tfmdata.MathConstants
local hasparameters, hasmathconstants = parameters and next(parameters), mathconstants and next(mathconstants)
if hasparameters then
write_nl(format("%s @ %s => parameters => ",tfmdata.fullname,tfmdata.size) .. serialize(parameters,false))
end
if hasmathconstants then
write_nl(format("%s @ %s => math constants => ",tfmdata.fullname,tfmdata.size) .. serialize(mathconstants,false))
end
if not hasparameters and not hasmathconstants then
write_nl(format("%s @ %s => no parameters and/or mathconstants",tfmdata.fullname,tfmdata.size))
end
end
end
|