summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/context/base/node-fin.lua
blob: 5c1cc9ad57afdcc30bba02e7b3e6ea6090a05da5 (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
if not modules then modules = { } end modules ['node-fin'] = {
    version   = 1.001,
    comment   = "companion to node-fin.mkiv",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files"
}

-- this module is being reconstructed

local next, type, format = next, type, string.format

local attributes, nodes, node = attributes, nodes, node

local has_attribute   = node.has_attribute
local copy_node       = node.copy

local nodecodes       = nodes.nodecodes
local whatcodes       = nodes.whatcodes

local glyph_code      = nodecodes.glyph
local disc_code       = nodecodes.disc
local glue_code       = nodecodes.glue
local rule_code       = nodecodes.rule
local whatsit_code    = nodecodes.whatsit
local hlist_code      = nodecodes.hlist
local vlist_code      = nodecodes.vlist

local pdfliteral_code = whatcodes.pdfliteral

local states     = attributes.states
local numbers    = attributes.numbers
local trigger    = attributes.private('trigger')
local triggering = false

local starttiming = statistics.starttiming
local stoptiming  = statistics.stoptiming

-- these two will be like trackers

function states.enabletriggering()
    triggering = true
end
function states.disabletriggering()
    triggering = false
end

-- the following code is no longer needed due to the new backend
-- but we keep it around for a while as an example
--
-- states.collected = states.collected or { }
--
-- storage.register("states/collected", states.collected, "states.collected")
--
-- local collected = states.collected
--
-- function states.collect(str)
--     collected[#collected+1] = str
-- end
--
-- function states.flush()
--     if #collected > 0 then
--         for i=1,#collected do
--             context(collected[i]) -- we're in context mode anyway
--         end
--         collected = { }
--         states.collected = collected
--     end
-- end
--
-- function states.check()
--     texio.write_nl(concat(collected,"\n"))
-- end

-- we used to do the main processor loop here and call processor for each node
-- but eventually this was too much a slow down (1 sec on 23 for 120 pages mk)
-- so that we moved looping to the processor itself; this may lead to a bit of
-- duplicate code once that we have more state handlers

local function process_attribute(head,plugin) -- head,attribute,enabled,initializer,resolver,processor,finalizer
    local namespace = plugin.namespace
    if namespace.enabled ~= false then -- this test will go away
        starttiming(attributes)
        local done, used, ok = false, nil, false
        local attribute = namespace.attribute or numbers[plugin.name] -- todo: plugin.attribute
        local processor = plugin.processor
        if processor then
            local initializer = plugin.initializer
            local resolver    = plugin.resolver
            local inheritance = (resolver and resolver()) or nil -- -0x7FFFFFFF -- we can best use nil and skip !
            if initializer then
                initializer(namespace,attribute,head)
            end
            head, ok = processor(namespace,attribute,head,inheritance)
            if ok then
                local finalizer = plugin.finalizer
                if finalizer then
                    head, ok, used = finalizer(namespace,attribute,head)
                    if used then
                        local flusher = plugin.flusher
                        if flusher then
                            head = flusher(namespace,attribute,head,used)
                        end
                    end
                end
                done = true
            end
        end
        stoptiming(attributes)
        return head, done
    else
        return head, false
    end
end

-- nodes.process_attribute = process_attribute

function nodes.installattributehandler(plugin) -- we need to avoid this nested function
    return function(head)
        return process_attribute(head,plugin)
    end
end

--~ experiment (maybe local to function makes more sense)
--~
--~ plugindata = { }
--~
--~ local template = [[
--~ local plugin = plugindata["%s"]
--~ local starttiming, stoptiming = statistics.starttiming, statistics.stoptiming
--~ local namespace = plugin.namespace
--~ local attribute = namespace.attribute
--~ local processor = plugin.processor
--~ local initializer = plugin.initializer
--~ local resolver = plugin.resolver
--~ local finalizer = plugin.finalizer
--~ local flusher = plugin.flusher
--~ return function (head)
--~     if namespace.enabled then
--~         starttiming(attributes)
--~         local done, used, ok = false, nil, false
--~         if procesxsor then
--~             local inheritance = (resolver and resolver()) or nil -- -0x7FFFFFFF -- we can best use nil and skip !
--~             if initializer then
--~                 initializer(namespace,attribute,head)
--~             end
--~             head, ok = processor(namespace,attribute,head,inheritance)
--~             if ok then
--~                 if finalizer then
--~                     head, ok, used = finalizer(namespace,attribute,head)
--~                     if used and flusher then
--~                         head = flusher(namespace,attribute,head,used)
--~                     end
--~                 end
--~                 done = true
--~             end
--~         end
--~         stoptiming(attributes)
--~         return head, done
--~     else
--~         return head, false
--~     end
--~ end
--~ ]]
--~
--~ function nodes.installattributehandler(plugin) -- we need to avoid this nested function
--~     plugindata[plugin.name] = plugin
--~     local str = format(template,plugin.name)
--~     return loadstring(str)()
--~ end

-- the injectors

local insert_node_before = node.insert_before
local insert_node_after  = node.insert_after

local nsdata, nsnone, nslistwise, nsforced, nsselector, nstrigger
local current, current_selector, done = 0, 0, false -- nb, stack has a local current !

function states.initialize(namespace,attribute,head)
    nsdata           = namespace.data
    nsnone           = namespace.none
    nsforced         = namespace.forced
    nsselector       = namespace.selector
    nslistwise       = namespace.listwise
    nstrigger        = triggering and namespace.triggering and trigger
    current          = 0
    current_selector = 0
    done             = false -- todo: done cleanup
end

function states.finalize(namespace,attribute,head) -- is this one ok?
    if current > 0 and nsnone then
        local id = head.id
        if id == hlist_code or id == vlist_code then
            local list = head.list
            if list then
                head.list = insert_node_before(list,list,copy_node(nsnone))
            end
        else
            head = insert_node_before(head,head,copy_node(nsnone))
        end
        return head, true, true
    end
    return head, false, false
end

local function process(namespace,attribute,head,inheritance,default) -- one attribute
    local stack, done = head, false
    while stack do
        local id = stack.id
        -- we need to deal with literals too (reset as well as oval)
        -- if id == glyph_code or (id == whatsit_code and stack.subtype == pdfliteral_code) or (id == rule_code and stack.width ~= 0) or (id == glue_code and stack.leader) then -- or disc_code
        if id == glyph_code -- or id == disc_code
                or (id == rule_code and stack.width ~= 0) or (id == glue_code and stack.leader) then -- or disc_code
            local c = has_attribute(stack,attribute)
            if c then
                if default and c == inheritance then
                    if current ~= default then
                        head = insert_node_before(head,stack,copy_node(nsdata[default]))
                        current = default
                        done = true
                    end
                elseif current ~= c then
                    head = insert_node_before(head,stack,copy_node(nsdata[c]))
                    current = c
                    done = true
                end
                -- here ? compare selective
                if id == glue_code then --leader
                    -- same as *list
                    local content = stack.leader
                    if content then
                        local savedcurrent = current
                        local ci = content.id
                        if ci == hlist_code or ci == vlist_code then
                            -- else we reset inside a box unneeded, okay, the downside is
                            -- that we trigger color in each repeated box, so there is room
                            -- for improvement here
                            current = 0
                        end
                        local ok = false
                        if nstrigger and has_attribute(stack,nstrigger) then
                            local outer = has_attribute(stack,attribute)
                            if outer ~= inheritance then
                                stack.leader, ok = process(namespace,attribute,content,inheritance,outer)
                            else
                                stack.leader, ok = process(namespace,attribute,content,inheritance,default)
                            end
                        else
                            stack.leader, ok = process(namespace,attribute,content,inheritance,default)
                        end
                        current = savedcurrent
                        done = done or ok
                    end
                end
            elseif default and inheritance then
                if current ~= default then
                    head = insert_node_before(head,stack,copy_node(nsdata[default]))
                    current = default
                    done = true
                end
            elseif current > 0 then
                head = insert_node_before(head,stack,copy_node(nsnone))
                current = 0
                done = true
            end
        elseif id == hlist_code or id == vlist_code then
            local content = stack.list
            if content then
                local ok = false
                if nstrigger and has_attribute(stack,nstrigger) then
                    local outer = has_attribute(stack,attribute)
                    if outer ~= inheritance then
                        stack.list, ok = process(namespace,attribute,content,inheritance,outer)
                    else
                        stack.list, ok = process(namespace,attribute,content,inheritance,default)
                    end
                else
                    stack.list, ok = process(namespace,attribute,content,inheritance,default)
                end
                done = done or ok
            end
        end
        stack = stack.next
    end
    return head, done
end

states.process = process

-- we can force a selector, e.g. document wide color spaces, saves a little
-- watch out, we need to check both the selector state (like colorspace) and
-- the main state (like color), otherwise we get into troubles when a selector
-- state changes while the main state stays the same (like two glyphs following
-- each other with the same color but different color spaces e.g. \showcolor)

local function selective(namespace,attribute,head,inheritance,default) -- two attributes
    local stack, done = head, false
    while stack do
        local id = stack.id
        -- we need to deal with literals too (reset as well as oval)
        -- if id == glyph_code or (id == whatsit_code and stack.subtype == pdfliteral_code) or (id == rule_code and stack.width ~= 0) or (id == glue_code and stack.leader) then -- or disc_code
        if id == glyph_code -- or id == disc_code
                or (id == rule_code and stack.width ~= 0) or (id == glue_code and stack.leader) then -- or disc_code
            local c = has_attribute(stack,attribute)
            if c then
                if default and c == inheritance then
                    if current ~= default then
                        local data = nsdata[default]
                        head = insert_node_before(head,stack,copy_node(data[nsforced or has_attribute(stack,nsselector) or nsselector]))
                        current = default
                        done = true
                    end
                else
                    local s = has_attribute(stack,nsselector)
                    if current ~= c or current_selector ~= s then
                        local data = nsdata[c]
                        head = insert_node_before(head,stack,copy_node(data[nsforced or has_attribute(stack,nsselector) or nsselector]))
                        current = c
                        current_selector = s
                        done = true
                    end
                end
            elseif default and inheritance then
                if current ~= default then
                    local data = nsdata[default]
                    head = insert_node_before(head,stack,copy_node(data[nsforced or has_attribute(stack,nsselector) or nsselector]))
                    current = default
                    done = true
                end
            elseif current > 0 then
                head = insert_node_before(head,stack,copy_node(nsnone))
                current, current_selector, done = 0, 0, true
            end
            if id == glue_code then -- leader
                -- same as *list
                local content = stack.leader
                if content then
                    local savedcurrent = current
                    local ci = content.id
                    if ci == hlist_code or ci == vlist_code then
                        -- else we reset inside a box unneeded, okay, the downside is
                        -- that we trigger color in each repeated box, so there is room
                        -- for improvement here
                        current = 0
                    end
                    local ok = false
                    if nstrigger and has_attribute(stack,nstrigger) then
                        local outer = has_attribute(stack,attribute)
                        if outer ~= inheritance then
                            stack.leader, ok = selective(namespace,attribute,content,inheritance,outer)
                        else
                            stack.leader, ok = selective(namespace,attribute,content,inheritance,default)
                        end
                    else
                        stack.leader, ok = selective(namespace,attribute,content,inheritance,default)
                    end
                    current = savedcurrent
                    done = done or ok
                end
            end
        elseif id == hlist_code or id == vlist_code then
            local content = stack.list
            if content then
                local ok = false
                if nstrigger and has_attribute(stack,nstrigger) then
                    local outer = has_attribute(stack,attribute)
                    if outer ~= inheritance then
                        stack.list, ok = selective(namespace,attribute,content,inheritance,outer)
                    else
                        stack.list, ok = selective(namespace,attribute,content,inheritance,default)
                    end
                else
                    stack.list, ok = selective(namespace,attribute,content,inheritance,default)
                end
                done = done or ok
            end
        end
        stack = stack.next
    end
    return head, done
end

states.selective = selective

-- Ideally the next one should be merged with the previous but keeping it separate is
-- safer. We deal with two situations: efficient boxwise (layoutareas) and mixed layers
-- (as used in the stepper). In the stepper we cannot use the box branch as it involves
-- paragraph lines and then getsmixed up. A messy business (esp since we want to be
-- efficient).

local function stacked(namespace,attribute,head,default) -- no triggering, no inheritance, but list-wise
    local stack, done = head, false
    local current, depth = default or 0, 0
    while stack do
        local id = stack.id
        if id == glyph_code or (id == rule_code and stack.width ~= 0) or (id == glue_code and stack.leader) then -- or disc_code
            local c = has_attribute(stack,attribute)
            if c then
                if current ~= c then
                    head = insert_node_before(head,stack,copy_node(nsdata[c]))
                    depth = depth + 1
                    current, done = c, true
                end
                if id == glue_code then
                    local content = stack.leader
                    if content then -- unchecked
                        local ok = false
                        stack.leader, ok = stacked(namespace,attribute,content,current)
                        done = done or ok
                    end
                end
--~             elseif default then
            elseif default > 0 then
                --
            elseif current > 0 then
                head = insert_node_before(head,stack,copy_node(nsnone))
                depth = depth - 1
                current, done = 0, true
            end
        elseif id == hlist_code or id == vlist_code then
            local content = stack.list
            if content then
             -- the problem is that broken lines gets the attribute which can be a later one
                if nslistwise then
                    local c = has_attribute(stack,attribute)
                    if c and current ~= c and nslistwise[c] then -- viewerlayer
                        local p = current
                        current, done = c, true
                        head = insert_node_before(head,stack,copy_node(nsdata[c]))
                        stack.list = stacked(namespace,attribute,content,current)
                        head, stack = insert_node_after(head,stack,copy_node(nsnone))
                        current = p
                    else
                        local ok = false
                        stack.list, ok = stacked(namespace,attribute,content,current)
                        done = done or ok
                    end
                else
                    local ok = false
                    stack.list, ok = stacked(namespace,attribute,content,current)
                    done = done or ok
                end
            end
        end
        stack = stack.next
    end
    while depth > 0 do
        head = insert_node_after(head,stack,copy_node(nsnone))
        depth = depth -1
    end
    return head, done
end

states.stacked = stacked

-- -- --

statistics.register("attribute processing time", function()
    return statistics.elapsedseconds(attributes,"front- and backend")
end)