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
376
377
|
if not modules then modules = { } end modules ['buff-ver'] = {
version = 1.001,
comment = "companion to buff-ver.mkiv",
author = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
copyright = "PRAGMA ADE / ConTeXt Development Team",
license = "see context related readme files"
}
-- The default visualizers have reserved names starting with v-*. Users are
-- supposed to use different names for their own variants.
local type, rawset, rawget, setmetatable, getmetatable = type, rawset, rawget, setmetatable, getmetatable
local format, lower, match = string.format, string.lower, string.match
local C, P, V, Carg = lpeg.C, lpeg.P, lpeg.V, lpeg.Carg
local patterns, lpegmatch, lpegtype = lpeg.patterns, lpeg.match, lpeg.type
local function is_lpeg(p)
return p and lpegtype(p) == "pattern"
end
visualizers = visualizers or { }
local specifications = { } visualizers.specifications = specifications
local verbatim = context.verbatim
local variables = interfaces.variables
local findfile = resolvers.findfile
local addsuffix = file.addsuffix
local v_yes = variables.yes
-- beware, these all get an argument (like newline)
local doinlineverbatimnewline = context.doinlineverbatimnewline
local doinlineverbatimbeginline = context.doinlineverbatimbeginline
local doinlineverbatimemptyline = context.doinlineverbatimemptyline
local doinlineverbatimstart = context.doinlineverbatimstart
local doinlineverbatimstop = context.doinlineverbatimstop
local dodisplayverbatimnewline = context.dodisplayverbatimnewline
local dodisplayverbatimbeginline = context.dodisplayverbatimbeginline
local dodisplayverbatimemptyline = context.dodisplayverbatimemptyline
local dodisplayverbatimstart = context.dodisplayverbatimstart
local dodisplayverbatimstop = context.dodisplayverbatimstop
local doverbatimspace = context.doverbatimspace
local CargOne = Carg(1)
local function f_emptyline(s,settings)
if settings and settings.currentnature == "inline" then
doinlineverbatimemptyline()
else
dodisplayverbatimemptyline()
end
end
local function f_beginline(s,settings)
if settings and settings.currentnature == "inline" then
doinlineverbatimbeginline()
else
dodisplayverbatimbeginline()
end
end
local function f_newline(s,settings)
if settings and settings.currentnature == "inline" then
doinlineverbatimnewline()
else
dodisplayverbatimnewline()
end
end
local function f_start(s,settings)
if settings and settings.currentnature == "inline" then
doinlineverbatimstart()
else
dodisplayverbatimstart()
end
end
local function f_stop(s,settings)
if settings and settings.currentnature == "inline" then
doinlineverbatimstop()
else
dodisplayverbatimstop()
end
end
local function f_default(s) -- (s,settings)
verbatim(s)
end
local function f_space() -- (s,settings)
doverbatimspace()
end
local functions = { __index = {
emptyline = f_emptyline,
newline = f_newline,
default = f_default,
beginline = f_beginline,
space = f_space,
start = f_start,
stop = f_stop,
}
}
local handlers = { }
function visualizers.newhandler(name,data)
local tname, tdata = type(name), type(data)
if tname == "table" then -- (data)
setmetatable(name,getmetatable(name) or functions)
return name
elseif tname == "string" then
if tdata == "string" then -- ("name","parent")
local result = { }
setmetatable(result,getmetatable(handlers[data]) or functions)
handlers[name] = result
return result
elseif tdata == "table" then -- ("name",data)
setmetatable(data,getmetatable(data) or functions)
handlers[name] = data
return data
else -- ("name")
local result = { }
setmetatable(result,functions)
handlers[name] = result
return result
end
else -- ()
local result = { }
setmetatable(result,functions)
return result
end
end
function visualizers.newgrammar(name,t)
t = t or { }
local g = visualizers.specifications[name]
g = g and g.grammar
if g then
for k,v in next, g do
if not t[k] then
t[k] = v
end
if is_lpeg(v) then
t[name..":"..k] = v
end
end
end
return t
end
local fallback = context.verbatim
local function makepattern(visualizer,kind,pattern)
if not pattern then
logs.simple("error in visualizer: %s",kind)
return patterns.alwaystrue
else
if type(visualizer) == "table" and type(kind) == "string" then
kind = visualizer[kind] or fallback
else
kind = fallback
end
return (C(pattern) * CargOne) / kind
end
end
visualizers.pattern = makepattern
visualizers.makepattern = makepattern
function visualizers.load(name)
if rawget(specifications,name) == nil then
name = lower(name)
local texname = findfile(format("v-%s.mkiv",name))
local luaname = findfile(format("v-%s.lua" ,name))
if texname == "" or luaname == "" then
-- assume a user specific file
luaname = findfile(addsuffix(name,"mkiv"))
texname = findfile(addsuffix(name,"lua" ))
end
if texname == "" or luaname == "" then
-- error message
else
lua.registercode(luaname)
context.input(texname)
end
if rawget(specifications,name) == nil then
rawset(specifications,name,false)
end
end
end
function commands.doifelsevisualizer(name)
commands.testcase(specifications[lower(name)])
end
function visualizers.register(name,specification)
specifications[name] = specification
local parser, handler = specification.parser, specification.handler
local displayparser = specification.display or parser
local inlineparser = specification.inline or parser
local isparser = is_lpeg(parser)
local start, stop
if isparser then
start = makepattern(handler,"start",patterns.alwaysmatched)
stop = makepattern(handler,"stop",patterns.alwaysmatched)
end
if handler then
if isparser then
specification.display = function(content,settings)
if handler.startdisplay then handler.startdisplay(settings) end
lpegmatch(start * displayparser * stop,content,1,settings)
if handler.stopdisplay then handler.stopdisplay(settings) end
end
specification.inline = function(content,settings)
if handler.startinline then handler.startinline(settings) end
lpegmatch(start * inlineparser * stop,content,1,settings)
if handler.stopinline then handler.stopinline(settings) end
end
specification.direct = function(content,settings)
lpegmatch(parser,content,1,settings)
end
elseif parser then
specification.display = function(content,settings)
if handler.startdisplay then handler.startdisplay(settings) end
parser(content,settings)
if handler.stopdisplay then handler.stopdisplay(settings) end
end
specification.inline = function(content,settings)
if handler.startinline then handler.startinline(settings) end
parser(content,settings)
if handler.stopinline then handler.stopinline(settings) end
end
specification.direct = parser
end
elseif isparser then
specification.display = function(content,settings)
lpegmatch(start * displayparser * stop,content,1,settings)
end
specification.inline = function(content,settings)
lpegmatch(start * inlineparser * stop,content,1,settings)
end
specification.direct = function(content,settings)
lpegmatch(parser,content,1,settings)
end
elseif parser then
specification.display = parser
specification.inline = parser
specification.direct = parser
end
return specification
end
local function getvisualizer(method,nature)
local m = specifications[method] or specifications.default
if nature then
return m and (m[nature] or m.parser) or nil
else
return m and m.parser or nil
end
end
local escapepatterns = { } visualizers.escapepatterns = escapepatterns
local function texmethod(s)
context.bgroup()
context(s)
context.egroup()
end
local function defaultmethod(s,settings)
lpegmatch(getvisualizer("default"),s,1,settings)
end
function visualizers.registerescapepattern(name,before,after,normalmethod,escapemethod)
local escapepattern = escapepatterns[name]
if not escapepattern then
before, after = P(before) * patterns.space^0, patterns.space^0 * P(after)
escapepattern = (
(before / "")
* ((1 - after)^0 / (escapemethod or texmethod))
* (after / "")
+ ((1 - before)^1) / (normalmethod or defaultmethod)
)^0
escapepatterns[name] = escapepattern
end
return escapepattern
end
local escapedvisualizers = { }
local function visualize(method,nature,content,settings) -- maybe also method and nature in settings
if content and content ~= "" then
local m
local e = settings.escape
if e and e ~= "" then
local newname = format("%s-%s",e,method)
local newspec = specifications[newname]
if newspec then
m = newspec
else
local start, stop
if e == v_yes then
start, stop = "/BTEX", "/ETEX"
else
start,stop = match(e,"^(.-),(.-)$") -- todo: lpeg
end
if start and stop then
local oldvisualizer = specifications[method] or specifications.default
local oldparser = oldvisualizer.direct
local newparser = visualizers.registerescapepattern(newname,start,stop,oldparser)
m = visualizers.register(newname, {
parser = newparser,
handler = oldvisualizer.handler,
})
else
-- visualizers.register(newname,n)
specifications[newname] = m -- old spec so that we have one lookup only
end
end
else
m = specifications[method] or specifications.default
end
local n = m and m[nature]
settings.currentnature = nature or settings.nature or "display" -- tricky ... why sometimes no nature
if n then
n(content,settings)
else
fallback(content,1,settings)
end
end
end
visualizers.visualize = visualize
visualizers.getvisualizer = getvisualizer
function visualizers.visualizestring(method,content,settings)
visualize(method,"inline",content)
end
function visualizers.visualizefile(method,name,settings)
visualize(method,"display",resolvers.loadtexfile(name),settings)
end
function visualizers.visualizebuffer(method,name,settings)
visualize(method,"display",buffers.content(name),settings)
end
-- --
local space = C(patterns.space) * CargOne / f_space
local newline = C(patterns.newline) * CargOne / f_newline
local emptyline = C(patterns.emptyline) * CargOne / f_emptyline
local beginline = C(patterns.beginline) * CargOne / f_beginline
local anything = C(patterns.somecontent^1) * CargOne / f_default
local verbosed = (space + newline * (emptyline^0) * beginline + anything)^0
local function write(s,settings) -- bad name
lpegmatch(verbosed,s,1,settings or false)
end
visualizers.write = write
visualizers.writenewline = f_newline
visualizers.writeemptyline = f_emptyline
visualizers.writespace = f_space
visualizers.writedefault = f_default
function visualizers.writeargument(...)
context("{") -- If we didn't have tracing then we could
write(...) -- use a faster print to tex variant for the
context("}") -- { } tokens as they always have ctxcatcodes.
end
|