micropython

Annotated rsvp.py

593:ea6f6921c325
513:e43264ed5c5d
479:9f8b0962e215
2012-06-03 Paul Boddie file changeset files shortlog Added missing operator handler.
paul@68 1 
#!/usr/bin/env python
paul@68 2 
 
 paul@68      3 
"""
 
 paul@68      4 
A really simple virtual processor employing a simple set of instructions which
 
 paul@68      5 
ignore low-level operations and merely concentrate on variable access, structure
 
 paul@68      6 
access, structure allocation and function invocations.
 
 paul@68      7 
 
 paul@394      8 
Copyright (C) 2007, 2008, 2009, 2010, 2011 Paul Boddie <paul@boddie.org.uk>
 
 paul@68      9 
 
 paul@68     10 
This program is free software; you can redistribute it and/or modify it under
 
 paul@68     11 
the terms of the GNU General Public License as published by the Free Software
 
 paul@68     12 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@68     13 
version.
 
 paul@68     14 
 
 paul@68     15 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@68     16 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@68     17 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@68     18 
details.
 
 paul@68     19 
 
 paul@68     20 
You should have received a copy of the GNU General Public License along with
 
 paul@68     21 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@68     22 
 
 paul@68     23 
--------
 
 paul@68     24 
 
 paul@68     25 
The execution model of the virtual processor involves the following things:
 
 paul@68     26 
 
 paul@145     27 
  * Memory                          contains constants, global variable
 
 paul@145     28 
                                    references and program code
 
 paul@145     29 
 
 paul@145     30 
  * PC (program counter) stack      contains the return address associated
 
 paul@145     31 
                                    with each function invocation
 
 paul@145     32 
 
 paul@145     33 
  * Frame stack                     contains invocation frames in use and in
 
 paul@145     34 
                                    preparation plus temporary storage
 
 paul@145     35 
 
 paul@145     36 
  * Local frame pointer stack       refers to the frames in the frame stack
 
 paul@145     37 
 
 paul@117     38 
  * Invocation frame pointer stack
 
 paul@145     39 
 
 paul@117     40 
  * Exception handler stack
 
 paul@68     41 
 
 paul@145     42 
  * Exception handler locals stack  refers to the state of the local frame
 
 paul@145     43 
                                    pointer stack
 
 paul@145     44 
 
 paul@145     45 
  * Exception handler PC stack      refers to the state of the PC stack
 
 paul@68     46 
 
 paul@450     47 
  * Registers: working context/value,
 
 paul@450     48 
               assignment source context/value,
 
 paul@429     49 
               current exception value,
 
 paul@460     50 
               boolean status value,
 
 paul@460     51 
               object list start (constant),
 
 paul@460     52 
               parameter list start (constant)
 
 paul@68     53 
"""
 
 paul@68     54 
 
 paul@264     55 
from micropython.program import DataValue, ReplaceableContext, PlaceholderContext, FragmentObject
 
 paul@261     56 
from rsvplib import Library
 
 paul@182     57 
 
 paul@68     58 
class IllegalInstruction(Exception):
 
 paul@68     59 
    pass
 
 paul@68     60 
 
 paul@68     61 
class IllegalAddress(Exception):
 
 paul@180     62 
    def __init__(self, address):
 
 paul@180     63 
        self.address = address
 
 paul@180     64 
    def __repr__(self):
 
 paul@180     65 
        return "IllegalAddress(%r)" % self.address
 
 paul@180     66 
    def __str__(self):
 
 paul@180     67 
        return repr(self)
 
 paul@68     68 
 
 paul@68     69 
class EmptyPCStack(Exception):
 
 paul@68     70 
    pass
 
 paul@68     71 
 
 paul@92     72 
class EmptyFrameStack(Exception):
 
 paul@68     73 
    pass
 
 paul@68     74 
 
 paul@194     75 
class BreakpointReached(Exception):
 
 paul@194     76 
    pass
 
 paul@194     77 
 
 paul@68     78 
