summaryrefslogtreecommitdiff
path: root/macros/luatex/generic/luaotfload/fontloader-font-oto.lua
blob: 0689f4dfb5b55d21a025aaa8a723bb85f3248a05 (plain)
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
if not modules then modules = { } end modules ['font-oto'] = { -- original tex
    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"
}

-- Todo: Enable fixes from the lmt to here. Also in font-con.lua wrt the changed
-- assignments. (Around texlive 2024 in order not to disturb generic.)

local concat, unpack = table.concat, table.unpack
local insert, remove = table.insert, table.remove
local format, gmatch, gsub, find, match, lower, strip = string.format, string.gmatch, string.gsub, string.find, string.match, string.lower, string.strip
local type, next, tonumber, tostring = type, next, tonumber, tostring

local trace_baseinit         = false  trackers.register("otf.baseinit",     function(v) trace_baseinit     = v end)
local trace_singles          = false  trackers.register("otf.singles",      function(v) trace_singles      = v end)
local trace_multiples        = false  trackers.register("otf.multiples",    function(v) trace_multiples    = v end)
local trace_alternatives     = false  trackers.register("otf.alternatives", function(v) trace_alternatives = v end)
local trace_ligatures        = false  trackers.register("otf.ligatures",    function(v) trace_ligatures    = v end)
local trace_kerns            = false  trackers.register("otf.kerns",        function(v) trace_kerns        = v end)
local trace_preparing        = false  trackers.register("otf.preparing",    function(v) trace_preparing    = v end)

local report_prepare         = logs.reporter("fonts","otf prepare")

local fonts                  = fonts
local otf                    = fonts.handlers.otf

local otffeatures            = otf.features
local registerotffeature     = otffeatures.register

otf.defaultbasealternate     = "none" -- first last

local getprivate             = fonts.constructors.getprivate

local wildcard               = "*"
local default                = "dflt"

local formatters             = string.formatters
local f_unicode              = formatters["%U"]
local f_uniname              = formatters["%U (%s)"]
local f_unilist              = formatters["% t (% t)"]

local function gref(descriptions,n)
    if type(n) == "number" then
        local name = descriptions[n].name
        if name then
            return f_uniname(n,name)
        else
            return f_unicode(n)
        end
    elseif n then
        local num = { }
        local nam = { }
        local j   = 0
        for i=1,#n do
            local ni = n[i]
            if tonumber(ni) then -- first is likely a key
                j = j + 1
                local di = descriptions[ni]
                num[j] = f_unicode(ni)
                nam[j] = di and di.name or "-"
            end
        end
        return f_unilist(num,nam)
    else
        return "<error in base mode tracing>"
    end
end

local function cref(feature,sequence)
    return formatters["feature %a, type %a, (chain) lookup %a"](feature,sequence.type,sequence.name)
end

local function report_substitution(feature,sequence,descriptions,unicode,substitution)
    if unicode == substitution then
        report_prepare("%s: base substitution %s maps onto itself",
            cref(feature,sequence),
            gref(descriptions,unicode))
    else
        report_prepare("%s: base substitution %s => %S",
            cref(feature,sequence),
            gref(descriptions,unicode),
            gref(descriptions,substitution))
    end
end

local function report_alternate(feature,sequence,descriptions,unicode,replacement,value,comment)
    if unicode == replacement then
        report_prepare("%s: base alternate %s maps onto itself",
            cref(feature,sequence),
            gref(descriptions,unicode))
    else
        report_prepare("%s: base alternate %s => %s (%S => %S)",
            cref(feature,sequence),
            gref(descriptions,unicode),
            replacement and gref(descriptions,replacement),
            value,
            comment)
    end
end

local function report_ligature(feature,sequence,descriptions,unicode,ligature)
    report_prepare("%s: base ligature %s => %S",
        cref(feature,sequence),
        gref(descriptions,ligature),
        gref(descriptions,unicode))
end

local function report_kern(feature,sequence,descriptions,unicode,otherunicode,value)
    report_prepare("%s: base kern %s + %s => %S",
        cref(feature,sequence),
        gref(descriptions,unicode),
        gref(descriptions,otherunicode),
        value)
end

-- We need to make sure that luatex sees the difference between base fonts that have
-- different glyphs in the same slots in fonts that have the same fullname (or filename).
-- LuaTeX will merge fonts eventually (and subset later on). If needed we can use a more
-- verbose name as long as we don't use <()<>[]{}/%> and the length is < 128.

local basehash, basehashes, applied = { }, 1, { }

