node-tsk.lua /size: 16 Kb    last modification: 2021-10-28 13:50
1
if
not
modules
then
modules
=
{
}
end
modules
[
'
node-tsk
'
]
=
{
2
version
=
1
.
001
,
3
comment
=
"
companion to node-ini.mkiv
"
,
4
author
=
"
Hans Hagen, PRAGMA-ADE, Hasselt NL
"
,
5
copyright
=
"
PRAGMA ADE / ConTeXt Development Team
"
,
6
license
=
"
see context related readme files
"
7
}
8 9
-- This might move to task-* and become less code as in sequencers
10
-- we already have dirty flags as well. On the other hand, nodes are
11
-- rather specialized and here we focus on node related tasks.
12 13
local
format
=
string
.
format
14 15
local
trace_tasks
=
false
trackers
.
register
(
"
tasks.creation
"
,
function
(
v
)
trace_tasks
=
v
end
)
16 17
local
report_tasks
=
logs
.
reporter
(
"
tasks
"
)
18 19
local
allocate
=
utilities
.
storage
.
allocate
20 21
local
context
=
context
22
local
nodes
=
nodes
23 24
local
tasks
=
nodes
.
tasks
or
{
}
25
nodes
.
tasks
=
tasks
26 27
local
tasksdata
=
{
}
-- no longer public
28 29
local
sequencers
=
utilities
.
sequencers
30
local
compile
=
sequencers
.
compile
31
local
nodeprocessor
=
sequencers
.
nodeprocessor
32 33
local
newsequencer
=
sequencers
.
new
34 35
local
appendgroup
=
sequencers
.
appendgroup
36
----- prependgroup = sequencers.prependgroup
37
----- replacegroup = sequencers.replacegroup
38
local
enablegroup
=
sequencers
.
enablegroup
39
local
disablegroup
=
sequencers
.
disablegroup
40 41
local
appendaction
=
sequencers
.
appendaction
42
local
prependaction
=
sequencers
.
prependaction
43
local
replaceaction
=
sequencers
.
replaceaction
44
local
enableaction
=
sequencers
.
enableaction
45
local
disableaction
=
sequencers
.
disableaction
46 47
local
frozengroups
=
"
no
"
48 49
function
tasks
.
freeze
(
kind
)
50
frozengroups
=
kind
or
"
tolerant
"
-- todo: hook into jobname
51
end
52 53
function
tasks
.
new
(
specification
)
-- was: name,arguments,list
54
local
name
=
specification
.
name
55
local
sequence
=
specification
.
sequence
56
if
name
and
sequence
then
57
local
tasklist
=
newsequencer
{
58
name
=
name
59
-- we can move more to the sequencer now .. todo
60
}
61
tasksdata
[
name
]
=
{
62
name
=
name
,
63
list
=
tasklist
,
64
runner
=
false
,
65
frozen
=
{
}
,
66
processor
=
specification
.
processor
or
nodeprocessor
,
67
-- could be metatable but best freeze it
68
arguments
=
specification
.
arguments
or
0
,
69
templates
=
specification
.
templates
,
70
}
71
for
l
=
1
,
#
sequence
do
72
appendgroup
(
tasklist
,
sequence
[
l
]
)
73
end
74
end
75
end
76 77
local
function
valid
(
name
)
78
local
data
=
tasksdata
[
name
]
79
if
not
data
then
80
report_tasks
(
"
unknown task %a
"
,
name
)
81
else
82
return
data
83
end
84
end
85 86
local
function
validgroup
(
name
,
group
,
what
)
87
local
data
=
tasksdata
[
name
]
88
if
not
data
then
89
report_tasks
(
"
unknown task %a
"
,
name
)
90
else
91
local
frozen
=
data
.
frozen
[
group
]
92
if
frozen
then
93
if
frozengroup
=
=
"
no
"
then
94
-- default
95
elseif
frozengroup
=
=
"
strict
"
then
96
report_tasks
(
"
warning: group %a of task %a is frozen, %a applied but not supported
"
,
group
,
name
,
what
)
97
return
98
else
-- if frozengroup == "tolerant" then
99
report_tasks
(
"
warning: group %a of task %a is frozen, %a ignored
"
,
group
,
name
,
what
)
100
end
101
end
102
return
data
103
end
104
end
105 106
function
tasks
.
freezegroup
(
name
,
group
)
107
local
data
=
valid
(
name
)
108
if
data
then
109
data
.
frozen
[
group
]
=
true
110
end
111
end
112 113
function
tasks
.
restart
(
name
)
114
local
data
=
valid
(
name
)
115
if
data
then
116
data
.
runner
=
false
117
end
118
end
119 120
function
tasks
.
enableaction
(
name
,
action
)
121
local
data
=
valid
(
name
)
122
if
data
then
123
enableaction
(
data
.
list
,
action
)
124
data
.
runner
=
false
125
end
126
end
127 128
function
tasks
.
disableaction
(
name
,
action
)
129
local
data
=
valid
(
name
)
130
if
data
then
131
disableaction
(
data
.
list
,
action
)
132
data
.
runner
=
false
133
end
134
end
135 136
function
tasks
.
replaceaction
(
name
,
group
,
oldaction
,
newaction
)
137
local
data
=
valid
(
name
)
138
if
data
then
139
replaceaction
(
data
.
list
,
group
,
oldaction
,
newaction
)
140
data
.
runner
=
false
141
end
142
end
143 144
do
145 146
local
enableaction
=
tasks
.
enableaction
147
local
disableaction
=
tasks
.
disableaction
148 149
function
tasks
.
setaction
(
name
,
action
,
value
)
150
if
value
then
151
enableaction
(
name
,
action
)
152
else
153
disableaction
(
name
,
action
)
154
end
155
end
156 157
end
158 159
function
tasks
.
enablegroup
(
name
,
group
)
160
local
data
=
validgroup
(
name
,
"
enable group
"
)
161
if
data
then
162
enablegroup
(
data
.
list
,
group
)
163
data
.
runner
=
false
164
end
165
end
166 167
function
tasks
.
disablegroup
(
name
,
group
)
168
local
data
=
validgroup
(
name
,
"
disable group
"
)
169
if
data
then
170
disablegroup
(
data
.
list
,
group
)
171
data
.
runner
=
false
172
end
173
end
174 175
function
tasks
.
appendaction
(
name
,
group
,
action
,
where
,
kind
,
state
)
176
local
data
=
validgroup
(
name
,
"
append action
"
)
177
if
data
then
178
local
list
=
data
.
list
179
appendaction
(
list
,
group
,
action
,
where
,
kind
)
180
if
state
=
=
"
disabled
"
or
(
state
=
=
"
production
"
and
environment
.
initex
)
then
181
disableaction
(
list
,
action
)
182
end
183
data
.
runner
=
false
184
end
185
end
186 187
function
tasks
.
prependaction
(
name
,
group
,
action
,
where
,
kind
,
state
)
188
local
data
=
validgroup
(
name
,
"
prepend action
"
)
189
if
data
then
190
local
list
=
data
.
list
191
prependaction
(
list
,
group
,
action
,
where
,
kind
)
192
if
state
=
=
"
disabled
"
or
(
state
=
=
"
production
"
and
environment
.
initex
)
then
193
disableaction
(
list
,
action
)
194
end
195
data
.
runner
=
false
196
end
197
end
198 199
function
tasks
.
removeaction
(
name
,
group
,
action
)
200
local
data
=
validgroup
(
name
,
"
remove action
"
)
201
if
data
then
202
removeaction
(
data
.
list
,
group
,
action
)
203
data
.
runner
=
false
204
end
205
end
206 207
function
tasks
.
showactions
(
name
,
group
,
action
,
where
,
kind
)
208
local
data
=
valid
(
name
)
209
if
data
then
210
report_tasks
(
"
task %a, list:\n%s
"
,
name
,
nodeprocessor
(
data
.
list
)
)
211
end
212
end
213 214
-- Optimizing for the number of arguments makes sense, but getting rid of
215
-- the nested call (no problem but then we also need to register the
216
-- callback with this mechanism so that it gets updated) does not save
217
-- much time (24K calls on mk.tex).
218 219
local
created
,
total
=
0
,
0
220 221
statistics
.
register
(
"
node list callback tasks
"
,
function
(
)
222
if
total
>
0
then
223
return
format
(
"
%s unique task lists, %s instances (re)created, %s calls
"
,
table
.
count
(
tasksdata
)
,
created
,
total
)
224
else
225
return
nil
226
end
227
end
)
228 229
local
function
create
(
data
,
t
)
230
created
=
created
+
1
231
local
runner
=
compile
(
data
.
list
,
data
.
processor
,
t
)
232
if
trace_tasks
then
233
report_tasks
(
"
creating runner %a, %i actions enabled
"
,
t
.
name
,
data
.
list
.
steps
or
0
)
234
end
235
data
.
runner
=
runner
236
return
runner
237
end
238 239
function
tasks
.
actions
(
name
)
240
local
data
=
tasksdata
[
name
]
241
if
data
then
242
local
t
=
data
.
templates
243
if
t
then
244
t
.
name
=
data
.
name
245
return
function
(
...
)
246
total
=
total
+
1
247
return
(
data
.
runner
or
create
(
data
,
t
)
)
(
...
)
248
end
249
end
250
end
251
return
nil
252
end
253 254
function
tasks
.
table
(
name
)
--maybe move this to task-deb.lua
255
local
tsk
=
tasksdata
[
name
]
256
local
lst
=
tsk
and
tsk
.
list
257
local
HL
,
NC
,
NR
,
bold
,
type
=
context
.
HL
,
context
.
NC
,
context
.
NR
,
context
.
bold
,
context
.
type
258
if
lst
then
259
local
list
,
order
=
lst
.
list
,
lst
.
order
260
if
list
and
order
then
261
context
.
starttabulate
{
"
|l|l|
"
}
262
NC
(
)
bold
(
"
category
"
)
NC
(
)
bold
(
"
function
"
)
NC
(
)
NR
(
)
263
for
i
=
1
,
#
order
do
264
HL
(
)
265
local
o
=
order
[
i
]
266
local
l
=
list
[
o
]
267
if
#
l
=
=
0
then
268
NC
(
)
type
(
o
)
NC
(
)
context
(
"
unset
"
)
NC
(
)
NR
(
)
269
else
270
local
done
=
false
271
for
k
,
v
in
table
.
sortedhash
(
l
)
do
272
NC
(
)
if
not
done
then
type
(
o
)
done
=
true
end
NC
(
)
type
(
v
)
NC
(
)
NR
(
)
273
end
274
end
275
end
276
context
.
stoptabulate
(
)
277
end
278
end
279
end
280 281
-- -- shipouts everypar -- --
282 283
-- the shipout handlers acts on boxes so we don't need to return something
284
-- and also don't need to keep the state (done)
285 286
local
templates
=
{
287 288
default
=
[[
289return function(head) 290 return head 291end 292
]]
,
293 294
process
=
[[
295local tonut = nodes.tonut 296local tonode = nodes.nuts.tonode 297 298%localize% 299 300return function(head) 301 local nuthead = tonut(head) 302 303%actions% 304 return tonode(nuthead) 305end 306
]]
,
307 308
step
=
[[
309 nuthead = tonut((%action%(tonode(nuthead)))) 310
]]
,
311 312
nut
=
[[
313 nuthead = %action%(nuthead) 314
]]
,
315 316
nohead
=
[[
317 %action%(tonode(nuthead)) 318
]]
,
319 320
nonut
=
[[
321 %action%(nuthead) 322
]]
,
323 324
}
325 326
tasks
.
new
{
327
name
=
"
shipouts
"
,
328
processor
=
nodeprocessor
,
329
sequence
=
{
330
"
before
"
,
-- users
331
"
normalizers
"
,
-- system
332
"
finishers
"
,
-- system
333
"
after
"
,
-- users
334
"
wrapup
"
,
-- system
335
}
,
336
templates
=
templates
337
}
338 339
tasks
.
new
{
340
name
=
"
everypar
"
,
341
processor
=
nodeprocessor
,
342
sequence
=
{
343
"
before
"
,
-- users
344
"
normalizers
"
,
-- system
345
"
after
"
,
-- users
346
}
,
347
templates
=
templates
,
348
}
349 350
-- -- finalizers -- --
351 352
tasks
.
new
{
353
name
=
"
finalizers
"
,
354
sequence
=
{
355
"
before
"
,
-- for users
356
"
normalizers
"
,
357
"
fonts
"
,
358
"
lists
"
,
359
"
after
"
,
-- for users
360
}
,
361
processor
=
nodeprocessor
,
362
templates
=
{
363 364
default
=
[[
365return function(head) 366 return head 367end 368
]]
,
369 370
process
=
[[
371local tonut = nodes.tonut 372local tonode = nodes.nuts.tonode 373 374%localize% 375 376return function(head,groupcode) 377 local nuthead = tonut(head) 378 379%actions% 380 return tonode(nuthead) 381end 382
]]
,
383 384
step
=
[[
385 nuthead = tonut((%action%(tonode(nuthead),groupcode))) 386
]]
,
387 388
nut
=
[[
389 nuthead = %action%(nuthead,groupcode) 390
]]
,
391 392
nohead
=
[[
393 %action%(tonode(nuthead),groupcode) 394
]]
,
395 396
nonut
=
[[
397 %action%(nuthead,groupcode) 398
]]
,
399 400
}
401
}
402 403
-- -- processors -- --
404 405
tasks
.
new
{
406
name
=
"
processors
"
,
407
processor
=
nodeprocessor
,
408
sequence
=
{
409
"
before
"
,
-- for users
410
"
normalizers
"
,
411
"
characters
"
,
412
"
words
"
,
413
"
fonts
"
,
414
"
lists
"
,
415
"
after
"
,
-- for users
416
}
,
417
templates
=
{
418 419
default
=
[[
420return function(head) 421 return head 422end 423
]]
,
424 425
process
=
[[
426local tonut = nodes.tonut 427local tonode = nodes.nuts.tonode 428 429%localize% 430 431return function(head,groupcode,size,packtype,direction,attributes) 432 local nuthead = tonut(head) 433 434%actions% 435 return tonode(nuthead) 436end 437
]]
,
438 439
step
=
[[
440 nuthead = tonut((%action%(tonode(nuthead),groupcode,size,packtype,direction,attributes))) 441
]]
,
442 443
nut
=
[[
444 nuthead = %action%(nuthead,groupcode,size,packtype,direction,attributes) 445
]]
,
446 447
nohead
=
[[
448 %action%(tonode(nuthead),groupcode,size,packtype,direction,attributes) 449
]]
,
450 451
nonut
=
[[
452 %action%(nuthead,groupcode,size,packtype,direction,attributes) 453
]]
,
454 455
}
456
}
457 458
tasks
.
new
{
459
name
=
"
finalizers
"
,
460
processor
=
nodeprocessor
,
461
sequence
=
{
462
"
before
"
,
-- for users
463
"
normalizers
"
,
464
"
fonts
"
,
465
"
lists
"
,
466
"
after
"
,
-- for users
467
}
,
468
templates
=
{
469 470
default
=
[[
471return function(head) 472 return head 473end 474
]]
,
475 476
process
=
[[
477local tonut = nodes.tonut 478local tonode = nodes.nuts.tonode 479 480%localize% 481 482return function(head) 483 local nuthead = tonut(head) 484 485%actions% 486 return tonode(nuthead) 487end 488
]]
,
489 490
step
=
[[
491 nuthead = tonut((%action%(tonode(nuthead)))) 492
]]
,
493 494
nut
=
[[
495 nuthead = %action%(nuthead) 496
]]
,
497 498
nohead
=
[[
499 %action%(tonode(nuthead)) 500
]]
,
501 502
nonut
=
[[
503 %action%(nuthead) 504
]]
,
505 506
}
507
}
508 509
tasks
.
new
{
510
name
=
"
mvlbuilders
"
,
511
processor
=
nodeprocessor
,
512
sequence
=
{
513
"
before
"
,
-- for users
514
"
normalizers
"
,
515
"
after
"
,
-- for users
516
}
,
517
templates
=
{
518 519
default
=
[[
520return function(head) 521 return head 522end 523
]]
,
524 525
process
=
[[
526local tonut = nodes.tonut 527local tonode = nodes.nuts.tonode 528 529%localize% 530 531return function(head,groupcode) 532 local nuthead = tonut(head) 533 534%actions% 535 return tonode(nuthead) 536end 537
]]
,
538 539
step
=
[[
540 nuthead = tonut((%action%(tonode(nuthead),groupcode))) 541
]]
,
542 543
nut
=
[[
544 nuthead = %action%(nuthead,groupcode) 545
]]
,
546 547
nohead
=
[[
548 %action%(tonode(nuthead),groupcode) 549
]]
,
550 551
nonut
=
[[
552 %action%(nuthead,groupcode) 553
]]
,
554 555
}
556
}
557 558
tasks
.
new
{
559
name
=
"
vboxbuilders
"
,
560
processor
=
nodeprocessor
,
561
sequence
=
{
562
"
before
"
,
-- for users
563
"
normalizers
"
,
564
"
after
"
,
-- for users
565
}
,
566
templates
=
{
567 568
default
=
[[
569return function(head) 570 return head 571end 572
]]
,
573 574
process
=
[[
575local tonut = nodes.tonut 576local tonode = nodes.nuts.tonode 577 578%localize% 579 580return function(head,groupcode,size,packtype,maxdepth,direction) 581 local nuthead = tonut(head) 582 583%actions% 584 return tonode(nuthead) 585end 586
]]
,
587 588
step
=
[[
589 nuthead = tonut((%action%(tonode(nuthead),groupcode,size,packtype,maxdepth,direction))) 590
]]
,
591 592
nut
=
[[
593 nuthead = %action%(nuthead,groupcode,size,packtype,maxdepth,direction) 594
]]
,
595 596
nohead
=
[[
597 %action%(tonode(nuthead),groupcode,size,packtype,maxdepth,direction) 598
]]
,
599 600
nonut
=
[[
601 %action%(nuthead,groupcode,size,packtype,maxdepth,direction) 602
]]
,
603 604
}
605 606
}
607 608
tasks
.
new
{
609
name
=
"
contributers
"
,
610
processor
=
nodeprocessor
,
611
sequence
=
{
612
"
before
"
,
-- for users
613
"
normalizers
"
,
614
"
after
"
,
-- for users
615
}
,
616
templates
=
{
617 618
default
=
[[
619return function(head) 620 return head 621end 622
]]
,
623 624
process
=
[[
625local tonut = nodes.tonut 626local tonode = nodes.nuts.tonode 627 628%localize% 629 630-- we operate exclusively on nuts 631 632return function(nuthead,groupcode,nutline) 633%actions% 634 return nuthead 635end 636
]]
,
637 638
step
=
[[
639 nuthead = tonut((%action%(tonode(nuthead),groupcode,line))) 640
]]
,
641 642
nut
=
[[
643 nuthead = %action%(nuthead,groupcode,nutline) 644
]]
,
645 646
nohead
=
[[
647 %action%(tonode(nuthead),groupcode,line) 648
]]
,
649 650
nonut
=
[[
651 %action%(nuthead,groupcode,nutline) 652
]]
,
653 654
}
655
}
656 657
-- -- math -- --
658 659
tasks
.
new
{
660
name
=
"
math
"
,
661
processor
=
nodeprocessor
,
662
sequence
=
{
663
"
before
"
,
664
"
normalizers
"
,
665
"
builders
"
,
666
"
finalizers
"
,
667
"
after
"
,
668
}
,
669
templates
=
{
670 671
default
=
[[
672return function(head) 673 return head 674end 675
]]
,
676 677
process
=
[[
678local tonut = nodes.tonut 679local tonode = nodes.nuts.tonode 680 681%localize% 682 683return function(head,style,penalties) 684 local nuthead = tonut(head) 685 686%actions% 687 return tonode(nuthead) 688end 689
]]
,
690 691
step
=
[[
692 nuthead = tonut((%action%(tonode(nuthead),style,penalties))) 693
]]
,
694 695
nut
=
[[
696 nuthead = %action%(nuthead,style,penalties) 697
]]
,
698 699
nohead
=
[[
700 %action%(tonode(nuthead),style,penalties) 701
]]
,
702 703
nonut
=
[[
704 %action%(nuthead,style,penalties) 705
]]
,
706 707
}
708
}
709 710
-- tasks.new {
711
-- name = "parbuilders",
712
-- arguments = 1,
713
-- processor = nodeprocessor,
714
-- sequence = {
715
-- "before", -- for users
716
-- "lists",
717
-- "after", -- for users
718
-- }
719
-- }
720 721
-- tasks.new {
722
-- name = "pagebuilders",
723
-- arguments = 5,
724
-- processor = nodeprocessor,
725
-- sequence = {
726
-- "before", -- for users
727
-- "lists",
728
-- "after", -- for users
729
-- }
730
-- }
731 732
-- for now quite useless (too fuzzy)
733
--
734
-- tasks.new {
735
-- name = "listbuilders",
736
-- processor = nodeprocessor,
737
-- sequence = {
738
-- "before", -- for users
739
-- "normalizers",
740
-- "after", -- for users
741
-- },
742
-- templates = {
743
-- -- we don't need a default
744
-- default = [[
745
-- return function(box,location,prevdepth)
746
-- return box, prevdepth
747
-- end
748
-- ]],
749
-- process = [[
750
-- %localize%
751
-- return function(box,location,prevdepth,mirrored)
752
-- %actions%
753
-- return box, prevdepth
754
-- end
755
-- ]],
756
-- step = [[
757
-- box, prevdepth = %action%(box,location,prevdepth,mirrored)
758
-- ]],
759
-- },
760
-- }
761 762
-- -- math -- --
763 764
-- not really a node processor
765 766
-- tasks.new {
767
-- name = "newpar",
768
-- processor = nodeprocessor,
769
-- sequence = {
770
-- "before",
771
-- "normalizers",
772
-- "after",
773
-- },
774
-- templates = {
775
--
776
-- default = [[
777
-- return function(mode,indent)
778
-- return indent
779
-- end
780
-- ]],
781
--
782
-- process = [[
783
-- %localize%
784
--
785
-- return function(mode,indent)
786
--
787
-- %actions%
788
-- return indent
789
-- end
790
-- ]],
791
--
792
-- step = [[
793
-- indent = %action%(mode,indent)
794
-- ]],
795
--
796
-- }
797
-- }
798