summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/context/base/s-math-characters.lua
blob: b0a79fcb6e519b84a7b38de8a8a43c4eca633f47 (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
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 fontdata = fonts.hashes.identifiers
local chardata = characters.data

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
    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)
    elseif type(list) == "table" then
        sorted = list
    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
        for k, v in ipairs(tfmdata.fonts) do
            local id = v.id
            local name = fontdata[id].properties.name
            names[k] = (name and file.basename(name)) or id
        end
    end
    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 next_sizes  = char.next
                local v_variants  = char.vert_variants
                local h_variants  = char.horiz_variants
                local commands    = char.commands
                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
    context.showmathcharactersstop()
end