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

-- experimental -> will become builders

-- if there is demand for it, we can support multiple numbering streams
-- and use more than one attibute

local next, tonumber = next, tonumber

local trace_numbers      = false  trackers.register("lines.numbers",  function(v) trace_numbers = v end)

local report_lines       = logs.reporter("lines")

local attributes         = attributes
local nodes              = nodes
local context            = context

local implement          = interfaces.implement

nodes.lines              = nodes.lines or { }
local lines              = nodes.lines

lines.data               = lines.data or { } -- start step tag
local data               = lines.data
local last               = #data

lines.scratchbox         = lines.scratchbox or 0

storage.register("lines/data", data, "nodes.lines.data")

local variables          = interfaces.variables

local v_next             = variables.next
local v_page             = variables.page
local v_no               = variables.no

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

local hlist_code         = nodecodes.hlist
local vlist_code         = nodecodes.vlist
local whatsit_code       = nodecodes.whatsit
local glue_code          = nodecodes.glue
local glyph_code         = nodecodes.glyph
local leftskip_code      = skipcodes.leftskip
local textdir_code       = whatcodes.dir

local a_displaymath      = attributes.private('displaymath')
local a_linenumber       = attributes.private('linenumber')
local a_linereference    = attributes.private('linereference')
local a_verbatimline     = attributes.private('verbatimline')

local current_list       = { }
local cross_references   = { }
local chunksize          = 250 -- not used in boxed

local nuts               = nodes.nuts

local getid              = nuts.getid
local getsubtype         = nuts.getsubtype
local getnext            = nuts.getnext
local getattr            = nuts.getattr
local getlist            = nuts.getlist
local getbox             = nuts.getbox
local getfield           = nuts.getfield

local setfield           = nuts.setfield

local traverse_id        = nuts.traverse_id
local traverse           = nuts.traverse
local copy_node          = nuts.copy
local hpack_node         = nuts.hpack
local insert_node_after  = nuts.insert_after
local insert_node_before = nuts.insert_before
local is_display_math    = nuts.is_display_math
local leftmarginwidth    = nuts.leftmarginwidth

local negated_glue       = nuts.pool.negatedglue
local new_hlist          = nuts.pool.hlist

local ctx_convertnumber  = context.convertnumber
local ctx_makelinenumber = context.makelinenumber

-- cross referencing

function lines.number(n)
    n = tonumber(n)
    local cr = cross_references[n] or 0
    cross_references[n] = nil
    return cr
end

local function resolve(n,m) -- we can now check the 'line' flag (todo)
    while n do
        local id = getid(n)
        if id == whatsit_code then -- why whatsit
            local a = getattr(n,a_linereference)
            if a then
                cross_references[a] = m
            end
        elseif id == hlist_code or id == vlist_code then
            resolve(getlist(n),m)
        end
        n = getnext(n)
    end
end

function lines.finalize(t)
    local getnumber = lines.number
    for _,p in next, t do
        for _,r in next, p do
            local m = r.metadata
            if m and m.kind == "line" then
                local e = r.entries
                local u = r.userdata
                e.linenumber = getnumber(e.text or 0) -- we can nil e.text
                e.conversion = u and u.conversion
                r.userdata = nil -- hack
            end
        end
    end
end

local filters = structures.references.filters
local helpers = structures.helpers

structures.references.registerfinalizer(lines.finalize)

filters.line = filters.line or { }

function filters.line.default(data)
--  helpers.title(data.entries.linenumber or "?",data.metadata)
    ctx_convertnumber(data.entries.conversion or "numbers",data.entries.linenumber or "0")
end

function filters.line.page(data,prefixspec,pagespec) -- redundant
    helpers.prefixpage(data,prefixspec,pagespec)
end

function filters.line.linenumber(data) -- raw
    context(data.entries.linenumber or "0")
end

-- boxed variant, todo: use number mechanism

lines.boxed = { }
local boxed = lines.boxed

-- todo: cache setups, and free id no longer used
-- use interfaces.cachesetup(t)

function boxed.register(configuration)
    last = last + 1
    data[last] = configuration
    if trace_numbers then
        report_lines("registering setup %a",last)
    end
    return last
end

implement {
    name      = "registerlinenumbering",
    actions   = { boxed.register, context },
    arguments = {
        {
            { "continue" },
            { "start", "integer" },
            { "step", "integer" },
            { "method" },
            { "tag" },
        }
    }
}

function boxed.setup(n,configuration)
    local d = data[n]
    if d then
        if trace_numbers then
            report_lines("updating setup %a",n)
        end
        for k,v in next, configuration do
            d[k] = v
        end
    else
        if trace_numbers then
            report_lines("registering setup %a (br)",n)
        end
        data[n] = configuration
    end
    return n
end

implement {
    name      = "setuplinenumbering",
    actions   = boxed.setup,
    arguments = {
        "integer",
        {
            { "continue" },
            { "start", "integer" },
            { "step", "integer" },
            { "method" },
            { "tag" },
        }
    }
}

