#!/usr/bin/env python  """ Translate the AST of a Python program into a more interpretable representation.  Copyright (C) 2007, 2008 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from micropython.common import * from micropython.data import * from micropython.rsvp import * import compiler.ast from compiler.visitor import ASTVisitor  # Program visitors.  class Translation(ASTVisitor):      "A translated module."      supported_optimisations = [         "constant_storage", "source_storage", "known_target", "self_access",         "temp_storage", "load_operations", "no_operations", "unused_results"         ]      # Attribute access instructions, for use with the appropriate handlers.      attribute_load_instructions = (LoadAddress, LoadAddressContext, LoadAttr, LoadAttrIndex)     attribute_store_instructions = (None, None, StoreAttr, StoreAttrIndex)      # Name access instructions, for use with the appropriate handlers.      name_load_instructions = (LoadName, LoadAddress)     name_store_instructions = (StoreName, StoreAddress)      # Instructions which affect the current value.      current_value_instructions = (LoadConst, LoadName, LoadTemp, LoadAddress, LoadAddressContext, LoadAttr, LoadAttrIndex,         LoadCallable, LoadContext, LoadResult, LoadException, MakeObject)      def __init__(self, module, importer, optimisations=None):          """         Initialise the translation with an inspected 'module', the 'importer'         and optional 'optimisations'. See the 'supported_optimisations'         attribute of this class for permitted values.         """          ASTVisitor.__init__(self)         self.visitor = self         self.module = module          # Global program dependencies.          self.importer = importer         self.objtable = self.importer.get_object_table()         self.paramtable = self.importer.get_parameter_table()         self.builtins = self.importer.modules.get("__builtins__")          # Desired optimisations.          self.optimisations = set(optimisations or [])          # The current unit being translated.          self.unit = None          # The current "active" instruction.         # As a rule, this will become the last instruction, but some         # control-flow operations will flush the "active" instruction.          self.active = None         self.active_value = None          # The temporary storage used by the current assignment expression.          self.expr_temp = None          # Wiring within the code.          self.labels = {}         self.label_number = 0         self.loop_labels = []         self.exception_labels = []          # The code itself. This is limited to the code for a particular block         # being processed. Also retained is information about temporary values         # and instructions which construct frames.          self.code = None         self.temp_positions = set()         self.max_temp_position = -1         self.frame_makers = []      def __repr__(self):         return "Translation(%r)" % self.module      def get_module_code(self):          "Return the top-level module code."          self.unit = self.module         self.code = []         self.temp_positions = set()         self.max_temp_position = -1          if self.module.module is not None:             self.dispatch(self.module.module)          self.unit.temp_usage = self.max_temp_position + 1         return self.code      def get_code(self, unit):          "Return the code for the given 'unit'."          self.unit = unit         self.code = []         self.temp_positions = set()         self.max_temp_position = -1          if unit.astnode is not None:             self.dispatch(unit.astnode)          self.unit.temp_usage = self.max_temp_position + 1         return self.code      def get_instantiator_code(self, cls):          "Return the code for the given class 'cls'."          self.unit = cls.get_instantiator()         self.code = []         self.temp_positions = set()         self.max_temp_position = -1          init_method = cls.get_init_method()          # Convert this frame back to being an invocation frame.          self.new_op(RecoverFrame())          # Fix the current frame to include a new storage slot at the beginning.          self.new_op(AdjustFrame(-1))          # Make an object.          self.make_object(cls, len(cls.instance_attributes()))         self.new_op(StoreFrame(0))          # Invoke the appropriate initialiser.          self.new_op(LoadConst(init_method))         self.new_op(LoadCallable())         self.new_op(JumpWithFrame())          # Store the object as the result.          self.new_op(LoadName(init_method.all_locals()["self"])) # load the context in the invocation frame         self.new_op(StoreResult())         self.new_op(Return())          return self.code      # Allocation-related methods.      def make_object(self, cls, n):          """         Request a new object with the given class 'cls' and with 'n' attributes.         """          # NOTE: Object headers are one location.          self.new_op(LoadConst(cls))         self.new_op(MakeObject(n + 1))      # Name-related methods.      def get_scope(self, name):          "Return the scope for the given 'name'."          if self.unit.has_key(name):             return "local"         elif self.module.has_key(name):             return "global"         else:             return "builtins"      def load_builtin(self, name, node):          "Generate an instruction loading 'name' for the given 'node'."          self.new_op(LoadAddress(self.get_builtin(name, node)))      def get_builtin_class(self, name, node):         return self.get_builtin(name, node).value      def get_builtin(self, name, node):          """         Return the built-in module definition for the given 'name', used by the         given 'node'.         """          if self.builtins is not None:             try:                 return self.builtins[name]             except KeyError:                 raise TranslateError(self.module.full_name(), node, "No __builtins__ definition is available for name %r." % name)         else:             raise TranslateError(self.module.full_name(), node, "No __builtins__ module is available for name %r." % name)      # Code feature methods.      def new_label(self):          "Return a new label object for use with set_label."          number = self.label_number         label = Label(number)         self.labels[label] = label         self.label_number += 1         return label      def set_label(self, label):          """         Set the location of 'label' to that within the entire image: the         location within the code combined with location of the code unit.         """          label.location = len(self.code) + self.unit.code_location      def get_loop_labels(self):         return self.loop_labels[-1]      def add_loop_labels(self, next_label, exit_label):         self.loop_labels.append((next_label, exit_label))      def drop_loop_labels(self):         self.loop_labels.pop()      def get_exception_labels(self):         return self.exception_labels[-1]      def add_exception_labels(self, handler_label, exit_label):         self.exception_labels.append((handler_label, exit_label))      def drop_exception_labels(self):         self.exception_labels.pop()      # Assignment expression values.      def record_value(self):         self.expr_temp = self._optimise_temp_storage()         self.active_source = self.active      def discard_value(self):         self.discard_temp(self.expr_temp)         self.expr_temp = None         self.active_source = None      def set_source(self):         if self.active is not None:             self.active.source = self.expr_temp          # Optimise away constant storage if appropriate.          self._optimise_constant_storage()      # Temporary storage administration.      def get_temp(self):          """         Add a temporary storage instruction for the current value and return a         sequence of access instructions.         """          position_in_frame = self.reserve_temp()         self.new_op(StoreTemp(position_in_frame))         return LoadTemp(position_in_frame)      def reserve_temp(self):         if not self.temp_positions:             temp_position = 0         else:             temp_position = max(self.temp_positions)         self.temp_positions.add(temp_position)         self.max_temp_position = max(self.max_temp_position, temp_position)         return self.unit.all_local_usage + temp_position # position in frame      def discard_temp(self, instruction=None):         if isinstance(instruction, LoadTemp):             temp_position = instruction.attr - self.unit.all_local_usage             self.free_temp(temp_position)      def free_temp(self, temp_position):         if temp_position in self.temp_positions:             self.temp_positions.remove(temp_position)      def set_frame_usage(self, node, extend):         extend.attr = self.max_temp_position + node.unit.local_usage # NOTE: See get_code for similar code.      # Code writing methods.      def new_op(self, op):          "Add 'op' to the generated code."          # Optimise load operations employed by this instruction.          self._optimise_load_operations(op)         if self._optimise_away_no_operations(op):             return          self.code.append(op)         self.active = op          # Record specific types of instructions for optimisation.          if isinstance(op, self.current_value_instructions):             self.active_value = op      def remove_op(self):          "Remove the last instruction."          op = self.code.pop()         self.active = None      def remove_active_value(self):          "Remove the value-providing active instruction if appropriate."          if self.active_value is self.active:             self.remove_op()      def replace_op(self, op):          "Replace the last added instruction with 'op'."          self.remove_op()         self.new_op(op)      def replace_active_value(self, op):          """         Replace the value-providing active instruction with 'op' if appropriate.         """          self.remove_active_value()         self.new_op(op)      def last_op(self):          "Return the last added instruction."          try:             return self.code[-1]         except IndexError:             return None      def clear_active(self):          "Prevent incorrect optimisation."          self.active = None         self.active_value = None         self.active_source = None      # Optimisation tests.      def _should_optimise_constant_storage(self):         return "constant_storage" in self.optimisations      def _should_optimise_source_storage(self):         return "source_storage" in self.optimisations      def _should_optimise_known_target(self):         return "known_target" in self.optimisations      def _should_optimise_self_access(self):         return "self_access" in self.optimisations      def _should_optimise_temp_storage(self):         return "temp_storage" in self.optimisations      def _should_optimise_load_operations(self):         return "load_operations" in self.optimisations      def _should_optimise_away_no_operations(self):         return "no_operations" in self.optimisations      def _should_optimise_unused_results(self):         return "unused_results" in self.optimisations      # Simple tests.      def _is_constant_input(self, instruction):          "Return whether 'instruction' provides a constant input."          return isinstance(instruction, LoadAddress) and instruction.attr.assignments == 1 or \             isinstance(instruction, LoadConst)      def _is_constant_target(self, instruction):          "Return whether 'instruction' provides a constant target."          return isinstance(instruction, (StoreName, StoreAddress)) and \             instruction.attr.assignments == 1      def _is_simple_input(self, instruction):          """         Return whether 'instruction' provides a simple input (typically a load         instruction).         """          return isinstance(instruction, (LoadConst, LoadName, LoadTemp, LoadResult, LoadAddress))      def _is_simple_input_user(self, instruction):          "Return whether 'instruction' can use simple input from the current value."          return isinstance(instruction, (             StoreTemp, StoreFrame, StoreResult, StoreException, # as the value being stored             LoadAddressContext, LoadAttr, LoadAttrIndex,        # as the object being referenced             StoreAttr, StoreAttrIndex, StoreCallable,           # as the object being referenced             LoadCallable,             TestIdentity, TestIdentityAddress, CheckSelf,       # as one of the operands             CheckFrame, MakeObject,             LoadContext                                         # as the object providing the result             ))      def _is_resultant_no_operation(self, instruction):          """         Return whether 'instruction' merely stores its input where the input         originally came from.         """          return (             isinstance(instruction.input, LoadTemp) and isinstance(instruction, StoreTemp) and                 instruction.input.attr == instruction.attr) or (             isinstance(instruction.input, LoadResult) and isinstance(instruction, StoreResult)             )      def _is_input(self, instruction):          "Return whether 'instruction' provides an input."          return isinstance(instruction, self.current_value_instructions)      # Convenience tests on outputs.      def _have_constant_target(self):          "Return whether the active instruction provides a constant target."          return self._is_constant_target(self.active)      def _have_constant_source(self):          "Return whether the active instruction has a constant source."          return self._is_constant_input(self.active.source)      # Convenience tests on inputs.      def _have_constant_input(self):          "Return whether the active instruction provides a constant input."          return self._is_constant_input(self.active_value)      _have_known_target = _have_constant_input      def _have_simple_input(self):          "Return whether the active instruction provides a simple input."          return self._is_simple_input(self.active_value)      def _have_input(self):          "Return whether the active instruction provides an input."          return self._is_input(self.active_value)      def _have_self_input(self):          "Return whether the active instruction is a reference to self."          return isinstance(self.unit, Function) and \             self.unit.is_method() and isinstance(self.active_value, LoadName) and \             self.active_value.attr.name == "self"      def _have_temp_compatible_access(self):          """         Indicate whether the active instruction can be used in place of access         to a temporary variable retaining the result of the last instruction.         """          # LoadResult cannot be relied upon in general since the result register         # could be updated since first being referenced.          return isinstance(self.active_value, (LoadName, LoadTemp, LoadAddress, LoadConst)) or \             isinstance(self.active_value, LoadResult) and self.active_value is self.active      def _have_correct_self_for_target(self, context):          "Return whether the 'context' is compatible with the current value."          if context is not None and self._have_self_input():              parent = self.unit.parent             if parent is context or parent.has_subclass(context) or context.has_subclass(parent):                 return 1          return 0      # Optimisation methods. See the supported_optimisations class attribute.      def _optimise_constant_storage(self):          """         Where the last operation stores a constant into a target which is also         constant, optimise away both operations.         """          if self._should_optimise_constant_storage() and \             self._have_constant_target() and \             self._have_constant_source():              self.remove_op()             return 1         else:             return 0      def _optimise_source_storage(self):          """         Where the source value in an assignment can be inserted into the         eventual target without intermediate storage, optimise away the storage         instruction.         """          if self._should_optimise_source_storage() and \             self.active_source is not None and \             self.active_source.source is None and \             self.active_source.input is None and \             self.active_source is self.active:              self.remove_op()             return 1         else:             return 0      def _optimise_known_target(self):          """         Where the target of an invocation is known, provide information about it         and its context. If a class is being invoked and the conditions are         appropriate, get information about the specific initialiser.         """          if self._should_optimise_known_target() and self._have_known_target():             last = self.active_value             target = last.attr.value             context = last.attr.context              return target, context         else:             return None      def _optimise_self_access(self, attrname, classes, node):          """         Where the provided 'attrname' accesses an attribute which occupies the         same position in all possible objects which can be accessed, generate an         instruction using one of the given 'classes', accessing the attribute         directly.         """          AddressInstruction, AddressContextInstruction, AttrInstruction = classes          if self._should_optimise_self_access() and self._have_self_input() and \             not self.unit.is_relocated(attrname):              # Either generate an instruction operating on an instance attribute.              try:                 attr = self.unit.parent.instance_attributes()[attrname]                 self.new_op(AttrInstruction(attr))              # Or generate an instruction operating on a class attribute.              except KeyError:                 attr = self.unit.parent.all_attributes()[attrname]                  # Switch the context if the class attribute is compatible with                 # the instance.                  if attr.defined_within_hierarchy():                      # Only permit loading (not storing) of class attributes via self.                      if AddressContextInstruction is not None:                         self.new_op(AddressContextInstruction(attr))                     else:                         raise TranslateError(self.module.full_name(), node,                             "Storing of class attribute %r via self not permitted." % attrname)                  # Preserve the context if the class attribute comes from an                 # incompatible class.                  else:                     if AddressInstruction is not None:                         self.new_op(AddressInstruction(attr))                     else:                         raise TranslateError(self.module.full_name(), node,                             "Storing of class attribute %r via self not permitted." % attrname)              return 1         else:             return 0      def _optimise_temp_storage(self):          """         Where the next operation would involve storing a value into temporary         storage at 'temp_position', record and remove any simple instruction         which produced the value to be stored such that instead of subsequently         accessing the temporary storage, that instruction is substituted.          If no optimisation can be achieved, a StoreTemp instruction is produced         and the appropriate LoadTemp instruction is returned.          Restriction: for use only in situations where the source of the         temporary data will not be disturbed between its first access and its         subsequent use.         """          if self._should_optimise_temp_storage() and \             self._have_temp_compatible_access():              removed = self.active             self.remove_active_value()             return removed         else:             return self.get_temp()      def _optimise_load_operations(self, instruction):          """         Incorporate previous load operations into other operations.         """          if self._should_optimise_load_operations() and \             self._have_simple_input() and \             self._is_simple_input_user(instruction):              self.remove_active_value()             instruction.input = self.active_value      def _optimise_away_no_operations(self, instruction):          """         Optimise away operations which just store their inputs in the place         the inputs originally came from.         """          if self._should_optimise_away_no_operations() and \             self._is_resultant_no_operation(instruction):              return 1         else:             return 0      def _optimise_unused_results(self):          "Discard results which will not be used."          if self._have_simple_input():             self.remove_active_value()      # Visitor methods.      def default(self, node, *args):         raise TranslateError(self.module.full_name(), node, "Node class %r is not supported." % node.__class__)      def dispatch(self, node, *args):         return ASTVisitor.dispatch(self, node, *args)      # Internal helper methods.      def _visitAttr(self, node, classes):          """         Visit the attribute-related 'node', generating instructions based on the         given 'classes'.         """          self.dispatch(node.expr)         self._generateAttr(node, node.attrname, classes)      def _generateAttr(self, node, attrname, classes):          """         Generate code for the access to 'attrname' using the given 'classes'.         """          AddressInstruction, AddressContextInstruction, AttrInstruction, AttrIndexInstruction = classes          # Where the last operation (defining the attribute owner) yields a         # constant...          if self._have_constant_input():             last = self.active_value              # Get the details of the access.              if isinstance(last.attr, Const):                 target_name = last.attr.value_type_name()             else:                 target = last.attr.value                  if isinstance(target, Const):                     target_name = target.value_type_name()                 elif isinstance(target, Instance):                     target_name = None # skip production of optimised code                 else:                     target_name = target.full_name()              # Only try and discover the position if the target can be resolved.              if target_name is not None:                  # Access the object table to get the attribute position.                  try:                     table_entry = self.objtable.table[target_name]                 except KeyError:                     raise TranslateError(self.module.full_name(), node,                         "No object entry exists for target %r." % target_name)                  try:                     pos = table_entry[attrname]                 except KeyError:                     raise TranslateError(self.module.full_name(), node,                         "No attribute entry exists for name %r in target %r." % (attrname, target_name))                  # Produce a suitable instruction.                  if AddressInstruction is not None:                     self.replace_active_value(AddressInstruction(pos))                 else:                     raise TranslateError(self.module.full_name(), node,                         "Storing of class or module attribute %r via an object is not permitted." % attrname)                  return          # Where the last operation involves the special 'self' name, check to         # see if the attribute is acceptably positioned and produce a direct         # access to the attribute.          elif self._optimise_self_access(attrname, (AddressInstruction, AddressContextInstruction, AttrInstruction), node):             return          # Otherwise, perform a normal operation.          try:             index = self.objtable.get_index(attrname)         except self.objtable.TableError:             raise TranslateError(self.module.full_name(), node,                 "No attribute entry exists for name %r." % attrname)          self.new_op(AttrIndexInstruction(index))      # Invocations involve the following:     #     # 1. Reservation of a frame for the arguments     # 2. Identification of the target which is then held in temporary storage     # 3. Optional inclusion of a context (important for methods)     # 4. Preparation of the argument frame     # 5. Invocation of the target     # 6. Discarding of the frame     #     # In order to support nested invocations - eg. a(b(c)) - use of the     # temporary storage is essential.      def _startCallFunc(self):          "Record the location of the invocation."          op = MakeFrame()         self.new_op(op) # records the start of the frame         self.frame_makers.append(op)      def _generateCallFunc(self, args, node):          """         Support a generic function invocation using the given 'args', occurring         on the given 'node', where the expression providing the invocation         target has just been generated.          In other situations, the invocation is much simpler and does not need to         handle the full flexibility of a typical Python invocation. Internal         invocations, such as those employed by operators and certain         control-flow mechanisms, use predetermined arguments and arguably do not         need to support the same things as the more general invocations.         """          target, context, temp = self._generateCallFuncContext()         self._generateCallFuncArgs(target, context, temp, args, node)         return temp, target      def _generateCallFuncContext(self):          """         Produce code which loads and checks the context of the current         invocation, the instructions for whose target have already been         produced, returning a list of instructions which reference the         invocation target.         """          t = self._optimise_known_target()         if t:             target, context = t         else:             target, context = None, None          # Store the target in temporary storage for subsequent referencing.         # NOTE: This may not be appropriate for class invocations         # NOTE: (instantiation).          temp = self._optimise_temp_storage()          # Where a target or context are not known or where an instance is known         # to be the context, load the context.          if target is None or isinstance(context, Instance):             self.new_op(temp)             self.new_op(LoadContext())             self.new_op(StoreFrame(0))          # For known instantiations, provide a new object as the first argument         # to the __init__ method.          elif isinstance(target, Class):             self.make_object(target, len(target.instance_attributes()))             self.new_op(StoreFrame(0))          # Otherwise omit the context.          else:             pass # NOTE: Class methods should be supported.          return target, context, temp      def _generateCallFuncArgs(self, target, context, temp, args, node):          """         Given invocation 'target' and 'context' information, the 'temp'         reference to the target, a list of nodes representing the 'args'         (arguments), generate instructions which load the arguments for the         invocation defined by the given 'node'.         """          # Evaluate the arguments.          employed_positions = set()         employed_keywords = set()         extra_keywords = []          # Find keyword arguments in advance in order to help resolve targets.          for arg in args:             if isinstance(arg, compiler.ast.Keyword):                 employed_keywords.add(arg.name)          possible_targets = self.paramtable.all_possible_objects(employed_keywords)          # Note the presence of the context in the frame where appropriate.          if target is None or isinstance(context, Instance):             ncontext = 1             expect_context = 0          # Handle calls to classes.          elif isinstance(target, Class):             ncontext = 1             expect_context = 0             target = target.get_init_method()          # Method calls via classes.          elif isinstance(context, Class):             ncontext = 0             expect_context = 1          # Function calls.          else:             ncontext = 0             expect_context = 0          first = 1         frame_pos = ncontext         max_keyword_pos = -1          for arg in args:              # Handle positional and keyword arguments separately.              if isinstance(arg, compiler.ast.Keyword):                  # Optimise where the target is known now.                  if target is not None:                      # Find the parameter table entry for the target.                      target_name = target.full_name()                      # Look for a callable with the precise target name.                      table_entry = self.paramtable.table[target_name]                      # Look the name up in the parameter table entry.                      try:                         pos = table_entry[arg.name]                      # Where no position is found, this could be an extra keyword                     # argument.                      except KeyError:                         extra_keywords.append(arg)                         continue                      # Test for illegal conditions.                      if pos in employed_positions:                         raise TranslateError(self.module.full_name(), node,                             "Keyword argument %r overwrites parameter %r." % (arg.name, pos))                      employed_positions.add(pos)                      # Generate code for the keyword and the positioning                     # operation.                      self.dispatch(arg.expr)                     self.new_op(StoreFrame(pos))                  # Otherwise, generate the code needed to obtain the details of                 # the parameter location.                  else:                      # Combine the target details with the name to get the location.                     # See the access method on the List class.                      try:                         paramindex = self.paramtable.get_index(arg.name)                      # Where no position is found, this could be an extra keyword                     # argument.                      except self.paramtable.TableError:                         extra_keywords.append(arg)                         continue                      # Generate code for the keyword and the positioning                     # operation.                      self.dispatch(arg.expr)                     self.new_op(StoreFrameIndex(paramindex))                      # use (callable+0)+paramindex+table                     # checks embedded offset against (callable+0)                     # moves the current value to frame+position                      # Record the highest possible frame position for this argument.                      max_keyword_pos = max(max_keyword_pos, max(self.paramtable.all_attribute_positions(arg.name)))              else:                 self.dispatch(arg)                 self.new_op(StoreFrame(frame_pos))                  employed_positions.add(frame_pos)              # Check to see if the first argument is appropriate (compatible with             # the target where methods are being invoked via classes).              if first and expect_context:                  # Drop any test if the target and the context are known.                  if not self._have_correct_self_for_target(context):                      continue_label = self.new_label()                     self.new_op(CheckSelf())                     self.active.source = temp                     self.new_op(JumpIfTrue(continue_label))                      # Where the context is inappropriate, drop the incomplete frame and                     # raise an exception.                      self.new_op(DropFrame())                     self.new_op(LoadResult())                      self.load_builtin("TypeError", node)                     self.new_op(StoreException())                     self.new_op(RaiseException())                     self.set_label(continue_label)              first = 0             frame_pos += 1          # NOTE: Extra keywords are not supported.         # NOTE: Somehow, the above needs to be combined with * arguments.          if extra_keywords:             print "Warning: extra keyword argument(s) %s not handled." % ", ".join([arg.name for arg in extra_keywords])          # Either test for a complete set of arguments.          if target is not None:              # Make sure that enough arguments have been given.              nargs_max = len(target.positional_names)             ndefaults = len(target.defaults)             nargs_min = nargs_max - ndefaults              for i in range(ncontext, nargs_min):                 if i not in employed_positions:                     raise TranslateError(self.module.full_name(), node,                         "Argument %r not supplied for %r: need at least %d argument(s)." % (i+1, target.name, nargs_min))              nargs = frame_pos              if nargs > nargs_max and not target.has_star and not target.has_dstar:                 raise TranslateError(self.module.full_name(), node,                     "Too many arguments for %r: need at most %d argument(s)." % (target.name, nargs_max))              # Where defaults are involved, put them into the frame.              self._generateCallFuncDefaultArgs(target, temp, nargs_min, nargs_max, employed_positions)              # Set the frame size.              self._endCallFuncArgs(nargs_max)          # Or generate instructions to do this at run-time.         # NOTE: CheckFrame has to check the number of arguments and to fill in         # NOTE: defaults; it also has to shift the invocation frame according to         # NOTE: the context in use.          else:             max_pos = max(max(employed_positions or [-1]), max_keyword_pos, frame_pos - 1)              # Only check non-empty frames (using the callable's details).              if employed_positions or max_pos >= 0:                 self.new_op(temp)                 self.new_op(CheckFrame(max_pos + 1))              # Set the frame size.              self._endCallFuncArgs(max_pos + 1)      def _generateCallFuncDefaultArgs(self, target, temp, nargs_min, nargs_max, employed_positions):          """         For the given 'target' and 'temp' reference to the target, generate         default arguments for those positions in the range 'nargs_min'...         'nargs_max' which are not present in the 'employed_positions'         collection.         """          # Where a lambda is involved, construct a dynamic object to hold the         # defaults.          dynamic = target.name is None          # Here, we use negative index values to visit the right hand end of         # the defaults list.          for pos in range(nargs_min, nargs_max):             if pos not in employed_positions:                 if dynamic:                     self.new_op(temp)                     self.new_op(LoadAttr(target.default_attrs[pos - nargs_min]))                 else:                     self.new_op(LoadAddress(target.default_attrs[pos - nargs_min]))                 self.new_op(StoreFrame(pos))      def _doCallFunc(self, instruction, target=None):          "Make the invocation."          if isinstance(target, Class):             self.new_op(LoadConst(target.get_init_method()))         else:             self.new_op(instruction)         self.new_op(LoadCallable())         self.new_op(JumpWithFrame())      def _endCallFuncArgs(self, nargs):          "Set the frame size."          self.frame_makers[-1].attr = nargs         self.frame_makers.pop()      def _endCallFunc(self, instruction=None, target=None, load_result=1):          "Finish the invocation and tidy up afterwards."          if isinstance(target, Class):             self.new_op(LoadName(target.get_init_method().all_locals()["self"])) # load the context in the invocation frame             self.new_op(StoreResult())         self.new_op(DropFrame())         if load_result:             self.new_op(LoadResult())          # Discard any temporary storage instructions.          if instruction is not None:             self.discard_temp(instruction)      def _generateFunctionDefaults(self, function):          """         Generate the default initialisation code for 'function', returning         a temporary storage reference if a dynamic object was created for the         function.         """          attr_to_default = zip(function.default_attrs, function.defaults)         if not attr_to_default:             return None          # Where a lambda is involved, construct a dynamic object to hold the         # defaults.          dynamic = function.name is None          if dynamic:             self.make_object(self.get_builtin_class("function", function), len(attr_to_default))             temp = self.get_temp()          for attr, default in attr_to_default:             self.dispatch(default)              self.record_value()             if dynamic:                 self.new_op(temp)                 self.new_op(StoreAttr(attr))             else:                 self.new_op(StoreAddress(attr))             self.set_source()             self.discard_value()          if dynamic:             return temp         else:             return None      def _visitName(self, node, classes):          """         Visit the name-related 'node', generating instructions based on the         given 'classes'.         """          name = node.name         scope = self.get_scope(name)         #print self.module.name, node.lineno, name, scope         self._generateName(name, scope, classes, node)      def _generateName(self, name, scope, classes, node):          """         Generate code for the access to 'name' in 'scope' using the given         'classes', and using the given 'node' as the source of the access.         """          NameInstruction, AddressInstruction = classes          if scope == "local":             unit = self.unit             if isinstance(unit, Function):                 self.new_op(NameInstruction(unit.all_locals()[name]))             elif isinstance(unit, Class):                 self.new_op(AddressInstruction(unit.all_class_attributes()[name]))             elif isinstance(unit, Module):                 self.new_op(AddressInstruction(unit.module_attributes()[name]))             else:                 raise TranslateError(self.module.full_name(), node, "Program unit %r has no local %r." % (unit, name))          elif scope == "global":             globals = self.module.module_attributes()             if globals.has_key(name):                 self.new_op(AddressInstruction(globals[name]))             else:                 raise TranslateError(self.module.full_name(), node, "Module %r has no attribute %r." % (self.module, name))          else:             self.new_op(AddressInstruction(self.get_builtin(name, node)))      def _visitUnary(self, node, method):          """         _t = node.expr         try:             _result = _t.__pos__()         except AttributeError:             raise TypeError         """          end_call_label = self.new_label()         end_label = self.new_label()          # Evaluate and store the operand in temporary storage.          self.dispatch(node.expr)         temp = self._optimise_temp_storage()          # Produce the invocation.          self._startCallFunc()         self.new_op(temp)          # Get the method on temp.          self._generateAttr(node, method, self.attribute_load_instructions)         temp_method = self._optimise_temp_storage()          self._handleAttributeError(node, end_call_label)          # Add arguments.         # NOTE: No support for defaults.          self.new_op(temp) # Explicit context as first argument.         self.new_op(StoreFrame(0))         self._endCallFuncArgs(1)         self._doCallFunc(temp_method)         self._endCallFunc(temp_method)         self.new_op(Jump(end_label))          # End method attempt.          self.set_label(end_call_label)         self._endCallFunc() # From the method call.          # Raise a TypeError.          self.load_builtin("TypeError", node)         self.new_op(StoreException())         self.new_op(RaiseException())          self.set_label(end_label)          # Compilation duties...          self.discard_temp(temp)      def _visitBinary(self, node, left_method, right_method):          """         _t1 = node.left         _t2 = node.right         try:             _result = _t1.__add__(_t2)             if _result is NotImplemented:                 raise AttributeError         except AttributeError:             try:                 _result = _t2.__radd__(_t1)                 if _result is NotImplemented:                     raise AttributeError             except AttributeError:                 raise TypeError         """          # Evaluate and store the left operand in temporary storage.          self.dispatch(node.left)         temp1 = self._optimise_temp_storage()          # Evaluate and store the right operand in temporary storage.          self.dispatch(node.right)         temp2 = self._optimise_temp_storage()          self._generateBinary(node, temp1, temp2, left_method, right_method)          # Compilation duties...          self.discard_temp(temp1)         self.discard_temp(temp2)      def _generateBinary(self, node, temp1, temp2, left_method, right_method):          """         For the given 'node', generate the binary operator pattern for the         operands 'temp1' and 'temp2', employing 'left_method' and 'right_method'         as defined for binary operators, but also used in comparisons (for which         this method is provided).         """          right_label = self.new_label()         type_error_label = self.new_label()         end_label = self.new_label()          # Left method.          self._generateOpMethod(node, temp1, temp2, left_method, right_label, end_label)          # Right method.          self.set_label(right_label)         self._generateOpMethod(node, temp2, temp1, right_method, type_error_label, end_label)          # Raise a TypeError.          self.set_label(type_error_label)         self.load_builtin("TypeError", node)         self.new_op(StoreException())         self.new_op(RaiseException())          self.set_label(end_label)      def _generateOpMethod(self, node, temp1, temp2, method_name, next_method_label, end_label):          """         For the given 'node', generate the operator method invocation using the         operands 'temp1' and 'temp2', employing the given 'method_name', and         jumping appropriately to 'next_method_label' where a NotImplemented         result is returned, or to 'end_label' if the method call was successful.         """          end_attempt_label = self.new_label()          self.new_op(temp1)          # Get method on temp1.          self._generateAttr(node, method_name, self.attribute_load_instructions)         temp_method = self._optimise_temp_storage()          self._handleAttributeError(node, end_attempt_label)          # Add arguments.         # NOTE: No support for defaults.          self._startCallFunc()         self.new_op(temp1)         self.new_op(StoreFrame(0))         self.new_op(temp2)         self.new_op(StoreFrame(1))         self._endCallFuncArgs(2)         self._doCallFunc(temp_method)         self._endCallFunc(temp_method)          # Test for NotImplemented.         # Don't actually raise an exception.          self.new_op(TestIdentityAddress(self.get_builtin("NotImplemented", node)))         self.new_op(JumpIfTrue(next_method_label))         self.new_op(Jump(end_label))          # End method attempt.          self.set_label(end_attempt_label)      def _handleAttributeError(self, node, end_call_label):          """         Add exception handling to the method acquisition instructions where the         attribute access cannot be resolved at compile-time.         """          if not self._optimise_known_target():             self.load_builtin("AttributeError", node)             self.new_op(CheckException())             self.new_op(JumpIfTrue(end_call_label))      def _generateSequence(self, sequence_type, node):          "Make a sequence of 'sequence_type' for the given program 'node'."          self.make_object(self.get_builtin(sequence_type, node), len(node.nodes))         temp = self.get_temp()          for i, n in enumerate(node.nodes):             self.dispatch(n)             self.record_value()             self.new_op(temp)             self.new_op(StoreAttr(Attr(i, None, None, None)))             self.set_source()             self.discard_value()          self.new_op(temp)         self.discard_temp(temp)      def _generateTestBoolean(self, node, temp):          """         Generate a test of the boolean status of the current value for the given         program 'node'.         """          # Get method on temp.         # NOTE: Using __bool__ instead of __nonzero__.          self._generateAttr(node, "__bool__", self.attribute_load_instructions)         temp_method = self._optimise_temp_storage()          self._startCallFunc()         self.new_op(temp)         self.new_op(StoreFrame(0))         self._endCallFuncArgs(1)         self._doCallFunc(temp_method)         self._endCallFunc(temp_method)          self.discard_temp(temp_method)          # Convert result to boolean (a StoreBoolean operation).          self.new_op(TestIdentityAddress(self.get_builtin("True", node)))      def _generateLoadBoolean(self, node):          """         Generate instructions to load the appropriate value given the current         boolean status.         """          true_label = self.new_label()         end_label = self.new_label()          self.new_op(JumpIfTrue(true_label))         self.load_builtin("False", node)         self.new_op(Jump(end_label))          self.set_label(true_label)         self.load_builtin("True", node)          self.set_label(end_label)      # Concrete visitor methods.      def visitAdd(self, node):         self._visitBinary(node, "__add__", "__radd__")      def visitAnd(self, node):         end_label = self.new_label()         temp_pos = self.reserve_temp()         temp = LoadTemp(temp_pos)          for n in node.nodes[:-1]:             self.dispatch(n)             self.new_op(StoreTemp(temp_pos))              self._generateTestBoolean(n, temp)             self.new_op(JumpIfFalse(end_label))          self.dispatch(node.nodes[-1])         self.new_op(StoreTemp(temp_pos))          self.set_label(end_label)          # Prevent incorrect optimisation.          self.clear_active()          self.new_op(temp)         self.discard_temp(temp)      def visitAssert(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Assert")      def visitAssign(self, node):         self.dispatch(node.expr)         self.record_value()          for n in node.nodes:             self.dispatch(n)          self.discard_value()      def visitAssAttr(self, node):         self._visitAttr(node, self.attribute_store_instructions)         self.set_source()      def visitAssList(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "AssList")      def visitAssName(self, node):          # Optimise away intermediate source storage.          no_source = self._optimise_source_storage()         self._visitName(node, self.name_store_instructions)         if not no_source:             self.set_source()      visitAssTuple = visitAssList      def visitAugAssign(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "AugAssign")      def visitBackquote(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Backquote")      def visitBitand(self, node):         self._visitBinary(node, "__and__", "__rand__")      def visitBitor(self, node):         self._visitBinary(node, "__or__", "__ror__")      def visitBitxor(self, node):         self._visitBinary(node, "__xor__", "__rxor__")      def visitBreak(self, node):         next_label, exit_label = self.get_loop_labels()         self.new_op(Jump(exit_label))      def visitCallFunc(self, node):          """         Evaluate positional arguments, evaluate and store keyword arguments in         the correct location, then invoke the function.         """          # Mark the frame, evaluate the target, generate the call.          self._startCallFunc()         self.dispatch(node.node)         temp, target = self._generateCallFunc(node.args, node)         self._doCallFunc(temp, target)         self._endCallFunc(temp, target)      def visitClass(self, node):          # Store the name.          self.new_op(LoadConst(node.unit))         self.record_value()         self._visitName(node, self.name_store_instructions)         self.set_source()         self.discard_value()          # Visit the code.          unit = self.unit         self.unit = node.unit         self.unit.code_location = self.module.code_location # class body code is not independently addressable         self.dispatch(node.code)         self.unit = unit      def visitCompare(self, node):          """         _t1 = node.expr         _t1 op1 _t2 and _t2 op2 _t3 and ...         """          end_label = self.new_label()         temp_pos = self.reserve_temp()         temp_result = LoadTemp(temp_pos)          self.dispatch(node.expr)         temp2 = self._optimise_temp_storage()          last_op = node.ops[-1]          for op in node.ops:             op_name, next_node = op             methods = self.comparison_methods[op_name]              temp1 = temp2             self.dispatch(next_node)             temp2 = self._optimise_temp_storage()              # Use the appropriate mechanism, setting the boolean status for the             # comparison.              if methods is not None:                 left_method, right_method = methods                  # Generate method call using evaluated argument and next node.                  self._generateBinary(node, temp1, temp2, left_method, right_method)                 self.new_op(StoreTemp(temp_pos))                 self._generateTestBoolean(node, temp_result)              else:                 # Deal with the special operators.                  if op_name.startswith("is"):                     self.new_op(temp1)                     self.record_value()                     self.new_op(temp2)                     self.new_op(TestIdentity())                     self.set_source()                     self.discard_value()                  elif op_name.endswith("in"):                     self._startCallFunc()                     self.new_op(temp2)                      # Get method on temp2.                      self._generateAttr(node, "__contains__", self.attribute_load_instructions)                     temp_method = self._optimise_temp_storage()                      # Add arguments.                     # NOTE: No support for defaults.                      self.new_op(temp2)                     self.new_op(StoreFrame(0))                     self.new_op(temp1)                     self.new_op(StoreFrame(1))                     self._endCallFuncArgs(2)                     self._doCallFunc(temp_method)                     self._endCallFunc(temp_method)                      self.new_op(StoreTemp(temp_pos))                     self._generateTestBoolean(node, temp_result)                  if op_name.find("not") != -1:                     self.new_op(InvertBoolean())              # Test the result and jump to the end label if false.              if op is not last_op:                 self.new_op(JumpIfFalse(end_label))              # Compilation duties...              self.discard_temp(temp1)          self.discard_temp(temp2)         self.discard_temp(temp_result)         self.set_label(end_label)          # Yield the appropriate value.          self._generateLoadBoolean(node)      def visitConst(self, node):         const = self.module.constant_values[node.value]         self.new_op(LoadConst(const))      def visitContinue(self, node):         next_label, exit_label = self.get_loop_labels()         self.new_op(Jump(next_label))      def visitDecorators(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Decorators")      def visitDict(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Dict")      def visitDiscard(self, node):         self.dispatch(node.expr)         self._optimise_unused_results()      def visitDiv(self, node):         self._visitBinary(node, "__div__", "__rdiv__")      def visitEllipsis(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Ellipsis")      def visitExec(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Exec")      def visitExpression(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Expression")      def visitFloorDiv(self, node):         self._visitBinary(node, "__floordiv__", "__rfloordiv__")      def visitFor(self, node):         exit_label = self.new_label()         next_label = self.new_label()         else_label = self.new_label()          # Get the "list" to be iterated over, obtain its iterator.          self._startCallFunc()         self.dispatch(node.list)         self._generateAttr(node, "__iter__", self.attribute_load_instructions)         temp, target = self._generateCallFunc([], node)         self._doCallFunc(temp, target)         self._endCallFunc(temp, target)          temp_iterator = self._optimise_temp_storage()          # In the loop...          self.set_label(next_label)          # Use the iterator to get the next value.          self._startCallFunc()         self.new_op(temp_iterator)         self._generateAttr(node, "next", self.attribute_load_instructions)         temp, target = self._generateCallFunc([], node)         self._doCallFunc(temp, target)         self._endCallFunc(temp, target)          # Test for StopIteration.          self.load_builtin("StopIteration", node)         self.new_op(CheckException())         if node.else_ is not None:             self.new_op(JumpIfTrue(else_label))         else:             self.new_op(JumpIfTrue(exit_label))          # Assign to the target.          self.dispatch(node.assign)          # Process the body with the current next and exit points.          self.add_loop_labels(next_label, exit_label)         self.dispatch(node.body)         self.drop_loop_labels()          # Repeat the loop.          self.new_op(Jump(next_label))          # Produce the "else" section.          if node.else_ is not None:             self.set_label(exit_label)             self.dispatch(node.else_)          # After the loop...          self.set_label(exit_label)          # Compilation duties...          self.discard_temp(temp_iterator)      def visitFrom(self, node): pass      def visitFunction(self, node):          # Only store the name when visiting this node from outside.          if self.unit is not node.unit:             self.new_op(LoadConst(node.unit))              self.record_value()             self._visitName(node, self.name_store_instructions) # AssName equivalent             self.set_source()             self.discard_value()              self._generateFunctionDefaults(node.unit)          # Visiting of the code occurs when get_code is invoked on this node.          else:             extend = ExtendFrame()             self.new_op(extend)              self.dispatch(node.code)             if not isinstance(self.last_op(), Return):                 self.dispatch(compiler.ast.Name("None"))                 self.new_op(StoreResult())                  self.new_op(Return())              self.set_frame_usage(node, extend)      def visitGenExpr(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "GenExpr")      def visitGenExprFor(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "GenExprFor")      def visitGenExprIf(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "GenExprIf")      def visitGenExprInner(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "GenExprInner")      def visitGetattr(self, node):         self._visitAttr(node, self.attribute_load_instructions)      def visitGlobal(self, node): pass      def visitIf(self, node):         first = 1         exit_label = self.new_label()          clauses = node.tests + [(None, node.else_)]         last_clause = clauses[-1]          for clause in clauses:             test, body = clause             if body is None:                 break             if not first:                 self.set_label(next_label)             if test is not None:                 self.dispatch(test)                 next_label = self.new_label()                 self.new_op(JumpIfFalse(next_label))             self.dispatch(body)             if clause is not last_clause:                 self.new_op(Jump(exit_label))             first = 0          self.set_label(exit_label)      def visitImport(self, node): pass      def visitInvert(self, node):         self._visitUnary(node, "__invert__")      def visitKeyword(self, node): pass      def visitLambda(self, node):          """         Lambda functions can be represented as globally defined functions         provided they do not define any default parameter values, since these         may defined in a non-global scope.          Where defaults are defined, an object must be created and its content         defined: the callable member of the object's structure must be set to         the lambda function definition; each default must be attached to the         object as an attribute, as is the case with normal functions and         methods.         """          # Produce the reference to this function when visiting this node from         # outside.          if self.unit is not node.unit:             temp = self._generateFunctionDefaults(node.unit)             self.new_op(LoadConst(node.unit))              # Populate the new object required for the function.              if temp is not None:                 self.new_op(LoadCallable())                 self.new_op(temp)                 self.new_op(StoreCallable())                  self.new_op(temp)                 #self.discard_temp(temp)          # Visiting of the code occurs when get_code is invoked on this node.          else:             self.dispatch(node.code)             self.new_op(StoreResult())             self.new_op(Return())      def visitLeftShift(self, node):         self._visitBinary(node, "__lshift__", "__rlshift__")      def visitList(self, node):         self._generateSequence("list", node)      def visitListComp(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "ListComp")      def visitListCompFor(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "ListCompFor")      def visitListCompIf(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "ListCompIf")      def visitMod(self, node):         self._visitBinary(node, "__mod__", "__rmod__")      def visitModule(self, node):         self.dispatch(node.node)      def visitMul(self, node):         self._visitBinary(node, "__mul__", "__rmul__")      def visitName(self, node):         if node.name == "None":             const = self.module.constant_values[None]             self.new_op(LoadConst(const))         else:             self._visitName(node, self.name_load_instructions)      def visitNot(self, node):         self.dispatch(node.expr)          temp = self._optimise_temp_storage()         self._generateTestBoolean(node.expr, temp)         self.discard_temp(temp)          self.new_op(InvertBoolean())         self._generateLoadBoolean(node)          # Prevent incorrect optimisation.          self.clear_active()      def visitOr(self, node):         end_label = self.new_label()         temp_pos = self.reserve_temp()         temp = LoadTemp(temp_pos)          for n in node.nodes[:-1]:             self.dispatch(n)             self.new_op(StoreTemp(temp_pos))              self._generateTestBoolean(n, temp)             self.new_op(JumpIfTrue(end_label))          self.dispatch(node.nodes[-1])         self.new_op(StoreTemp(temp_pos))          self.set_label(end_label)          # Prevent incorrect optimisation.          self.clear_active()          self.new_op(temp)         self.discard_temp(temp)      def visitPass(self, node): pass      def visitPower(self, node):         self._visitBinary(node, "__pow__", "__rpow__")      def visitPrint(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Print")      def visitPrintnl(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Printnl")      def visitRaise(self, node):         # NOTE: expr1 only => instance provided         self.dispatch(node.expr1)          if node.expr2 is not None:             temp = self._optimise_temp_storage()              self.dispatch(node.expr2)             temp_arg = self._optimise_temp_storage()              self._startCallFunc()             self.new_op(temp_arg)             self.new_op(StoreFrame(0))             self._endCallFuncArgs(1)             self._doCallFunc(temp)             self._endCallFunc(temp)              self.discard_temp(temp_arg)          self.new_op(StoreException())         self.new_op(RaiseException())      def visitReturn(self, node):         if node.value is not None:             self.dispatch(node.value)         else:             self.dispatch(compiler.ast.Name("None"))          self.new_op(StoreResult())         self.new_op(Return())      def visitRightShift(self, node):         self._visitBinary(node, "__rshift__", "__rrshift__")      def visitSlice(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Slice")      def visitStmt(self, node):         for n in node.nodes:             self.dispatch(n)      def visitSub(self, node):         self._visitBinary(node, "__sub__", "__rsub__")      def visitSubscript(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Subscript")      def visitTryExcept(self, node):         exit_label = self.new_label()         success_label = self.new_label()         handler_label = self.new_label()          self.add_exception_labels(handler_label, exit_label)          # Try...         # Produce the code, then jump to the exit.          self.new_op(PushHandler(handler_label))         self.dispatch(node.body)         self.new_op(PopHandler())         self.new_op(Jump(exit_label))          # Start of handlers.          self.set_label(handler_label)         self.new_op(PopHandler())          for name, assignment, handler in node.handlers:             next_label = self.new_label()              # Test the given exception against the current exception.              if name is not None:                 self.dispatch(name)                 self.new_op(CheckException())                 self.new_op(JumpIfFalse(next_label))              # Handle assignment to exception variable.              if assignment is not None:                 self.dispatch(assignment)              # Produce the handler code, then jump to the exit.              self.dispatch(handler)             self.new_op(Jump(exit_label))              self.set_label(next_label)          # Unhandled exceptions.          #self.new_op(LoadException())         self.new_op(RaiseException())          # Optional else clause.          if node.else_ is not None:             self.dispatch(node.else_)          self.set_label(exit_label)         self.drop_exception_labels()      def visitTryFinally(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "TryFinally")      def visitTuple(self, node):         self._generateSequence("tuple", node)      def visitUnaryAdd(self, node):         self._visitUnary(node, "__pos__")      def visitUnarySub(self, node):         self._visitUnary(node, "__neg__")      def visitWhile(self, node):         exit_label = self.new_label()         next_label = self.new_label()         else_label = self.new_label()          self.set_label(next_label)         self.dispatch(node.test)         if node.else_ is not None:             self.new_op(JumpIfFalse(else_label))         else:             self.new_op(JumpIfFalse(exit_label))          self.add_loop_labels(next_label, exit_label)          self.dispatch(node.body)         self.new_op(Jump(next_label))          if node.else_ is not None:             self.set_label(else_label)             self.dispatch(node.else_)          self.set_label(exit_label)         self.drop_loop_labels()          # Prevent incorrect optimisation.          self.clear_active()      def visitWith(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "With")      def visitYield(self, node): raise TranslationNotImplementedError(self.module.full_name(), node, "Yield")      # Useful data.      comparison_methods = {         "==" : ("__eq__", "__ne__"),         "!=" : ("__ne__", "__eq__"),         "<" : ("__lt__", "__gt__"),         "<=" : ("__le__", "__ge__"),         ">=" : ("__ge__", "__le__"),         ">" : ("__gt__", "__lt__"),         "is" : None,         "is not" : None,         "in" : None,         "not in" : None         }  # vim: tabstop=4 expandtab shiftwidth=4