summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/lualatex/simurgh/simurgh-unibidi-core.lua
blob: d842a2e2b3c658552c82208cd82ecb023c837e37 (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
if not modules then modules = { } end modules ['simurgh-unibidi-core'] = {
    version   = 0.01,
    comment   = "unicode bidi",
    author    = "Vafa Khalighi",
    copyright = "Vafa Khalighi",
    license   = "see simurgh package documentation",
    derived   = "derived from typo-dha by Hans Hagen"
}

-- Some analysis:
--
-- 1. Assuming the reading- vs word-order distinction (bidi-char types) is governing;
-- 2. Assuming that 'PARSI' represents an actual parsi string in raw input order, not word-order;
-- 3. Assuming that 'ISRAP' represent the correct RL word order;
--
-- Then we have, with input: LATIN PARSI
--
-- \simurgh@textdir TLT LATIN PARSI => LATIN ISRAP
-- \simurgh@textdir TRT LATIN PARSI => LATIN ISRAP
-- \simurgh@textdir TRT LRO LATIN PARSI => LATIN PARSI
-- \simurgh@textdir TLT LRO LATIN PARSI => LATIN PARSI
-- \simurgh@textdir TLT RLO LATIN PARSI => NITAL PARSI
-- \simurgh@textdir TRT RLO LATIN PARSI => NITAL PARSI

-- elseif d == "es"  then -- European Number Separator
-- elseif d == "et"  then -- European Number Terminator
-- elseif d == "cs"  then -- Common Number Separator
-- elseif d == "nsm" then -- Non-Spacing Mark
-- elseif d == "bn"  then -- Boundary Neutral
-- elseif d == "b"   then -- Paragraph Separator
-- elseif d == "s"   then -- Segment Separator
-- elseif d == "ws"  then -- Whitespace
-- elseif d == "on"  then -- Other Neutrals

-- todo  : delayed inserts here
-- todo  : get rid of local functions here
-- beware: math adds whatsits afterwards so that will mess things up
-- todo  : use new dir functions
-- todo  : make faster
-- todo  : move dir info into nodes
-- todo  : swappable tables and floats i.e. start-end overloads (probably loop in builders)
-- todo  : check if we still have crashes in luatex when non-matched (used to be the case)

local nodes, node = nodes, node

local trace_directions   = false  trackers.register("typesetters.directions.default", function(v) trace_directions = v end)

local report_directions  = logs.reporter("typesetting","text directions")


local insert_node_before = nodes.insert_before
local insert_node_after  = nodes.insert_after
local remove_node        = nodes.remove
local end_of_math        = nodes.end_of_math

local nodepool           = nodes.pool

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

local glyph_code         = nodecodes.glyph
local whatsit_code       = nodecodes.whatsit
local math_code          = nodecodes.math
local penalty_code       = nodecodes.penalty
local kern_code          = nodecodes.kern
local glue_code          = nodecodes.glue
local hlist_code         = nodecodes.hlist
local vlist_code         = nodecodes.vlist

local localpar_code      = whatcodes.localpar
local dir_code           = whatcodes.dir

local new_textdir        = nodepool.textdir

local hasbit             = number.hasbit
local formatters         = string.formatters
local insert             = table.insert

local fonthashes         = fonts.hashes
local fontdata           = fonthashes.identifiers
local fontchar           = fonthashes.characters

local chardirections     = characters.directions
local charmirrors        = characters.mirrors
local charclasses        = characters.textclasses

local directions         = typesetters.directions
local getglobal          = directions.getglobal

local a_state            = attributes.private('state')
local a_directions       = attributes.private('directions')

local strip              = false

local s_isol             = fonts.analyzers.states.isol

local function stopdir(finish)
    return new_textdir(finish == "TRT" and "-TRT" or "-TLT")
end

local function startdir(finish)
    return new_textdir(finish == "TRT" and "+TRT" or "+TLT")
end

local function process(namespace,attribute,start)

    local head     = start

    local current  = head
    local inserted = nil
    local finish   = nil
    local autodir  = 0
    local embedded = 0
    local override = 0
    local pardir   = 1
    local textdir  = 1
    local done     = false
    local finished = nil
    local finidir  = nil
    local stack    = { }
    local top      = 0
    local obsolete = { }
    local lro      = false
    local lro      = false
    local prevattr = false
    local fences   = { }

    local function finish_auto_before()
        head, inserted = insert_node_before(head,current,stopdir(finish))
        finished, finidir, autodir = inserted, finish, 0
        finish, done = nil, true
    end

    local function finish_auto_after()
        head, current = insert_node_after(head,current,stopdir(finish))
        finished, finidir, autodir = current, finish, 0
        finish, done = nil, true
    end

    local function force_auto_left_before(direction)
        if finish then
            head, inserted = insert_node_before(head,current,stopdir(finish))
            finished = inserted
            finidir  = finish
        end
        if embedded >= 0 then
            finish, autodir = "TLT",  1
        else
            finish, autodir = "TRT", -1
        end
        done = true
        if finidir == finish then
            head = remove_node(head,finished,true)
        else
            head, inserted = insert_node_before(head,current,startdir(finish))
        end
    end

    local function force_auto_right_before(direction)
        if finish then
            head, inserted = insert_node_before(head,current,stopdir(finish))
            finished = inserted
            finidir  = finish
        end
        if embedded <= 0 then
            finish, autodir, done = "TRT", -1
        else
            finish, autodir, done = "TLT",  1
        end
        done = true
        if finidir == finish then
            head = remove_node(head,finished,true)
        else
            head, inserted = insert_node_before(head,current,startdir(finish))
        end
    end

    local function nextisright(current)
        current = current.next
        local id = current.id
        if id == glyph_code then
            local character = current.char
            local direction = chardirections[character]
            return direction == "r" or direction == "al" or direction == "an"
        end
    end

    local function previsright(current)
        current = current.prev
        local id = current.id
        if id == glyph_code then
            local char = current.char
            local direction = chardirections[character]
            return direction == "r" or direction == "al" or direction == "an"
        end
    end

    while current do
        local id = current.id
        if id == math_code then
            current = end_of_math(current.next).next
        else
            local attr = current[attribute]
            if attr and attr > 0 and attr ~= prevattr then
                if not getglobal(a) then
                    lro, rlo = false, false
                end
                prevattr = attr
            end
            if id == glyph_code then
                if attr and attr > 0 then
                    local character = current.char
                    local direction = chardirections[character]
                    local reversed  = false
                    if rlo or override > 0 then
                        if direction == "l" then
                            direction = "r"
                            reversed = true
                        end
                    elseif lro or override < 0 then
                        if direction == "r" or direction == "al" then
                            current[a_state] = s_isol
                            direction = "l"
                            reversed = true
                        end
                    end
                    if direction == "on" then
                        local mirror = charmirrors[character]
                        if mirror and fontchar[current.font][mirror] then
                            local class = charclasses[character]
                            if class == "open" then
                                if nextisright(current) then
                                    if autodir >= 0 then
                                        force_auto_right_before(direction)
                                    end
                                    current.char = mirror
                                    done = true
                                elseif autodir < 0 then
                                    current.char = mirror
                                    done = true
                                else
                                    mirror = false
                                end
                                local fencedir = autodir == 0 and textdir or autodir
                                fences[#fences+1] = fencedir
                            elseif class == "close" and #fences > 0 then
                                local fencedir = fences[#fences]
                                fences[#fences] = nil
                                if fencedir < 0 then
                                    current.char = mirror
                                    done = true
                                    force_auto_right_before(direction)
                                else
                                    mirror = false
                                end
                            elseif autodir < 0 then
                                current.char = mirror
                                done = true
                            else
                                mirror = false
                            end
                        end
                    elseif direction == "l" then
                        if autodir <= 0 then -- could be option
                            force_auto_left_before(direction)
                        end
                    elseif direction == "r" then
                        if autodir >= 0 then
                            force_auto_right_before(direction)
                        end
                    elseif direction == "en" then -- european number
                        if autodir <= 0 then -- could be option
                            force_auto_left_before(direction)
                        end
                    elseif direction == "al" then -- arabic number
                        if autodir >= 0 then
                            force_auto_right_before(direction)
                        end
                    elseif direction == "an" then -- arabic number
                        if autodir >= 0 then
                            force_auto_right_before(direction)
                        end
                    elseif direction == "lro" then -- Left-to-Right Override -> right becomes left
                        top = top + 1
                        stack[top] = { override, embedded }
                        override = -1
                        obsolete[#obsolete+1] = current
                    elseif direction == "rlo" then -- Right-to-Left Override -> left becomes right
                        top = top + 1
                        stack[top] = { override, embedded }
                        override = 1
                        obsolete[#obsolete+1] = current
                    elseif direction == "lre" then -- Left-to-Right Embedding -> TLT
                        top = top + 1
                        stack[top] = { override, embedded }
                        embedded = 1
                        obsolete[#obsolete+1] = current
                    elseif direction == "rle" then -- Right-to-Left Embedding -> TRT
                        top = top + 1
                        stack[top] = { override, embedded }
                        embedded = -1
                        obsolete[#obsolete+1] = current
                    elseif direction == "pdf" then -- Pop Directional Format
                        if top > 0 then
                            local s = stack[top]
                            override, embedded = s[1], s[2]
                            top = top - 1
                        end
                        obsolete[#obsolete+1] = current
                    end
                else
                    -- we do nothing
                end
            elseif id == whatsit_code then
                local subtype = current.subtype
                if subtype == localpar_code then
                    local dir = current.dir
                    if dir == 'TRT' then
                        autodir = -1
                    elseif dir == 'TLT' then
                        autodir = 1
                    end
                    pardir = autodir
                    textdir = pardir
                elseif subtype == dir_code then
                    -- todo: also treat as lro|rlo and stack
                    if finish then
                        finish_auto_before()
                    end
                    local dir = current.dir
                    if dir == "+TRT" then
                        finish, autodir = "TRT", -1
                    elseif dir == "-TRT" then
                        finish, autodir = nil, 0
                    elseif dir == "+TLT" then
                        finish, autodir = "TLT", 1
                    elseif dir == "-TLT" then
                        finish, autodir = nil, 0
                    end
                    textdir = autodir
                else
                    if finish then
                        finish_auto_before()
                    end
                end
            elseif finish then
                finish_auto_before()
            end
            local cn = current.next
            if cn then
                -- we're okay
            elseif finish then
                finish_auto_after()
            end
            current = cn
        end
    end

    if done and strip then
        local n = #obsolete
        if n > 0 then
            for i=1,n do
                remove_node(head,obsolete[i],true)
            end
            report_directions("%s character nodes removed",n)
        end
    end

    return head, done

end

directions.installhandler(interfaces.variables.default,process)