#!/usr/bin/env python  """ A really simple virtual processor employing a simple set of instructions which ignore low-level operations and merely concentrate on variable access, structure access, structure allocation and function invocations.  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/>.  --------  The execution model of the virtual processor involves the following things:    * Memory                          contains constants, global variable                                     references and program code    * PC (program counter) stack      contains the return address associated                                     with each function invocation    * Frame stack                     contains invocation frames in use and in                                     preparation plus temporary storage    * Local frame pointer stack       refers to the frames in the frame stack    * Invocation frame pointer stack    * Exception handler stack    * Exception handler locals stack  refers to the state of the local frame                                     pointer stack    * Exception handler PC stack      refers to the state of the PC stack    * Registers: working context/value,                assignment source context/value,                current exception value,                boolean status value,                object list start (constant),                parameter list start (constant) """  from micropython.program import DataValue, ReplaceableContext, PlaceholderContext, FragmentObject from rsvplib import Library  class IllegalInstruction(Exception):     pass  class IllegalAddress(Exception):     def __init__(self, address):         self.address = address     def __repr__(self):         return "IllegalAddress(%r)" % self.address     def __str__(self):         return repr(self)  class EmptyPCStack(Exception):     pass  class EmptyFrameStack(Exception):     pass  class BreakpointReached(Exception):     pass  class RSVPMachine:      "A really simple virtual processor."      def __init__(self, memory, objlist, paramlist, pc=None, debug=0, abort_upon_exception=0):          """         Initialise the processor with a 'memory' (a list of values containing         instructions and data), the object and parameter lists 'objlist' and         'paramlist', and the optional program counter 'pc'.         """          self.memory = memory         self._objlist = objlist         self._paramlist = paramlist         end_of_code = len(self.memory)          # Add the object list.          objlist_start = len(self.memory)         self.memory += objlist.as_raw()          # Add the parameter list.          paramlist_start = len(self.memory)         self.memory += paramlist.as_raw()          # A reference to the native library.          self.library = None          # Program counter and machine configuration.          self.pc = pc or 0         self.debug = debug         self.abort_upon_exception = abort_upon_exception          # Profiling.          self.coverage = [0] * end_of_code         self.counter = 0         self.cost = 0          # Stacks.          self.pc_stack = []         self.frame_stack = []         self.local_sp_stack = [0]         self.invocation_sp_stack = []          # Exception handler stacks are used to reset the state of the main         # stacks.          self.handler_stack = [end_of_code - 1] # final handler is the end of the code         self.handler_local_sp_stack = []         self.handler_invocation_sp_stack = []         self.handler_pc_stack = []          # Registers.          self.register_names = (             "working",             "working_context",             "source",             "source_context",             "exception",             "status",             "objlist",             "paramlist"             )         self.registers = {}          for name in self.register_names:             self.registers[name] = None          self.registers["objlist"] = objlist_start         self.registers["paramlist"] = paramlist_start          self.instruction = None          # Constants.         # NOTE: These should eventually be removed once the code using them has         # NOTE: been migrated to the native code library.          cls = self._get_class("__builtins__", "AttributeError")         self.attr_error = cls.location         self.attr_error_instance = cls.instance_template_location         cls = self._get_class("__builtins__", "TypeError")         self.type_error = cls.location         self.type_error_instance = cls.instance_template_location         cls = self._get_class("__builtins__", "tuple")         self.tuple_class = cls.location         self.tuple_instance = cls.instance_template_location          # Debugging attributes.          self.breakpoints = set()      def get_program_size(self):         return self.registers["objlist"]      def _get_class(self, module, name):         attr = self._objlist.access(module, name)         if attr is not None:             return attr.get_value()         else:             return None      # Debugging methods.      def dump(self):         print "PC", self.pc, "->", self.load(self.pc)         print "PC stack", self.pc_stack         print "Frame stack:"         if self.local_sp_stack:             start = self.local_sp_stack[0]             for end in self.local_sp_stack[1:]:                 print "  %2d" % start, self.frame_stack[start:end]                 start = end             else:                 print "  %2d" % start, self.frame_stack[start:]         print         print "Local stack pointers", self.local_sp_stack         print "Invocation stack pointers", self.invocation_sp_stack         print "Handler stack", self.handler_stack         print "Handler frame stack", self.handler_local_sp_stack         print "Handler PC stack", self.handler_pc_stack         print         print "Registers:"         print         for name in self.register_names:             print "%s: %s" % (name, self.registers[name])         print         print "Instruction", self.instruction      def show(self, start=None, end=None):         self.show_memory(self.memory[start:end], self.coverage[start:end], start or 0)      def show_pc(self, run_in=10):         start = max(0, self.pc - run_in)         end = self.pc + run_in         memory = self.memory[start:end]         coverage = self.coverage[start:end]         self.show_memory(memory, coverage, start)      def show_object(self, start):         obj = self.memory[start]         end = start + obj.size         self.show_memory(self.memory[start:end], self.coverage[start:end], start)      def show_memory(self, memory, coverage, start):         for i, (c, x) in enumerate(map(None, coverage, memory)):             location = start + i             if location == self.pc:                 print "->",             elif location in self.pc_stack:                 print "..",             else:                 print "  ",             print "%-5s %5d %r" % (c or "", location, x)      def step(self, dump=0):         self.execute()         self.show_pc()         if dump:             self.dump()      def set_break(self, location):         self.breakpoints.add(location)      def up(self):         retaddr = self.pc_stack[-1]         self.set_break(retaddr)         self.run()      # Internal operations.      def load(self, address):          "Return the value at the given 'address'."          try:             return self.memory[address]         except IndexError:             raise IllegalAddress(address)         except TypeError:             raise IllegalAddress(address)      def save(self, address, value):          "Save to the given 'address' the specified 'value'."          try:             self.memory[address] = value         except IndexError:             raise IllegalAddress(address)         except TypeError:             raise IllegalAddress(address)      def new(self, size):          """         Allocate space of the given 'size', returning the address of the space.         """          addr = len(self.memory)         for i in range(0, size):             self.memory.append(None)         return addr      def push_pc(self, data):          "Push 'data' onto the PC stack."          self.pc_stack.append(data)      def pull_pc(self):          "Pull a value from the PC stack and return it."          try:             return self.pc_stack.pop()         except IndexError:             raise EmptyPCStack      def run(self):          "Execute code in the memory, starting from the current PC address."          breakpoint = 0          try:             while 1:                 self.execute()         except EmptyPCStack:             pass         except BreakpointReached:             breakpoint = 1          print "Execution terminated",         if breakpoint:             print "with breakpoint."             print "At address", self.pc         elif self.registers["exception"] is not None:             ref = self.registers["exception"]             addr = self.load(ref + Library.instance_data_offset)             print "with exception:", self.load(ref)             print "At address %d: %r" % (addr, self.load(addr))         else:             print "successfully."         print "After", self.counter, "instructions at cost", self.cost, "units."      def test(self, module):          """         Test the code in the memory by running the code and investigating the         contents of variables. Use 'module' to identify result variables.         """          self.run()         success = 1          if self.registers["exception"] is None:             for name in module.keys():                 if name.startswith("result"):                     label, expected = name.split("_")                     attr = module[name]                      # Need to skip the header to get at the members.                      attr_location = module.location + Library.instance_data_offset + attr.position                     value = self.load(attr_location)                      if value is not None:                         content = self.load(value.ref + Library.instance_data_offset)                         print label, expected, content                         success = success and (int(expected) == content)                     else:                         print label, expected, "missing"                         success = 0              return success         else:             return 0      def execute(self):          "Execute code in the memory at the current PC address."          if self.pc in self.breakpoints:             self.breakpoints.remove(self.pc)             raise BreakpointReached          self.instruction = self.load(self.pc)          # Perform the instruction itself.          next_pc = self.perform(self.instruction)          # Update the coverage.          self.coverage[self.pc] += 1          # Update the program counter.          if next_pc is None:             self.pc += 1         else:             self.pc = next_pc      def get_method(self, instruction):          "Return the handler method for the given 'instruction'."          instruction_name = instruction.__class__.__name__         if self.debug:             print "%8d %s" % (self.pc, instruction_name)         method = getattr(self, instruction_name, None)         if method is None:             raise IllegalInstruction, (self.pc, instruction_name)         return method      def perform(self, instruction):          "Perform the 'instruction', returning the next PC value or None."          self.counter += 1         self.cost += instruction.cost         operand = instruction.get_operand()         method = self.get_method(instruction)         return method(operand, instruction)      def jump(self, addr, next):          """         Jump to the subroutine at (or identified by) 'addr'. If 'addr'         identifies a library function then invoke the library function and set         PC to 'next' afterwards; otherwise, set PC to 'addr'.         """          # Trap library functions introduced through the use of strings instead         # of proper locations.          if isinstance(addr, str):             handler = self.library and self.library.native_functions[addr](self.library)             if handler is None:                 return next             else:                 return handler         else:             self.push_pc(self.pc + 1)             return addr      # Helper methods.      def context_of(self, register):         return "%s_context" % register      def load_from_frame(self, operand):         frame = self.local_sp_stack[-1]         return self.frame_stack[frame + operand]      # Low-level instructions.      def LoadImmediate(self, operand, target):         self.registers[target] = operand      def LoadMemory(self, operand, target, source):         self.registers[target] = self.load(             self.registers[source] + (operand is not None and operand or 0)             )      # Instructions.      def Transfer(self, operand, instruction):         self.registers[instruction.target] = self.registers[instruction.source]      def LoadConst(self, operand, instruction):         self.LoadImmediate(operand, self.context_of(instruction.target))         self.LoadImmediate(operand, instruction.target)      def LoadClass(self, operand, instruction):         self.LoadImmediate(PlaceholderContext, self.context_of(instruction.target))         self.LoadImmediate(operand, instruction.target)      def LoadFunction(self, operand, instruction):         self.LoadImmediate(ReplaceableContext, self.context_of(instruction.target))         self.LoadImmediate(operand, instruction.target)      def LoadName(self, operand, instruction):         data = self.load_from_frame(operand)         self.LoadImmediate(data.context, self.context_of(instruction.target))         self.LoadImmediate(data.ref, instruction.target)      def StoreName(self, operand, instruction):         frame = self.local_sp_stack[-1]         self.frame_stack[frame + operand] = DataValue(             self.registers[self.context_of(instruction.source)],             self.registers[instruction.source])      LoadTemp = LoadName      def StoreTemp(self, operand, instruction):         frame = self.local_sp_stack[-1]         self.frame_stack[frame + operand] = DataValue(             self.registers[self.context_of(instruction.working)],             self.registers[instruction.working])      def LoadAddress(self, operand, instruction):         # Preserve context (potentially null).         data = self.load(operand)         self.LoadImmediate(data.context, self.context_of(instruction.target))         self.LoadImmediate(data.ref, instruction.target)      def LoadAddressContext(self, operand, instruction):         # Value becomes context.         data = self.load(operand)         self.LoadImmediate(self.registers[instruction.working], self.context_of(instruction.target))         self.LoadImmediate(data.ref, instruction.target)      def LoadAddressContextCond(self, operand, instruction):         data = self.load(operand)         data = self._LoadAddressContextCond(data.context, data.ref, self.registers[instruction.working])         self.LoadImmediate(data.context, self.context_of(instruction.target))         self.LoadImmediate(data.ref, instruction.target)      def StoreAddress(self, operand, instruction):         # Preserve context.         self.save(operand, DataValue(             self.registers[self.context_of(instruction.source)],             self.registers[instruction.source]))      def StoreAddressContext(self, operand, instruction):         # Overwrite context if null.         self._StoreAddressContext(operand,             self.registers[self.context_of(instruction.working)],             self.registers[instruction.working],             self.registers[self.context_of(instruction.source)],             self.registers[instruction.source])      def MakeInstance(self, size, instruction):         # NOTE: Referencing the instance template.         addr = self._MakeObject(size, self.registers[instruction.working] - Library.instance_template_size)         # Introduce object as context for the new object.         self.LoadImmediate(addr, self.context_of(instruction.target))         self.LoadImmediate(addr, instruction.target)      def MakeFragment(self, size, instruction):         # Reserve twice the amount of space.         addr = self._MakeFragment(size, size * 2)         # NOTE: Context is not relevant for fragments.         self.LoadImmediate(None, self.context_of(instruction.target))         self.LoadImmediate(addr, instruction.target)      def LoadAttr(self, pos, instruction):         # Retrieved context should already be appropriate for the instance.         # Skip any header.         data = self.load(self.registers[instruction.working] + Library.instance_data_offset + pos)         self.LoadImmediate(data.context, self.context_of(instruction.target))         self.LoadImmediate(data.ref, instruction.target)      def StoreAttr(self, pos, instruction):         # Target should already be an instance.         # Skip any header.         self.save(self.registers[instruction.working] + Library.instance_data_offset + pos , DataValue(             self.registers[self.context_of(instruction.source)],             self.registers[instruction.source]))      def LoadAttrIndex(self, index, instruction):         data = self.load(self.registers[instruction.working])         element = self.load(self.registers["objlist"] + data.classcode + index)          if element is not None:             attr_index, static_attr, offset = element             if attr_index == index:                 if static_attr:                     data = self.load(offset) # offset is address of class/module attribute                 else:                     data = self.load(self.registers[instruction.working] + offset)                 self.LoadImmediate(data.context, self.context_of(instruction.target))                 self.LoadImmediate(data.ref, instruction.target)                 return          self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)         return self.RaiseException()      # LoadAttrIndexContext not defined.      def LoadAttrIndexContextCond(self, index, instruction):         data = self.load(self.registers[instruction.working])         element = self.load(self.registers["objlist"] + data.classcode + index)          if element is not None:             attr_index, static_attr, offset = element             if attr_index == index:                 if static_attr:                     loaded_data = self.load(offset) # offset is address of class/module attribute                     # Absent attrcode == class/module.                     if data.attrcode is not None:                         loaded_data = self._LoadAddressContextCond(                             loaded_data.context, loaded_data.ref,                             self.registers[instruction.working])                 else:                     loaded_data = self.load(self.registers[instruction.working] + offset)                 self.LoadImmediate(loaded_data.context, self.context_of(instruction.target))                 self.LoadImmediate(loaded_data.ref, instruction.target)                 return          self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)         return self.RaiseException()      def StoreAttrIndex(self, index, instruction):         data = self.load(self.registers[instruction.working])         element = self.load(self.registers["objlist"] + data.classcode + index)          if element is not None:             attr_index, static_attr, offset = element             if attr_index == index:                 if static_attr:                     self._StoreAddressContext(offset,                         self.registers[self.context_of(instruction.working)],                         self.registers[instruction.working],                         self.registers[self.context_of(instruction.source)],                         self.registers[instruction.source])                     return                 else:                     self.save(self.registers[instruction.working] + offset, DataValue(                         self.registers[self.context_of(instruction.source)],                         self.registers[instruction.source]))                     return          self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)         return self.RaiseException()      # NOTE: LoadAttrIndexContext is a possibility if a particular attribute can always be overridden.      def MakeFrame(self, size, instruction):         self.invocation_sp_stack.append(len(self.frame_stack))         self.frame_stack.extend([None] * size)      def DropFrame(self, operand, instruction):         self.local_sp_stack.pop()         frame = self.invocation_sp_stack.pop()         del self.frame_stack[frame:] # reset stack before call      def StoreFrame(self, pos, instruction):         frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame         self.frame_stack[frame + pos] = DataValue(             self.registers[self.context_of(instruction.working)],             self.registers[instruction.working])      def StoreFrameIndex(self, index, instruction):         frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame         data = self.load(self.registers[instruction.working])         element = self.load(self.registers["paramlist"] + data.funccode + index)          if element is not None:             # NOTE: Need to ensure correct positioning where a context has been generated.             param_index, offset = element             if param_index == index:                 self.frame_stack[frame + offset] = DataValue(                     self.registers[self.context_of(instruction.source)],                     self.registers[instruction.source])                 return          self.registers["exception"] = self._MakeObject(Library.instance_size, self.type_error_instance)         return self.RaiseException()      def LoadCallable(self, operand, instruction):         data = self.load(self.registers[instruction.working])         self.registers[instruction.target] = data.codeaddr      def StoreCallable(self, operand, instruction):         # NOTE: Should improve the representation and permit direct saving.         data = self.load(self.registers[instruction.working])         self.save(self.registers[instruction.working], data.with_callable(self.registers[instruction.source]))      def CheckContext(self, operand, instruction):         self.registers[instruction.target] = self.registers[instruction.working] is not ReplaceableContext      def CheckClass(self, operand, instruction):         if self.registers[instruction.working] in (ReplaceableContext, PlaceholderContext):             self.registers[instruction.target] = 0             return          data = self.load(self.registers[instruction.working])          # Classes are not themselves usable as the self argument.         # NOTE: This may change at some point.         # However, where classes appear as the context, instance         # compatibility is required in the first argument.          self.registers[instruction.target] = data.attrcode is None # absent attrcode == class      def CheckFrame(self, operand, instruction):         (nargs, ndefaults) = operand          # The frame is actually installed as the locals.         # Retrieve the context from the first local.          frame = self.local_sp_stack[-1]         nlocals = len(self.frame_stack[frame:])          if not ((nargs - ndefaults) <= nlocals):             raise Exception, "CheckFrame %r (%r <= %r <= %r)" % (operand, nargs - ndefaults, nlocals, nargs)             self.registers["exception"] = self._MakeObject(Library.instance_size, self.type_error_instance)             return self.RaiseException()      def CheckExtra(self, nargs, instruction):          # The frame is actually installed as the locals.         # Retrieve the context from the first local.          frame = self.local_sp_stack[-1]         nlocals = len(self.frame_stack[frame:])          # Provide the extra star parameter if necessary.          if nlocals == nargs:             self.frame_stack.extend([None]) # ExtendFrame(1)      def FillDefaults(self, operand, instruction):         (nargs, ndefaults) = operand          # The frame is actually installed as the locals.          frame = self.local_sp_stack[-1]         nlocals = len(self.frame_stack[frame:])          # Support population of defaults.         # This involves copying the "attributes" of a function into the frame.          default = nlocals - (nargs - ndefaults)         self.frame_stack.extend([None] * (nargs - nlocals))         pos = nlocals          while pos < nargs:              # Skip any header.              self.frame_stack[frame + pos] = self.load(self.registers[instruction.working] + Library.instance_data_offset + default)             default += 1             pos += 1      def CopyExtra(self, start, instruction):          # The frame is the source of the extra arguments.          frame = self.local_sp_stack[-1]         nlocals = len(self.frame_stack[frame:])          # Make a tuple to hold the arguments.          ref = self._MakeObject(nlocals - start + 1, self.tuple_instance)          extra = 0         pos = start          while pos < nlocals:              # Skip any header.              self.save(ref + Library.instance_data_offset + extra, self.frame_stack[frame + pos])             extra += 1             pos += 1          self.LoadImmediate(ref, self.context_of(instruction.working))         self.LoadImmediate(ref, instruction.working)      def CheckInstance(self, operand, instruction):         # For the 'self' parameter in an invoked function, the proposed context         # ('self') is checked against the target's context.         self.registers[instruction.target] = self._CheckInstance(             self.registers[instruction.working],             self.registers[instruction.source])      def JumpInFrame(self, operand, instruction):         codeaddr = self.registers[instruction.working]         return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one      def JumpInFrameDirect(self, addr, instruction):         return self.jump(addr, self.pc + 1) # return to the instruction after this one      def JumpWithFrame(self, operand, instruction):         codeaddr = self.registers[instruction.working]         self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame         return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one      def JumpWithFrameDirect(self, addr, instruction):         self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame         return self.jump(addr, self.pc + 1) # return to the instruction after this one      def ExtendFrame(self, size, instruction):         self.frame_stack.extend([None] * size)      def AdjustFrame(self, size, instruction):         self.invocation_sp_stack[-1] += size      def Return(self, operand, instruction):         return self.pull_pc()      def Jump(self, addr, instruction):         return addr      def JumpIfTrue(self, addr, instruction):         if self.registers[instruction.working]:             return addr      def JumpIfFalse(self, addr, instruction):         if not self.registers[instruction.working]:             return addr      def ClearException(self, operand, instruction):         self.LoadImmediate(None, instruction.target)      def RaiseException(self, operand=None, instruction=None):         # NOTE: Adding the program counter as the first attribute after __class__.         self.save(self.registers["exception"] + Library.instance_data_offset, self.pc)         # Jumping to the current handler.         if self.abort_upon_exception:             raise Exception         return self.handler_stack[-1]      def PushHandler(self, addr, instruction):         self.handler_stack.append(addr)         self.handler_local_sp_stack.append(len(self.local_sp_stack))         self.handler_invocation_sp_stack.append(len(self.invocation_sp_stack))         self.handler_pc_stack.append(len(self.pc_stack))      def PopHandler(self, nframes, instruction):         # Get the new local frame pointer and PC stack references.         local_sp_top = self.handler_local_sp_stack[-nframes]         invocation_sp_top = self.handler_invocation_sp_stack[-nframes]         pc_top = self.handler_pc_stack[-nframes]         # Reduce the local frame pointer stack to refer to the handler's frame.         del self.local_sp_stack[local_sp_top:]         # Reduce the invocation frame pointer stack to refer to an outer frame.         del self.invocation_sp_stack[invocation_sp_top:]         # Reduce the PC stack to discard all superfluous return addresses.         del self.pc_stack[pc_top:]         # Remove elements from the handler stacks.         del self.handler_pc_stack[-nframes:]         del self.handler_local_sp_stack[-nframes:]         del self.handler_invocation_sp_stack[-nframes:]         del self.handler_stack[-nframes:]      def CheckException(self, operand, instruction):         self.registers[instruction.target] = self.registers["exception"] is not None and \             self._CheckInstance(self.registers["exception"], self.registers[instruction.working])      def TestIdentity(self, operand, instruction):         self.registers[instruction.target] = self.registers[instruction.working] == self.registers[instruction.source]      def TestIdentityAddress(self, addr, instruction):         self.registers[instruction.target] = self.registers[instruction.working] == addr      def InvertBoolean(self, operand, instruction):         self.registers[instruction.target] = not self.registers[instruction.source]      # Common implementation details.      def _CheckInstance(self, ref, cls):         data = self.load(ref)         target_data = self.load(cls)          # Insist on instance vs. class.          if data.attrcode is None: # absent attrcode == class/module             return 0          if target_data.attrcode is not None: # present attrcode == instance             return 0          # Find the table entry for the descendant.          element = self.load(self.registers["objlist"] + target_data.classcode + data.attrcode)          if element is not None:             attr_index, static_attr, offset = element             return attr_index == data.attrcode         else:             return 0      def _MakeObject(self, size, ref):         # Load the template.         data = self.load(ref)         addr = self.new(size)         # Save the header, overriding the size.         self.save(addr, data.with_size(size))         return addr      def _MakeFragment(self, occupied, size):         addr = self.new(size)         # Save the header, overriding the size.         self.save(addr, FragmentObject(occupied, size))         return addr      def _LoadAddressContextCond(self, context, value, inst_value):         # Check the instance context against the target's context.         # This provides the context overriding for methods.         if context is ReplaceableContext or context is not PlaceholderContext and self._CheckInstance(inst_value, context):             # Replace the context with the instance.             return DataValue(inst_value, value)         else:             return DataValue(context, value)      def _StoreAddressContext(self, location, context, value, source_context, source_value):         if source_context is ReplaceableContext:             context = value         else:             context = source_context         self.save(location, DataValue(context, source_value))  # Convenience functions.  def machine(program, with_builtins=0, debug=0, abort_upon_exception=0):     print "Making the image..."     code = program.get_image(with_builtins)     print "Getting raw structures..."     ot = program.get_object_table()     pt = program.get_parameter_table()     objlist = ot.as_list()     paramlist = pt.as_list()     print "Getting raw image..."     rc = program.get_raw_image()     print "Initialising the machine..."     importer = program.get_importer()     constants = {}     for x in (True, False, NotImplemented):         constants[x] = importer.get_constant(x).location     rm = RSVPMachine(rc, objlist, paramlist, debug=debug, abort_upon_exception=abort_upon_exception)     library = Library(rm, constants)     rm.library = library     rm.pc = program.code_location     print "Returning program occupying %d locations." % rm.get_program_size()     return rm  # vim: tabstop=4 expandtab shiftwidth=4