class RSVPMachine:
 
 paul@68     79 
 
 paul@68     80 
    "A really simple virtual processor."
 
 paul@68     81 
 
 paul@248     82 
    def __init__(self, memory, objlist, paramlist, pc=None, debug=0, abort_upon_exception=0):
 
 paul@68     83 
 
 paul@68     84 
        """
 
 paul@68     85 
        Initialise the processor with a 'memory' (a list of values containing
 
 paul@196     86 
        instructions and data), the object and parameter lists 'objlist' and
 
 paul@248     87 
        'paramlist', and the optional program counter 'pc'.
 
 paul@68     88 
        """
 
 paul@68     89 
 
 paul@68     90 
        self.memory = memory
 
 paul@202     91 
        self._objlist = objlist
 
 paul@202     92 
        self._paramlist = paramlist
 
 paul@459     93 
        end_of_code = len(self.memory)
 
 paul@459     94 
 
 paul@459     95 
        # Add the object list.
 
 paul@459     96 
 
 paul@460     97 
        objlist_start = len(self.memory)
 
 paul@459     98 
        self.memory += objlist.as_raw()
 
 paul@459     99 
 
 paul@459    100 
        # Add the parameter list.
 
 paul@459    101 
 
 paul@460    102 
        paramlist_start = len(self.memory)
 
 paul@459    103 
        self.memory += paramlist.as_raw()
 
 paul@459    104 
 
 paul@459    105 
        # A reference to the native library.
 
 paul@459    106 
 
 paul@248    107 
        self.library = None
 
 paul@196    108 
 
 paul@459    109 
        # Program counter and machine configuration.
 
 paul@459    110 
 
 paul@68    111 
        self.pc = pc or 0
 
 paul@68    112 
        self.debug = debug
 
 paul@246    113 
        self.abort_upon_exception = abort_upon_exception
 
 paul@313    114 
 
 paul@313    115 
        # Profiling.
 
 paul@313    116 
 
 paul@459    117 
        self.coverage = [0] * end_of_code
 
 paul@285    118 
        self.counter = 0
 
 paul@313    119 
        self.cost = 0
 
 paul@117    120 
 
 paul@117    121 
        # Stacks.
 
 paul@117    122 
 
 paul@68    123 
        self.pc_stack = []
 
 paul@68    124 
        self.frame_stack = []
 
 paul@143    125 
        self.local_sp_stack = [0]
 
 paul@117    126 
        self.invocation_sp_stack = []
 
 paul@398    127 
 
 paul@398    128 
        # Exception handler stacks are used to reset the state of the main
 
 paul@398    129 
        # stacks.
 
 paul@398    130 
 
 paul@459    131 
        self.handler_stack = [end_of_code - 1] # final handler is the end of the code
 
 paul@145    132 
        self.handler_local_sp_stack = []
 
 paul@398    133 
        self.handler_invocation_sp_stack = []
 
 paul@145    134 
        self.handler_pc_stack = []
 
 paul@117    135 
 
 paul@117    136 
        # Registers.
 
 paul@117    137 
 
 paul@450    138 
        self.register_names = (
 
 paul@450    139 
            "working",
 
 paul@450    140 
            "working_context",
 
 paul@450    141 
            "source",
 
 paul@450    142 
            "source_context",
 
 paul@450    143 
            "exception",
 
 paul@460    144 
            "status",
 
 paul@460    145 
            "objlist",
 
 paul@460    146 
            "paramlist"
 
 paul@450    147 
            )
 
 paul@450    148 
        self.registers = {}
 
 paul@429    149 
 
 paul@450    150 
        for name in self.register_names:
 
 paul@450    151 
            self.registers[name] = None
 
 paul@429    152 
 
 paul@460    153 
        self.registers["objlist"] = objlist_start
 
 paul@460    154 
        self.registers["paramlist"] = paramlist_start
 
 paul@460    155 
 
 paul@119    156 
        self.instruction = None
 
 paul@68    157 
 
 paul@146    158 
        # Constants.
 
 paul@450    159 
        # NOTE: These should eventually be removed once the code using them has
 
 paul@450    160 
        # NOTE: been migrated to the native code library.
 
 paul@146    161 
 
 paul@221    162 
        cls = self._get_class("__builtins__", "AttributeError")
 
 paul@221    163 
        self.attr_error = cls.location
 
 paul@221    164 
        self.attr_error_instance = cls.instance_template_location
 
 paul@221    165 
        cls = self._get_class("__builtins__", "TypeError")
 
 paul@221    166 
        self.type_error = cls.location
 
 paul@221    167 
        self.type_error_instance = cls.instance_template_location
 
 paul@256    168 
        cls = self._get_class("__builtins__", "tuple")
 
 paul@255    169 
        self.tuple_class = cls.location
 
 paul@255    170 
        self.tuple_instance = cls.instance_template_location
 
 paul@181    171 
 
 paul@194    172 
        # Debugging attributes.
 
 paul@194    173 
 
 paul@194    174 
        self.breakpoints = set()
 
 paul@194    175 
 
 paul@461    176 
    def get_program_size(self):
 
 paul@461    177 
        return self.registers["objlist"]
 
 paul@461    178 
 
 paul@221    179 
    def _get_class(self, module, name):
 
 paul@346    180 
        attr = self._objlist.access(module, name)
 
 paul@346    181 
        if attr is not None:
 
 paul@346    182 
            return attr.get_value()
 
 paul@346    183 
        else:
 
 paul@346    184 
            return None
 
 paul@221    185 
 
 paul@162    186 
    # Debugging methods.
 
 paul@162    187 
 
 paul@137    188 
    def dump(self):
 
 paul@138    189 
        print "PC", self.pc, "->", self.load(self.pc)
 
 paul@137    190 
        print "PC stack", self.pc_stack
 
 paul@401    191 
        print "Frame stack:"
 
 paul@401    192 
        if self.local_sp_stack:
 
 paul@401    193 
            start = self.local_sp_stack[0]
 
 paul@401    194 
            for end in self.local_sp_stack[1:]:
 
 paul@401    195 
                print "  %2d" % start, self.frame_stack[start:end]
 
 paul@401    196 
                start = end
 
 paul@401    197 
            else:
 
 paul@401    198 
                print "  %2d" % start, self.frame_stack[start:]
 
 paul@401    199 
        print
 
 paul@137    200 
        print "Local stack pointers", self.local_sp_stack
 
 paul@137    201 
        print "Invocation stack pointers", self.invocation_sp_stack
 
 paul@137    202 
        print "Handler stack", self.handler_stack
 
 paul@145    203 
        print "Handler frame stack", self.handler_local_sp_stack
 
 paul@145    204 
        print "Handler PC stack", self.handler_pc_stack
 
 paul@137    205 
        print
 
 paul@450    206 
        print "Registers:"
 
 paul@429    207 
        print
 
 paul@450    208 
        for name in self.register_names:
 
 paul@450    209 
            print "%s: %s" % (name, self.registers[name])
 
 paul@429    210 
        print
 
 paul@137    211 
        print "Instruction", self.instruction
 
 paul@137    212 
 
 paul@399    213 
    def show(self, start=None, end=None):
 
 paul@399    214 
        self.show_memory(self.memory[start:end], self.coverage[start:end], start or 0)
 
 paul@162    215 
 
 paul@162    216 
    def show_pc(self, run_in=10):
 
 paul@162    217 
        start = max(0, self.pc - run_in)
 
 paul@162    218 
        end = self.pc + run_in
 
 paul@162    219 
        memory = self.memory[start:end]
 
 paul@389    220 
        coverage = self.coverage[start:end]
 
 paul@389    221 
        self.show_memory(memory, coverage, start)
 
 paul@162    222 
 
 paul@479    223 
    def show_object(self, start):
 
 paul@479    224 
        obj = self.memory[start]
 
 paul@479    225 
        end = start + obj.size
 
 paul@479    226 
        self.show_memory(self.memory[start:end], self.coverage[start:end], start)
 
 paul@479    227 
 
 paul@389    228 
    def show_memory(self, memory, coverage, start):
 
 paul@389    229 
        for i, (c, x) in enumerate(map(None, coverage, memory)):
 
 paul@162    230 
            location = start + i
 
 paul@162    231 
            if location == self.pc:
 
 paul@162    232 
                print "->",
 
 paul@381    233 
            elif location in self.pc_stack:
 
 paul@381    234 
                print "..",
 
 paul@162    235 
            else:
 
 paul@162    236 
                print "  ",
 
 paul@389    237 
            print "%-5s %5d %r" % (c or "", location, x)
 
 paul@162    238 
 
 paul@162    239 
    def step(self, dump=0):
 
 paul@138    240 
        self.execute()
 
 paul@162    241 
        self.show_pc()
 
 paul@162    242 
        if dump:
 
 paul@162    243 
            self.dump()
 
 paul@162    244 
 
 paul@194    245 
    def set_break(self, location):
 
 paul@194    246 
        self.breakpoints.add(location)
 
 paul@194    247 
 
 paul@399    248 
    def up(self):
 
 paul@399    249 
        retaddr = self.pc_stack[-1]
 
 paul@401    250 
        self.set_break(retaddr)
 
 paul@399    251 
        self.run()
 
 paul@399    252 
 
 paul@162    253 
    # Internal operations.
 
 paul@138    254 
 
 paul@68    255 
    def load(self, address):
 
 paul@68    256 
 
 paul@68    257 
        "Return the value at the given 'address'."
 
 paul@68    258 
 
 paul@68    259 
        try:
 
 paul@68    260 
            return self.memory[address]
 
 paul@68    261 
        except IndexError:
 
 paul@180    262 
            raise IllegalAddress(address)
 
 paul@180    263 
        except TypeError:
 
 paul@180    264 
            raise IllegalAddress(address)
 
 paul@68    265 
 
 paul@68    266 
    def save(self, address, value):
 
 paul@68    267 
 
 paul@68    268 
        "Save to the given 'address' the specified 'value'."
 
 paul@68    269 
 
 paul@68    270 
        try:
 
 paul@68    271 
            self.memory[address] = value
 
 paul@68    272 
        except IndexError:
 
 paul@180    273 
            raise IllegalAddress(address)
 
 paul@180    274 
        except TypeError:
 
 paul@180    275 
            raise IllegalAddress(address)
 
 paul@68    276 
 
 paul@68    277 
    def new(self, size):
 
 paul@68    278 
 
 paul@68    279 
        """
 
 paul@68    280 
        Allocate space of the given 'size', returning the address of the space.
 
 paul@68    281 
        """
 
 paul@68    282 
 
 paul@68    283 
        addr = len(self.memory)
 
 paul@68    284 
        for i in range(0, size):
 
 paul@68    285 
            self.memory.append(None)
 
 paul@68    286 
        return addr
 
 paul@68    287 
 
 paul@68    288 
    def push_pc(self, data):
 
 paul@68    289 
 
 paul@68    290 
        "Push 'data' onto the PC stack."
 
 paul@68    291 
 
 paul@68    292 
        self.pc_stack.append(data)
 
 paul@68    293 
 
 paul@68    294 
    def pull_pc(self):
 
 paul@68    295 
 
 paul@68    296 
        "Pull a value from the PC stack and return it."
 
 paul@68    297 
 
 paul@68    298 
        try:
 
 paul@68    299 
            return self.pc_stack.pop()
 
 paul@68    300 
        except IndexError:
 
 paul@68    301 
            raise EmptyPCStack
 
 paul@68    302 
 
 paul@90    303 
    def run(self):
 
 paul@68    304 
 
 paul@68    305 
        "Execute code in the memory, starting from the current PC address."
 
 paul@68    306 
 
 paul@228    307 
        breakpoint = 0
 
 paul@228    308 
 
 paul@68    309 
        try:
 
 paul@68    310 
            while 1:
 
 paul@90    311 
                self.execute()
 
 paul@68    312 
        except EmptyPCStack:
 
 paul@68    313 
            pass
 
 paul@228    314 
        except BreakpointReached:
 
 paul@228    315 
            breakpoint = 1
 
 paul@68    316 
 
 paul@221    317 
        print "Execution terminated",
 
 paul@450    318 
        if breakpoint:
 
 paul@450    319 
            print "with breakpoint."
 
 paul@450    320 
            print "At address", self.pc
 
 paul@450    321 
        elif self.registers["exception"] is not None:
 
 paul@450    322 
            ref = self.registers["exception"]
 
 paul@399    323 
            addr = self.load(ref + Library.instance_data_offset)
 
 paul@221    324 
            print "with exception:", self.load(ref)
 
 paul@222    325 
            print "At address %d: %r" % (addr, self.load(addr))
 
 paul@221    326 
        else:
 
 paul@221    327 
            print "successfully."
 
 paul@313    328 
        print "After", self.counter, "instructions at cost", self.cost, "units."
 
 paul@221    329 
 
 paul@228    330 
    def test(self, module):
 
 paul@228    331 
 
 paul@228    332 
        """
 
 paul@228    333 
        Test the code in the memory by running the code and investigating the
 
 paul@228    334 
        contents of variables. Use 'module' to identify result variables.
 
 paul@228    335 
        """
 
 paul@228    336 
 
 paul@228    337 
        self.run()
 
 paul@228    338 
        success = 1
 
 paul@228    339 
 
 paul@450    340 
        if self.registers["exception"] is None:
 
 paul@229    341 
            for name in module.keys():
 
 paul@229    342 
                if name.startswith("result"):
 
 paul@229    343 
                    label, expected = name.split("_")
 
 paul@229    344 
                    attr = module[name]
 
 paul@228    345 
 
 paul@450    346 
                    # Need to skip the header to get at the members.
 
 paul@228    347 
 
 paul@450    348 
                    attr_location = module.location + Library.instance_data_offset + attr.position
 
 paul@264    349 
                    value = self.load(attr_location)
 
 paul@228    350 
 
 paul@264    351 
                    if value is not None:
 
 paul@395    352 
                        content = self.load(value.ref + Library.instance_data_offset)
 
 paul@243    353 
                        print label, expected, content
 
 paul@243    354 
                        success = success and (int(expected) == content)
 
 paul@243    355 
                    else:
 
 paul@243    356 
                        print label, expected, "missing"
 
 paul@243    357 
                        success = 0
 
 paul@228    358 
 
 paul@229    359 
            return success
 
 paul@229    360 
        else:
 
 paul@229    361 
            return 0
 
 paul@228    362 
 
 paul@90    363 
    def execute(self):
 
 paul@90    364 
 
 paul@90    365 
        "Execute code in the memory at the current PC address."
 
 paul@90    366 
 
 paul@194    367 
        if self.pc in self.breakpoints:
 
 paul@194    368 
            self.breakpoints.remove(self.pc)
 
 paul@194    369 
            raise BreakpointReached
 
 paul@194    370 
 
 paul@119    371 
        self.instruction = self.load(self.pc)
 
 paul@118    372 
 
 paul@137    373 
        # Perform the instruction itself.
 
 paul@137    374 
 
 paul@137    375 
        next_pc = self.perform(self.instruction)
 
 paul@118    376 
 
 paul@389    377 
        # Update the coverage.
 
 paul@389    378 
 
 paul@389    379 
        self.coverage[self.pc] += 1
 
 paul@389    380 
 
 paul@119    381 
        # Update the program counter.
 
 paul@118    382 
 
 paul@119    383 
        if next_pc is None:
 
 paul@119    384 
            self.pc += 1
 
 paul@119    385 
        else:
 
 paul@119    386 
            self.pc = next_pc
 
 paul@118    387 
 
 paul@137    388 
    def get_method(self, instruction):
 
 paul@137    389 
 
 paul@137    390 
        "Return the handler method for the given 'instruction'."
 
 paul@119    391 
 
 paul@137    392 
        instruction_name = instruction.__class__.__name__
 
 paul@137    393 
        if self.debug:
 
 paul@137    394 
            print "%8d %s" % (self.pc, instruction_name)
 
 paul@119    395 
        method = getattr(self, instruction_name, None)
 
 paul@90    396 
        if method is None:
 
 paul@119    397 
            raise IllegalInstruction, (self.pc, instruction_name)
 
 paul@118    398 
        return method
 
 paul@118    399 
 
 paul@450    400 
    def perform(self, instruction):
 
 paul@137    401 
 
 paul@137    402 
        "Perform the 'instruction', returning the next PC value or None."
 
 paul@137    403 
 
 paul@450    404 
        self.counter += 1
 
 paul@450    405 
        self.cost += instruction.cost
 
 paul@430    406 
        operand = instruction.get_operand()
 
 paul@137    407 
        method = self.get_method(instruction)
 
 paul@450    408 
        return method(operand, instruction)
 
 paul@90    409 
 
 paul@68    410 
    def jump(self, addr, next):
 
 paul@68    411 
 
 paul@68    412 
        """
 
 paul@68    413 
        Jump to the subroutine at (or identified by) 'addr'. If 'addr'
 
 paul@68    414 
        identifies a library function then invoke the library function and set
 
 paul@68    415 
        PC to 'next' afterwards; otherwise, set PC to 'addr'.
 
 paul@68    416 
        """
 
 paul@68    417 
 
 paul@181    418 
        # Trap library functions introduced through the use of strings instead
 
 paul@181    419 
        # of proper locations.
 
 paul@181    420 
 
 paul@68    421 
        if isinstance(addr, str):
 
 paul@248    422 
            handler = self.library and self.library.native_functions[addr](self.library)
 
 paul@196    423 
            if handler is None:
 
 paul@196    424 
                return next
 
 paul@196    425 
            else:
 
 paul@196    426 
                return handler
 
 paul@68    427 
        else:
 
 paul@138    428 
            self.push_pc(self.pc + 1)
 
 paul@119    429 
            return addr
 
 paul@68    430 
 
 paul@450    431 
    # Helper methods.
 
 paul@450    432 
 
 paul@450    433 
    def context_of(self, register):
 
 paul@450    434 
        return "%s_context" % register
 
 paul@450    435 
 
 paul@450    436 
    def load_from_frame(self, operand):
 
 paul@450    437 
        frame = self.local_sp_stack[-1]
 
 paul@450    438 
        return self.frame_stack[frame + operand]
 
 paul@450    439 
 
 paul@429    440 
    # Low-level instructions.
 
 paul@429    441 
 
 paul@450    442 
    def LoadImmediate(self, operand, target):
 
 paul@450    443 
        self.registers[target] = operand
 
 paul@429    444 
 
 paul@450    445 
    def LoadMemory(self, operand, target, source):
 
 paul@450    446 
        self.registers[target] = self.load(
 
 paul@450    447 
            self.registers[source] + (operand is not None and operand or 0)
 
 paul@450    448 
            )
 
 paul@430    449 
 
 paul@68    450 
    # Instructions.
 
 paul@68    451 
 
 paul@450    452 
    def Transfer(self, operand, instruction):
 
 paul@450    453 
        self.registers[instruction.target] = self.registers[instruction.source]
 
 paul@223    454 
 
 paul@450    455 
    def LoadConst(self, operand, instruction):
 
 paul@450    456 
        self.LoadImmediate(operand, self.context_of(instruction.target))
 
 paul@450    457 
        self.LoadImmediate(operand, instruction.target)
 
 paul@450    458 
 
 paul@450    459 
    def LoadClass(self, operand, instruction):
 
 paul@450    460 
        self.LoadImmediate(PlaceholderContext, self.context_of(instruction.target))
 
 paul@450    461 
        self.LoadImmediate(operand, instruction.target)
 
 paul@237    462 
 
 paul@450    463 
    def LoadFunction(self, operand, instruction):
 
 paul@450    464 
        self.LoadImmediate(ReplaceableContext, self.context_of(instruction.target))
 
 paul@450    465 
        self.LoadImmediate(operand, instruction.target)
 
 paul@68    466 
 
 paul@450    467 
    def LoadName(self, operand, instruction):
 
 paul@450    468 
        data = self.load_from_frame(operand)
 
 paul@450    469 
        self.LoadImmediate(data.context, self.context_of(instruction.target))
 
 paul@450    470 
        self.LoadImmediate(data.ref, instruction.target)
 
 paul@450    471 
 
 paul@450    472 
    def StoreName(self, operand, instruction):
 
 paul@117    473 
        frame = self.local_sp_stack[-1]
 
 paul@450    474 
        self.frame_stack[frame + operand] = DataValue(
 
 paul@450    475 
            self.registers[self.context_of(instruction.source)],
 
 paul@450    476 
            self.registers[instruction.source])
 
 paul@68    477 
 
 paul@72    478 
    LoadTemp = LoadName
 
 paul@203    479 
 
 paul@450    480 
    def StoreTemp(self, operand, instruction):
 
 paul@203    481 
        frame = self.local_sp_stack[-1]
 
 paul@450    482 
        self.frame_stack[frame + operand] = DataValue(
 
 paul@450    483 
            self.registers[self.context_of(instruction.working)],
 
 paul@450    484 
            self.registers[instruction.working])
 
 paul@72    485 
 
 paul@450    486 
    def LoadAddress(self, operand, instruction):
 
 paul@119    487 
        # Preserve context (potentially null).
 
 paul@430    488 
        data = self.load(operand)
 
 paul@450    489 
        self.LoadImmediate(data.context, self.context_of(instruction.target))
 
 paul@450    490 
        self.LoadImmediate(data.ref, instruction.target)
 
 paul@72    491 
 
 paul@450    492 
    def LoadAddressContext(self, operand, instruction):
 
 paul@429    493 
        # Value becomes context.
 
 paul@430    494 
        data = self.load(operand)
 
 paul@450    495 
        self.LoadImmediate(self.registers[instruction.working], self.context_of(instruction.target))
 
 paul@450    496 
        self.LoadImmediate(data.ref, instruction.target)
 
 paul@194    497 
 
 paul@450    498 
    def LoadAddressContextCond(self, operand, instruction):
 
 paul@430    499 
        data = self.load(operand)
 
 paul@450    500 
        data = self._LoadAddressContextCond(data.context, data.ref, self.registers[instruction.working])
 
 paul@450    501 
        self.LoadImmediate(data.context, self.context_of(instruction.target))
 
 paul@450    502 
        self.LoadImmediate(data.ref, instruction.target)
 
 paul@72    503 
 
 paul@450    504 
    def StoreAddress(self, operand, instruction):
 
 paul@119    505 
        # Preserve context.
 
 paul@450    506 
        self.save(operand, DataValue(
 
 paul@450    507 
            self.registers[self.context_of(instruction.source)],
 
 paul@450    508 
            self.registers[instruction.source]))
 
 paul@72    509 
 
 paul@450    510 
    def StoreAddressContext(self, operand, instruction):
 
 paul@223    511 
        # Overwrite context if null.
 
 paul@450    512 
        self._StoreAddressContext(operand,
 
 paul@450    513 
            self.registers[self.context_of(instruction.working)],
 
 paul@450    514 
            self.registers[instruction.working],
 
 paul@450    515 
            self.registers[self.context_of(instruction.source)],
 
 paul@450    516 
            self.registers[instruction.source])
 
 paul@223    517 
 
 paul@450    518 
    def MakeInstance(self, size, instruction):
 
 paul@184    519 
        # NOTE: Referencing the instance template.
 
 paul@450    520 
        addr = self._MakeObject(size, self.registers[instruction.working] - Library.instance_template_size)
 
 paul@184    521 
        # Introduce object as context for the new object.
 
 paul@450    522 
        self.LoadImmediate(addr, self.context_of(instruction.target))
 
 paul@450    523 
        self.LoadImmediate(addr, instruction.target)
 
 paul@72    524 
 
 paul@450    525 
    def MakeFragment(self, size, instruction):
 
 paul@336    526 
        # Reserve twice the amount of space.
 
 paul@336    527 
        addr = self._MakeFragment(size, size * 2)
 
 paul@246    528 
        # NOTE: Context is not relevant for fragments.
 
 paul@450    529 
        self.LoadImmediate(None, self.context_of(instruction.target))
 
 paul@450    530 
        self.LoadImmediate(addr, instruction.target)
 
 paul@246    531 
 
 paul@450    532 
    def LoadAttr(self, pos, instruction):
 
 paul@127    533 
        # Retrieved context should already be appropriate for the instance.
 
 paul@450    534 
        # Skip any header.
 
 paul@450    535 
        data = self.load(self.registers[instruction.working] + Library.instance_data_offset + pos)
 
 paul@450    536 
        self.LoadImmediate(data.context, self.context_of(instruction.target))
 
 paul@450    537 
        self.LoadImmediate(data.ref, instruction.target)
 
 paul@118    538 
 
 paul@450    539 
    def StoreAttr(self, pos, instruction):
 
 paul@129    540 
        # Target should already be an instance.
 
 paul@450    541 
        # Skip any header.
 
 paul@450    542 
        self.save(self.registers[instruction.working] + Library.instance_data_offset + pos , DataValue(
 
 paul@450    543 
            self.registers[self.context_of(instruction.source)],
 
 paul@450    544 
            self.registers[instruction.source]))
 
 paul@119    545 
 
 paul@450    546 
    def LoadAttrIndex(self, index, instruction):
 
 paul@450    547 
        data = self.load(self.registers[instruction.working])
 
 paul@460    548 
        element = self.load(self.registers["objlist"] + data.classcode + index)
 
 paul@238    549 
 
 paul@238    550 
        if element is not None:
 
 paul@242    551 
            attr_index, static_attr, offset = element
 
 paul@430    552 
            if attr_index == index:
 
 paul@242    553 
                if static_attr:
 
 paul@429    554 
                    data = self.load(offset) # offset is address of class/module attribute
 
 paul@238    555 
                else:
 
 paul@450    556 
                    data = self.load(self.registers[instruction.working] + offset)
 
 paul@450    557 
                self.LoadImmediate(data.context, self.context_of(instruction.target))
 
 paul@450    558 
                self.LoadImmediate(data.ref, instruction.target)
 
 paul@238    559 
                return
 
 paul@238    560 
 
 paul@450    561 
        self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    562 
        return self.RaiseException()
 
 paul@118    563 
 
 paul@226    564 
    # LoadAttrIndexContext not defined.
 
 paul@194    565 
 
 paul@450    566 
    def LoadAttrIndexContextCond(self, index, instruction):
 
 paul@450    567 
        data = self.load(self.registers[instruction.working])
 
 paul@460    568 
        element = self.load(self.registers["objlist"] + data.classcode + index)
 
 paul@238    569 
 
 paul@238    570 
        if element is not None:
 
 paul@242    571 
            attr_index, static_attr, offset = element
 
 paul@430    572 
            if attr_index == index:
 
 paul@242    573 
                if static_attr:
 
 paul@429    574 
                    loaded_data = self.load(offset) # offset is address of class/module attribute
 
 paul@429    575 
                    # Absent attrcode == class/module.
 
 paul@429    576 
                    if data.attrcode is not None:
 
 paul@450    577 
                        loaded_data = self._LoadAddressContextCond(
 
 paul@450    578 
                            loaded_data.context, loaded_data.ref,
 
 paul@450    579 
                            self.registers[instruction.working])
 
 paul@223    580 
                else:
 
 paul@450    581 
                    loaded_data = self.load(self.registers[instruction.working] + offset)
 
 paul@450    582 
                self.LoadImmediate(loaded_data.context, self.context_of(instruction.target))
 
 paul@450    583 
                self.LoadImmediate(loaded_data.ref, instruction.target)
 
 paul@238    584 
                return
 
 paul@238    585 
 
 paul@450    586 
        self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    587 
        return self.RaiseException()
 
 paul@194    588 
 
 paul@450    589 
    def StoreAttrIndex(self, index, instruction):
 
 paul@450    590 
        data = self.load(self.registers[instruction.working])
 
 paul@460    591 
        element = self.load(self.registers["objlist"] + data.classcode + index)
 
 paul@238    592 
 
 paul@238    593 
        if element is not None:
 
 paul@242    594 
            attr_index, static_attr, offset = element
 
 paul@430    595 
            if attr_index == index:
 
 paul@242    596 
                if static_attr:
 
 paul@450    597 
                    self._StoreAddressContext(offset,
 
 paul@450    598 
                        self.registers[self.context_of(instruction.working)],
 
 paul@450    599 
                        self.registers[instruction.working],
 
 paul@450    600 
                        self.registers[self.context_of(instruction.source)],
 
 paul@450    601 
                        self.registers[instruction.source])
 
 paul@405    602 
                    return
 
 paul@238    603 
                else:
 
 paul@450    604 
                    self.save(self.registers[instruction.working] + offset, DataValue(
 
 paul@450    605 
                        self.registers[self.context_of(instruction.source)],
 
 paul@450    606 
                        self.registers[instruction.source]))
 
 paul@238    607 
                    return
 
 paul@238    608 
 
 paul@450    609 
        self.registers["exception"] = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    610 
        return self.RaiseException()
 
 paul@118    611 
 
 paul@127    612 
    # NOTE: LoadAttrIndexContext is a possibility if a particular attribute can always be overridden.
 
 paul@127    613 
 
 paul@450    614 
    def MakeFrame(self, size, instruction):
 
 paul@117    615 
        self.invocation_sp_stack.append(len(self.frame_stack))
 
 paul@430    616 
        self.frame_stack.extend([None] * size)
 
 paul@98    617 
 
 paul@450    618 
    def DropFrame(self, operand, instruction):
 
 paul@117    619 
        self.local_sp_stack.pop()
 
 paul@117    620 
        frame = self.invocation_sp_stack.pop()
 
 paul@248    621 
        del self.frame_stack[frame:] # reset stack before call
 
 paul@98    622 
 
 paul@450    623 
    def StoreFrame(self, pos, instruction):
 
 paul@129    624 
        frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame
 
 paul@450    625 
        self.frame_stack[frame + pos] = DataValue(
 
 paul@450    626 
            self.registers[self.context_of(instruction.working)],
 
 paul@450    627 
            self.registers[instruction.working])
 
 paul@129    628 
 
 paul@450    629 
    def StoreFrameIndex(self, index, instruction):
 
 paul@129    630 
        frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame
 
 paul@450    631 
        data = self.load(self.registers[instruction.working])
 
 paul@460    632 
        element = self.load(self.registers["paramlist"] + data.funccode + index)
 
 paul@238    633 
 
 paul@238    634 
        if element is not None:
 
 paul@238    635 
            # NOTE: Need to ensure correct positioning where a context has been generated.
 
 paul@238    636 
            param_index, offset = element
 
 paul@430    637 
            if param_index == index:
 
 paul@450    638 
                self.frame_stack[frame + offset] = DataValue(
 
 paul@450    639 
                    self.registers[self.context_of(instruction.source)],
 
 paul@450    640 
                    self.registers[instruction.source])
 
 paul@238    641 
                return
 
 paul@238    642 
 
 paul@450    643 
        self.registers["exception"] = self._MakeObject(Library.instance_size, self.type_error_instance)
 
 paul@238    644 
        return self.RaiseException()
 
 paul@129    645 
 
 paul@450    646 
    def LoadCallable(self, operand, instruction):
 
 paul@450    647 
        data = self.load(self.registers[instruction.working])
 
 paul@450    648 
        self.registers[instruction.target] = data.codeaddr
 
 paul@132    649 
 
 paul@450    650 
    def StoreCallable(self, operand, instruction):
 
 paul@450    651 
        # NOTE: Should improve the representation and permit direct saving.
 
 paul@450    652 
        data = self.load(self.registers[instruction.working])
 
 paul@450    653 
        self.save(self.registers[instruction.working], data.with_callable(self.registers[instruction.source]))
 
 paul@132    654 
 
 paul@450    655 
    def CheckContext(self, operand, instruction):
 
 paul@450    656 
        self.registers[instruction.target] = self.registers[instruction.working] is not ReplaceableContext
 
 paul@222    657 
 
 paul@450    658 
    def CheckClass(self, operand, instruction):
 
 paul@450    659 
        if self.registers[instruction.working] in (ReplaceableContext, PlaceholderContext):
 
 paul@450    660 
            self.registers[instruction.target] = 0
 
 paul@237    661 
            return
 
 paul@237    662 
 
 paul@450    663 
        data = self.load(self.registers[instruction.working])
 
 paul@222    664 
 
 paul@222    665 
        # Classes are not themselves usable as the self argument.
 
 paul@222    666 
        # NOTE: This may change at some point.
 
 paul@222    667 
        # However, where classes appear as the context, instance
 
 paul@222    668 
        # compatibility is required in the first argument.
 
 paul@222    669 
 
 paul@450    670 
        self.registers[instruction.target] = data.attrcode is None # absent attrcode == class
 
 paul@222    671 
 
 paul@450    672 
    def CheckFrame(self, operand, instruction):
 
 paul@430    673 
        (nargs, ndefaults) = operand
 
 paul@215    674 
 
 paul@215    675 
        # The frame is actually installed as the locals.
 
 paul@215    676 
        # Retrieve the context from the first local.
 
 paul@215    677 
 
 paul@215    678 
        frame = self.local_sp_stack[-1]
 
 paul@215    679 
        nlocals = len(self.frame_stack[frame:])
 
 paul@134    680 
 
 paul@234    681 
        if not ((nargs - ndefaults) <= nlocals):
 
 paul@430    682 
            raise Exception, "CheckFrame %r (%r <= %r <= %r)" % (operand, nargs - ndefaults, nlocals, nargs)
 
 paul@450    683 
            self.registers["exception"] = self._MakeObject(Library.instance_size, self.type_error_instance)
 
 paul@221    684 
            return self.RaiseException()
 
 paul@215    685 
 
 paul@450    686 
    def CheckExtra(self, nargs, instruction):
 
 paul@256    687 
 
 paul@256    688 
        # The frame is actually installed as the locals.
 
 paul@256    689 
        # Retrieve the context from the first local.
 
 paul@256    690 
 
 paul@256    691 
        frame = self.local_sp_stack[-1]
 
 paul@256    692 
        nlocals = len(self.frame_stack[frame:])
 
 paul@256    693 
 
 paul@256    694 
        # Provide the extra star parameter if necessary.
 
 paul@256    695 
 
 paul@256    696 
        if nlocals == nargs:
 
 paul@256    697 
            self.frame_stack.extend([None]) # ExtendFrame(1)
 
 paul@256    698 
 
 paul@450    699 
    def FillDefaults(self, operand, instruction):
 
 paul@430    700 
        (nargs, ndefaults) = operand
 
 paul@215    701 
 
 paul@215    702 
        # The frame is actually installed as the locals.
 
 paul@215    703 
 
 paul@215    704 
        frame = self.local_sp_stack[-1]
 
 paul@215    705 
        nlocals = len(self.frame_stack[frame:])
 
 paul@134    706 
 
 paul@190    707 
        # Support population of defaults.
 
 paul@190    708 
        # This involves copying the "attributes" of a function into the frame.
 
 paul@190    709 
 
 paul@215    710 
        default = nlocals - (nargs - ndefaults)
 
 paul@215    711 
        self.frame_stack.extend([None] * (nargs - nlocals))
 
 paul@215    712 
        pos = nlocals
 
 paul@190    713 
 
 paul@215    714 
        while pos < nargs:
 
 paul@450    715 
 
 paul@450    716 
            # Skip any header.
 
 paul@450    717 
 
 paul@450    718 
            self.frame_stack[frame + pos] = self.load(self.registers[instruction.working] + Library.instance_data_offset + default)
 
 paul@190    719 
            default += 1
 
 paul@190    720 
            pos += 1
 
 paul@117    721 
 
 paul@450    722 
    def CopyExtra(self, start, instruction):
 
 paul@255    723 
 
 paul@255    724 
        # The frame is the source of the extra arguments.
 
 paul@255    725 
 
 paul@255    726 
        frame = self.local_sp_stack[-1]
 
 paul@255    727 
        nlocals = len(self.frame_stack[frame:])
 
 paul@255    728 
 
 paul@255    729 
        # Make a tuple to hold the arguments.
 
 paul@255    730 
 
 paul@255    731 
        ref = self._MakeObject(nlocals - start + 1, self.tuple_instance)
 
 paul@255    732 
 
 paul@255    733 
        extra = 0
 
 paul@255    734 
        pos = start
 
 paul@255    735 
 
 paul@255    736 
        while pos < nlocals:
 
 paul@450    737 
 
 paul@450    738 
            # Skip any header.
 
 paul@450    739 
 
 paul@450    740 
            self.save(ref + Library.instance_data_offset + extra, self.frame_stack[frame + pos])
 
 paul@255    741 
            extra += 1
 
 paul@255    742 
            pos += 1
 
 paul@255    743 
 
 paul@450    744 
        self.LoadImmediate(ref, self.context_of(instruction.working))
 
 paul@450    745 
        self.LoadImmediate(ref, instruction.working)
 
 paul@255    746 
 
 paul@450    747 
    def CheckInstance(self, operand, instruction):
 
 paul@285    748 
        # For the 'self' parameter in an invoked function, the proposed context
 
 paul@285    749 
        # ('self') is checked against the target's context.
 
 paul@450    750 
        self.registers[instruction.target] = self._CheckInstance(
 
 paul@450    751 
            self.registers[instruction.working],
 
 paul@450    752 
            self.registers[instruction.source])
 
 paul@308    753 
 
 paul@450    754 
    def JumpInFrame(self, operand, instruction):
 
 paul@450    755 
        codeaddr = self.registers[instruction.working]
 
 paul@230    756 
        return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one
 
 paul@230    757 
 
 paul@479    758 
    def JumpInFrameDirect(self, addr, instruction):
 
 paul@479    759 
        return self.jump(addr, self.pc + 1) # return to the instruction after this one
 
 paul@479    760 
 
 paul@450    761 
    def JumpWithFrame(self, operand, instruction):
 
 paul@450    762 
        codeaddr = self.registers[instruction.working]
 
 paul@132    763 
        self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame
 
 paul@138    764 
        return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one
 
 paul@98    765 
 
 paul@450    766 
    def JumpWithFrameDirect(self, addr, instruction):
 
 paul@215    767 
        self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame
 
 paul@430    768 
        return self.jump(addr, self.pc + 1) # return to the instruction after this one
 
 paul@215    769 
 
 paul@450    770 
    def ExtendFrame(self, size, instruction):
 
 paul@430    771 
        self.frame_stack.extend([None] * size)
 
 paul@98    772 
 
 paul@450    773 
    def AdjustFrame(self, size, instruction):
 
 paul@430    774 
        self.invocation_sp_stack[-1] += size
 
 paul@137    775 
 
 paul@450    776 
    def Return(self, operand, instruction):
 
 paul@138    777 
        return self.pull_pc()
 
 paul@68    778 
 
 paul@450    779 
    def Jump(self, addr, instruction):
 
 paul@430    780 
        return addr
 
 paul@98    781 
 
 paul@450    782 
    def JumpIfTrue(self, addr, instruction):
 
 paul@450    783 
        if self.registers[instruction.working]:
 
 paul@430    784 
            return addr
 
 paul@68    785 
 
 paul@450    786 
    def JumpIfFalse(self, addr, instruction):
 
 paul@450    787 
        if not self.registers[instruction.working]:
 
 paul@450    788 
            return addr
 
 paul@129    789 
 
 paul@450    790 
    def ClearException(self, operand, instruction):
 
 paul@450    791 
        self.LoadImmediate(None, instruction.target)
 
 paul@232    792 
 
 paul@450    793 
    def RaiseException(self, operand=None, instruction=None):
 
 paul@399    794 
        # NOTE: Adding the program counter as the first attribute after __class__.
 
 paul@450    795 
        self.save(self.registers["exception"] + Library.instance_data_offset, self.pc)
 
 paul@221    796 
        # Jumping to the current handler.
 
 paul@246    797 
        if self.abort_upon_exception:
 
 paul@246    798 
            raise Exception
 
 paul@145    799 
        return self.handler_stack[-1]
 
 paul@129    800 
 
 paul@450    801 
    def PushHandler(self, addr, instruction):
 
 paul@430    802 
        self.handler_stack.append(addr)
 
 paul@145    803 
        self.handler_local_sp_stack.append(len(self.local_sp_stack))
 
 paul@398    804 
        self.handler_invocation_sp_stack.append(len(self.invocation_sp_stack))
 
 paul@145    805 
        self.handler_pc_stack.append(len(self.pc_stack))
 
 paul@129    806 
 
 paul@450    807 
    def PopHandler(self, nframes, instruction):
 
 paul@398    808 
        # Get the new local frame pointer and PC stack references.
 
 paul@398    809 
        local_sp_top = self.handler_local_sp_stack[-nframes]
 
 paul@398    810 
        invocation_sp_top = self.handler_invocation_sp_stack[-nframes]
 
 paul@398    811 
        pc_top = self.handler_pc_stack[-nframes]
 
 paul@145    812 
        # Reduce the local frame pointer stack to refer to the handler's frame.
 
 paul@398    813 
        del self.local_sp_stack[local_sp_top:]
 
 paul@398    814 
        # Reduce the invocation frame pointer stack to refer to an outer frame.
 
 paul@398    815 
        del self.invocation_sp_stack[invocation_sp_top:]
 
 paul@145    816 
        # Reduce the PC stack to discard all superfluous return addresses.
 
 paul@398    817 
        del self.pc_stack[pc_top:]
 
 paul@398    818 
        # Remove elements from the handler stacks.
 
 paul@398    819 
        del self.handler_pc_stack[-nframes:]
 
 paul@398    820 
        del self.handler_local_sp_stack[-nframes:]
 
 paul@398    821 
        del self.handler_invocation_sp_stack[-nframes:]
 
 paul@398    822 
        del self.handler_stack[-nframes:]
 
 paul@129    823 
 
 paul@450    824 
    def CheckException(self, operand, instruction):
 
 paul@450    825 
        self.registers[instruction.target] = self.registers["exception"] is not None and \
 
 paul@450    826 
            self._CheckInstance(self.registers["exception"], self.registers[instruction.working])
 
 paul@129    827 
 
 paul@450    828 
    def TestIdentity(self, operand, instruction):
 
 paul@450    829 
        self.registers[instruction.target] = self.registers[instruction.working] == self.registers[instruction.source]
 
 paul@129    830 
 
 paul@450    831 
    def TestIdentityAddress(self, addr, instruction):
 
 paul@450    832 
        self.registers[instruction.target] = self.registers[instruction.working] == addr
 
 paul@68    833 
 
 paul@450    834 
    def InvertBoolean(self, operand, instruction):
 
 paul@450    835 
        self.registers[instruction.target] = not self.registers[instruction.source]
 
 paul@132    836 
 
 paul@145    837 
    # Common implementation details.
 
 paul@145    838 
 
 paul@145    839 
    def _CheckInstance(self, ref, cls):
 
 paul@182    840 
        data = self.load(ref)
 
 paul@182    841 
        target_data = self.load(cls)
 
 paul@145    842 
 
 paul@223    843 
        # Insist on instance vs. class.
 
 paul@223    844 
 
 paul@242    845 
        if data.attrcode is None: # absent attrcode == class/module
 
 paul@223    846 
            return 0
 
 paul@191    847 
 
 paul@207    848 
        if target_data.attrcode is not None: # present attrcode == instance
 
 paul@191    849 
            return 0
 
 paul@191    850 
 
 paul@145    851 
        # Find the table entry for the descendant.
 
 paul@145    852 
 
 paul@460    853 
        element = self.load(self.registers["objlist"] + target_data.classcode + data.attrcode)
 
 paul@238    854 
 
 paul@220    855 
        if element is not None:
 
 paul@242    856 
            attr_index, static_attr, offset = element
 
 paul@220    857 
            return attr_index == data.attrcode
 
 paul@220    858 
        else:
 
 paul@220    859 
            return 0
 
 paul@181    860 
 
 paul@181    861 
    def _MakeObject(self, size, ref):
 
 paul@203    862 
        # Load the template.
 
 paul@182    863 
        data = self.load(ref)
 
 paul@181    864 
        addr = self.new(size)
 
 paul@203    865 
        # Save the header, overriding the size.
 
 paul@203    866 
        self.save(addr, data.with_size(size))
 
 paul@181    867 
        return addr
 
 paul@181    868 
 
 paul@336    869 
    def _MakeFragment(self, occupied, size):
 
 paul@336    870 
        addr = self.new(size)
 
 paul@246    871 
        # Save the header, overriding the size.
 
 paul@336    872 
        self.save(addr, FragmentObject(occupied, size))
 
 paul@246    873 
        return addr
 
 paul@246    874 
 
 paul@429    875 
    def _LoadAddressContextCond(self, context, value, inst_value):
 
 paul@191    876 
        # Check the instance context against the target's context.
 
 paul@230    877 
        # This provides the context overriding for methods.
 
 paul@429    878 
        if context is ReplaceableContext or context is not PlaceholderContext and self._CheckInstance(inst_value, context):
 
 paul@191    879 
            # Replace the context with the instance.
 
 paul@429    880 
            return DataValue(inst_value, value)
 
 paul@191    881 
        else:
 
 paul@429    882 
            return DataValue(context, value)
 
 paul@191    883 
 
 paul@429    884 
    def _StoreAddressContext(self, location, context, value, source_context, source_value):
 
 paul@429    885 
        if source_context is ReplaceableContext:
 
 paul@429    886 
            context = value
 
 paul@405    887 
        else:
 
 paul@429    888 
            context = source_context
 
 paul@429    889 
        self.save(location, DataValue(context, source_value))
 
 paul@405    890 
 
 paul@228    891 
