Mercurial > p > roundup > code

comparison roundup/cgi/TAL/TALInterpreter.py @ 1356:83f33642d220 maint-0.5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[[Metadata associated with this commit was garbled during conversion from CVS to Subversion.]]
author Richard Jones <richard@users.sourceforge.net>
date Thu, 09 Jan 2003 22:59:22 +0000
parents
children 5127c4560f1e
comparison
equal deleted inserted replaced
1242:3d0158c8c32b 1356:83f33642d220
1 ##############################################################################
2 #
3 # Copyright (c) 2001, 2002 Zope Corporation and Contributors.
4 # All Rights Reserved.
5 #
6 # This software is subject to the provisions of the Zope Public License,
7 # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
8 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11 # FOR A PARTICULAR PURPOSE
12 #
13 ##############################################################################
14 """
15 Interpreter for a pre-compiled TAL program.
16 """
17
18 import sys
19 import getopt
20
21 from cgi import escape
22
23 try:
24 from cStringIO import StringIO
25 except ImportError:
26 from StringIO import StringIO
27
28 from TALDefs import quote, TAL_VERSION, TALError, METALError
29 from TALDefs import isCurrentVersion, getProgramVersion, getProgramMode
30 from TALGenerator import TALGenerator
31
32 BOOLEAN_HTML_ATTRS = [
33 # List of Boolean attributes in HTML that should be rendered in
34 # minimized form (e.g. <img ismap> rather than <img ismap="">)
35 # From http://www.w3.org/TR/xhtml1/#guidelines (C.10)
36 # XXX The problem with this is that this is not valid XML and
37 # can't be parsed back!
38 "compact", "nowrap", "ismap", "declare", "noshade", "checked",
39 "disabled", "readonly", "multiple", "selected", "noresize",
40 "defer"
41 ]
42
43 EMPTY_HTML_TAGS = [
44 # List of HTML tags with an empty content model; these are
45 # rendered in minimized form, e.g. <img />.
46 # From http://www.w3.org/TR/xhtml1/#dtds
47 "base", "meta", "link", "hr", "br", "param", "img", "area",
48 "input", "col", "basefont", "isindex", "frame",
49 ]
50
51 class AltTALGenerator(TALGenerator):
52
53 def __init__(self, repldict, expressionCompiler=None, xml=0):
54 self.repldict = repldict
55 self.enabled = 1
56 TALGenerator.__init__(self, expressionCompiler, xml)
57
58 def enable(self, enabled):
59 self.enabled = enabled
60
61 def emit(self, *args):
62 if self.enabled:
63 apply(TALGenerator.emit, (self,) + args)
64
65 def emitStartElement(self, name, attrlist, taldict, metaldict,
66 position=(None, None), isend=0):
67 metaldict = {}
68 taldict = {}
69 if self.enabled and self.repldict:
70 taldict["attributes"] = "x x"
71 TALGenerator.emitStartElement(self, name, attrlist,
72 taldict, metaldict, position, isend)
73
74 def replaceAttrs(self, attrlist, repldict):
75 if self.enabled and self.repldict:
76 repldict = self.repldict
77 self.repldict = None
78 return TALGenerator.replaceAttrs(self, attrlist, repldict)
79
80
81 class TALInterpreter:
82
83 def __init__(self, program, macros, engine, stream=None,
84 debug=0, wrap=60, metal=1, tal=1, showtal=-1,
85 strictinsert=1, stackLimit=100):
86 self.program = program
87 self.macros = macros
88 self.engine = engine
89 self.Default = engine.getDefault()
90 self.stream = stream or sys.stdout
91 self._stream_write = self.stream.write
92 self.debug = debug
93 self.wrap = wrap
94 self.metal = metal
95 self.tal = tal
96 if tal:
97 self.dispatch = self.bytecode_handlers_tal
98 else:
99 self.dispatch = self.bytecode_handlers
100 assert showtal in (-1, 0, 1)
101 if showtal == -1:
102 showtal = (not tal)
103 self.showtal = showtal
104 self.strictinsert = strictinsert
105 self.stackLimit = stackLimit
106 self.html = 0
107 self.endsep = "/>"
108 self.endlen = len(self.endsep)
109 self.macroStack = []
110 self.popMacro = self.macroStack.pop
111 self.position = None, None # (lineno, offset)
112 self.col = 0
113 self.level = 0
114 self.scopeLevel = 0
115 self.sourceFile = None
116
117 def saveState(self):
118 return (self.position, self.col, self.stream,
119 self.scopeLevel, self.level)
120
121 def restoreState(self, state):
122 (self.position, self.col, self.stream, scopeLevel, level) = state
123 self._stream_write = self.stream.write
124 assert self.level == level
125 while self.scopeLevel > scopeLevel:
126 self.engine.endScope()
127 self.scopeLevel = self.scopeLevel - 1
128 self.engine.setPosition(self.position)
129
130 def restoreOutputState(self, state):
131 (dummy, self.col, self.stream, scopeLevel, level) = state
132 self._stream_write = self.stream.write
133 assert self.level == level
134 assert self.scopeLevel == scopeLevel
135
136 def pushMacro(self, macroName, slots, entering=1):
137 if len(self.macroStack) >= self.stackLimit:
138 raise METALError("macro nesting limit (%d) exceeded "
139 "by %s" % (self.stackLimit, `macroName`))
140 self.macroStack.append([macroName, slots, entering])
141
142 def macroContext(self, what):
143 macroStack = self.macroStack
144 i = len(macroStack)
145 while i > 0:
146 i = i-1
147 if macroStack[i][0] == what:
148 return i
149 return -1
150
151 def __call__(self):
152 assert self.level == 0
153 assert self.scopeLevel == 0
154 self.interpret(self.program)
155 assert self.level == 0
156 assert self.scopeLevel == 0
157 if self.col > 0:
158 self._stream_write("\n")
159 self.col = 0
160
161 def stream_write(self, s, len=len):
162 self._stream_write(s)
163 i = s.rfind('\n')
164 if i < 0:
165 self.col = self.col + len(s)
166 else:
167 self.col = len(s) - (i + 1)
168
169 bytecode_handlers = {}
170
171 def interpret(self, program, None=None):
172 oldlevel = self.level
173 self.level = oldlevel + 1
174 handlers = self.dispatch
175 try:
176 if self.debug:
177 for (opcode, args) in program:
178 s = "%sdo_%s%s\n" % (" "*self.level, opcode,
179 repr(args))
180 if len(s) > 80:
181 s = s[:76] + "...\n"
182 sys.stderr.write(s)
183 handlers[opcode](self, args)
184 else:
185 for (opcode, args) in program:
186 handlers[opcode](self, args)
187 finally:
188 self.level = oldlevel
189
190 def do_version(self, version):
191 assert version == TAL_VERSION
192 bytecode_handlers["version"] = do_version
193
194 def do_mode(self, mode):
195 assert mode in ("html", "xml")
196 self.html = (mode == "html")
197 if self.html:
198 self.endsep = " />"
199 else:
200 self.endsep = "/>"
201 self.endlen = len(self.endsep)
202 bytecode_handlers["mode"] = do_mode
203
204 def do_setSourceFile(self, source_file):
205 self.sourceFile = source_file
206 self.engine.setSourceFile(source_file)
207 bytecode_handlers["setSourceFile"] = do_setSourceFile
208
209 def do_setPosition(self, position):
210 self.position = position
211 self.engine.setPosition(position)
212 bytecode_handlers["setPosition"] = do_setPosition
213
214 def do_startEndTag(self, stuff):
215 self.do_startTag(stuff, self.endsep, self.endlen)
216 bytecode_handlers["startEndTag"] = do_startEndTag
217
218 def do_startTag(self, (name, attrList),
219 end=">", endlen=1, _len=len):
220 # The bytecode generator does not cause calls to this method
221 # for start tags with no attributes; those are optimized down
222 # to rawtext events. Hence, there is no special "fast path"
223 # for that case.
224 _stream_write = self._stream_write
225 _stream_write("<" + name)
226 namelen = _len(name)
227 col = self.col + namelen + 1
228 wrap = self.wrap
229 align = col + 1
230 if align >= wrap/2:
231 align = 4 # Avoid a narrow column far to the right
232 attrAction = self.dispatch["<attrAction>"]
233 try:
234 for item in attrList:
235 if _len(item) == 2:
236 name, s = item
237 else:
238 ok, name, s = attrAction(self, item)
239 if not ok:
240 continue
241 slen = _len(s)
242 if (wrap and
243 col >= align and
244 col + 1 + slen > wrap):
245 _stream_write("\n" + " "*align)
246 col = align + slen
247 else:
248 s = " " + s
249 col = col + 1 + slen
250 _stream_write(s)
251 _stream_write(end)
252 col = col + endlen
253 finally:
254 self.col = col
255 bytecode_handlers["startTag"] = do_startTag
256
257 def attrAction(self, item):
258 name, value, action = item[:3]
259 if action == 1 or (action > 1 and not self.showtal):
260 return 0, name, value
261 macs = self.macroStack
262 if action == 2 and self.metal and macs:
263 if len(macs) > 1 or not macs[-1][2]:
264 # Drop all METAL attributes at a use-depth above one.
265 return 0, name, value
266 # Clear 'entering' flag
267 macs[-1][2] = 0
268 # Convert or drop depth-one METAL attributes.
269 i = name.rfind(":") + 1
270 prefix, suffix = name[:i], name[i:]
271 if suffix == "define-macro":
272 # Convert define-macro as we enter depth one.
273 name = prefix + "use-macro"
274 value = macs[-1][0] # Macro name
275 elif suffix == "define-slot":
276 name = prefix + "slot"
277 elif suffix == "fill-slot":
278 pass
279 else:
280 return 0, name, value
281
282 if value is None:
283 value = name
284 else:
285 value = "%s=%s" % (name, quote(value))
286 return 1, name, value
287
288 def attrAction_tal(self, item):
289 name, value, action = item[:3]
290 if action > 1:
291 return self.attrAction(item)
292 ok = 1
293 if self.html and name.lower() in BOOLEAN_HTML_ATTRS:
294 evalue = self.engine.evaluateBoolean(item[3])
295 if evalue is self.Default:
296 if action == 1: # Cancelled insert
297 ok = 0
298 elif evalue:
299 value = None
300 else:
301 ok = 0
302 else:
303 evalue = self.engine.evaluateText(item[3])
304 if evalue is self.Default:
305 if action == 1: # Cancelled insert
306 ok = 0
307 else:
308 if evalue is None:
309 ok = 0
310 value = evalue
311 if ok:
312 if value is None:
313 value = name
314 value = "%s=%s" % (name, quote(value))
315 return ok, name, value
316
317 bytecode_handlers["<attrAction>"] = attrAction
318
319 def no_tag(self, start, program):
320 state = self.saveState()
321 self.stream = stream = StringIO()
322 self._stream_write = stream.write
323 self.interpret(start)
324 self.restoreOutputState(state)
325 self.interpret(program)
326
327 def do_optTag(self, (name, cexpr, tag_ns, isend, start, program),
328 omit=0):
329 if tag_ns and not self.showtal:
330 return self.no_tag(start, program)
331
332 self.interpret(start)
333 if not isend:
334 self.interpret(program)
335 s = '</%s>' % name
336 self._stream_write(s)
337 self.col = self.col + len(s)
338
339 def do_optTag_tal(self, stuff):
340 cexpr = stuff[1]
341 if cexpr is not None and (cexpr == '' or
342 self.engine.evaluateBoolean(cexpr)):
343 self.no_tag(stuff[-2], stuff[-1])
344 else:
345 self.do_optTag(stuff)
346 bytecode_handlers["optTag"] = do_optTag
347
348 def dumpMacroStack(self, prefix, suffix, value):
349 sys.stderr.write("+---- %s%s = %s\n" % (prefix, suffix, value))
350 for i in range(len(self.macroStack)):
351 what, macroName, slots = self.macroStack[i]
352 sys.stderr.write("| %2d. %-12s %-12s %s\n" %
353 (i, what, macroName, slots and slots.keys()))
354 sys.stderr.write("+--------------------------------------\n")
355
356 def do_rawtextBeginScope(self, (s, col, position, closeprev, dict)):
357 self._stream_write(s)
358 self.col = col
359 self.do_setPosition(position)
360 if closeprev:
361 engine = self.engine
362 engine.endScope()
363 engine.beginScope()
364 else:
365 self.engine.beginScope()
366 self.scopeLevel = self.scopeLevel + 1
367
368 def do_rawtextBeginScope_tal(self, (s, col, position, closeprev, dict)):
369 self._stream_write(s)
370 self.col = col
371 self.do_setPosition(position)
372 engine = self.engine
373 if closeprev:
374 engine.endScope()
375 engine.beginScope()
376 else:
377 engine.beginScope()
378 self.scopeLevel = self.scopeLevel + 1
379 engine.setLocal("attrs", dict)
380 bytecode_handlers["rawtextBeginScope"] = do_rawtextBeginScope
381
382 def do_beginScope(self, dict):
383 self.engine.beginScope()
384 self.scopeLevel = self.scopeLevel + 1
385
386 def do_beginScope_tal(self, dict):
387 engine = self.engine
388 engine.beginScope()
389 engine.setLocal("attrs", dict)
390 self.scopeLevel = self.scopeLevel + 1
391 bytecode_handlers["beginScope"] = do_beginScope
392
393 def do_endScope(self, notused=None):
394 self.engine.endScope()
395 self.scopeLevel = self.scopeLevel - 1
396 bytecode_handlers["endScope"] = do_endScope
397
398 def do_setLocal(self, notused):
399 pass
400
401 def do_setLocal_tal(self, (name, expr)):
402 self.engine.setLocal(name, self.engine.evaluateValue(expr))
403 bytecode_handlers["setLocal"] = do_setLocal
404
405 def do_setGlobal_tal(self, (name, expr)):
406 self.engine.setGlobal(name, self.engine.evaluateValue(expr))
407 bytecode_handlers["setGlobal"] = do_setLocal
408
409 def do_insertText(self, stuff):
410 self.interpret(stuff[1])
411
412 def do_insertText_tal(self, stuff):
413 text = self.engine.evaluateText(stuff[0])
414 if text is None:
415 return
416 if text is self.Default:
417 self.interpret(stuff[1])
418 return
419 s = escape(text)
420 self._stream_write(s)
421 i = s.rfind('\n')
422 if i < 0:
423 self.col = self.col + len(s)
424 else:
425 self.col = len(s) - (i + 1)
426 bytecode_handlers["insertText"] = do_insertText
427
428 def do_insertStructure(self, stuff):
429 self.interpret(stuff[2])
430
431 def do_insertStructure_tal(self, (expr, repldict, block)):
432 structure = self.engine.evaluateStructure(expr)
433 if structure is None:
434 return
435 if structure is self.Default:
436 self.interpret(block)
437 return
438 text = str(structure)
439 if not (repldict or self.strictinsert):
440 # Take a shortcut, no error checking
441 self.stream_write(text)
442 return
443 if self.html:
444 self.insertHTMLStructure(text, repldict)
445 else:
446 self.insertXMLStructure(text, repldict)
447 bytecode_handlers["insertStructure"] = do_insertStructure
448
449 def insertHTMLStructure(self, text, repldict):
450 from HTMLTALParser import HTMLTALParser
451 gen = AltTALGenerator(repldict, self.engine, 0)
452 p = HTMLTALParser(gen) # Raises an exception if text is invalid
453 p.parseString(text)
454 program, macros = p.getCode()
455 self.interpret(program)
456
457 def insertXMLStructure(self, text, repldict):
458 from TALParser import TALParser
459 gen = AltTALGenerator(repldict, self.engine, 0)
460 p = TALParser(gen)
461 gen.enable(0)
462 p.parseFragment('<!DOCTYPE foo PUBLIC "foo" "bar"><foo>')
463 gen.enable(1)
464 p.parseFragment(text) # Raises an exception if text is invalid
465 gen.enable(0)
466 p.parseFragment('</foo>', 1)
467 program, macros = gen.getCode()
468 self.interpret(program)
469
470 def do_loop(self, (name, expr, block)):
471 self.interpret(block)
472
473 def do_loop_tal(self, (name, expr, block)):
474 iterator = self.engine.setRepeat(name, expr)
475 while iterator.next():
476 self.interpret(block)
477 bytecode_handlers["loop"] = do_loop
478
479 def do_rawtextColumn(self, (s, col)):
480 self._stream_write(s)
481 self.col = col
482 bytecode_handlers["rawtextColumn"] = do_rawtextColumn
483
484 def do_rawtextOffset(self, (s, offset)):
485 self._stream_write(s)
486 self.col = self.col + offset
487 bytecode_handlers["rawtextOffset"] = do_rawtextOffset
488
489 def do_condition(self, (condition, block)):
490 if not self.tal or self.engine.evaluateBoolean(condition):
491 self.interpret(block)
492 bytecode_handlers["condition"] = do_condition
493
494 def do_defineMacro(self, (macroName, macro)):
495 macs = self.macroStack
496 if len(macs) == 1:
497 entering = macs[-1][2]
498 if not entering:
499 macs.append(None)
500 self.interpret(macro)
501 macs.pop()
502 return
503 self.interpret(macro)
504 bytecode_handlers["defineMacro"] = do_defineMacro
505
506 def do_useMacro(self, (macroName, macroExpr, compiledSlots, block)):
507 if not self.metal:
508 self.interpret(block)
509 return
510 macro = self.engine.evaluateMacro(macroExpr)
511 if macro is self.Default:
512 macro = block
513 else:
514 if not isCurrentVersion(macro):
515 raise METALError("macro %s has incompatible version %s" %
516 (`macroName`, `getProgramVersion(macro)`),
517 self.position)
518 mode = getProgramMode(macro)
519 if mode != (self.html and "html" or "xml"):
520 raise METALError("macro %s has incompatible mode %s" %
521 (`macroName`, `mode`), self.position)
522 self.pushMacro(macroName, compiledSlots)
523 saved_source = self.sourceFile
524 saved_position = self.position # Used by Boa Constructor
525 self.interpret(macro)
526 if self.sourceFile != saved_source:
527 self.engine.setSourceFile(saved_source)
528 self.sourceFile = saved_source
529 self.popMacro()
530 bytecode_handlers["useMacro"] = do_useMacro
531
532 def do_fillSlot(self, (slotName, block)):
533 # This is only executed if the enclosing 'use-macro' evaluates
534 # to 'default'.
535 self.interpret(block)
536 bytecode_handlers["fillSlot"] = do_fillSlot
537
538 def do_defineSlot(self, (slotName, block)):
539 if not self.metal:
540 self.interpret(block)
541 return
542 macs = self.macroStack
543 if macs and macs[-1] is not None:
544 saved_source = self.sourceFile
545 saved_position = self.position # Used by Boa Constructor
546 macroName, slots = self.popMacro()[:2]
547 slot = slots.get(slotName)
548 if slot is not None:
549 self.interpret(slot)
550 if self.sourceFile != saved_source:
551 self.engine.setSourceFile(saved_source)
552 self.sourceFile = saved_source
553 self.pushMacro(macroName, slots, entering=0)
554 return
555 self.pushMacro(macroName, slots)
556 if len(macs) == 1:
557 self.interpret(block)
558 return
559 self.interpret(block)
560 bytecode_handlers["defineSlot"] = do_defineSlot
561
562 def do_onError(self, (block, handler)):
563 self.interpret(block)
564
565 def do_onError_tal(self, (block, handler)):
566 state = self.saveState()
567 self.stream = stream = StringIO()
568 self._stream_write = stream.write
569 try:
570 self.interpret(block)
571 except:
572 exc = sys.exc_info()[1]
573 self.restoreState(state)
574 engine = self.engine
575 engine.beginScope()
576 error = engine.createErrorInfo(exc, self.position)
577 engine.setLocal('error', error)
578 try:
579 self.interpret(handler)
580 finally:
581 engine.endScope()
582 else:
583 self.restoreOutputState(state)
584 self.stream_write(stream.getvalue())
585 bytecode_handlers["onError"] = do_onError
586
587 bytecode_handlers_tal = bytecode_handlers.copy()
588 bytecode_handlers_tal["rawtextBeginScope"] = do_rawtextBeginScope_tal
589 bytecode_handlers_tal["beginScope"] = do_beginScope_tal
590 bytecode_handlers_tal["setLocal"] = do_setLocal_tal
591 bytecode_handlers_tal["setGlobal"] = do_setGlobal_tal
592 bytecode_handlers_tal["insertStructure"] = do_insertStructure_tal
593 bytecode_handlers_tal["insertText"] = do_insertText_tal
594 bytecode_handlers_tal["loop"] = do_loop_tal
595 bytecode_handlers_tal["onError"] = do_onError_tal
596 bytecode_handlers_tal["<attrAction>"] = attrAction_tal
597 bytecode_handlers_tal["optTag"] = do_optTag_tal
598
599
600 def test():
601 from driver import FILE, parsefile
602 from DummyEngine import DummyEngine
603 try:
604 opts, args = getopt.getopt(sys.argv[1:], "")
605 except getopt.error, msg:
606 print msg
607 sys.exit(2)
608 if args:
609 file = args[0]
610 else:
611 file = FILE
612 doc = parsefile(file)
613 compiler = TALCompiler(doc)
614 program, macros = compiler()
615 engine = DummyEngine()
616 interpreter = TALInterpreter(program, macros, engine)
617 interpreter()
618
619 if __name__ == "__main__":
620 test()
Roundup Issue Tracker: http://roundup-tracker.org/