Premiere version : mise en route du suivi.
[auf_roundup.git] / roundup / cgi / TAL / TALGenerator.py
CommitLineData
c638d827
CR
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"""
15Code generator for TALInterpreter intermediate code.
16"""
17
18import re
19import cgi
20
21import TALDefs
22
23from TALDefs import NAME_RE, TAL_VERSION
24from TALDefs import I18NError, METALError, TALError
25from TALDefs import parseSubstitution
26from TranslationContext import TranslationContext, DEFAULT_DOMAIN
27
28I18N_REPLACE = 1
29I18N_CONTENT = 2
30I18N_EXPRESSION = 3
31
32_name_rx = re.compile(NAME_RE)
33
34
35class TALGenerator:
36
37 inMacroUse = 0
38 inMacroDef = 0
39 source_file = None
40
41 def __init__(self, expressionCompiler=None, xml=1, source_file=None):
42 if not expressionCompiler:
43 from DummyEngine import DummyEngine
44 expressionCompiler = DummyEngine()
45 self.expressionCompiler = expressionCompiler
46 self.CompilerError = expressionCompiler.getCompilerError()
47 # This holds the emitted opcodes representing the input
48 self.program = []
49 # The program stack for when we need to do some sub-evaluation for an
50 # intermediate result. E.g. in an i18n:name tag for which the
51 # contents describe the ${name} value.
52 self.stack = []
53 # Another stack of postponed actions. Elements on this stack are a
54 # dictionary; key/values contain useful information that
55 # emitEndElement needs to finish its calculations
56 self.todoStack = []
57 self.macros = {}
58 self.slots = {}
59 self.slotStack = []
60 self.xml = xml
61 self.emit("version", TAL_VERSION)
62 self.emit("mode", xml and "xml" or "html")
63 if source_file is not None:
64 self.source_file = source_file
65 self.emit("setSourceFile", source_file)
66 self.i18nContext = TranslationContext()
67 self.i18nLevel = 0
68
69 def getCode(self):
70 assert not self.stack
71 assert not self.todoStack
72 return self.optimize(self.program), self.macros
73
74 def optimize(self, program):
75 output = []
76 collect = []
77 cursor = 0
78 if self.xml:
79 endsep = "/>"
80 else:
81 endsep = " />"
82 for cursor in xrange(len(program)+1):
83 try:
84 item = program[cursor]
85 except IndexError:
86 item = (None, None)
87 opcode = item[0]
88 if opcode == "rawtext":
89 collect.append(item[1])
90 continue
91 if opcode == "endTag":
92 collect.append("</%s>" % item[1])
93 continue
94 if opcode == "startTag":
95 if self.optimizeStartTag(collect, item[1], item[2], ">"):
96 continue
97 if opcode == "startEndTag":
98 if self.optimizeStartTag(collect, item[1], item[2], endsep):
99 continue
100 if opcode in ("beginScope", "endScope"):
101 # Push *Scope instructions in front of any text instructions;
102 # this allows text instructions separated only by *Scope
103 # instructions to be joined together.
104 output.append(self.optimizeArgsList(item))
105 continue
106 if opcode == 'noop':
107 # This is a spacer for end tags in the face of i18n:name
108 # attributes. We can't let the optimizer collect immediately
109 # following end tags into the same rawtextOffset.
110 opcode = None
111 pass
112 text = "".join(collect)
113 if text:
114 i = text.rfind("\n")
115 if i >= 0:
116 i = len(text) - (i + 1)
117 output.append(("rawtextColumn", (text, i)))
118 else:
119 output.append(("rawtextOffset", (text, len(text))))
120 if opcode != None:
121 output.append(self.optimizeArgsList(item))
122 collect = []
123 return self.optimizeCommonTriple(output)
124
125 def optimizeArgsList(self, item):
126 if len(item) == 2:
127 return item
128 else:
129 return item[0], tuple(item[1:])
130
131 # These codes are used to indicate what sort of special actions
132 # are needed for each special attribute. (Simple attributes don't
133 # get action codes.)
134 #
135 # The special actions (which are modal) are handled by
136 # TALInterpreter.attrAction() and .attrAction_tal().
137 #
138 # Each attribute is represented by a tuple:
139 #
140 # (name, value) -- a simple name/value pair, with
141 # no special processing
142 #
143 # (name, value, action, *extra) -- attribute with special
144 # processing needs, action is a
145 # code that indicates which
146 # branch to take, and *extra
147 # contains additional,
148 # action-specific information
149 # needed by the processing
150 #
151 def optimizeStartTag(self, collect, name, attrlist, end):
152 # return true if the tag can be converted to plain text
153 if not attrlist:
154 collect.append("<%s%s" % (name, end))
155 return 1
156 opt = 1
157 new = ["<" + name]
158 for i in range(len(attrlist)):
159 item = attrlist[i]
160 if len(item) > 2:
161 opt = 0
162 name, value, action = item[:3]
163 attrlist[i] = (name, value, action) + item[3:]
164 else:
165 if item[1] is None:
166 s = item[0]
167 else:
168 s = '%s="%s"' % (item[0], TALDefs.attrEscape(item[1]))
169 attrlist[i] = item[0], s
170 new.append(" " + s)
171 # if no non-optimizable attributes were found, convert to plain text
172 if opt:
173 new.append(end)
174 collect.extend(new)
175 return opt
176
177 def optimizeCommonTriple(self, program):
178 if len(program) < 3:
179 return program
180 output = program[:2]
181 prev2, prev1 = output
182 for item in program[2:]:
183 if ( item[0] == "beginScope"
184 and prev1[0] == "setPosition"
185 and prev2[0] == "rawtextColumn"):
186 position = output.pop()[1]
187 text, column = output.pop()[1]
188 prev1 = None, None
189 closeprev = 0
190 if output and output[-1][0] == "endScope":
191 closeprev = 1
192 output.pop()
193 item = ("rawtextBeginScope",
194 (text, column, position, closeprev, item[1]))
195 output.append(item)
196 prev2 = prev1
197 prev1 = item
198 return output
199
200 def todoPush(self, todo):
201 self.todoStack.append(todo)
202
203 def todoPop(self):
204 return self.todoStack.pop()
205
206 def compileExpression(self, expr):
207 try:
208 return self.expressionCompiler.compile(expr)
209 except self.CompilerError, err:
210 raise TALError('%s in expression %s' % (err.args[0], `expr`),
211 self.position)
212
213 def pushProgram(self):
214 self.stack.append(self.program)
215 self.program = []
216
217 def popProgram(self):
218 program = self.program
219 self.program = self.stack.pop()
220 return self.optimize(program)
221
222 def pushSlots(self):
223 self.slotStack.append(self.slots)
224 self.slots = {}
225
226 def popSlots(self):
227 slots = self.slots
228 self.slots = self.slotStack.pop()
229 return slots
230
231 def emit(self, *instruction):
232 self.program.append(instruction)
233
234 def emitStartTag(self, name, attrlist, isend=0):
235 if isend:
236 opcode = "startEndTag"
237 else:
238 opcode = "startTag"
239 self.emit(opcode, name, attrlist)
240
241 def emitEndTag(self, name):
242 if self.xml and self.program and self.program[-1][0] == "startTag":
243 # Minimize empty element
244 self.program[-1] = ("startEndTag",) + self.program[-1][1:]
245 else:
246 self.emit("endTag", name)
247
248 def emitOptTag(self, name, optTag, isend):
249 program = self.popProgram() #block
250 start = self.popProgram() #start tag
251 if (isend or not program) and self.xml:
252 # Minimize empty element
253 start[-1] = ("startEndTag",) + start[-1][1:]
254 isend = 1
255 cexpr = optTag[0]
256 if cexpr:
257 cexpr = self.compileExpression(optTag[0])
258 self.emit("optTag", name, cexpr, optTag[1], isend, start, program)
259
260 def emitRawText(self, text):
261 self.emit("rawtext", text)
262
263 def emitText(self, text):
264 self.emitRawText(cgi.escape(text))
265
266 def emitDefines(self, defines):
267 for part in TALDefs.splitParts(defines):
268 m = re.match(
269 r"(?s)\s*(?:(global|local)\s+)?(%s)\s+(.*)\Z" % NAME_RE, part)
270 if not m:
271 raise TALError("invalid define syntax: " + `part`,
272 self.position)
273 scope, name, expr = m.group(1, 2, 3)
274 scope = scope or "local"
275 cexpr = self.compileExpression(expr)
276 if scope == "local":
277 self.emit("setLocal", name, cexpr)
278 else:
279 self.emit("setGlobal", name, cexpr)
280
281 def emitOnError(self, name, onError, TALtag, isend):
282 block = self.popProgram()
283 key, expr = parseSubstitution(onError)
284 cexpr = self.compileExpression(expr)
285 if key == "text":
286 self.emit("insertText", cexpr, [])
287 else:
288 assert key == "structure"
289 self.emit("insertStructure", cexpr, {}, [])
290 if TALtag:
291 self.emitOptTag(name, (None, 1), isend)
292 else:
293 self.emitEndTag(name)
294 handler = self.popProgram()
295 self.emit("onError", block, handler)
296
297 def emitCondition(self, expr):
298 cexpr = self.compileExpression(expr)
299 program = self.popProgram()
300 self.emit("condition", cexpr, program)
301
302 def emitRepeat(self, arg):
303 m = re.match("(?s)\s*(%s)\s+(.*)\Z" % NAME_RE, arg)
304 if not m:
305 raise TALError("invalid repeat syntax: " + `arg`,
306 self.position)
307 name, expr = m.group(1, 2)
308 cexpr = self.compileExpression(expr)
309 program = self.popProgram()
310 self.emit("loop", name, cexpr, program)
311
312 def emitSubstitution(self, arg, attrDict={}):
313 key, expr = parseSubstitution(arg)
314 cexpr = self.compileExpression(expr)
315 program = self.popProgram()
316 if key == "text":
317 self.emit("insertText", cexpr, program)
318 else:
319 assert key == "structure"
320 self.emit("insertStructure", cexpr, attrDict, program)
321
322 def emitI18nVariable(self, stuff):
323 # Used for i18n:name attributes. arg is extra information describing
324 # how the contents of the variable should get filled in, and it will
325 # either be a 1-tuple or a 2-tuple. If arg[0] is None, then the
326 # i18n:name value is taken implicitly from the contents of the tag,
327 # e.g. "I live in <span i18n:name="country">the USA</span>". In this
328 # case, arg[1] is the opcode sub-program describing the contents of
329 # the tag.
330 #
331 # When arg[0] is not None, it contains the tal expression used to
332 # calculate the contents of the variable, e.g.
333 # "I live in <span i18n:name="country"
334 # tal:replace="here/countryOfOrigin" />"
335 varname, action, expression = stuff
336 m = _name_rx.match(varname)
337 if m is None or m.group() != varname:
338 raise TALError("illegal i18n:name: %r" % varname, self.position)
339 key = cexpr = None
340 program = self.popProgram()
341 if action == I18N_REPLACE:
342 # This is a tag with an i18n:name and a tal:replace (implicit or
343 # explicit). Get rid of the first and last elements of the
344 # program, which are the start and end tag opcodes of the tag.
345 program = program[1:-1]
346 elif action == I18N_CONTENT:
347 # This is a tag with an i18n:name and a tal:content
348 # (explicit-only). Keep the first and last elements of the
349 # program, so we keep the start and end tag output.
350 pass
351 else:
352 assert action == I18N_EXPRESSION
353 key, expr = parseSubstitution(expression)
354 cexpr = self.compileExpression(expr)
355 # XXX Would key be anything but 'text' or None?
356 assert key in ('text', None)
357 self.emit('i18nVariable', varname, program, cexpr)
358
359 def emitTranslation(self, msgid, i18ndata):
360 program = self.popProgram()
361 if i18ndata is None:
362 self.emit('insertTranslation', msgid, program)
363 else:
364 key, expr = parseSubstitution(i18ndata)
365 cexpr = self.compileExpression(expr)
366 assert key == 'text'
367 self.emit('insertTranslation', msgid, program, cexpr)
368
369 def emitDefineMacro(self, macroName):
370 program = self.popProgram()
371 macroName = macroName.strip()
372 if self.macros.has_key(macroName):
373 raise METALError("duplicate macro definition: %s" % `macroName`,
374 self.position)
375 if not re.match('%s$' % NAME_RE, macroName):
376 raise METALError("invalid macro name: %s" % `macroName`,
377 self.position)
378 self.macros[macroName] = program
379 self.inMacroDef = self.inMacroDef - 1
380 self.emit("defineMacro", macroName, program)
381
382 def emitUseMacro(self, expr):
383 cexpr = self.compileExpression(expr)
384 program = self.popProgram()
385 self.inMacroUse = 0
386 self.emit("useMacro", expr, cexpr, self.popSlots(), program)
387
388 def emitDefineSlot(self, slotName):
389 program = self.popProgram()
390 slotName = slotName.strip()
391 if not re.match('%s$' % NAME_RE, slotName):
392 raise METALError("invalid slot name: %s" % `slotName`,
393 self.position)
394 self.emit("defineSlot", slotName, program)
395
396 def emitFillSlot(self, slotName):
397 program = self.popProgram()
398 slotName = slotName.strip()
399 if self.slots.has_key(slotName):
400 raise METALError("duplicate fill-slot name: %s" % `slotName`,
401 self.position)
402 if not re.match('%s$' % NAME_RE, slotName):
403 raise METALError("invalid slot name: %s" % `slotName`,
404 self.position)
405 self.slots[slotName] = program
406 self.inMacroUse = 1
407 self.emit("fillSlot", slotName, program)
408
409 def unEmitWhitespace(self):
410 collect = []
411 i = len(self.program) - 1
412 while i >= 0:
413 item = self.program[i]
414 if item[0] != "rawtext":
415 break
416 text = item[1]
417 if not re.match(r"\A\s*\Z", text):
418 break
419 collect.append(text)
420 i = i-1
421 del self.program[i+1:]
422 if i >= 0 and self.program[i][0] == "rawtext":
423 text = self.program[i][1]
424 m = re.search(r"\s+\Z", text)
425 if m:
426 self.program[i] = ("rawtext", text[:m.start()])
427 collect.append(m.group())
428 collect.reverse()
429 return "".join(collect)
430
431 def unEmitNewlineWhitespace(self):
432 collect = []
433 i = len(self.program)
434 while i > 0:
435 i = i-1
436 item = self.program[i]
437 if item[0] != "rawtext":
438 break
439 text = item[1]
440 if re.match(r"\A[ \t]*\Z", text):
441 collect.append(text)
442 continue
443 m = re.match(r"(?s)^(.*)(\n[ \t]*)\Z", text)
444 if not m:
445 break
446 text, rest = m.group(1, 2)
447 collect.reverse()
448 rest = rest + "".join(collect)
449 del self.program[i:]
450 if text:
451 self.emit("rawtext", text)
452 return rest
453 return None
454
455 def replaceAttrs(self, attrlist, repldict):
456 # Each entry in attrlist starts like (name, value).
457 # Result is (name, value, action, expr, xlat) if there is a
458 # tal:attributes entry for that attribute. Additional attrs
459 # defined only by tal:attributes are added here.
460 #
461 # (name, value, action, expr, xlat)
462 if not repldict:
463 return attrlist
464 newlist = []
465 for item in attrlist:
466 key = item[0]
467 if repldict.has_key(key):
468 expr, xlat, msgid = repldict[key]
469 item = item[:2] + ("replace", expr, xlat, msgid)
470 del repldict[key]
471 newlist.append(item)
472 # Add dynamic-only attributes
473 for key, (expr, xlat, msgid) in repldict.items():
474 newlist.append((key, None, "insert", expr, xlat, msgid))
475 return newlist
476
477 def emitStartElement(self, name, attrlist, taldict, metaldict, i18ndict,
478 position=(None, None), isend=0):
479 if not taldict and not metaldict and not i18ndict:
480 # Handle the simple, common case
481 self.emitStartTag(name, attrlist, isend)
482 self.todoPush({})
483 if isend:
484 self.emitEndElement(name, isend)
485 return
486
487 self.position = position
488 for key, value in taldict.items():
489 if key not in TALDefs.KNOWN_TAL_ATTRIBUTES:
490 raise TALError("bad TAL attribute: " + `key`, position)
491 if not (value or key == 'omit-tag'):
492 raise TALError("missing value for TAL attribute: " +
493 `key`, position)
494 for key, value in metaldict.items():
495 if key not in TALDefs.KNOWN_METAL_ATTRIBUTES:
496 raise METALError("bad METAL attribute: " + `key`,
497 position)
498 if not value:
499 raise TALError("missing value for METAL attribute: " +
500 `key`, position)
501 for key, value in i18ndict.items():
502 if key not in TALDefs.KNOWN_I18N_ATTRIBUTES:
503 raise I18NError("bad i18n attribute: " + `key`, position)
504 if not value and key in ("attributes", "data", "id"):
505 raise I18NError("missing value for i18n attribute: " +
506 `key`, position)
507 todo = {}
508 defineMacro = metaldict.get("define-macro")
509 useMacro = metaldict.get("use-macro")
510 defineSlot = metaldict.get("define-slot")
511 fillSlot = metaldict.get("fill-slot")
512 define = taldict.get("define")
513 condition = taldict.get("condition")
514 repeat = taldict.get("repeat")
515 content = taldict.get("content")
516 replace = taldict.get("replace")
517 attrsubst = taldict.get("attributes")
518 onError = taldict.get("on-error")
519 omitTag = taldict.get("omit-tag")
520 TALtag = taldict.get("tal tag")
521 i18nattrs = i18ndict.get("attributes")
522 # Preserve empty string if implicit msgids are used. We'll generate
523 # code with the msgid='' and calculate the right implicit msgid during
524 # interpretation phase.
525 msgid = i18ndict.get("translate")
526 varname = i18ndict.get('name')
527 i18ndata = i18ndict.get('data')
528
529 if varname and not self.i18nLevel:
530 raise I18NError(
531 "i18n:name can only occur inside a translation unit",
532 position)
533
534 if i18ndata and not msgid:
535 raise I18NError("i18n:data must be accompanied by i18n:translate",
536 position)
537
538 if len(metaldict) > 1 and (defineMacro or useMacro):
539 raise METALError("define-macro and use-macro cannot be used "
540 "together or with define-slot or fill-slot",
541 position)
542 if replace:
543 if content:
544 raise TALError(
545 "tal:content and tal:replace are mutually exclusive",
546 position)
547 if msgid is not None:
548 raise I18NError(
549 "i18n:translate and tal:replace are mutually exclusive",
550 position)
551
552 repeatWhitespace = None
553 if repeat:
554 # Hack to include preceding whitespace in the loop program
555 repeatWhitespace = self.unEmitNewlineWhitespace()
556 if position != (None, None):
557 # XXX at some point we should insist on a non-trivial position
558 self.emit("setPosition", position)
559 if self.inMacroUse:
560 if fillSlot:
561 self.pushProgram()
562 if self.source_file is not None:
563 self.emit("setSourceFile", self.source_file)
564 todo["fillSlot"] = fillSlot
565 self.inMacroUse = 0
566 else:
567 if fillSlot:
568 raise METALError("fill-slot must be within a use-macro",
569 position)
570 if not self.inMacroUse:
571 if defineMacro:
572 self.pushProgram()
573 self.emit("version", TAL_VERSION)
574 self.emit("mode", self.xml and "xml" or "html")
575 if self.source_file is not None:
576 self.emit("setSourceFile", self.source_file)
577 todo["defineMacro"] = defineMacro
578 self.inMacroDef = self.inMacroDef + 1
579 if useMacro:
580 self.pushSlots()
581 self.pushProgram()
582 todo["useMacro"] = useMacro
583 self.inMacroUse = 1
584 if defineSlot:
585 if not self.inMacroDef:
586 raise METALError(
587 "define-slot must be within a define-macro",
588 position)
589 self.pushProgram()
590 todo["defineSlot"] = defineSlot
591
592 if defineSlot or i18ndict:
593
594 domain = i18ndict.get("domain") or self.i18nContext.domain
595 source = i18ndict.get("source") or self.i18nContext.source
596 target = i18ndict.get("target") or self.i18nContext.target
597 if ( domain != DEFAULT_DOMAIN
598 or source is not None
599 or target is not None):
600 self.i18nContext = TranslationContext(self.i18nContext,
601 domain=domain,
602 source=source,
603 target=target)
604 self.emit("beginI18nContext",
605 {"domain": domain, "source": source,
606 "target": target})
607 todo["i18ncontext"] = 1
608 if taldict or i18ndict:
609 dict = {}
610 for item in attrlist:
611 key, value = item[:2]
612 dict[key] = value
613 self.emit("beginScope", dict)
614 todo["scope"] = 1
615 if onError:
616 self.pushProgram() # handler
617 if TALtag:
618 self.pushProgram() # start
619 self.emitStartTag(name, list(attrlist)) # Must copy attrlist!
620 if TALtag:
621 self.pushProgram() # start
622 self.pushProgram() # block
623 todo["onError"] = onError
624 if define:
625 self.emitDefines(define)
626 todo["define"] = define
627 if condition:
628 self.pushProgram()
629 todo["condition"] = condition
630 if repeat:
631 todo["repeat"] = repeat
632 self.pushProgram()
633 if repeatWhitespace:
634 self.emitText(repeatWhitespace)
635 if content:
636 if varname:
637 todo['i18nvar'] = (varname, I18N_CONTENT, None)
638 todo["content"] = content
639 self.pushProgram()
640 else:
641 todo["content"] = content
642 elif replace:
643 # tal:replace w/ i18n:name has slightly different semantics. What
644 # we're actually replacing then is the contents of the ${name}
645 # placeholder.
646 if varname:
647 todo['i18nvar'] = (varname, I18N_EXPRESSION, replace)
648 else:
649 todo["replace"] = replace
650 self.pushProgram()
651 # i18n:name w/o tal:replace uses the content as the interpolation
652 # dictionary values
653 elif varname:
654 todo['i18nvar'] = (varname, I18N_REPLACE, None)
655 self.pushProgram()
656 if msgid is not None:
657 self.i18nLevel += 1
658 todo['msgid'] = msgid
659 if i18ndata:
660 todo['i18ndata'] = i18ndata
661 optTag = omitTag is not None or TALtag
662 if optTag:
663 todo["optional tag"] = omitTag, TALtag
664 self.pushProgram()
665 if attrsubst or i18nattrs:
666 if attrsubst:
667 repldict = TALDefs.parseAttributeReplacements(attrsubst,
668 self.xml)
669 else:
670 repldict = {}
671 if i18nattrs:
672 i18nattrs = _parseI18nAttributes(i18nattrs, attrlist, repldict,
673 self.position, self.xml,
674 self.source_file)
675 else:
676 i18nattrs = {}
677 # Convert repldict's name-->expr mapping to a
678 # name-->(compiled_expr, translate) mapping
679 for key, value in repldict.items():
680 if i18nattrs.get(key, None):
681 raise I18NError(
682 ("attribute [%s] cannot both be part of tal:attributes" +
683 " and have a msgid in i18n:attributes") % key,
684 position)
685 ce = self.compileExpression(value)
686 repldict[key] = ce, key in i18nattrs, i18nattrs.get(key)
687 for key in i18nattrs:
688 if not repldict.has_key(key):
689 repldict[key] = None, 1, i18nattrs.get(key)
690 else:
691 repldict = {}
692 if replace:
693 todo["repldict"] = repldict
694 repldict = {}
695 self.emitStartTag(name, self.replaceAttrs(attrlist, repldict), isend)
696 if optTag:
697 self.pushProgram()
698 if content and not varname:
699 self.pushProgram()
700 if msgid is not None:
701 self.pushProgram()
702 if content and varname:
703 self.pushProgram()
704 if todo and position != (None, None):
705 todo["position"] = position
706 self.todoPush(todo)
707 if isend:
708 self.emitEndElement(name, isend)
709
710 def emitEndElement(self, name, isend=0, implied=0):
711 todo = self.todoPop()
712 if not todo:
713 # Shortcut
714 if not isend:
715 self.emitEndTag(name)
716 return
717
718 self.position = position = todo.get("position", (None, None))
719 defineMacro = todo.get("defineMacro")
720 useMacro = todo.get("useMacro")
721 defineSlot = todo.get("defineSlot")
722 fillSlot = todo.get("fillSlot")
723 repeat = todo.get("repeat")
724 content = todo.get("content")
725 replace = todo.get("replace")
726 condition = todo.get("condition")
727 onError = todo.get("onError")
728 define = todo.get("define")
729 repldict = todo.get("repldict", {})
730 scope = todo.get("scope")
731 optTag = todo.get("optional tag")
732 msgid = todo.get('msgid')
733 i18ncontext = todo.get("i18ncontext")
734 varname = todo.get('i18nvar')
735 i18ndata = todo.get('i18ndata')
736
737 if implied > 0:
738 if defineMacro or useMacro or defineSlot or fillSlot:
739 exc = METALError
740 what = "METAL"
741 else:
742 exc = TALError
743 what = "TAL"
744 raise exc("%s attributes on <%s> require explicit </%s>" %
745 (what, name, name), position)
746
747 # If there's no tal:content or tal:replace in the tag with the
748 # i18n:name, tal:replace is the default.
749 if content:
750 self.emitSubstitution(content, {})
751 # If we're looking at an implicit msgid, emit the insertTranslation
752 # opcode now, so that the end tag doesn't become part of the implicit
753 # msgid. If we're looking at an explicit msgid, it's better to emit
754 # the opcode after the i18nVariable opcode so we can better handle
755 # tags with both of them in them (and in the latter case, the contents
756 # would be thrown away for msgid purposes).
757 #
758 # Still, we should emit insertTranslation opcode before i18nVariable
759 # in case tal:content, i18n:translate and i18n:name in the same tag
760 if msgid is not None:
761 if (not varname) or (
762 varname and (varname[1] == I18N_CONTENT)):
763 self.emitTranslation(msgid, i18ndata)
764 self.i18nLevel -= 1
765 if optTag:
766 self.emitOptTag(name, optTag, isend)
767 elif not isend:
768 # If we're processing the end tag for a tag that contained
769 # i18n:name, we need to make sure that optimize() won't collect
770 # immediately following end tags into the same rawtextOffset, so
771 # put a spacer here that the optimizer will recognize.
772 if varname:
773 self.emit('noop')
774 self.emitEndTag(name)
775 # If i18n:name appeared in the same tag as tal:replace then we're
776 # going to do the substitution a little bit differently. The results
777 # of the expression go into the i18n substitution dictionary.
778 if replace:
779 self.emitSubstitution(replace, repldict)
780 elif varname:
781 # o varname[0] is the variable name
782 # o varname[1] is either
783 # - I18N_REPLACE for implicit tal:replace
784 # - I18N_CONTENT for tal:content
785 # - I18N_EXPRESSION for explicit tal:replace
786 # o varname[2] will be None for the first two actions and the
787 # replacement tal expression for the third action.
788 assert (varname[1]
789 in [I18N_REPLACE, I18N_CONTENT, I18N_EXPRESSION])
790 self.emitI18nVariable(varname)
791 # Do not test for "msgid is not None", i.e. we only want to test for
792 # explicit msgids here. See comment above.
793 if msgid is not None:
794 # in case tal:content, i18n:translate and i18n:name in the
795 # same tag insertTranslation opcode has already been
796 # emitted
797 if varname and (varname[1] <> I18N_CONTENT):
798 self.emitTranslation(msgid, i18ndata)
799 if repeat:
800 self.emitRepeat(repeat)
801 if condition:
802 self.emitCondition(condition)
803 if onError:
804 self.emitOnError(name, onError, optTag and optTag[1], isend)
805 if scope:
806 self.emit("endScope")
807 if i18ncontext:
808 self.emit("endI18nContext")
809 assert self.i18nContext.parent is not None
810 self.i18nContext = self.i18nContext.parent
811 if defineSlot:
812 self.emitDefineSlot(defineSlot)
813 if fillSlot:
814 self.emitFillSlot(fillSlot)
815 if useMacro:
816 self.emitUseMacro(useMacro)
817 if defineMacro:
818 self.emitDefineMacro(defineMacro)
819
820
821def _parseI18nAttributes(i18nattrs, attrlist, repldict, position,
822 xml, source_file):
823
824 def addAttribute(dic, attr, msgid, position, xml):
825 if not xml:
826 attr = attr.lower()
827 if attr in dic:
828 raise TALError(
829 "attribute may only be specified once in i18n:attributes: "
830 + attr,
831 position)
832 dic[attr] = msgid
833
834 d = {}
835 if ';' in i18nattrs:
836 i18nattrlist = i18nattrs.split(';')
837 i18nattrlist = [attr.strip().split()
838 for attr in i18nattrlist if attr.strip()]
839 for parts in i18nattrlist:
840 if len(parts) > 2:
841 raise TALError("illegal i18n:attributes specification: %r"
842 % parts, position)
843 if len(parts) == 2:
844 attr, msgid = parts
845 else:
846 # len(parts) == 1
847 attr = parts[0]
848 msgid = None
849 addAttribute(d, attr, msgid, position, xml)
850 else:
851 i18nattrlist = i18nattrs.split()
852 if len(i18nattrlist) == 2:
853 staticattrs = [attr[0] for attr in attrlist if len(attr) == 2]
854 if (not i18nattrlist[1] in staticattrs) and (
855 not i18nattrlist[1] in repldict):
856 attr, msgid = i18nattrlist
857 addAttribute(d, attr, msgid, position, xml)
858 else:
859 msgid = None
860 for attr in i18nattrlist:
861 addAttribute(d, attr, msgid, position, xml)
862 else:
863 msgid = None
864 for attr in i18nattrlist:
865 addAttribute(d, attr, msgid, position, xml)
866 return d
867
868def test():
869 t = TALGenerator()
870 t.pushProgram()
871 t.emit("bar")
872 p = t.popProgram()
873 t.emit("foo", p)
874
875if __name__ == "__main__":
876 test()