SourceBrowser

typo-duc.lua /size: 37 Kb last modification: 2025-02-21 11:03
1if not modules then modules = { } end modules ['typo-duc'] = {
2    version   = 1.001,
3    comment   = "companion to typo-dir.mkiv",
4    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
5    copyright = "PRAGMA ADE / ConTeXt Development Team",
6    license   = "see context related readme files",
7    comment   = "Unicode bidi (sort of) variant c",
8}
9
10-- This is a follow up on typo-uda which itself is a follow up on t-bidi by Khaled Hosny which
11-- in turn is based on minibidi.c from Arabeyes. This is a further optimizations, as well as
12-- an update on some recent unicode bidi developments. There is (and will) also be more control
13-- added. As a consequence this module is somewhat slower than its precursor which itself is
14-- slower than the one-pass bidi handler. This is also a playground and I might add some plugin
15-- support. However, in the meantime performance got a bit better and this third variant is again
16-- some 10% faster than the second variant.
17
18-- todo (cf html):
19--
20-- normal            The element does not offer a additional level of embedding with respect to the bidirectional algorithm. For inline elements implicit reordering works across element boundaries.
21-- embed             If the element is inline, this value opens an additional level of embedding with respect to the bidirectional algorithm. The direction of this embedding level is given by the direction property.
22-- bidi-override     For inline elements this creates an override. For block container elements this creates an override for inline-level descendants not within another block container element. This means that inside the element, reordering is strictly in sequence according to the direction property; the implicit part of the bidirectional algorithm is ignored.
23-- isolate           This keyword indicates that the element's container directionality should be calculated without considering the content of this element. The element is therefore isolated from its siblings. When applying its bidirectional-resolution algorithm, its container element treats it as one or several U+FFFC Object Replacement Character, i.e. like an image.
24-- isolate-override  This keyword applies the isolation behavior of the isolate keyword to the surrounding content and the override behavior o f the bidi-override keyword to the inner content.
25-- plaintext         This keyword makes the elements directionality calculated without considering its parent bidirectional state or the value of the direction property. The directionality is calculated using the P2 and P3 rules of the Unicode Bidirectional Algorithm.
26--                   This value allows to display data which has already formatted using a tool following the Unicode Bidirectional Algorithm.
27--
28-- todo: check for introduced errors
29-- todo: reuse list, we have size, so we can just change values (and auto allocate when not there)
30-- todo: reuse the stack
31-- todo: no need for a max check
32-- todo: collapse bound similar ranges (not ok yet)
33-- todo: combine some sweeps
34-- todo: removing is not needed when we inject at the same spot (only chnage the dir property)
35-- todo: isolated runs (isolating runs are similar to bidi=local in the basic analyzer)
36
37-- todo: check unicode addenda (from the draft):
38--
39-- Added support for canonical equivalents in BD16.
40-- Changed logic in N0 to not check forwards for context in the case of enclosed text opposite the embedding direction.
41-- Major extension of the algorithm to allow for the implementation of directional isolates and the introduction of new isolate-related values to the Bidi_Class property.
42-- Adds BD8, BD9, BD10, BD11, BD12, BD13, BD14, BD15, and BD16, Sections 2.4 and 2.5, and Rules X5a, X5b, X5c and X6a.
43-- Extensively revises Section 3.3.2, Explicit Levels and Directions and its existing X rules to formalize the algorithm for matching a PDF with the embedding or override initiator whose scope it terminates.
44-- Moves Rules X9 and X10 into a separate new Section 3.3.3, Preparations for Implicit Processing.
45-- Modifies Rule X10 to make the isolating run sequence the unit to which subsequent rules are applied.
46-- Modifies Rule W1 to change an NSM preceded by an isolate initiator or PDI into ON.
47-- Adds Rule N0 and makes other changes to Section 3.3.5, Resolving Neutral and Isolate Formatting Types to resolve bracket pairs to the same level.
48
49local insert, remove, unpack, concat = table.insert, table.remove, table.unpack, table.concat
50local utfchar = utf.char
51local setmetatable = setmetatable
52local formatters = string.formatters
53
54local directiondata        = characters.directions
55local mirrordata           = characters.mirrors
56local textclassdata        = characters.textclasses
57
58local nuts                 = nodes.nuts
59
60local getnext              = nuts.getnext
61local getprev              = nuts.getprev
62local getid                = nuts.getid
63local getsubtype           = nuts.getsubtype
64local getlist              = nuts.getlist
65local getchar              = nuts.getchar
66local getattr              = nuts.getattr
67local getprop              = nuts.getprop
68local getdirection         = nuts.getdirection
69local isglyph              = nuts.isglyph
70
71local setprop              = nuts.setprop
72local setchar              = nuts.setchar
73local setdirection         = nuts.setdirection
74local setattrlist          = nuts.setattrlist
75
76local properties           = nodes.properties.data
77
78local remove_node          = nuts.remove
79local insertnodeafter      = nuts.insertafter
80local insertnodebefore     = nuts.insertbefore
81
82local startofpar           = nuts.startofpar
83
84local nodepool             = nuts.pool
85local new_direction        = nodepool.direction
86
87local nodecodes            = nodes.nodecodes
88local gluecodes            = nodes.gluecodes
89
90local glyph_code           = nodecodes.glyph
91local glue_code            = nodecodes.glue
92local hlist_code           = nodecodes.hlist
93local vlist_code           = nodecodes.vlist
94local math_code            = nodecodes.math
95local dir_code             = nodecodes.dir
96local par_code             = nodecodes.par
97local penalty_code         = nodecodes.penalty
98
99local parfillskip_code     = gluecodes.parfillskip
100local parfillleftskip_code = gluecodes.parfillleftskip
101
102local dirvalues            = nodes.dirvalues
103local lefttoright_code     = dirvalues.lefttoright
104local righttoleft_code     = dirvalues.righttoleft
105
106local maximum_stack        = 0xFF
107
108local a_directions         = attributes.private('directions')
109
110local directions           = typesetters.directions
111local setcolor             = directions.setcolor
112local getfences            = directions.getfences
113
114local remove_controls      = true  directives.register("typesetters.directions.removecontrols",function(v) remove_controls  = v end)
115----- analyze_fences       = true  directives.register("typesetters.directions.analyzefences", function(v) analyze_fences   = v end)
116
117local report_directions    = logs.reporter("typesetting","directions three")
118
119local trace_directions     = false trackers.register("typesetters.directions",         function(v) trace_directions = v end)
120local trace_details        = false trackers.register("typesetters.directions.details", function(v) trace_details    = v end)
121local trace_list           = false trackers.register("typesetters.directions.list",    function(v) trace_list       = v end)
122
123-- strong (old):
124--
125-- l   : left to right
126-- r   : right to left
127-- lro : left to right override
128-- rlo : left to left override
129-- lre : left to right embedding
130-- rle : left to left embedding
131-- al  : right to legt arabic (esp punctuation issues)
132--
133-- weak:
134--
135-- en  : english number
136-- es  : english number separator
137-- et  : english number terminator
138-- an  : arabic number
139-- cs  : common number separator
140-- nsm : nonspacing mark
141-- bn  : boundary neutral
142--
143-- neutral:
144--
145-- b  : paragraph separator
146-- s  : segment separator
147-- ws : whitespace
148-- on : other neutrals
149--
150-- interesting: this is indeed better (and more what we expect i.e. we already use this split
151-- in the old original (also these isolates)
152--
153-- strong (new):
154--
155-- l   : left to right
156-- r   : right to left
157-- al  : right to left arabic (esp punctuation issues)
158--
159-- explicit: (new)
160--
161-- lro : left to right override
162-- rlo : left to left override
163-- lre : left to right embedding
164-- rle : left to left embedding
165-- pdf : pop dir format
166-- lri : left to right isolate
167-- rli : left to left isolate
168-- fsi : first string isolate
169-- pdi : pop directional isolate
170
171local whitespace = {
172    lre = true,
173    rle = true,
174    lro = true,
175    rlo = true,
176    pdf = true,
177    bn  = true,
178    ws  = true,
179}
180
181local b_s_ws_on = {
182    b   = true,
183    s   = true,
184    ws  = true,
185    on  = true
186}
187
188-- tracing
189
190local function show_list(list,size,what)
191    local what   = what or "direction"
192    local joiner = utfchar(0x200C)
193    local result = { }
194    for i=1,size do
195        local entry     = list[i]
196        local character = entry.char
197        local direction = entry[what]
198        if character == 0xFFFC then
199            local first = entry.id
200            local last  = entry.last
201            local skip  = entry.skip
202            if last then
203                result[i] = formatters["%-3s:%s %s..%s (%i)"](direction,joiner,nodecodes[first],nodecodes[last],skip or 0)
204            else
205                result[i] = formatters["%-3s:%s %s (%i)"](direction,joiner,nodecodes[first],skip or 0)
206            end
207        elseif character >= 0x202A and character <= 0x202C then
208            result[i] = formatters["%-3s:%s %U"](direction,joiner,character)
209        else
210            result[i] = formatters["%-3s:%s %c %U"](direction,joiner,character,character)
211        end
212    end
213    return concat(result,joiner .. " | " .. joiner)
214end
215
216-- preparation
217
218local function show_done(list,size)
219    local joiner = utfchar(0x200C)
220    local result = { }
221    local format = formatters["<%s>"]
222    for i=1,size do
223        local entry     = list[i]
224        local character = entry.char
225        local begindir  = entry.begindir
226        local enddir    = entry.enddir
227        if begindir then
228            result[#result+1] = format(begindir)
229        end
230        if entry.remove then
231            -- continue
232        elseif character == 0xFFFC then
233            result[#result+1] = format("?")
234        elseif character == 0x0020 then
235            result[#result+1] = format(" ")
236        elseif character >= 0x202A and character <= 0x202C then
237            result[#result+1] = format(entry.original)
238        else
239            result[#result+1] = utfchar(character)
240        end
241        if enddir then
242            result[#result+1] = format(enddir)
243        end
244    end
245    return concat(result,joiner)
246end
247
248-- keeping the list and overwriting doesn't save much runtime, only a few percent
249-- char is only used for mirror, so in fact we can as well only store it for
250-- glyphs only
251--
252-- tracking what direction is used and skipping tests is not faster (extra kind of
253-- compensates gain)
254
255local mt_space  = { __index = { char = 0x0020, direction = "ws",  original = "ws",  level = 0, skip = 0 } }
256local mt_lre    = { __index = { char = 0x202A, direction = "lre", original = "lre", level = 0, skip = 0 } }
257local mt_rle    = { __index = { char = 0x202B, direction = "rle", original = "rle", level = 0, skip = 0 } }
258local mt_pdf    = { __index = { char = 0x202C, direction = "pdf", original = "pdf", level = 0, skip = 0 } }
259local mt_object = { __index = { char = 0xFFFC, direction = "on",  original = "on",  level = 0, skip = 0 } }
260
261local stack = table.setmetatableindex("table") -- shared
262local list  = { }                              -- shared
263
264local function build_list(head,where)
265    -- P1
266    local current = head
267    local size    = 0
268    while current do
269        size = size + 1
270        local id = getid(current)
271        local p  = properties[current]
272        if p and p.directions then
273            -- tricky as dirs can be injected in between
274            local skip = 0
275            local last = id
276            current    = getnext(current)
277            while current do
278                local id = getid(current)
279                local p  = properties[current]
280                if p and p.directions then
281                    skip    = skip + 1
282                    last    = id
283                    current = getnext(current)
284                else
285                    break
286                end
287            end
288            if id == last then -- the start id
289                list[size] = setmetatable({ skip = skip, id = id },mt_object)
290            else
291                list[size] = setmetatable({ skip = skip, id = id, last = last },mt_object)
292            end
293        elseif id == glyph_code then
294            local chr  = getchar(current)
295            local dir  = directiondata[chr]
296            -- could also be a metatable
297            list[size] = { char = chr, direction = dir, original = dir, level = 0 }
298            current    = getnext(current)
299         -- if not list[dir] then list[dir] = true end -- not faster when we check for usage
300        elseif id == glue_code then -- and how about kern
301            list[size] = setmetatable({ },mt_space)
302            current    = getnext(current)
303        elseif id == dir_code then
304            local dir, pop = getdirection(current)
305            if dir == lefttoright_code then
306                list[size] = setmetatable({ },pop and mt_pdf or mt_lre)
307            elseif dir == righttoleft_code then
308                list[size] = setmetatable({ },pop and mt_pdf or mt_rle)
309            else
310                list[size] = setmetatable({ id = id },mt_object)
311            end
312            current = getnext(current)
313        elseif id == math_code then
314            local skip = 0
315            current    = getnext(current)
316            while getid(current) ~= math_code do
317                skip    = skip + 1
318                current = getnext(current)
319            end
320            skip       = skip + 1
321            current    = getnext(current)
322            list[size] = setmetatable({ id = id, skip = skip },mt_object)
323        else -- disc_code: we assume that these are the same as the surrounding
324            local skip = 0
325            local last = id
326            current    = getnext(current)
327            while n do
328                local id = getid(current)
329                if id ~= glyph_code and id ~= glue_code and id ~= dir_code then
330                    skip    = skip + 1
331                    last    = id
332                    current = getnext(current)
333                else
334                    break
335                end
336            end
337            if id == last then -- the start id
338                list[size] = setmetatable({ id = id, skip = skip },mt_object)
339            else
340                list[size] = setmetatable({ id = id, skip = skip, last = last },mt_object)
341            end
342        end
343    end
344    return list, size
345end
346
347-- new
348
349-- we could support ( ] and [ ) and such ...
350
351-- ש ) ל ( א       0-0
352-- ש ( ל ] א       0-0
353-- ש ( ל ) א       2-4
354-- ש ( ל [ א ) כ ] 2-6
355-- ש ( ל ] א ) כ   2-6
356-- ש ( ל ) א ) כ   2-4
357-- ש ( ל ( א ) כ   4-6
358-- ש ( ל ( א ) כ ) 2-8,4-6
359-- ש ( ל [ א ] כ ) 2-8,4-6
360
361local fencestack = table.setmetatableindex("table")
362
363local function resolve_fences(list,size,start,limit)
364    -- N0: funny effects, not always better, so it's an option
365    local nofstack = 0
366    for i=start,limit do
367        local entry = list[i]
368        if entry.direction == "on" then
369            local char   = entry.char
370            local mirror = mirrordata[char]
371            if mirror then
372                local class = textclassdata[char]
373                entry.mirror = mirror
374                entry.class  = class
375                if class == "open" then
376                    nofstack       = nofstack + 1
377                    local stacktop = fencestack[nofstack]
378                    stacktop[1]    = mirror
379                    stacktop[2]    = i
380                elseif nofstack == 0 then
381                    -- skip
382                elseif class == "close" then
383                    while nofstack > 0 do
384                        local stacktop = fencestack[nofstack]
385                        if stacktop[1] == char then
386                            local open  = stacktop[2]
387                            local close = i
388                            list[open ].paired = close
389                            list[close].paired = open
390                            break
391                        else
392                            -- do we mirror or not
393                        end
394                        nofstack = nofstack - 1
395                    end
396                end
397            end
398        end
399    end
400end
401
402-- local function test_fences(str)
403--     local list  = { }
404--     for s in string.gmatch(str,".") do
405--         local b = utf.byte(s)
406--         list[#list+1] = { c = s, char = b, direction = directiondata[b] }
407--     end
408--     resolve_fences(list,#list,1,#size)
409--     inspect(list)
410-- end
411--
412-- test_fences("a(b)c(d)e(f(g)h)i")
413-- test_fences("a(b[c)d]")
414
415-- the action
416
417local function get_baselevel(head,list,size,direction)
418    if direction == lefttoright_code or direction == righttoleft_code then
419        return direction, true
420    elseif getid(head) == par_code and startofpar(head) then
421        direction = getdirection(head)
422        if direction == lefttoright_code or direction == righttoleft_code then
423            return direction, true
424        end
425    end
426    -- P2, P3
427    for i=1,size do
428        local entry     = list[i]
429        local direction = entry.direction
430        if direction == "r" or direction == "al" then -- and an ?
431            return righttoleft_code, true
432        elseif direction == "l" then
433            return lefttoright_code, true
434        end
435    end
436    return lefttoright_code, false
437end
438
439local function resolve_explicit(list,size,baselevel)
440-- if list.rle or list.lre or list.rlo or list.lro then
441    -- X1
442    local level    = baselevel
443    local override = "on"
444    local nofstack = 0
445    for i=1,size do
446        local entry     = list[i]
447        local direction = entry.direction
448        -- X2
449        if direction == "rle" then
450            if nofstack < maximum_stack then
451                nofstack        = nofstack + 1
452                local stacktop  = stack[nofstack]
453                stacktop[1]     = level
454                stacktop[2]     = override
455                level           = level + (level % 2 == 1 and 2 or 1) -- least_greater_odd(level)
456                override        = "on"
457                entry.level     = level
458                entry.direction = "bn"
459                entry.remove    = true
460            elseif trace_directions then
461                report_directions("stack overflow at position %a with direction %a",i,direction)
462            end
463        -- X3
464        elseif direction == "lre" then
465            if nofstack < maximum_stack then
466                nofstack        = nofstack + 1
467                local stacktop  = stack[nofstack]
468                stacktop[1]     = level
469                stacktop[2]     = override
470                level           = level + (level % 2 == 1 and 1 or 2) -- least_greater_even(level)
471                override        = "on"
472                entry.level     = level
473                entry.direction = "bn"
474                entry.remove    = true
475            elseif trace_directions then
476                report_directions("stack overflow at position %a with direction %a",i,direction)
477            end
478        -- X4
479        elseif direction == "rlo" then
480            if nofstack < maximum_stack then
481                nofstack        = nofstack + 1
482                local stacktop  = stack[nofstack]
483                stacktop[1]     = level
484                stacktop[2]     = override
485                level           = level + (level % 2 == 1 and 2 or 1) -- least_greater_odd(level)
486                override        = "r"
487                entry.level     = level
488                entry.direction = "bn"
489                entry.remove    = true
490            elseif trace_directions then
491                report_directions("stack overflow at position %a with direction %a",i,direction)
492            end
493        -- X5
494        elseif direction == "lro" then
495            if nofstack < maximum_stack then
496                nofstack        = nofstack + 1
497                local stacktop  = stack[nofstack]
498                stacktop[1]     = level
499                stacktop[2]     = override
500                level           = level + (level % 2 == 1 and 1 or 2) -- least_greater_even(level)
501                override        = "l"
502                entry.level     = level
503                entry.direction = "bn"
504                entry.remove    = true
505            elseif trace_directions then
506                report_directions("stack overflow at position %a with direction %a",i,direction)
507            end
508        -- X7
509        elseif direction == "pdf" then
510            if nofstack > 0 then
511                local stacktop  = stack[nofstack]
512                level           = stacktop[1]
513                override        = stacktop[2]
514                nofstack        = nofstack - 1
515                entry.level     = level
516                entry.direction = "bn"
517                entry.remove    = true
518            elseif trace_directions then
519                report_directions("stack underflow at position %a with direction %a",
520                    i, direction)
521            else
522                report_directions("stack underflow at position %a with direction %a: %s",
523                    i, direction, show_list(list,size))
524            end
525        -- X6
526        else
527            entry.level = level
528            if override ~= "on" then
529                entry.direction = override
530            end
531        end
532    end
533    -- X8 (reset states and overrides after paragraph)
534end
535
536local function resolve_weak(list,size,start,limit,orderbefore,orderafter)
537    -- W1: non spacing marks get the direction of the previous character
538-- if list.nsm then
539    for i=start,limit do
540        local entry = list[i]
541        if entry.direction == "nsm" then
542            if i == start then
543                entry.direction = orderbefore
544            else
545                entry.direction = list[i-1].direction
546            end
547        end
548    end
549-- end
550    -- W2: mess with numbers and arabic
551-- if list.en then
552    for i=start,limit do
553        local entry = list[i]
554        if entry.direction == "en" then
555            for j=i-1,start,-1 do
556                local prev = list[j]
557                local direction = prev.direction
558                if direction == "al" then
559                    entry.direction = "an"
560                    break
561                elseif direction == "r" or direction == "l" then
562                    break
563                end
564            end
565        end
566    end
567-- end
568    -- W3
569-- if list.al then
570    for i=start,limit do
571        local entry = list[i]
572        if entry.direction == "al" then
573            entry.direction = "r"
574        end
575    end
576-- end
577    -- W4: make separators number
578-- if list.es or list.cs then
579        -- skip
580    if false then
581        for i=start+1,limit-1 do
582            local entry     = list[i]
583            local direction = entry.direction
584            if direction == "es" then
585                if list[i-1].direction == "en" and list[i+1].direction == "en" then
586                    entry.direction = "en"
587                end
588            elseif direction == "cs" then
589                local prevdirection = list[i-1].direction
590                if prevdirection == "en" then
591                    if list[i+1].direction == "en" then
592                        entry.direction = "en"
593                    end
594                elseif prevdirection == "an" and list[i+1].direction == "an" then
595                    entry.direction = "an"
596                end
597            end
598        end
599    else -- only more efficient when we have es/cs
600        local runner = start + 2
601        if runner <= limit then
602            local before  = list[start]
603            local current = list[start + 1]
604            local after   = list[runner]
605            while after do
606                local direction = current.direction
607                if direction == "es" then
608                    if before.direction == "en" and after.direction == "en" then
609                        current.direction = "en"
610                    end
611                elseif direction == "cs" then
612                    local prevdirection = before.direction
613                    if prevdirection == "en" then
614                        if after.direction == "en" then
615                            current.direction = "en"
616                        end
617                    elseif prevdirection == "an" and after.direction == "an" then
618                        current.direction = "an"
619                    end
620                end
621                before  = current
622                current = after
623                after   = list[runner]
624                runner  = runner + 1
625            end
626        end
627    end
628-- end
629    -- W5
630-- if list.et then
631    local i = start
632    while i <= limit do
633        if list[i].direction == "et" then
634            local runstart = i
635            local runlimit = runstart
636            for i=runstart,limit do
637                if list[i].direction == "et" then
638                    runlimit = i
639                else
640                    break
641                end
642            end
643            local rundirection = runstart == start and sor or list[runstart-1].direction
644            if rundirection ~= "en" then
645                rundirection = runlimit == limit and orderafter or list[runlimit+1].direction
646            end
647            if rundirection == "en" then
648                for j=runstart,runlimit do
649                    list[j].direction = "en"
650                end
651            end
652            i = runlimit
653        end
654        i = i + 1
655    end
656-- end
657    -- W6
658-- if list.es or list.cs or list.et then
659    for i=start,limit do
660        local entry     = list[i]
661        local direction = entry.direction
662        if direction == "es" or direction == "et" or direction == "cs" then
663            entry.direction = "on"
664        end
665    end
666-- end
667    -- W7
668    for i=start,limit do
669        local entry = list[i]
670        if entry.direction == "en" then
671            local prev_strong = orderbefore
672            for j=i-1,start,-1 do
673                local direction = list[j].direction
674                if direction == "l" or direction == "r" then
675                    prev_strong = direction
676                    break
677                end
678            end
679            if prev_strong == "l" then
680                entry.direction = "l"
681            end
682        end
683    end
684end
685
686local function resolve_neutral(list,size,start,limit,orderbefore,orderafter)
687    -- N1, N2
688    local i = start
689    while i <= limit do
690        local entry = list[i]
691        if b_s_ws_on[entry.direction] then
692            -- this needs checking
693            local leading_direction, trailing_direction, resolved_direction
694            local runstart = i
695            local runlimit = runstart
696--             for j=runstart,limit do
697            for j=runstart+1,limit do
698                if b_s_ws_on[list[j].direction] then
699--                     runstart = j
700                    runlimit = j
701                else
702                    break
703                end
704            end
705            if runstart == start then
706                leading_direction = orderbefore
707            else
708                leading_direction = list[runstart-1].direction
709                if leading_direction == "en" or leading_direction == "an" then
710                    leading_direction = "r"
711                end
712            end
713            if runlimit == limit then
714                trailing_direction = orderafter
715            else
716                trailing_direction = list[runlimit+1].direction
717                if trailing_direction == "en" or trailing_direction == "an" then
718                    trailing_direction = "r"
719                end
720            end
721            if leading_direction == trailing_direction then
722                -- N1
723                resolved_direction = leading_direction
724            else
725                -- N2 / does the weird period
726                resolved_direction = entry.level % 2 == 1 and "r" or "l"
727            end
728            for j=runstart,runlimit do
729                list[j].direction = resolved_direction
730            end
731            i = runlimit
732        end
733        i = i + 1
734    end
735end
736
737local function resolve_implicit(list,size,start,limit,orderbefore,orderafter,baselevel)
738    for i=start,limit do
739        local entry     = list[i]
740        local level     = entry.level
741        local direction = entry.direction
742        if level % 2 ~= 1 then -- even
743            -- I1
744            if direction == "r" then
745                entry.level = level + 1
746            elseif direction == "an" or direction == "en" then
747                entry.level = level + 2
748            end
749        else
750            -- I2
751            if direction == "l" or direction == "en" or direction == "an" then
752                entry.level = level + 1
753            end
754        end
755    end
756end
757
758local function resolve_levels(list,size,baselevel,analyze_fences)
759    -- X10
760    local start = 1
761    while start < size do
762        local level = list[start].level
763        local limit = start + 1
764        while limit < size and list[limit].level == level do
765            limit = limit + 1
766        end
767        local prev_level  = start == 1    and baselevel or list[start-1].level
768        local next_level  = limit == size and baselevel or list[limit+1].level
769        local orderbefore = (level > prev_level and level or prev_level) % 2 == 1 and "r" or "l"
770        local orderafter  = (level > next_level and level or next_level) % 2 == 1 and "r" or "l"
771        -- W1 .. W7
772        resolve_weak(list,size,start,limit,orderbefore,orderafter)
773        -- N0
774        if analyze_fences then
775            resolve_fences(list,size,start,limit)
776        end
777        -- N1 .. N2
778        resolve_neutral(list,size,start,limit,orderbefore,orderafter)
779        -- I1 .. I2
780        resolve_implicit(list,size,start,limit,orderbefore,orderafter,baselevel)
781        start = limit
782    end
783    -- L1
784    for i=1,size do
785        local entry     = list[i]
786        local direction = entry.original
787        -- (1)
788        if direction == "s" or direction == "b" then
789            entry.level = baselevel
790            -- (2)
791            for j=i-1,1,-1 do
792                local entry = list[j]
793                if whitespace[entry.original] then
794                    entry.level = baselevel
795                else
796                    break
797                end
798            end
799        end
800    end
801    -- (3)
802    for i=size,1,-1 do
803        local entry = list[i]
804        if whitespace[entry.original] then
805            entry.level = baselevel
806        else
807            break
808        end
809    end
810    -- L4
811    if analyze_fences then
812        for i=1,size do
813            local entry = list[i]
814            if entry.level % 2 == 1 then -- odd(entry.level)
815                if entry.mirror and not entry.paired then
816                    entry.mirror = false
817                end
818                -- okay
819            elseif entry.mirror then
820                entry.mirror = false
821            end
822        end
823    else
824        for i=1,size do
825            local entry = list[i]
826            if entry.level % 2 == 1 then -- odd(entry.level)
827                local mirror = mirrordata[entry.char]
828                if mirror then
829                    entry.mirror = mirror
830                end
831            end
832        end
833    end
834end
835
836local stack = { }
837
838local function insert_dir_points(list,size)
839    -- L2, but no actual reversion is done, we simply annotate where
840    -- begindir/endddir node will be inserted.
841    local maxlevel = 0
842    local toggle   = true
843    for i=1,size do
844        local level = list[i].level
845        if level > maxlevel then
846            maxlevel = level
847        end
848    end
849    for level=0,maxlevel do
850        local started  -- = false
851        local begindir -- = nil
852        local enddir   -- = nil
853        local prev     -- = nil
854        if toggle then
855            begindir = lefttoright_code
856            enddir   = lefttoright_code
857            toggle   = false
858        else
859            begindir = righttoleft_code
860            enddir   = righttoleft_code
861            toggle   = true
862        end
863        for i=1,size do
864            local entry = list[i]
865            if entry.level >= level then
866                if not started then
867                    entry.begindir = begindir
868                    started        = true
869                end
870            else
871                if started then
872                    prev.enddir = enddir
873                    started     = false
874                end
875            end
876            prev = entry
877        end
878    end
879    -- make sure to close the run at end of line
880    local last = list[size]
881    if not last.enddir then
882        local n = 0
883        for i=1,size do
884            local entry = list[i]
885            local e = entry.enddir
886            local b = entry.begindir
887            if e then
888                n = n - 1
889            end
890            if b then
891                n = n + 1
892                stack[n] = b
893            end
894        end
895        if n > 0 then
896            if trace_list and n > 1 then
897                report_directions("unbalanced list")
898            end
899            last.enddir = stack[n]
900        end
901    end
902end
903
904-- We flag nodes that can be skipped when we see them again but because whatever
905-- mechanism can injetc dir nodes that then are not flagged, we don't flag dir
906-- nodes that we inject here.
907
908local function apply_to_list(list,size,head,pardir)
909    local index   = 1
910    local current = head
911    if trace_list then
912        report_directions("start run")
913    end
914    while current do
915        if index > size then
916            report_directions("fatal error, size mismatch")
917            break
918        end
919        local id       = getid(current)
920        local entry    = list[index]
921        local begindir = entry.begindir
922        local enddir   = entry.enddir
923        local p = properties[current]
924        if p then
925            p.directions = true
926        else
927            properties[current] = { directions = true }
928        end
929        if id == glyph_code then
930            local mirror = entry.mirror
931            if mirror then
932                setchar(current,mirror)
933            end
934            if trace_directions then
935                local direction = entry.direction
936                if trace_list then
937                    local original = entry.original
938                    local char     = entry.char
939                    local level    = entry.level
940                    if direction == original then
941                        report_directions("%2i : %C : %s",level,char,direction)
942                    else
943                        report_directions("%2i : %C : %s -> %s",level,char,original,direction)
944                    end
945                end
946                setcolor(current,direction,false,mirror)
947            end
948        elseif id == hlist_code or id == vlist_code then
949            setdirection(current,pardir) -- is this really needed?
950        elseif id == glue_code then
951            -- Maybe I should also fix dua and dub but on the other hand ... why?
952            if enddir and getsubtype(current) == parfillskip_code then
953                -- insert the last enddir before \parfillskip glue
954                local c = current
955                local p = getprev(c)
956                if p and getid(p) == glue_code and getsubtype(p) == parfillleftskip_code then
957                    c = p
958                    p = getprev(c)
959                end
960                if p and getid(p) == penalty_code then -- linepenalty
961                    c = p
962                end
963                -- there is always a par nodes so head will stay
964                head = insertnodebefore(head,c,new_direction(enddir,true))
965                enddir = false
966            end
967        elseif begindir then
968            if id == par_code and startofpar(current) then
969                -- par should always be the 1st node
970                head, current = insertnodeafter(head,current,new_direction(begindir))
971                begindir = nil
972            end
973        end
974        if begindir then
975            head = insertnodebefore(head,current,new_direction(begindir))
976        end
977        local skip = entry.skip
978        if skip and skip > 0 then
979            for i=1,skip do
980                current = getnext(current)
981                local p = properties[current]
982                if p then
983                    p.directions = true
984                else
985                    properties[current] = { directions = true }
986                end
987            end
988        end
989        if enddir then
990            head, current = insertnodeafter(head,current,new_direction(enddir,true))
991        end
992        if not entry.remove then
993            current = getnext(current)
994        elseif remove_controls then
995            -- X9
996            head, current = remove_node(head,current,true)
997        else
998            current = getnext(current)
999        end
1000        index = index + 1
1001    end
1002    if trace_list then
1003        report_directions("stop run")
1004    end
1005    return head
1006end
1007
1008-- If needed we can optimize for only_one. There is no need to do anything
1009-- when it's not a glyph. Otherwise we only need to check mirror and apply
1010-- directions when it's different from the surrounding. Paragraphs always
1011-- have more than one node. Actually, we only enter this function when we
1012-- do have a glyph!
1013
1014local function process(head,direction,only_one,where)
1015    -- for the moment a whole paragraph property
1016    local attr = getattr(head,a_directions)
1017    local analyze_fences = getfences(attr)
1018    --
1019    local list, size = build_list(head,where)
1020    local baselevel, dirfound = get_baselevel(head,list,size,direction)
1021    if trace_details then
1022        report_directions("analyze: baselevel %a",baselevel == righttoleft_code and "r2l" or "l2r")
1023        report_directions("before : %s",show_list(list,size,"original"))
1024    end
1025    resolve_explicit(list,size,baselevel)
1026    resolve_levels(list,size,baselevel,analyze_fences)
1027    insert_dir_points(list,size)
1028    if trace_details then
1029        report_directions("after  : %s",show_list(list,size,"direction"))
1030        report_directions("result : %s",show_done(list,size))
1031    end
1032    return apply_to_list(list,size,head,baselevel)
1033end
1034
1035local variables = interfaces.variables
1036
1037directions.installhandler(variables.one,    process) -- for old times sake
1038directions.installhandler(variables.two,    process) -- for old times sake
1039directions.installhandler(variables.three,  process) -- for old times sake
1040directions.installhandler(variables.unicode,process)
1041
Source Browser ?