# Convenience functions.
 
 paul@228    892 
 
 paul@246    893 
def machine(program, with_builtins=0, debug=0, abort_upon_exception=0):
 
 paul@228    894 
    print "Making the image..."
 
 paul@228    895 
    code = program.get_image(with_builtins)
 
 paul@228    896 
    print "Getting raw structures..."
 
 paul@228    897 
    ot = program.get_object_table()
 
 paul@228    898 
    pt = program.get_parameter_table()
 
 paul@228    899 
    objlist = ot.as_list()
 
 paul@228    900 
    paramlist = pt.as_list()
 
 paul@228    901 
    print "Getting raw image..."
 
 paul@228    902 
    rc = program.get_raw_image()
 
 paul@228    903 
    print "Initialising the machine..."
 
 paul@228    904 
    importer = program.get_importer()
 
 paul@354    905 
    constants = {}
 
 paul@354    906 
    for x in (True, False, NotImplemented):
 
 paul@354    907 
        constants[x] = importer.get_constant(x).location
 
 paul@248    908 
    rm = RSVPMachine(rc, objlist, paramlist, debug=debug, abort_upon_exception=abort_upon_exception)
 
 paul@354    909 
    library = Library(rm, constants)
 
 paul@248    910 
    rm.library = library
 
 paul@228    911 
    rm.pc = program.code_location
 
 paul@461    912 
    print "Returning program occupying %d locations." % rm.get_program_size()
 
 paul@228    913 
    return rm
 
 paul@228    914 
 
 paul@68    915 
# vim: tabstop=4 expandtab shiftwidth=4