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
|
if not modules then modules = { } end modules ['sort-ini'] = {
version = 1.001,
comment = "companion to sort-ini.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
license = "see context related readme files"
}
-- todo:
--
-- out of range
-- uppercase
-- texutil compatible
-- always expand to utf
local utf = unicode.utf8
local gsub, rep, sort, concat = string.gsub, string.rep, table.sort, table.concat
local utfbyte, utfchar = utf.byte, utf.char
local utfcharacters, utfvalues, strcharacters = string.utfcharacters, string.utfvalues, string.characters
local chardata = characters.data
local trace_tests = false trackers.register("sorters.tests", function(v) trace_tests = v end)
sorters = { }
sorters.comparers = { }
sorters.splitters = { }
sorters.entries = { }
sorters.mappings = { }
sorters.replacements = { }
sorters.language = 'en'
local mappings = sorters.mappings
local entries = sorters.entries
local replacements = sorters.replacements
function sorters.comparers.basic(sort_a,sort_b,map)
-- sm assignment is slow, will become sorters.initialize
local sm = map or mappings[sorters.language or sorters.defaultlanguage] or mappings.en
if #sort_a > #sort_b then
if #sort_b == 0 then
return 1
else
for i=1,#sort_b do
local ai, bi = sort_a[i], sort_b[i]
local am, bm = sm[ai], sm[bi]
if am and bm then
if am > bm then
return 1
elseif am < bm then
return -1
end
else
if ai > bi then
return 1
elseif ai < bi then
return -1
end
end
end
return 1
end
elseif #sort_a < #sort_b then
if #sort_a == 0 then
return -1
else
for i=1,#sort_a do
local ai, bi = sort_a[i], sort_b[i]
local am, bm = sm[ai], sm[bi]
if am and bm then
if am > bm then
return 1
elseif am < bm then
return -1
end
else
if ai > bi then
return 1
elseif ai < bi then
return -1
end
end
end
return -1
end
elseif #sort_a == 0 then
return 0
else
for i=1,#sort_a do
local ai, bi = sort_a[i], sort_b[i]
local am, bm = sm[ai], sm[bi]
if am and bm then
if am > bm then
return 1
elseif am < bm then
return -1
end
else
if ai > bi then
return 1
elseif ai < bi then
return -1
end
end
end
return 0
end
end
local function padd(s) return rep(" ",10-#s) .. s end -- or format with padd
function sorters.strip(str) -- todo: only letters and such utf.gsub("([^%w%d])","")
if str then
str = gsub(str,"\\%S*","")
str = gsub(str,"[%s%[%](){}%$\"\']*","")
str = gsub(str,"(%d+)",padd) -- sort numbers properly
return str
else
return ""
end
end
function sorters.firstofsplit(split)
-- numbers are left padded by spaces
local se = entries[sorters.language or sorters.defaultlanguage] or entries.en -- slow, will become sorters.initialize
local vs = split[1]
local entry = vs and vs[1] or ""
return entry, (se and se[entry]) or "\000"
end
sorters.defaultlanguage = 'en'
-- beware, numbers get spaces in front
function sorters.splitters.utf(str) -- brrr, todo: language
local r = sorters.replacements[sorters.language] or sorters.replacements[sorters.defaultlanguage] or { }
-- local m = mappings [sorters.language] or mappings [sorters.defaultlanguage] or { }
local u = characters.uncompose
local t = { }
for _,v in next, r do
str = gsub(str,v[1],v[2])
end
for c in utfcharacters(str) do -- maybe an lpeg
t[#t+1] = c
end
return t
end
function table.remap(t)
local tt = { }
for k,v in next, t do
tt[v] = k
end
return tt
end
function sorters.sort(entries,cmp)
local language = sorters.language or sorters.defaultlanguage
local map = mappings[language] or mappings.en
if trace_tests then
local function pack(l)
local t = { }
for i=1,#l do
local tt, li = { }, l[i]
for j=1,#li do
local lij = li[j]
if utfbyte(lij) > 0xFF00 then
tt[j] = "[]"
else
tt[j] = li[j]
end
end
t[i] = concat(tt)
end
return concat(t," + ")
end
sort(entries, function(a,b)
local r = cmp(a,b,map)
local as, bs = a.split, b.split
if as and bs then
logs.report("sorter","%s %s %s",pack(as),(not r and "?") or (r<0 and "<") or (r>0 and ">") or "=",pack(bs))
end
return r == -1
end)
local s
for i=1,#entries do
local split = entries[i].split
local entry, first = sorters.firstofsplit(split)
if first == s then
first = " "
else
s = first
logs.report("sorter",">> %s 0x%05X (%s 0x%05X)",first,utfbyte(first),entry,utfbyte(entry))
end
logs.report("sorter"," %s",pack(split))
end
else
sort(entries, function(a,b)
return cmp(a,b,map) == -1
end)
end
end
-- some day we can have a characters.upper and characters.lower
function sorters.add_uppercase_entries(entries)
local new = { }
for k, v in next, entries do
local u = chardata[utfbyte(k)].uccode
if u then
new[utfchar(u)] = v
end
end
for k, v in next, new do
entries[k] = v
end
end
function sorters.add_uppercase_mappings(mappings,offset)
local new = { }
for k, v in next, mappings do
local u = chardata[utfbyte(k)].uccode
if u then
new[utfchar(u)] = v + offset
end
end
offset = offset or 0
for k, v in next, new do
mappings[k] = v
end
end
|