local function check_number(n,a,skip,sameline)
    local d = data[a]
    if d then
        local tag, skipflag, s = d.tag or "", 0, d.start or 1
        current_list[#current_list+1] = { n, s }
        if sameline then
            skipflag = 0
            if trace_numbers then
                report_lines("skipping broken line number %s for setup %a: %s (%s)",#current_list,a,s,d.continue or v_no)
            end
        elseif not skip and s % d.step == 0 then
            skipflag, d.start = 1, s + 1 -- (d.step or 1)
            if trace_numbers then
                report_lines("making number %s for setup %a: %s (%s)",#current_list,a,s,d.continue or v_no)
            end
        else
            skipflag, d.start = 0, s + 1 -- (d.step or 1)
            if trace_numbers then
                report_lines("skipping line number %s for setup %a: %s (%s)",#current_list,a,s,d.continue or v_no)
            end
        end
        ctx_makelinenumber(tag,skipflag,s,getfield(n,"shift"),getfield(n,"width"),leftmarginwidth(getlist(n)),getfield(n,"dir"))
    end
end

-- xlist
--   xlist
--     hlist

local function identify(list)
    if list then
        for n in traverse_id(hlist_code,list) do
            local a = getattr(n,a_linenumber)
            if a then
                return list, a
            end
        end
        local n = list
        while n do
            local id = getid(n)
            if id == hlist_code or id == vlist_code then
                local ok, a = identify(getlist(n))
                if ok then
                    return ok, a
                end
            end
            n = getnext(n)
        end
    end
end

function boxed.stage_zero(n)
    return identify(getlist(getbox(n)))
end

-- reset ranges per page
-- store first and last per page
-- maybe just set marks directly

function boxed.stage_one(n,nested)
    current_list = { }
    local box = getbox(n)
    if box then
        local found = nil
        local list  = getlist(box)
        if list and nested then
            list, found = identify(list)
        end
        if list then
            local last_a, last_v, skip = nil, -1, false
            for n in traverse_id(hlist_code,list) do -- attr test here and quit as soon as zero found
                if getfield(n,"height") == 0 and getfield(n,"depth") == 0 then
                    -- skip funny hlists -- todo: check line subtype
                else
                    local list = getlist(n)
                    local a = getattr(list,a_linenumber)
                    if not a or a == 0 then
                        local n = getnext(list)
                        while n do
                            local id = getid(n)
                            if id == whatsit_code and getsubtype(n) == textdir_code then
                                n = getnext(n)
                            elseif id == glue_code and getsubtype(n) == leftskip_code then
                                n = getnext(n)
                            else
if id == glyph_code then
                                break
else
    -- can be hlist or skip (e.g. footnote line)
    n = getnext(n)
end
                            end
                        end
                        a = n and getattr(n,a_linenumber)
                    end
                    if a and a > 0 then
                        if last_a ~= a then
                            local da = data[a]
                            local ma = da.method
                            if ma == v_next then
                                skip = true
                            elseif ma == v_page then
                                da.start = 1 -- eventually we will have a normal counter
                            end
                            last_a = a
                            if trace_numbers then
                                report_lines("starting line number range %s: start %s, continue %s",a,da.start,da.continue or v_no)
                            end
                        end
                        if getattr(n,a_displaymath) then
                            if is_display_math(n) then
                                check_number(n,a,skip)
                            end
                        else
                            local v = getattr(list,a_verbatimline)
                            if not v or v ~= last_v then
                                last_v = v
                                check_number(n,a,skip)
                            else
                                check_number(n,a,skip,true)
                            end
                        end
                        skip = false
                    end
                end
            end
        end
    end
end

-- [dir][leftskip][content]

function boxed.stage_two(n,m)
    if #current_list > 0 then
        m = m or lines.scratchbox
        local t, tn = { }, 0
        for l in traverse_id(hlist_code,getlist(getbox(m))) do
            tn = tn + 1
            t[tn] = copy_node(l) -- use take_box instead
        end
        for i=1,#current_list do
            local li = current_list[i]
            local n, m, ti = li[1], li[2], t[i]
            if ti then
                local l = getlist(n)
                -- we want to keep leftskip at the start
--                 local id = getid(l)
--                 if id == whatsit_code and getsubtype(l) == textdir_code then
--                     l = getnext(l)
--                     id = getid(l)
--                 end
--                 if getid(l) == glue_code and getsubtype(l) == leftskip_code then
--                     -- [leftskip] [number] [rest]
--                     local forward  = copy_node(l)
--                     local backward = negated_glue(l)
--                     local next     = getnext(l)
--                     setfield(l,"next",backward)
--                     setfield(backward,"prev",l)
--                     setfield(backward,"next",ti)
--                     setfield(ti,"prev",backward)
--                     setfield(ti,"next",forward)
--                     setfield(forward,"prev",ti)
--                     setfield(forward,"next",next)
--                     setfield(next,"prev",forward)
--                 else
                    -- [number] [rest]
                    setfield(ti,"next",l)
                    setfield(l,"prev",ti)
                    setfield(n,"list",ti)
--                 end
                resolve(n,m)
            else
                report_lines("error in linenumbering (1)")
                return
            end
       end
    end
end

function boxed.stage_two(n,m)
    if #current_list > 0 then
        m = m or lines.scratchbox
        local t, tn = { }, 0
        for l in traverse_id(hlist_code,getlist(getbox(m))) do
            tn = tn + 1
            t[tn] = copy_node(l) -- use take_box instead
        end
        for i=1,#current_list do
            local li = current_list[i]
            local n, m, ti = li[1], li[2], t[i]
            if ti then
                local l = getlist(n)
                setfield(ti,"next",l)
                setfield(l,"prev",ti)
                local h = copy_node(n)
                setfield(h,"dir","TLT")
                setfield(h,"list",ti)
                setfield(n,"list",h)
                resolve(n,m)
            else
                report_lines("error in linenumbering (1)")
                return
            end
       end
    end
end

implement {
    name      = "linenumbersstageone",
    actions   = boxed.stage_one,
    arguments = { "integer", "boolean" }
}

implement {
    name      = "linenumbersstagetwo",
    actions   = boxed.stage_two,
    arguments = { "integer", "integer" }
}