Mercurial Repository: p/roundup/code: roundup/cgi/TAL/TALInterpreter.py comparison

comparison roundup/cgi/TAL/TALInterpreter.py @ 5393:46b2fd6d342e

Python 3 preparation: avoid implicit tuple parameter unpacking. Tool-assisted patch.

author	Joseph Myers <jsm@polyomino.org.uk>
date	Tue, 24 Jul 2018 23:02:44 +0000
parents	d26921b851c3
children	2120f77554d5

comparison

equal deleted inserted replaced

-:a7bf8c4e502f
+:46b2fd6d342e
 def do_startEndTag(self, stuff):
 self.do_startTag(stuff, self.endsep, self.endlen)
 bytecode_handlers["startEndTag"] = do_startEndTag
-def do_startTag(self, (name, attrList),
+def do_startTag(self, name_attrList,
 end=">", endlen=1, _len=len):
 # The bytecode generator does not cause calls to this method
 # for start tags with no attributes; those are optimized down
 # to rawtext events.  Hence, there is no special "fast path"
 # for that case.
+(name, attrList) = name_attrList
 L = ["<", name]
 append = L.append
 col = self.col + _len(name) + 1
 wrap = self.wrap
 align = col + 1
 self._stream_write = stream.write
 self.interpret(start)
 self.restoreOutputState(state)
 self.interpret(program)
-def do_optTag(self, (name, cexpr, tag_ns, isend, start, program),
+def do_optTag(self, args_tuple,
 omit=0):
+(name, cexpr, tag_ns, isend, start, program) = args_tuple
 if tag_ns and not self.showtal:
 return self.no_tag(start, program)
 self.interpret(start)
 if not isend:
 self.no_tag(stuff[-2], stuff[-1])
 else:
 self.do_optTag(stuff)
 bytecode_handlers["optTag"] = do_optTag
-def do_rawtextBeginScope(self, (s, col, position, closeprev, dict)):
+def do_rawtextBeginScope(self, args_tuple):
+(s, col, position, closeprev, dict) = args_tuple
 self._stream_write(s)
 self.col = col
 self.position = position
 self.engine.setPosition(position)
 if closeprev:
 engine.beginScope()
 else:
 self.engine.beginScope()
 self.scopeLevel = self.scopeLevel + 1
-def do_rawtextBeginScope_tal(self, (s, col, position, closeprev, dict)):
+def do_rawtextBeginScope_tal(self, args_tuple):
+(s, col, position, closeprev, dict) = args_tuple
 self._stream_write(s)
 self.col = col
 engine = self.engine
 self.position = position
 engine.setPosition(position)
 bytecode_handlers["endScope"] = do_endScope
 def do_setLocal(self, notused):
 pass
-def do_setLocal_tal(self, (name, expr)):
+def do_setLocal_tal(self, name_expr):
+(name, expr) = name_expr
 self.engine.setLocal(name, self.engine.evaluateValue(expr))
 bytecode_handlers["setLocal"] = do_setLocal
-def do_setGlobal_tal(self, (name, expr)):
+def do_setGlobal_tal(self, name_expr):
+(name, expr) = name_expr
 self.engine.setGlobal(name, self.engine.evaluateValue(expr))
 bytecode_handlers["setGlobal"] = do_setLocal
 def do_beginI18nContext(self, settings):
 get = settings.get
 bytecode_handlers['insertTranslation'] = do_insertTranslation
 def do_insertStructure(self, stuff):
 self.interpret(stuff[2])
-def do_insertStructure_tal(self, (expr, repldict, block)):
+def do_insertStructure_tal(self, expr_repldict_block):
+(expr, repldict, block) = expr_repldict_block
 structure = self.engine.evaluateStructure(expr)
 if structure is None:
 return
 if structure is self.Default:
 self.interpret(block)
 gen.enable(0)
 p.parseFragment('</foo>', 1)
 program, macros = gen.getCode()
 self.interpret(program)
-def do_loop(self, (name, expr, block)):
+def do_loop(self, name_expr_block):
+(name, expr, block) = name_expr_block
 self.interpret(block)
-def do_loop_tal(self, (name, expr, block)):
+def do_loop_tal(self, name_expr_block):
+(name, expr, block) = name_expr_block
 iterator = self.engine.setRepeat(name, expr)
 while iterator.next():
 self.interpret(block)
 bytecode_handlers["loop"] = do_loop
 return msgid
 # XXX We need to pass in one of context or target_language
 return self.engine.translate(self.i18nContext.domain,
 msgid, i18ndict, default=default)
-def do_rawtextColumn(self, (s, col)):
+def do_rawtextColumn(self, s_col):
+(s, col) = s_col
 self._stream_write(s)
 self.col = col
 bytecode_handlers["rawtextColumn"] = do_rawtextColumn
-def do_rawtextOffset(self, (s, offset)):
+def do_rawtextOffset(self, s_offset):
+(s, offset) = s_offset
 self._stream_write(s)
 self.col = self.col + offset
 bytecode_handlers["rawtextOffset"] = do_rawtextOffset
-def do_condition(self, (condition, block)):
+def do_condition(self, condition_block):
+(condition, block) = condition_block
 if not self.tal or self.engine.evaluateBoolean(condition):
 self.interpret(block)
 bytecode_handlers["condition"] = do_condition
-def do_defineMacro(self, (macroName, macro)):
+def do_defineMacro(self, macroName_macro):
+(macroName, macro) = macroName_macro
 macs = self.macroStack
 if len(macs) == 1:
 entering = macs[-1][2]
 if not entering:
 macs.append(None)
 macs.pop()
 return
 self.interpret(macro)
 bytecode_handlers["defineMacro"] = do_defineMacro
-def do_useMacro(self, (macroName, macroExpr, compiledSlots, block)):
+def do_useMacro(self, args_tuple):
+(macroName, macroExpr, compiledSlots, block) = args_tuple
 if not self.metal:
 self.interpret(block)
 return
 macro = self.engine.evaluateMacro(macroExpr)
 if macro is self.Default:
 self.engine.setSourceFile(prev_source)
 self.sourceFile = prev_source
 self.popMacro()
 bytecode_handlers["useMacro"] = do_useMacro
-def do_fillSlot(self, (slotName, block)):
+def do_fillSlot(self, slotName_block):
 # This is only executed if the enclosing 'use-macro' evaluates
 # to 'default'.
+(slotName, block) = slotName_block
 self.interpret(block)
 bytecode_handlers["fillSlot"] = do_fillSlot
-def do_defineSlot(self, (slotName, block)):
+def do_defineSlot(self, slotName_block):
+(slotName, block) = slotName_block
 if not self.metal:
 self.interpret(block)
 return
 macs = self.macroStack
 if macs and macs[-1] is not None:
 self.pushMacro(macroName, slots)
 # Falling out of the 'if' allows the macro to be interpreted.
 self.interpret(block)
 bytecode_handlers["defineSlot"] = do_defineSlot
-def do_onError(self, (block, handler)):
+def do_onError(self, block_handler):
+(block, handler) = block_handler
 self.interpret(block)
-def do_onError_tal(self, (block, handler)):
+def do_onError_tal(self, block_handler):
+(block, handler) = block_handler
 state = self.saveState()
 self.stream = stream = self.StringIO()
 self._stream_write = stream.write
 try:
 self.interpret(block)

Mercurial > p > roundup > code

comparison roundup/cgi/TAL/TALInterpreter.py @ 5393:46b2fd6d342e