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
|
if not modules then modules = { } end modules['s-math-characters'] = {
version = 1.001,
comment = "companion to s-math-characters.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
license = "see context related readme files"
}
-- This is one of the oldest cld files but I'm not going to clean it up.
moduledata.math = moduledata.math or { }
moduledata.math.characters = moduledata.math.characters or { }
local concat = table.concat
local lower = string.lower
local utfchar = utf.char
local round = math.round
local context = context
local fontdata = fonts.hashes.identifiers
local chardata = characters.data
local blocks = characters.blocks
local no_description = "no description, private to font"
local limited = true
local fillinthegaps = true
local upperlimit = 0x0007F
local upperlimit = 0xF0000
local f_unicode = string.formatters["%U"]
local f_slot = string.formatters["%s/%0X"]
function moduledata.math.characters.showlist(specification)
specification = interfaces.checkedspecification(specification)
local id = specification.number -- or specification.id
local list = specification.list
local showvirtual = specification.virtual == "all"
local check = specification.check == "yes"
if not id then
id = font.current()
end
if list == "" then
list = nil
end
local tfmdata = fontdata[id]
local characters = tfmdata.characters
local descriptions = tfmdata.descriptions
local resources = tfmdata.resources
local lookuptypes = resources.lookuptypes
local virtual = tfmdata.properties.virtualized
local names = { }
local gaps = mathematics.gaps
local sorted = { }
if type(list) == "string" then
sorted = utilities.parsers.settings_to_array(list)
for i=1,#sorted do
sorted[i] = tonumber(sorted[i])
end
elseif type(list) == "table" then
sorted = list
for i=1,#sorted do
sorted[i] = tonumber(sorted[i])
end
elseif fillinthegaps then
sorted = table.keys(characters)
for k, v in next, gaps do
if characters[v] then
sorted[#sorted+1] = k
end
end
table.sort(sorted)
else
sorted = table.sortedkeys(characters)
end
if virtual then
local fonts = tfmdata.fonts
for i=1,#fonts do
local id = fonts[i].id
local name = fontdata[id].properties.name
names[i] = (name and file.basename(name)) or id
end
end
if check then
for k, v in table.sortedhash(blocks) do
if v.math then
local first = v.first
local last = v.last
local f, l = 0, 0
if first and last then
for unicode=first,last do
local code = gaps[unicode] or unicode
local char = characters[code]
if char and not (char.commands and not showvirtual) then
f = unicode
break
end
end
for unicode=last,first,-1 do
local code = gaps[unicode] or unicode
local char = characters[code]
if char and not (char.commands and not showvirtual) then
l = unicode
break
end
end
context.showmathcharacterssetrange(k,f,l)
end
end
end
else
context.showmathcharactersstart()
for _, unicode in next, sorted do
if not limited or unicode < upperlimit then
local code = gaps[unicode] or unicode
local char = characters[code]
local desc = descriptions[code]
local info = chardata[code]
if char then
local commands = char.commands
if commands and not showvirtual then
-- skip
else
local next_sizes = char.next
local v_variants = char.vert_variants
local h_variants = char.horiz_variants
local slookups = desc and desc.slookups
local mlookups = desc and desc.mlookups
local mathclass = info.mathclass
local mathspec = info.mathspec
local mathsymbol = info.mathsymbol
local description = info.description or no_description
context.showmathcharactersstartentry()
context.showmathcharactersreference(f_unicode(unicode))
context.showmathcharactersentryhexdectit(f_unicode(code),code,lower(description))
context.showmathcharactersentrywdhtdpic(round(char.width or 0),round(char.height or 0),round(char.depth or 0),round(char.italic or 0))
if virtual and commands then
local t = { }
for i=1,#commands do
local ci = commands[i]
if ci[1] == "slot" then
local fnt, idx = ci[2], ci[3]
t[#t+1] = f_slot(names[fnt] or fnt,idx)
end
end
if #t > 0 then
context.showmathcharactersentryresource(concat(t,", "))
end
end
if mathclass or mathspec then
context.showmathcharactersstartentryclassspec()
if mathclass then
context.showmathcharactersentryclassname(mathclass,info.mathname or "no name")
end
if mathspec then
for i=1,#mathspec do
local mi = mathspec[i]
context.showmathcharactersentryclassname(mi.class,mi.name or "no name")
end
end
context.showmathcharactersstopentryclassspec()
end
if mathsymbol then
context.showmathcharactersentrysymbol(f_unicode(mathsymbol),mathsymbol)
end
if next_sizes then
local n, done = 0, { }
context.showmathcharactersstartnext()
while next_sizes do
n = n + 1
if done[next_sizes] then
context.showmathcharactersnextcycle(n)
break
else
done[next_sizes] = true
context.showmathcharactersnextentry(n,f_unicode(next_sizes),next_sizes)
next_sizes = characters[next_sizes]
v_variants = next_sizes.vert_variants or v_variants
h_variants = next_sizes.horiz_variants or h_variants
if next_sizes then
next_sizes = next_sizes.next
end
end
end
context.showmathcharactersstopnext()
if h_variants or v_variants then
context.showmathcharactersbetweennextandvariants()
end
end
if h_variants then
context.showmathcharactersstarthvariants()
for i=1,#h_variants do -- we might go top-down in the original
local vi = h_variants[i]
context.showmathcharactershvariantsentry(i,f_unicode(vi.glyph),vi.glyph)
end
context.showmathcharactersstophvariants()
elseif v_variants then
context.showmathcharactersstartvvariants()
for i=1,#v_variants do
local vi = v_variants[#v_variants-i+1]
context.showmathcharactersvvariantsentry(i,f_unicode(vi.glyph),vi.glyph)
end
context.showmathcharactersstopvvariants()
end
if slookups or mlookups then
local variants = { }
if slookups then
for lookupname, lookupdata in next, slookups do
local lookuptype = lookuptypes[lookupname]
if lookuptype == "substitution" then
variants[lookupdata] = "sub"
elseif lookuptype == "alternate" then
for i=1,#lookupdata do
variants[lookupdata[i]] = "alt"
end
end
end
end
if mlookups then
for lookupname, lookuplist in next, mlookups do
local lookuptype = lookuptypes[lookupname]
for i=1,#lookuplist do
local lookupdata = lookuplist[i]
local lookuptype = lookuptypes[lookupname]
if lookuptype == "substitution" then
variants[lookupdata] = "sub"
elseif lookuptype == "alternate" then
for i=1,#lookupdata do
variants[lookupdata[i]] = "alt"
end
end
end
end
end
context.showmathcharactersstartlookupvariants()
local i = 0
for variant, lookuptype in table.sortedpairs(variants) do
i = i + 1
context.showmathcharacterslookupvariant(i,f_unicode(variant),variant,lookuptype)
end
context.showmathcharactersstoplookupvariants()
end
context.showmathcharactersstopentry()
end
end
end
end
context.showmathcharactersstop()
end
end
|