local function registerbasehash(tfmdata)
    local properties = tfmdata.properties
    local hash       = concat(applied," ")
    local base       = basehash[hash]
    if not base then
        basehashes     = basehashes + 1
        base           = basehashes
        basehash[hash] = base
    end
    properties.basehash = base
    properties.fullname = (properties.fullname or properties.name) .. "-" .. base
 -- report_prepare("fullname base hash '%a, featureset %a",tfmdata.properties.fullname,hash)
    applied = { }
end

local function registerbasefeature(feature,value)
    applied[#applied+1] = feature  .. "=" .. tostring(value)
end

-- The original basemode ligature builder used the names of components and did some expression
-- juggling to get the chain right. The current variant starts with unicodes but still uses
-- names to make the chain. This is needed because we have to create intermediates when needed
-- but use predefined snippets when available. To some extend the current builder is more stupid
-- but I don't worry that much about it as ligatures are rather predicatable.
--
-- Personally I think that an ff + i == ffi rule as used in for instance latin modern is pretty
-- weird as no sane person will key that in and expect a glyph for that ligature plus the following
-- character. Anyhow, as we need to deal with this, we do, but no guarantes are given.
--
--         latin modern       dejavu
--
-- f+f       102 102             102 102
-- f+i       102 105             102 105
-- f+l       102 108             102 108
-- f+f+i                         102 102 105
-- f+f+l     102 102 108         102 102 108
-- ff+i    64256 105           64256 105
-- ff+l                        64256 108
--
-- As you can see here, latin modern is less complete than dejavu but
-- in practice one will not notice it.
--
-- The while loop is needed because we need to resolve for instance pseudo names like
-- hyphen_hyphen to endash so in practice we end up with a bit too many definitions but the
-- overhead is neglectable. We can have changed[first] or changed[second] but it quickly becomes
-- messy if we need to take that into account.

local function makefake(tfmdata,name,present)
    local private   = getprivate(tfmdata)
    local character = { intermediate = true, ligatures = { } }
    tfmdata.resources.unicodes[name] = private
    tfmdata.characters[private] = character
    tfmdata.descriptions[private] = { name = name }
    present[name] = private
    return character
end

local function make_1(present,tree,name)
    if tonumber(tree) then
        present[name] = v
    else
        for k, v in next, tree do
            if k == "ligature" then
                present[name] = v
            else
                make_1(present,v,name .. "_" .. k)
            end
        end
    end
end

local function make_3(present,tfmdata,characters,tree,name,preceding,unicode,done,v)
    local character = characters[preceding]
    if not character then
        if trace_baseinit then
            report_prepare("weird ligature in lookup %a, current %C, preceding %C",sequence.name,v,preceding)
        end
        character = makefake(tfmdata,name,present)
    end
    local ligatures = character.ligatures
    if ligatures then
        ligatures[unicode] = { char = v }
    else
        character.ligatures = { [unicode] = { char = v } }
    end
    if done then
        local d = done[name]
        if not d then
            done[name] = { "dummy", v }
        else
            d[#d+1] = v
        end
    end
end

local function make_2(present,tfmdata,characters,tree,name,preceding,unicode,done)
    if tonumber(tree) then
        make_3(present,tfmdata,characters,tree,name,preceding,unicode,done,tree)
    else
        for k, v in next, tree do
            if k == "ligature" then
                make_3(present,tfmdata,characters,tree,name,preceding,unicode,done,v)
            else
                local code = present[name] or unicode
                local name = name .. "_" .. k
                make_2(present,tfmdata,characters,v,name,code,k,done)
            end
        end
    end
end

local function preparesubstitutions(tfmdata,feature,value,validlookups,lookuplist)
    local characters   = tfmdata.characters
    local descriptions = tfmdata.descriptions
    local resources    = tfmdata.resources
    local changed      = tfmdata.changed

    local ligatures    = { }
    local alternate    = tonumber(value) or true and 1
    local defaultalt   = otf.defaultbasealternate
    local trace_singles      = trace_baseinit and trace_singles
    local trace_alternatives = trace_baseinit and trace_alternatives
    local trace_ligatures    = trace_baseinit and trace_ligatures

    -- A chain of changes is handled in font-con which is cleaner because
    -- we can have shared changes and such.

    if not changed then
        changed = { }
        tfmdata.changed = changed
    end

    for i=1,#lookuplist do
        local sequence = lookuplist[i]
        local steps    = sequence.steps
        local kind     = sequence.type
        if kind == "gsub_single" then
            for i=1,#steps do
                for unicode, data in next, steps[i].coverage do
                    if unicode ~= data then
-- if not changed[unicode] then
                        changed[unicode] = data
-- end
                    end
                    if trace_singles then
                        report_substitution(feature,sequence,descriptions,unicode,data)
                    end
                end
            end
        elseif kind == "gsub_alternate" then
            for i=1,#steps do
                for unicode, data in next, steps[i].coverage do
                    local replacement = data[alternate]
                    if replacement then
                        if unicode ~= replacement then
-- if not changed[unicode] then
                            changed[unicode] = replacement
-- end
                        end
                        if trace_alternatives then
                            report_alternate(feature,sequence,descriptions,unicode,replacement,value,"normal")
                        end
                    elseif defaultalt == "first" then
                        replacement = data[1]
                        if unicode ~= replacement then
-- if not changed[unicode] then
                            changed[unicode] = replacement
-- end
                        end
                        if trace_alternatives then
                            report_alternate(feature,sequence,descriptions,unicode,replacement,value,defaultalt)
                        end
                    elseif defaultalt == "last" then
                        replacement = data[#data]
                        if unicode ~= replacement then
-- if not changed[unicode] then
                            changed[unicode] = replacement
-- end
                        end
                        if trace_alternatives then
                            report_alternate(feature,sequence,descriptions,unicode,replacement,value,defaultalt)
                        end
                    else
                        if trace_alternatives then
                            report_alternate(feature,sequence,descriptions,unicode,replacement,value,"unknown")
                        end
                    end
                end
            end
        elseif kind == "gsub_ligature" then
            for i=1,#steps do
                for unicode, data in next, steps[i].coverage do
                    ligatures[#ligatures+1] = { unicode, data, "" } -- lookupname }
                    if trace_ligatures then
                        report_ligature(feature,sequence,descriptions,unicode,data)
                    end
                end
            end
        end
    end

    local nofligatures = #ligatures

    if nofligatures > 0 then
        local characters = tfmdata.characters
        local present    = { }
        local done       = trace_baseinit and trace_ligatures and { }

        for i=1,nofligatures do
            local ligature = ligatures[i]
            local unicode  = ligature[1]
            local tree     = ligature[2]
            make_1(present,tree,"ctx_"..unicode)
        end

        for i=1,nofligatures do
            local ligature   = ligatures[i]
            local unicode    = ligature[1]
            local tree       = ligature[2]
            local lookupname = ligature[3]
            make_2(present,tfmdata,characters,tree,"ctx_"..unicode,unicode,unicode,done,sequence)
        end

    end

end

local function preparepositionings(tfmdata,feature,value,validlookups,lookuplist)
    local characters   = tfmdata.characters
    local descriptions = tfmdata.descriptions
    local resources    = tfmdata.resources
    local properties   = tfmdata.properties
    local traceindeed  = trace_baseinit and trace_kerns
    -- check out this sharedkerns trickery
    for i=1,#lookuplist do
        local sequence = lookuplist[i]
        local steps    = sequence.steps
        local kind     = sequence.type
        local format   = sequence.format
        if kind == "gpos_pair" then
            for i=1,#steps do
                local step   = steps[i]
                local format = step.format
                if format == "kern" or format == "move" then
                    for unicode, data in next, steps[i].coverage do
                        local character = characters[unicode]
                        local kerns = character.kerns
                        if not kerns then
                            kerns = { }
                            character.kerns = kerns
                        end
                        if traceindeed then
                            for otherunicode, kern in next, data do
                                if not kerns[otherunicode] and kern ~= 0 then
                                    kerns[otherunicode] = kern
                                    report_kern(feature,sequence,descriptions,unicode,otherunicode,kern)
                                end
                            end
                        else
                            for otherunicode, kern in next, data do
                                if not kerns[otherunicode] and kern ~= 0 then
                                    kerns[otherunicode] = kern
                                end
                            end
                        end
                    end
                else
                    for unicode, data in next, steps[i].coverage do
                        local character = characters[unicode]
                        local kerns     = character.kerns
                        for otherunicode, kern in next, data do
                            -- kern[2] is true (all zero) or a table
                            local other = kern[2]
                            if other == true or (not other and not (kerns and kerns[otherunicode])) then
                                local kern = kern[1]
                                if kern == true then
                                    -- all zero
                                elseif kern[1] ~= 0 or kern[2] ~= 0 or kern[4] ~= 0 then
                                    -- a complex pair not suitable for basemode
                                else
                                    kern = kern[3]
                                    if kern ~= 0 then
                                        if kerns then
                                            kerns[otherunicode] = kern
                                        else
                                            kerns = { [otherunicode] = kern }
                                            character.kerns = kerns
                                        end
                                        if traceindeed then
                                            report_kern(feature,sequence,descriptions,unicode,otherunicode,kern)
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end

end

local function initializehashes(tfmdata)
    -- already done
end

local function checkmathreplacements(tfmdata,fullname,fixitalics)
    if tfmdata.mathparameters then
        local characters = tfmdata.characters
        local changed    = tfmdata.changed
        if next(changed) then
            if trace_preparing or trace_baseinit then
                report_prepare("checking math replacements for %a",fullname)
            end
            for unicode, replacement in next, changed do
                local u = characters[unicode]
                local r = characters[replacement]
                if u and r then
                    local n = u.next
                    local v = u.vert_variants
                    local h = u.horiz_variants
                    if fixitalics then
                        -- quite some warnings on stix ...
                        local ui = u.italic
                        if ui and not r.italic then
                            if trace_preparing then
                                report_prepare("using %i units of italic correction from %C for %U",ui,unicode,replacement)
                            end
                            r.italic = ui -- print(ui,ri)
                        end
                    end
                    if n and not r.next then
                        if trace_preparing then
                            report_prepare("forcing %s for %C substituted by %U","incremental step",unicode,replacement)
                        end
                        r.next = n
                    end
                    if v and not r.vert_variants then
                        if trace_preparing then
                            report_prepare("forcing %s for %C substituted by %U","vertical variants",unicode,replacement)
                        end
                        r.vert_variants = v
                    end
                    if h and not r.horiz_variants then
                        if trace_preparing then
                            report_prepare("forcing %s for %C substituted by %U","horizontal variants",unicode,replacement)
                        end
                        r.horiz_variants = h
                    end
                else
                    if trace_preparing then
                        report_prepare("error replacing %C by %U",unicode,replacement)
                    end
                end
            end
        end
    end
end

local function featuresinitializer(tfmdata,value)
    if true then -- value then
        local starttime = trace_preparing and os.clock()
        local features  = tfmdata.shared.features
        local fullname  = tfmdata.properties.fullname or "?"
        if features then
            initializehashes(tfmdata)
            local collectlookups    = otf.collectlookups
            local rawdata           = tfmdata.shared.rawdata
            local properties        = tfmdata.properties
            local script            = properties.script
            local language          = properties.language
            local rawresources      = rawdata.resources
            local rawfeatures       = rawresources and rawresources.features
            local basesubstitutions = rawfeatures and rawfeatures.gsub
            local basepositionings  = rawfeatures and rawfeatures.gpos
            local substitutionsdone = false
            local positioningsdone  = false
            --
            if basesubstitutions or basepositionings then
                local sequences = tfmdata.resources.sequences
                for s=1,#sequences do
                    local sequence = sequences[s]
                    local sfeatures = sequence.features
                    if sfeatures then
                        local order = sequence.order
                        if order then
                            for i=1,#order do --
                                local feature = order[i]
                                local value = features[feature]
                                if value then
                                    local validlookups, lookuplist = collectlookups(rawdata,feature,script,language)
-- if not validlookups and not lookuplist and script == "math" then
--     validlookups, lookuplist = collectlookups(rawdata,feature,"dflt","dflt")
-- end
                                    if not validlookups then
                                        -- skip
                                    elseif basesubstitutions and basesubstitutions[feature] then
                                        if trace_preparing then
                                            report_prepare("filtering base %s feature %a for %a with value %a","sub",feature,fullname,value)
                                        end
                                        preparesubstitutions(tfmdata,feature,value,validlookups,lookuplist)
                                        registerbasefeature(feature,value)
                                        substitutionsdone = true
                                    elseif basepositionings and basepositionings[feature] then
                                        if trace_preparing then
                                            report_prepare("filtering base %a feature %a for %a with value %a","pos",feature,fullname,value)
                                        end
                                        preparepositionings(tfmdata,feature,value,validlookups,lookuplist)
                                        registerbasefeature(feature,value)
                                        positioningsdone = true
                                    end
                                end
                            end
                        end
                    end
                end
            end
            --
            if substitutionsdone then
                checkmathreplacements(tfmdata,fullname,features.fixitalics)
            end
            --
            registerbasehash(tfmdata)
        end
        if trace_preparing then
            report_prepare("preparation time is %0.3f seconds for %a",os.clock()-starttime,fullname)
        end
    end
end

registerotffeature {
    name         = "features",
    description  = "features",
    default      = true,
    initializers = {
     -- position = 1, -- after setscript (temp hack ... we need to force script / language to 1
        base     = featuresinitializer,
    }
}

otf.basemodeinitializer = featuresinitializer