#!/usr/bin/env python  """ Translate the AST of a Python program into a more interpretable representation.  Copyright (C) 2007, 2008, 2009, 2010, 2011 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  class Helper:      "Internal helper methods for AST visitors."      # Allocation-related methods.      def make_instance(self, cls, n):          """         Request a new instance using the given class 'cls' and with 'n'         attributes.         """          # Load the class in order to locate the instance template.          self.new_op(LoadConst(cls))          # NOTE: Instance headers are one location.          self.new_op(MakeInstance(n + 1))      def make_exception(self, name):          "Make an exception of the given 'name' using 'node'."          # NOTE: Reserving an attribute.          self.make_instance(self.get_builtin_class(name), 1)      # Name-related methods.      def get_scope(self, name):          "Return the scope for the given 'name'."          attr, scope, from_name = self.unit._get_with_scope(name)         return scope      def load_builtin(self, name, node):          "Generate an instruction loading 'name' for the given 'node'."          self.new_op(LoadAddress(self.get_builtin(name)))      def get_builtin_class(self, name):          "Return the built-in class with the given 'name'."          return self.get_builtin(name).get_value()      def get_builtin(self, name):          "Return the built-in module definition for the given 'name'."          if self.builtins is not None:             try:                 return self.builtins[name]             except KeyError:                 raise TranslateError("No __builtins__ definition is available for name %r." % name)         else:             raise TranslateError("No __builtins__ module is available for name %r." % name)      # Common methods.      def _generateGuards(self, node):          if not (self.optimiser.should_optimise_accesses_by_attribute_usage() and hasattr(node, "_attrtypes")):             return          # For each name, attempt to restrict the type employed.          for name, targets in node._attrtypes.items():              # NOTE: Need to merge targets using the same type but suggesting             # NOTE: different kinds of attributes (instance vs. class).              # Where only one object type is suggested, produce a guard.             # NOTE: This only supports classes as types, not modules.              if len(targets) == 1:                 target_name, is_static = list(targets)[0]                  # Access the object table to get the attribute.                 # NOTE: This depends on the special entry in the table                 # NOTE: for class equivalence tests.                  try:                     obj = self.objtable.access(target_name, target_name)                  # Where no attribute entry exists, the target could be a module.                 # NOTE: Should perhaps raise an error.                  except TableError, exc:                     print "Possible guard for", target_name, "not enforceable."                     continue                  # NOTE: Could test the correctness of the guard where the nature                 # NOTE: of the name is known.                 # NOTE: The known value would be retrieved from the unit's                 # NOTE: locals and tested as being a class or an instance of a                 # NOTE: particular class.                  # Generate the guard by loading a reference to the class.                  after_test_block = self.new_block()                  self.new_op(LoadClass(obj, target="source"))                  # For only static attributes, classes are acceptable.                  if is_static:                      # Generate name is target (for classes).                      self.dispatch(compiler.ast.Name(name))                     self.new_op(TestIdentity(source="source", target="status"))                      # Jump to the next guard or the code if successful.                      self.new_op(JumpIfTrue(after_test_block, working="status"))                  # Where instance attributes are involved, only instances are                 # acceptable.                  # Generate isinstance(name, target).                  self.dispatch(compiler.ast.Name(name))                 self.new_op(CheckInstance(source="source", target="status"))                  # Jump to the next guard or the code if successful.                  self.new_op(JumpIfTrue(after_test_block, working="status"))                  # Where the type is inappropriate, raise an exception.                  self.make_exception("TypeError")                 self.set_target("exception")                 self.new_op(RaiseException())                  self.set_block(after_test_block)      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, AddressContextCondInstruction, \             AttrInstruction, AttrIndexInstruction, AttrIndexContextCondInstruction = classes          # Where the last operation (defining the attribute owner) yields a         # constant...          target_plus_name = self.optimiser.optimise_constant_accessor()          # Only try and discover the position if the target can be resolved.         # Since instances cannot be constants, this involves classes and         # modules.         # It is acceptable to replace the instruction providing the constant         # input because doing so does not lose any input information required by         # the replacement instructions.          if target_plus_name is not None:             target, target_name = target_plus_name              # Check for class.__class__.              if attrname == "__class__":                 if isinstance(target, Class):                     if AddressInstruction is LoadAddress:                         self.replace_active_value(LoadAddress(self.get_builtin("type")))                         return                     else:                         raise TranslateError("Assigning to __class__ is not permitted.")              # Access the object table to get the attribute.              try:                 attr = self.objtable.access(target_name, attrname)             except TableError, exc:                 raise TranslateError(exc.args[0])              # Produce a suitable instruction.              if AddressInstruction is not None:                 self.replace_active_value(AddressInstruction(attr))             else:                 raise TranslateError("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.          # This is the only reliable way of detecting instance accesses at         # compile-time since in general, objects could be classes or modules,         # but 'self' should only refer to instances.          elif self.optimiser.optimise_self_access(self.unit, attrname):              # Either generate an instruction operating on an instance attribute.              try:                 attr = self.unit.parent.instance_attributes()[attrname]                 self.new_op(AttrInstruction(attr))                 return              # Or generate an instruction operating on a class attribute.             # NOTE: Any simple instruction providing self is not removed.              except KeyError:                  try:                     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("Storing of class attribute %r via self not permitted." % attrname)                      # Preserve the context if the class attribute comes from an                     # incompatible class.                      elif attr.defined_outside_hierarchy():                          # Only permit loading (not storing) of class attributes via self.                          if AddressInstruction is not None:                             self.new_op(AddressInstruction(attr))                         else:                             raise TranslateError("Storing of class attribute %r via self not permitted." % attrname)                      # Otherwise, test for a suitable context at run-time.                      else:                          # Only permit loading (not storing) of class attributes via self.                          if AddressContextCondInstruction is not None:                             self.new_op(AddressContextCondInstruction(attr))                         else:                             raise TranslateError("Storing of class attribute %r via self not permitted." % attrname)                      return                  # Or delegate the attribute access to a general instruction                 # since the kind of attribute cannot be deduced.                  except KeyError:                     pass          # Attempt to deduce the target of an attribute access by searching for a         # unique type providing the names associated with the accessed object.          elif self.optimiser.should_optimise_accesses_by_attribute_usage():              target_names = self.possible_accessor_types(node)              if target_names is not None and len(target_names) == 1:                 target_name, is_static = list(target_names)[0]                  # Check for class.__class__.                  if attrname == "__class__":                     if is_static:                         self.load_builtin("type", node)                         return                  # Access the object table to get the attribute.                  try:                     attr = self.objtable.access(target_name, attrname)                  # Disallow non-class/instance optimisations.                  except TableError, exc:                     print "Possible optimisation for", target_name, "not permissable."                  # Produce a suitable instruction.                  else:                     if AddressContextCondInstruction is not None and attr.is_static_attribute():                         self.new_op(AddressContextCondInstruction(attr))                     elif AttrInstruction is not None and not attr.is_static_attribute():                         self.new_op(AttrInstruction(attr))                     else:                         raise TranslateError("Storing of class or module attribute %r via an object is not permitted." % attrname)                      return          # Check for class.__class__.          if attrname == "__class__":              # Remember the accessor.              temp_accessor = self.get_temp()              attr_block = self.new_block()             end_block = self.new_block()              self.new_op(CheckClass(target="status"))             self.new_op(JumpIfFalse(attr_block, working="status"))             self.load_builtin("type", node)             self.new_op(Jump(end_block))             self.set_block(attr_block)              # Recall the accessor.              self.new_op(temp_accessor)          # Otherwise, perform a normal operation.          try:             index = self.objtable.get_index(attrname)          except self.objtable.TableError:              # If this error arises on generated code, check the names_used             # attribute on the Importer.              raise TranslateError("No attribute entry exists for name %r." % attrname)          # NOTE: Test for class vs. instance attributes, generating         # NOTE: context-related instructions.          if AttrIndexContextCondInstruction is not None:             self.new_op(AttrIndexContextCondInstruction(index))          # Store instructions do not need to consider context modifications.          else:             self.new_op(AttrIndexInstruction(index))          # Where __class__ was involved, define the start of the following code.          if attrname == "__class__":             self.set_block(end_block)             self.discard_temp(temp_accessor)      # 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 - such as 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_target, temp_context = self._generateCallFuncContext()         self._generateCallFuncArgs(target, context, temp_target, temp_context, args, node)         return temp_target, target, temp_context      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.optimiser.optimise_known_target()         if t:             target, context = t              # Detect dynamic functions acting like instances.              if isinstance(target, Function) and target.is_dynamic():                 target, context = None, None         else:             target, context = None, None          # Store the target in temporary storage for subsequent referencing.          temp_target = self.optimiser.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_target)             self.new_op(Transfer(source="working_context", target="working"))             temp_context = self.optimiser.optimise_temp_storage()             self.new_op(StoreFrame(0))          # Class contexts should be made available for testing of the first         # argument.         # NOTE: Class methods should eventually be supported.          elif isinstance(context, Class):             self.new_op(temp_target)             self.new_op(Transfer(source="working_context", target="working"))             temp_context = self.optimiser.optimise_temp_storage()          # Otherwise omit the context.          else:             temp_context = None          return target, context, temp_target, temp_context      def _generateCallFuncArgs(self, target, context, temp_target, temp_context, args, node):          """         Given invocation 'target' and 'context' information, the 'temp_target'         reference to the target, the 'temp_context' reference to the context, 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 = []         positional_args = []         keyword_args = []          # Find keyword arguments in advance in order to help resolve targets.          have_keywords = 0          for arg in args:             if isinstance(arg, compiler.ast.Keyword):                 employed_keywords.add(arg.name)                 keyword_args.append(arg)                 have_keywords = 1             elif not have_keywords:                 positional_args.append(arg)          possible_targets = self.paramtable.all_possible_objects(employed_keywords)          # Note the presence of the context in the frame where appropriate.          # For unknown invocations and method invocations.          if target is None or isinstance(context, Instance):             ncontext = 1             expect_testable_self = 0          # Handle calls to classes by obtaining the instantiator function.         # A context is reserved for the new instance, but this is not provided         # in the invocation (since the instantiator will fill the locals slot         # concerned).          elif isinstance(target, Class):             ncontext = 1             expect_testable_self = 0             target = target.get_instantiator()          # Method calls via classes.          elif isinstance(context, Class):             ncontext = 0             expect_testable_self = 1          # Function calls.          else:             ncontext = 0             expect_testable_self = 0          # Traverse the positional arguments adding them using the incrementing         # frame position.          first = 1         frame_pos = ncontext         temp_first_argument = None          for arg in positional_args:             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_testable_self or target is None):                  # Drop any test if the target and the context are known.                  if not self.optimiser.have_correct_self_for_target(context, self.unit):                      # Otherwise, remember the first argument for a subsequent                     # test.                      temp_first_argument = self.optimiser.optimise_temp_storage()              first = 0             frame_pos += 1          # Adjust the invocation frame for unknown invocations.         # Test the first argument if appropriate.          self._generateCallFuncContextTest(target, temp_context, temp_first_argument, node)          # Traverse the keyword arguments adding them at the appropriate frame         # positions.          max_keyword_pos = -1          for arg in keyword_args:              # 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("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. Get the value as the source of the assignment.                  self.dispatch(arg.expr)                 self.record_value()                  # Store the source value using the callable's parameter                 # table information.                  self.new_op(temp_target)                 self.new_op(StoreFrameIndex(paramindex))                  self.assign_value()                 self.discard_value()                  # Record the highest possible frame position for this argument.                  max_keyword_pos = max(max_keyword_pos, max(self.paramtable.all_attribute_positions(arg.name)))              # Use the frame position counter as a general argument counter.              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              # Visit each argument position and look for a supplied argument.              for i in range(ncontext, nargs_min):                 if i not in employed_positions:                     raise TranslateError(                         "Argument %r not supplied for %r: need at least %d argument(s)." % (i+1, target.name, nargs_min))              nargs = frame_pos              # Determine whether too many arguments have been given and how big             # the frame should be.              # For parameter lists with * or ** parameters, accept as many             # arguments as are allowed or as many as we have.              if target.has_star or target.has_dstar:                 frame_size = max(nargs, nargs_max)                  # NOTE: We now need to pack these arguments into a suitable                 # NOTE: structure for the * parameter.              # For other parameter lists, only accept as many arguments as we are             # allowed.              elif nargs > nargs_max:                 raise TranslateError(                     "Too many arguments for %r: need at most %d argument(s)." % (target.name, nargs_max))              else:                 frame_size = nargs_max              # Where defaults are involved, put them into the frame.              self._generateCallFuncDefaultArgs(target, temp_target, nargs_min, nargs_max, employed_positions)              # Set the frame size.              self._endCallFuncArgs(frame_size)          # Or just set the frame size and have the function check the arguments.          else:             max_pos = max(max(employed_positions or [-1]), max_keyword_pos, frame_pos - 1)             self._endCallFuncArgs(max_pos + 1)      def _generateCallFuncDefaultArgs(self, target, temp_target, nargs_min, nargs_max, employed_positions):          """         For the given 'target' and 'temp_target' 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 appropriate, construct a dynamic object to hold the defaults.          dynamic = target.is_dynamic()          # 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_target)                     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 _generateCallFuncContextTest(self, target, temp_context, temp_first_argument, node):          """         Generate code involved in a call to the given 'target' to test the         context provided by 'temp_context' against 'temp_first_argument', and to         signal an exception (using 'node') if the context is incompatible with         the first frame argument.          In addition, the invocation frame will be shifted if 'temp_context'         indicates a function or a class.         """          adjust_block = self.new_block()         continue_block = self.new_block()          # Add some preliminary tests where the target is not known.          if target is None:              # Adjust the frame if a replaceable context is provided.              self.new_op(temp_context)             self.new_op(CheckContext(target="status"))             self.new_op(JumpIfFalse(adjust_block, working="status"))              # Skip adjustment and tests if the context is not a class.             # Classes themselves employ a placeholder context so that             # instantiators can be callable with a context which will be             # overwritten in the frame.              # Here, the working value should still refer to the context.              self.new_op(CheckClass(target="status"))             self.new_op(JumpIfFalse(continue_block, working="status"))          # Test any explicit first argument against the context.          if temp_first_argument is not None:              # Check the current value (the argument) against the known context             # (given as the source).              if self.new_op(temp_context.copy()):                 self.last_op().target = "source"                 self.update_temp(temp_context, self.last_op())              self.new_op(temp_first_argument)             self.new_op(CheckInstance(source="source", target="status"))              if target is None:                 self.new_op(JumpIfTrue(adjust_block, working="status"))             else:                 self.new_op(JumpIfTrue(continue_block, working="status"))              # Where the context is inappropriate, drop the incomplete frame and             # raise an exception.              self.new_op(DropFrame())              self.make_exception("TypeError")             self.set_target("exception")             self.new_op(RaiseException())          if target is None or temp_first_argument is not None:             self.set_block(adjust_block)             self.new_op(AdjustFrame(1))              self.set_block(continue_block)      def _doCallFunc(self, temp_target, target=None):          "Make the invocation."          # For classes, the target itself is used, since the instantiator will be         # obtained via the class.          if isinstance(target, (Class, Function)):             self.new_op(JumpWithFrameDirect(target, working="status"))         else:             self.new_op(temp_target)             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, temp_target=None, temp_context=None):          "Finish the invocation and tidy up afterwards."          self.new_op(DropFrame())          # Discard any temporary storage instructions.          if temp_target is not None:             self.discard_temp(temp_target)          if temp_context is not None:             self.discard_temp(temp_context)      def _visitFunctionDeclaration(self, node):          """         Visit the function declaration at 'node', which can be a lambda or a         named function. As a consequence an instruction will be generated which         provides a reference to the function.         """          fn = node.unit         ndefaults = len(fn.defaults)         temp = self._generateFunctionDefaults(fn)          # Populate the new object required for the function.          if temp is not None:             self.new_op(LoadConst(fn))             self.new_op(LoadCallable(target="source"))             self.new_op(temp)             self.new_op(StoreCallable(source="source"))             self.new_op(temp)             #self.discard_temp(temp)         else:             self.new_op(LoadFunction(fn))      def _visitFunctionDefinition(self, node):          """         Visit the function definition at 'node', which can be a lambda or a         named function, generating the prelude with argument and default         checking, plus the body of the function itself.         """          # Check frames using the function's details.          fn = node.unit         nparams = len(fn.positional_names)         ndefaults = len(fn.defaults)          fn.body_block = self.new_block()          # Check the number of parameters and defaults.          self.new_op(CheckFrame((nparams, ndefaults), target="status"))          if ndefaults > 0:             if fn.is_dynamic():                 self.new_op(LoadTemp(0)) # context provides storage             else:                 self.new_op(LoadFunction(fn))              self.new_op(FillDefaults((nparams, ndefaults)))          # Produce the body.          self.set_block(fn.body_block)          # For functions with star parameters, make a special list for the         # extra arguments and re-map the parameter.          if fn.has_star:             self.new_op(CopyExtra(nparams))              # Ensure that the star parameter has a slot in the frame.              self.new_op(CheckExtra(nparams, target="status"))             self.new_op(StoreTemp(nparams))          # Extend the frame for local usage.          extend = ExtendFrame()         self.new_op(extend)          # Perform tuple assignment for any tuple parameters.          self._visitFunctionTupleParameters(fn, node)          # Add any attribute usage guards.          self._generateGuards(node)          # Visit the actual code.          self.dispatch(node.code)          # Add a return statement where one is not already produced.          if not isinstance(self.last_op(), Return):              # Return None for normal functions without explicit return             # statements.              if not fn.is_lambda():                 self.dispatch(compiler.ast.Name("None"))              self.new_op(Return())          # Make sure that enough frame space is reserved from the start.          self.set_frame_usage(node, extend)      def _visitFunctionTupleParameters(self, fn, node, parameters=None):          """         Visit the tuple parameters for function 'fn', obtaining the appropriate         elements from each supplied argument and assigning them to the specified         names for each parameter.         """          if parameters is not None:             self._generateAttr(node, "__getitem__", self.attribute_load_instructions)             temp_getitem = self.optimiser.optimise_temp_storage()          for i, parameter in parameters or fn.tuple_parameters():              # Either load the parameter from the frame.              if parameters is None:                 self.new_op(LoadName(Attr(i, None, None)))              # Or load a value from the current collection.              else:                 self._startCallFunc()                 self.new_op(temp_getitem)                 temp_target, target, temp_context = self._generateCallFunc([compiler.ast.Const(i)], node)                 self._doCallFunc(temp_target, target)                 self._endCallFunc()              # Where a tuple is the target, attempt to descend into the value             # obtained.              if isinstance(parameter, list):                 self._visitFunctionTupleParameters(fn, node, parameter)              # Store the item in the namespace entry for the given name.              else:                 self.record_value()                 self.new_op(StoreName(fn[parameter]))                 self.assign_value()                 self.discard_value()          if parameters is not None:             self.discard_temp(temp_getitem)      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 non-constant defaults are involved, construct a dynamic object         # to hold the defaults.          dynamic = function.is_dynamic()          if dynamic:             self.make_instance(self.get_builtin_class("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.assign_value()             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          # Get the expected scope of the name.          scope = getattr(node, "_scope", None) or self.get_scope(name)         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, AddressContextInstruction = classes          # Handle names referring to constants.          if scope == "constant":             const = self.importer.get_predefined_constant(name)             self.new_op(LoadConst(const))          # Handle all other names.          elif scope == "local":             unit = self.unit             if isinstance(unit, Function):                 self.new_op(NameInstruction(unit.all_locals()[name]))             elif isinstance(unit, Class):                 if AddressContextInstruction is not None:                     self.new_op(LoadConst(unit))                     self.new_op(AddressContextInstruction(unit.all_class_attributes()[name]))                 else:                     self.new_op(AddressInstruction(unit.all_class_attributes()[name]))             elif isinstance(unit, Module):                 self.new_op(AddressInstruction(unit.module_attributes()[name]))             else:                 raise TranslateError("Program unit has no local %r." % name)          elif scope == "global":             globals = self.module.module_attributes()             if globals.has_key(name):                 self.new_op(AddressInstruction(globals[name]))             else:                 raise TranslateError("Module has no attribute %r." % name)          elif scope == "builtins":             self.new_op(AddressInstruction(self.get_builtin(name)))          else:             # NOTE: This may happen because a class attribute is optimised away.             print "Program unit uses unknown name %r." % name      def _visitUnary(self, node):          """         Invoke the appropriate operator module function for the operation         represented by 'node'.         """          temp_fn = self._getOperatorFunction(node)         self._visitCall(node, temp_fn, (node.expr,))         self.discard_temp(temp_fn)      def _visitBinaryBit(self, node):          """         Need to impose binary rules over a sequence of nodes. The         short-circuiting of the similar logical operators is not imposed by the         bitwise operators.         """          temp_fn = self._getOperatorFunction(node)         left = None          for right in node.nodes:             if left is not None:                 self._visitCall(node, temp_fn, (left, right))             left = right          self.discard_temp(temp_fn)      def _visitBinary(self, node):          """         Invoke the appropriate operator module function for the operation         represented by 'node'.         """          temp_fn = self._getOperatorFunction(node)         self._visitCall(node, temp_fn, (node.left, node.right))         self.discard_temp(temp_fn)      def _visitCall(self, node, temp_fn, args):          """         Invoke the appropriate operator module function for the operation         represented by 'node', given a 'temp_fn' reference to a function, along         with the 'args' (the operand nodes).         """          # Evaluate and store the operands in temporary storage.          temp_list = []          for arg in args:             self.dispatch(arg)             temp_list.append(self.optimiser.optimise_temp_storage())          self._generateInvocation(temp_fn, temp_list)          # Compilation duties...          for temp in temp_list:             self.discard_temp(temp)      def _generateInvocation(self, temp_fn, temp_list):          """         Invoke the function 'temp_fn' using the operands from 'temp_list' as         arguments.         """          self._startCallFunc()          for i, temp in enumerate(temp_list):             self.new_op(temp)             self.new_op(StoreFrame(i))          self._endCallFuncArgs(len(temp_list))         self._doCallFunc(temp_fn)         self._endCallFunc(temp_fn)      def _getOperatorFunction(self, node, operator_name=None):          "Return an operator function reference for the given 'node'."          return self._generateOperatorFunction(operator_name or node.__class__.__name__)      def _getOperatorAugAssignFunction(self, node):          """         Return an operator augmented assignment function reference for the given         'node'.         """          return self._generateOperatorFunction(node.op)      def _generateOperatorFunction(self, opname):          "Return an operator function reference for the given 'opname'."          operator_fn = operator_functions[opname]          # Get the operator module.          operator_module = self.importer.get_module("operator")          # Get the appropriate function from the operator module.          self.new_op(LoadAddress(operator_module[operator_fn]))         return self.optimiser.optimise_temp_storage()      def _handleAttributeError(self, node, temp_method, handled_block):          """         Add exception handling to the method acquisition instructions where the         attribute access cannot be resolved at compile-time.         """          if not (self.optimiser.should_optimise_known_target() and self.optimiser.is_constant_input(temp_method)):             self.load_builtin("AttributeError", node)             self.new_op(CheckException(target="status"))             self.new_op(JumpIfTrue(handled_block, working="status"))             self.new_op(RaiseException())      def _generateTuple(self, node):          "Make a tuple using the given program 'node'."          # Reserve space for the elements themselves.          self.make_instance(self.get_builtin_class("tuple"), len(node.nodes))         temp = self.get_temp()          # Store using 0-based index values.          self._populateSequence(temp, node)          self.new_op(temp)         self.discard_temp(temp)      def _generateList(self, node):          "Make a list using the given program 'node'."          # Make a fragment containing the list elements.          self.new_op(MakeFragment(len(node.nodes) + 1))         temp = self.get_temp()         self._populateSequence(temp, node)         self.new_op(temp)         self.record_value()          # Reserve space for _elements (the fragment reference).          self.make_instance(self.get_builtin_class("list"), 1)         list_temp = self.get_temp()         self.new_op(list_temp)         self.new_op(StoreAttr(Attr(0, None, None))) # _elements is at position 0         self.assign_value()         self.discard_value()          self.new_op(list_temp)         self.discard_temp(temp)         self.discard_temp(list_temp)      def _populateSequence(self, temp, node, offset=0):          """         Populate a sequence using the given 'temp' reference and program 'node'.         """          for i, n in enumerate(node.nodes):             self.dispatch(n)             self.record_value()             self._storeInSequence(temp, i, offset)             self.discard_value()      def _storeInSequence(self, temp, i, offset=0):          """         Store the current active value in the fragment referenced by 'temp' at         position 'i' with the given starting 'offset'.         """          self.new_op(temp)         self.new_op(StoreAttr(Attr(i + offset, None, None)))         self.assign_value()      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.optimiser.optimise_temp_storage()          self._generateInvocation(temp_method, (temp,))          self.discard_temp(temp_method)          # Convert result to boolean (a StoreBoolean operation).          self.new_op(TestIdentityAddress(self.importer.get_predefined_constant("True"), target="status"))      def _generateLoadBoolean(self, node):          """         Generate instructions to load the appropriate value given the current         boolean status.         """          false_block = self.get_block()         true_block = self.new_block()         end_block = self.new_block()          self.new_op(JumpIfTrue(true_block, working="status"))         self.new_op(LoadConst(self.importer.get_predefined_constant("False")))         self.new_op(Jump(end_block))          self.set_block(true_block)         self.new_op(LoadConst(self.importer.get_predefined_constant("True")))          self.set_block(end_block, [false_block, true_block])      def _visitPrint(self, node, function_name):         self._startCallFunc()         self.load_builtin(function_name, node)          args = [node.dest or compiler.ast.Name("None")] + node.nodes          temp_target, target, temp_context = self._generateCallFunc(args, node)         self._doCallFunc(temp_target, target)         self._endCallFunc(temp_target, temp_context)  # vim: tabstop=4 expandtab shiftwidth=4