micropython

Annotated rsvp.py

450:5382a26943ca
442:13aae946513b
430:f2f566f67b5f
2011-07-05 Paul Boddie file changeset files shortlog Introduced Instance() in place of None as a result and for the value of the active expression where no definitive object can be deduced. Made all Instance values compare equal to each other in order to avoid duplication in sets. Improved Constant comparisons. Fixed assignment counting where many values are provided in a single assignment. Added inspection support for conditional expressions (since they are used in the standard library).
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@429     47 
  * Registers: current context/value,
 
 paul@429     48 
               source context/value,
 
 paul@429     49 
               current result context/value,
 
 paul@429     50 
               current exception value,
 
 paul@145     51 
               boolean status value,
 
 paul@145     52 
               current callable
 
 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@181     93 
        self.objlist = objlist.as_raw()
 
 paul@181     94 
        self.paramlist = paramlist.as_raw()
 
 paul@248     95 
        self.library = None
 
 paul@196     96 
 
 paul@68     97 
        self.pc = pc or 0
 
 paul@68     98 
        self.debug = debug
 
 paul@246     99 
        self.abort_upon_exception = abort_upon_exception
 
 paul@313    100 
 
 paul@313    101 
        # Profiling.
 
 paul@313    102 
 
 paul@389    103 
        self.coverage = [0] * len(self.memory)
 
 paul@285    104 
        self.counter = 0
 
 paul@313    105 
        self.cost = 0
 
 paul@117    106 
 
 paul@117    107 
        # Stacks.
 
 paul@117    108 
 
 paul@68    109 
        self.pc_stack = []
 
 paul@68    110 
        self.frame_stack = []
 
 paul@143    111 
        self.local_sp_stack = [0]
 
 paul@117    112 
        self.invocation_sp_stack = []
 
 paul@398    113 
 
 paul@398    114 
        # Exception handler stacks are used to reset the state of the main
 
 paul@398    115 
        # stacks.
 
 paul@398    116 
 
 paul@145    117 
        self.handler_stack = [len(self.memory) - 1] # final handler is the end of the code
 
 paul@145    118 
        self.handler_local_sp_stack = []
 
 paul@398    119 
        self.handler_invocation_sp_stack = []
 
 paul@145    120 
        self.handler_pc_stack = []
 
 paul@117    121 
 
 paul@117    122 
        # Registers.
 
 paul@117    123 
 
 paul@429    124 
        self.value = None
 
 paul@429    125 
        self.context = None
 
 paul@429    126 
 
 paul@429    127 
        self.source_value = None
 
 paul@429    128 
        self.source_context = None
 
 paul@429    129 
 
 paul@429    130 
        self.result_value = None
 
 paul@429    131 
        self.result_context = None
 
 paul@429    132 
 
 paul@429    133 
        self.exception = None
 
 paul@429    134 
 
 paul@119    135 
        self.instruction = None
 
 paul@117    136 
        self.status = None
 
 paul@132    137 
        self.callable = None
 
 paul@68    138 
 
 paul@146    139 
        # Constants.
 
 paul@146    140 
 
 paul@221    141 
        cls = self._get_class("__builtins__", "AttributeError")
 
 paul@221    142 
        self.attr_error = cls.location
 
 paul@221    143 
        self.attr_error_instance = cls.instance_template_location
 
 paul@221    144 
        cls = self._get_class("__builtins__", "TypeError")
 
 paul@221    145 
        self.type_error = cls.location
 
 paul@221    146 
        self.type_error_instance = cls.instance_template_location
 
 paul@256    147 
        cls = self._get_class("__builtins__", "tuple")
 
 paul@255    148 
        self.tuple_class = cls.location
 
 paul@255    149 
        self.tuple_instance = cls.instance_template_location
 
 paul@181    150 
 
 paul@194    151 
        # Debugging attributes.
 
 paul@194    152 
 
 paul@194    153 
        self.breakpoints = set()
 
 paul@194    154 
 
 paul@221    155 
    def _get_class(self, module, name):
 
 paul@346    156 
        attr = self._objlist.access(module, name)
 
 paul@346    157 
        if attr is not None:
 
 paul@346    158 
            return attr.get_value()
 
 paul@346    159 
        else:
 
 paul@346    160 
            return None
 
 paul@221    161 
 
 paul@162    162 
    # Debugging methods.
 
 paul@162    163 
 
 paul@137    164 
    def dump(self):
 
 paul@138    165 
        print "PC", self.pc, "->", self.load(self.pc)
 
 paul@137    166 
        print "PC stack", self.pc_stack
 
 paul@401    167 
        print "Frame stack:"
 
 paul@401    168 
        if self.local_sp_stack:
 
 paul@401    169 
            start = self.local_sp_stack[0]
 
 paul@401    170 
            for end in self.local_sp_stack[1:]:
 
 paul@401    171 
                print "  %2d" % start, self.frame_stack[start:end]
 
 paul@401    172 
                start = end
 
 paul@401    173 
            else:
 
 paul@401    174 
                print "  %2d" % start, self.frame_stack[start:]
 
 paul@401    175 
        print
 
 paul@137    176 
        print "Local stack pointers", self.local_sp_stack
 
 paul@137    177 
        print "Invocation stack pointers", self.invocation_sp_stack
 
 paul@137    178 
        print "Handler stack", self.handler_stack
 
 paul@145    179 
        print "Handler frame stack", self.handler_local_sp_stack
 
 paul@145    180 
        print "Handler PC stack", self.handler_pc_stack
 
 paul@137    181 
        print
 
 paul@429    182 
        print "Value", self.value
 
 paul@429    183 
        print "Context", self.context
 
 paul@429    184 
        print
 
 paul@429    185 
        print "Source value", self.source_value
 
 paul@429    186 
        print "Source context", self.source_context
 
 paul@429    187 
        print
 
 paul@429    188 
        print "Result value", self.result_value
 
 paul@429    189 
        print "Result context", self.result_context
 
 paul@429    190 
        print
 
 paul@429    191 
        print "Exception", self.exception
 
 paul@429    192 
        print
 
 paul@137    193 
        print "Instruction", self.instruction
 
 paul@137    194 
        print "Status", self.status
 
 paul@137    195 
        print "Callable", self.callable
 
 paul@137    196 
 
 paul@399    197 
    def show(self, start=None, end=None):
 
 paul@399    198 
        self.show_memory(self.memory[start:end], self.coverage[start:end], start or 0)
 
 paul@162    199 
 
 paul@162    200 
    def show_pc(self, run_in=10):
 
 paul@162    201 
        start = max(0, self.pc - run_in)
 
 paul@162    202 
        end = self.pc + run_in
 
 paul@162    203 
        memory = self.memory[start:end]
 
 paul@389    204 
        coverage = self.coverage[start:end]
 
 paul@389    205 
        self.show_memory(memory, coverage, start)
 
 paul@162    206 
 
 paul@389    207 
    def show_memory(self, memory, coverage, start):
 
 paul@389    208 
        for i, (c, x) in enumerate(map(None, coverage, memory)):
 
 paul@162    209 
            location = start + i
 
 paul@162    210 
            if location == self.pc:
 
 paul@162    211 
                print "->",
 
 paul@381    212 
            elif location in self.pc_stack:
 
 paul@381    213 
                print "..",
 
 paul@162    214 
            else:
 
 paul@162    215 
                print "  ",
 
 paul@389    216 
            print "%-5s %5d %r" % (c or "", location, x)
 
 paul@162    217 
 
 paul@162    218 
    def step(self, dump=0):
 
 paul@138    219 
        self.execute()
 
 paul@162    220 
        self.show_pc()
 
 paul@162    221 
        if dump:
 
 paul@162    222 
            self.dump()
 
 paul@162    223 
 
 paul@194    224 
    def set_break(self, location):
 
 paul@194    225 
        self.breakpoints.add(location)
 
 paul@194    226 
 
 paul@399    227 
    def up(self):
 
 paul@399    228 
        retaddr = self.pc_stack[-1]
 
 paul@401    229 
        self.set_break(retaddr)
 
 paul@399    230 
        self.run()
 
 paul@399    231 
 
 paul@162    232 
    # Internal operations.
 
 paul@138    233 
 
 paul@68    234 
    def load(self, address):
 
 paul@68    235 
 
 paul@68    236 
        "Return the value at the given 'address'."
 
 paul@68    237 
 
 paul@68    238 
        try:
 
 paul@68    239 
            return self.memory[address]
 
 paul@68    240 
        except IndexError:
 
 paul@180    241 
            raise IllegalAddress(address)
 
 paul@180    242 
        except TypeError:
 
 paul@180    243 
            raise IllegalAddress(address)
 
 paul@68    244 
 
 paul@68    245 
    def save(self, address, value):
 
 paul@68    246 
 
 paul@68    247 
        "Save to the given 'address' the specified 'value'."
 
 paul@68    248 
 
 paul@68    249 
        try:
 
 paul@68    250 
            self.memory[address] = value
 
 paul@68    251 
        except IndexError:
 
 paul@180    252 
            raise IllegalAddress(address)
 
 paul@180    253 
        except TypeError:
 
 paul@180    254 
            raise IllegalAddress(address)
 
 paul@68    255 
 
 paul@68    256 
    def new(self, size):
 
 paul@68    257 
 
 paul@68    258 
        """
 
 paul@68    259 
        Allocate space of the given 'size', returning the address of the space.
 
 paul@68    260 
        """
 
 paul@68    261 
 
 paul@68    262 
        addr = len(self.memory)
 
 paul@68    263 
        for i in range(0, size):
 
 paul@68    264 
            self.memory.append(None)
 
 paul@68    265 
        return addr
 
 paul@68    266 
 
 paul@68    267 
    def push_pc(self, data):
 
 paul@68    268 
 
 paul@68    269 
        "Push 'data' onto the PC stack."
 
 paul@68    270 
 
 paul@68    271 
        self.pc_stack.append(data)
 
 paul@68    272 
 
 paul@68    273 
    def pull_pc(self):
 
 paul@68    274 
 
 paul@68    275 
        "Pull a value from the PC stack and return it."
 
 paul@68    276 
 
 paul@68    277 
        try:
 
 paul@68    278 
            return self.pc_stack.pop()
 
 paul@68    279 
        except IndexError:
 
 paul@68    280 
            raise EmptyPCStack
 
 paul@68    281 
 
 paul@90    282 
    def run(self):
 
 paul@68    283 
 
 paul@68    284 
        "Execute code in the memory, starting from the current PC address."
 
 paul@68    285 
 
 paul@228    286 
        breakpoint = 0
 
 paul@228    287 
 
 paul@68    288 
        try:
 
 paul@68    289 
            while 1:
 
 paul@90    290 
                self.execute()
 
 paul@68    291 
        except EmptyPCStack:
 
 paul@68    292 
            pass
 
 paul@228    293 
        except BreakpointReached:
 
 paul@228    294 
            breakpoint = 1
 
 paul@68    295 
 
 paul@221    296 
        print "Execution terminated",
 
 paul@221    297 
        if self.exception is not None:
 
 paul@222    298 
            ref = self.exception
 
 paul@399    299 
            addr = self.load(ref + Library.instance_data_offset)
 
 paul@221    300 
            print "with exception:", self.load(ref)
 
 paul@222    301 
            print "At address %d: %r" % (addr, self.load(addr))
 
 paul@228    302 
        elif breakpoint:
 
 paul@228    303 
            print "with breakpoint."
 
 paul@228    304 
            print "At address", self.pc
 
 paul@221    305 
        else:
 
 paul@221    306 
            print "successfully."
 
 paul@313    307 
        print "After", self.counter, "instructions at cost", self.cost, "units."
 
 paul@221    308 
 
 paul@228    309 
    def test(self, module):
 
 paul@228    310 
 
 paul@228    311 
        """
 
 paul@228    312 
        Test the code in the memory by running the code and investigating the
 
 paul@228    313 
        contents of variables. Use 'module' to identify result variables.
 
 paul@228    314 
        """
 
 paul@228    315 
 
 paul@228    316 
        self.run()
 
 paul@228    317 
        success = 1
 
 paul@228    318 
 
 paul@229    319 
        if self.exception is None:
 
 paul@229    320 
            for name in module.keys():
 
 paul@229    321 
                if name.startswith("result"):
 
 paul@229    322 
                    label, expected = name.split("_")
 
 paul@229    323 
                    attr = module[name]
 
 paul@228    324 
 
 paul@229    325 
                    # NOTE: Assumptions about headers and content made.
 
 paul@228    326 
 
 paul@229    327 
                    attr_location = module.location + 1 + attr.position
 
 paul@264    328 
                    value = self.load(attr_location)
 
 paul@228    329 
 
 paul@264    330 
                    if value is not None:
 
 paul@395    331 
                        content = self.load(value.ref + Library.instance_data_offset)
 
 paul@243    332 
                        print label, expected, content
 
 paul@243    333 
                        success = success and (int(expected) == content)
 
 paul@243    334 
                    else:
 
 paul@243    335 
                        print label, expected, "missing"
 
 paul@243    336 
                        success = 0
 
 paul@228    337 
 
 paul@229    338 
            return success
 
 paul@229    339 
        else:
 
 paul@229    340 
            return 0
 
 paul@228    341 
 
 paul@90    342 
    def execute(self):
 
 paul@90    343 
 
 paul@90    344 
        "Execute code in the memory at the current PC address."
 
 paul@90    345 
 
 paul@194    346 
        if self.pc in self.breakpoints:
 
 paul@194    347 
            self.breakpoints.remove(self.pc)
 
 paul@194    348 
            raise BreakpointReached
 
 paul@194    349 
 
 paul@119    350 
        self.instruction = self.load(self.pc)
 
 paul@118    351 
 
 paul@118    352 
        # Process any inputs of the instruction.
 
 paul@118    353 
 
 paul@119    354 
        self.process_inputs()
 
 paul@137    355 
 
 paul@137    356 
        # Perform the instruction itself.
 
 paul@137    357 
 
 paul@137    358 
        next_pc = self.perform(self.instruction)
 
 paul@118    359 
 
 paul@389    360 
        # Update the coverage.
 
 paul@389    361 
 
 paul@389    362 
        self.coverage[self.pc] += 1
 
 paul@389    363 
 
 paul@119    364 
        # Update the program counter.
 
 paul@118    365 
 
 paul@119    366 
        if next_pc is None:
 
 paul@119    367 
            self.pc += 1
 
 paul@119    368 
        else:
 
 paul@119    369 
            self.pc = next_pc
 
 paul@118    370 
 
 paul@137    371 
    def get_method(self, instruction):
 
 paul@137    372 
 
 paul@137    373 
        "Return the handler method for the given 'instruction'."
 
 paul@119    374 
 
 paul@137    375 
        instruction_name = instruction.__class__.__name__
 
 paul@137    376 
        if self.debug:
 
 paul@137    377 
            print "%8d %s" % (self.pc, instruction_name)
 
 paul@119    378 
        method = getattr(self, instruction_name, None)
 
 paul@90    379 
        if method is None:
 
 paul@119    380 
            raise IllegalInstruction, (self.pc, instruction_name)
 
 paul@118    381 
        return method
 
 paul@118    382 
 
 paul@313    383 
    def perform(self, instruction, is_input=0):
 
 paul@137    384 
 
 paul@137    385 
        "Perform the 'instruction', returning the next PC value or None."
 
 paul@137    386 
 
 paul@313    387 
        if not is_input:
 
 paul@313    388 
            self.counter += 1
 
 paul@313    389 
            self.cost += instruction.cost
 
 paul@430    390 
        operand = instruction.get_operand()
 
 paul@137    391 
        method = self.get_method(instruction)
 
 paul@430    392 
        return method(operand)
 
 paul@137    393 
 
 paul@119    394 
    def process_inputs(self):
 
 paul@118    395 
 
 paul@118    396 
        """
 
 paul@119    397 
        Process any inputs of the current instruction. This permits any directly
 
 paul@118    398 
        connected sub-instructions to produce the effects that separate
 
 paul@118    399 
        instructions would otherwise have.
 
 paul@118    400 
        """
 
 paul@118    401 
 
 paul@429    402 
        value, context = self.value, self.context
 
 paul@174    403 
        if self.instruction.source is not None:
 
 paul@313    404 
            self.perform(self.instruction.source, 1)
 
 paul@429    405 
            self.source_value, self.source_context = self.value, self.context
 
 paul@429    406 
        self.value, self.context = value, context
 
 paul@174    407 
        if self.instruction.input is not None:
 
 paul@313    408 
            self.perform(self.instruction.input, 1)
 
 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@429    431 
    # Low-level instructions.
 
 paul@429    432 
 
 paul@429    433 
    def LoadValue(self, operand):
 
 paul@429    434 
        self.value = operand
 
 paul@429    435 
 
 paul@429    436 
    def LoadContext(self, operand):
 
 paul@429    437 
        self.context = operand
 
 paul@429    438 
 
 paul@430    439 
    def LoadSourceValue(self, operand):
 
 paul@430    440 
        self.source_value = operand
 
 paul@430    441 
 
 paul@430    442 
    def LoadSourceContext(self, operand):
 
 paul@430    443 
        self.source_context = operand
 
 paul@430    444 
 
 paul@68    445 
    # Instructions.
 
 paul@68    446 
 
 paul@430    447 
    def LoadConst(self, operand):
 
 paul@430    448 
        self.LoadContext(operand)
 
 paul@430    449 
        self.LoadValue(operand)
 
 paul@223    450 
 
 paul@430    451 
    def LoadClass(self, operand):
 
 paul@429    452 
        self.LoadContext(PlaceholderContext)
 
 paul@430    453 
        self.LoadValue(operand)
 
 paul@237    454 
 
 paul@430    455 
    def LoadFunction(self, operand):
 
 paul@429    456 
        self.LoadContext(ReplaceableContext)
 
 paul@430    457 
        self.LoadValue(operand)
 
 paul@68    458 
 
 paul@430    459 
    def LoadName(self, operand):
 
 paul@117    460 
        frame = self.local_sp_stack[-1]
 
 paul@430    461 
        data = self.frame_stack[frame + operand]
 
 paul@429    462 
        self.LoadContext(data.context)
 
 paul@429    463 
        self.LoadValue(data.ref)
 
 paul@68    464 
 
 paul@430    465 
    def StoreName(self, operand):
 
 paul@117    466 
        frame = self.local_sp_stack[-1]
 
 paul@430    467 
        self.frame_stack[frame + operand] = DataValue(self.source_context, self.source_value)
 
 paul@68    468 
 
 paul@72    469 
    LoadTemp = LoadName
 
 paul@203    470 
 
 paul@430    471 
    def StoreTemp(self, operand):
 
 paul@203    472 
        frame = self.local_sp_stack[-1]
 
 paul@430    473 
        self.frame_stack[frame + operand] = DataValue(self.context, self.value)
 
 paul@72    474 
 
 paul@430    475 
    def LoadAddress(self, operand):
 
 paul@119    476 
        # Preserve context (potentially null).
 
 paul@430    477 
        data = self.load(operand)
 
 paul@429    478 
        self.LoadContext(data.context)
 
 paul@429    479 
        self.LoadValue(data.ref)
 
 paul@72    480 
 
 paul@430    481 
    def LoadAddressContext(self, operand):
 
 paul@429    482 
        # Value becomes context.
 
 paul@430    483 
        data = self.load(operand)
 
 paul@429    484 
        self.LoadContext(self.value)
 
 paul@429    485 
        self.LoadValue(data.ref)
 
 paul@194    486 
 
 paul@430    487 
    def LoadAddressContextCond(self, operand):
 
 paul@430    488 
        data = self.load(operand)
 
 paul@429    489 
        data = self._LoadAddressContextCond(data.context, data.ref, self.value)
 
 paul@429    490 
        self.LoadContext(data.context)
 
 paul@429    491 
        self.LoadValue(data.ref)
 
 paul@72    492 
 
 paul@430    493 
    def StoreAddress(self, operand):
 
 paul@119    494 
        # Preserve context.
 
 paul@430    495 
        self.save(operand, DataValue(self.source_context, self.source_value))
 
 paul@72    496 
 
 paul@430    497 
    def StoreAddressContext(self, operand):
 
 paul@223    498 
        # Overwrite context if null.
 
 paul@430    499 
        self._StoreAddressContext(operand, self.context, self.value, self.source_context, self.source_value)
 
 paul@223    500 
 
 paul@430    501 
    def MakeInstance(self, size):
 
 paul@184    502 
        # NOTE: Referencing the instance template.
 
 paul@429    503 
        addr = self._MakeObject(size, self.value - Library.instance_template_size)
 
 paul@184    504 
        # Introduce object as context for the new object.
 
 paul@429    505 
        self.LoadContext(addr)
 
 paul@429    506 
        self.LoadValue(addr)
 
 paul@72    507 
 
 paul@430    508 
    def MakeFragment(self, size):
 
 paul@336    509 
        # Reserve twice the amount of space.
 
 paul@336    510 
        addr = self._MakeFragment(size, size * 2)
 
 paul@246    511 
        # NOTE: Context is not relevant for fragments.
 
 paul@429    512 
        self.LoadContext(None)
 
 paul@429    513 
        self.LoadValue(addr)
 
 paul@246    514 
 
 paul@430    515 
    def LoadAttr(self, pos):
 
 paul@127    516 
        # Retrieved context should already be appropriate for the instance.
 
 paul@184    517 
        # NOTE: Adding 1 to skip any header.
 
 paul@430    518 
        data = self.load(self.value + pos + 1)
 
 paul@429    519 
        self.LoadContext(data.context)
 
 paul@429    520 
        self.LoadValue(data.ref)
 
 paul@118    521 
 
 paul@430    522 
    def StoreAttr(self, pos):
 
 paul@129    523 
        # Target should already be an instance.
 
 paul@184    524 
        # NOTE: Adding 1 to skip any header.
 
 paul@430    525 
        self.save(self.value + pos + 1, DataValue(self.source_context, self.source_value))
 
 paul@119    526 
 
 paul@430    527 
    def LoadAttrIndex(self, index):
 
 paul@429    528 
        data = self.load(self.value)
 
 paul@430    529 
        element = self.objlist[data.classcode + index]
 
 paul@238    530 
 
 paul@238    531 
        if element is not None:
 
 paul@242    532 
            attr_index, static_attr, offset = element
 
 paul@430    533 
            if attr_index == index:
 
 paul@242    534 
                if static_attr:
 
 paul@429    535 
                    data = self.load(offset) # offset is address of class/module attribute
 
 paul@238    536 
                else:
 
 paul@429    537 
                    data = self.load(self.value + offset)
 
 paul@429    538 
                self.LoadContext(data.context)
 
 paul@429    539 
                self.LoadValue(data.ref)
 
 paul@238    540 
                return
 
 paul@238    541 
 
 paul@399    542 
        self.exception = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    543 
        return self.RaiseException()
 
 paul@118    544 
 
 paul@226    545 
    # LoadAttrIndexContext not defined.
 
 paul@194    546 
 
 paul@430    547 
    def LoadAttrIndexContextCond(self, index):
 
 paul@429    548 
        data = self.load(self.value)
 
 paul@430    549 
        element = self.objlist[data.classcode + index]
 
 paul@238    550 
 
 paul@238    551 
        if element is not None:
 
 paul@242    552 
            attr_index, static_attr, offset = element
 
 paul@430    553 
            if attr_index == index:
 
 paul@242    554 
                if static_attr:
 
 paul@429    555 
                    loaded_data = self.load(offset) # offset is address of class/module attribute
 
 paul@429    556 
                    # Absent attrcode == class/module.
 
 paul@429    557 
                    if data.attrcode is not None:
 
 paul@429    558 
                        loaded_data = self._LoadAddressContextCond(loaded_data.context, loaded_data.ref, self.value)
 
 paul@223    559 
                else:
 
 paul@429    560 
                    loaded_data = self.load(self.value + offset)
 
 paul@429    561 
                self.LoadContext(loaded_data.context)
 
 paul@429    562 
                self.LoadValue(loaded_data.ref)
 
 paul@238    563 
                return
 
 paul@238    564 
 
 paul@399    565 
        self.exception = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    566 
        return self.RaiseException()
 
 paul@194    567 
 
 paul@430    568 
    def StoreAttrIndex(self, index):
 
 paul@429    569 
        data = self.load(self.value)
 
 paul@430    570 
        element = self.objlist[data.classcode + index]
 
 paul@238    571 
 
 paul@238    572 
        if element is not None:
 
 paul@242    573 
            attr_index, static_attr, offset = element
 
 paul@430    574 
            if attr_index == index:
 
 paul@242    575 
                if static_attr:
 
 paul@429    576 
                    self._StoreAddressContext(offset, self.context, self.value, self.source_context, self.source_value)
 
 paul@405    577 
                    return
 
 paul@238    578 
                else:
 
 paul@429    579 
                    self.save(self.value + offset, DataValue(self.source_context, self.source_value))
 
 paul@238    580 
                    return
 
 paul@238    581 
 
 paul@399    582 
        self.exception = self._MakeObject(Library.instance_size, self.attr_error_instance)
 
 paul@238    583 
        return self.RaiseException()
 
 paul@118    584 
 
 paul@127    585 
    # NOTE: LoadAttrIndexContext is a possibility if a particular attribute can always be overridden.
 
 paul@127    586 
 
 paul@430    587 
    def MakeFrame(self, size):
 
 paul@117    588 
        self.invocation_sp_stack.append(len(self.frame_stack))
 
 paul@430    589 
        self.frame_stack.extend([None] * size)
 
 paul@98    590 
 
 paul@430    591 
    def DropFrame(self, operand=None):
 
 paul@117    592 
        self.local_sp_stack.pop()
 
 paul@117    593 
        frame = self.invocation_sp_stack.pop()
 
 paul@248    594 
        del self.frame_stack[frame:] # reset stack before call
 
 paul@98    595 
 
 paul@430    596 
    def StoreFrame(self, pos):
 
 paul@129    597 
        frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame
 
 paul@430    598 
        self.frame_stack[frame + pos] = DataValue(self.context, self.value)
 
 paul@129    599 
 
 paul@430    600 
    def StoreFrameIndex(self, index):
 
 paul@129    601 
        frame = self.invocation_sp_stack[-1] # different from the current frame after MakeFrame
 
 paul@429    602 
        data = self.load(self.value)
 
 paul@430    603 
        element = self.paramlist[data.funccode + index]
 
 paul@238    604 
 
 paul@238    605 
        if element is not None:
 
 paul@238    606 
            # NOTE: Need to ensure correct positioning where a context has been generated.
 
 paul@238    607 
            param_index, offset = element
 
 paul@430    608 
            if param_index == index:
 
 paul@429    609 
                self.frame_stack[frame + offset] = DataValue(self.source_context, self.source_value)
 
 paul@238    610 
                return
 
 paul@238    611 
 
 paul@399    612 
        self.exception = self._MakeObject(Library.instance_size, self.type_error_instance)
 
 paul@238    613 
        return self.RaiseException()
 
 paul@129    614 
 
 paul@430    615 
    def LoadCallable(self, operand=None):
 
 paul@429    616 
        data = self.load(self.value)
 
 paul@219    617 
        self.callable = data.codeaddr
 
 paul@132    618 
 
 paul@430    619 
    def StoreCallable(self, operand=None):
 
 paul@134    620 
        # NOTE: Should improve the representation and permit direct saving.
 
 paul@429    621 
        data = self.load(self.value)
 
 paul@429    622 
        self.save(self.value, data.with_callable(self.callable))
 
 paul@132    623 
 
 paul@430    624 
    def LoadContextIntoValue(self, operand=None):
 
 paul@218    625 
        # NOTE: Omission of the context of the context would make things like
 
 paul@218    626 
        # NOTE: self() inside methods impossible.
 
 paul@429    627 
        self.LoadValue(self.context)
 
 paul@132    628 
 
 paul@430    629 
    def CheckContext(self, operand=None):
 
 paul@429    630 
        self.status = self.value is not ReplaceableContext
 
 paul@222    631 
 
 paul@430    632 
    def CheckClass(self, operand=None):
 
 paul@429    633 
        if self.value in (ReplaceableContext, PlaceholderContext):
 
 paul@237    634 
            self.status = 0
 
 paul@237    635 
            return
 
 paul@237    636 
 
 paul@429    637 
        data = self.load(self.value)
 
 paul@222    638 
 
 paul@222    639 
        # Classes are not themselves usable as the self argument.
 
 paul@222    640 
        # NOTE: This may change at some point.
 
 paul@222    641 
        # However, where classes appear as the context, instance
 
 paul@222    642 
        # compatibility is required in the first argument.
 
 paul@222    643 
 
 paul@234    644 
        self.status = data.attrcode is None # absent attrcode == class
 
 paul@222    645 
 
 paul@430    646 
    def CheckFrame(self, operand):
 
 paul@430    647 
        (nargs, ndefaults) = operand
 
 paul@215    648 
 
 paul@215    649 
        # The frame is actually installed as the locals.
 
 paul@215    650 
        # Retrieve the context from the first local.
 
 paul@215    651 
 
 paul@215    652 
        frame = self.local_sp_stack[-1]
 
 paul@215    653 
        nlocals = len(self.frame_stack[frame:])
 
 paul@134    654 
 
 paul@234    655 
        if not ((nargs - ndefaults) <= nlocals):
 
 paul@430    656 
            raise Exception, "CheckFrame %r (%r <= %r <= %r)" % (operand, nargs - ndefaults, nlocals, nargs)
 
 paul@399    657 
            self.exception = self._MakeObject(Library.instance_size, self.type_error_instance)
 
 paul@221    658 
            return self.RaiseException()
 
 paul@215    659 
 
 paul@430    660 
    def CheckExtra(self, nargs):
 
 paul@256    661 
 
 paul@256    662 
        # The frame is actually installed as the locals.
 
 paul@256    663 
        # Retrieve the context from the first local.
 
 paul@256    664 
 
 paul@256    665 
        frame = self.local_sp_stack[-1]
 
 paul@256    666 
        nlocals = len(self.frame_stack[frame:])
 
 paul@256    667 
 
 paul@256    668 
        # Provide the extra star parameter if necessary.
 
 paul@256    669 
 
 paul@256    670 
        if nlocals == nargs:
 
 paul@256    671 
            self.frame_stack.extend([None]) # ExtendFrame(1)
 
 paul@256    672 
 
 paul@430    673 
    def FillDefaults(self, operand):
 
 paul@430    674 
        (nargs, ndefaults) = operand
 
 paul@215    675 
 
 paul@215    676 
        # The frame is actually installed as the locals.
 
 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@190    681 
        # Support population of defaults.
 
 paul@190    682 
        # This involves copying the "attributes" of a function into the frame.
 
 paul@190    683 
 
 paul@215    684 
        default = nlocals - (nargs - ndefaults)
 
 paul@215    685 
        self.frame_stack.extend([None] * (nargs - nlocals))
 
 paul@215    686 
        pos = nlocals
 
 paul@190    687 
 
 paul@215    688 
        while pos < nargs:
 
 paul@429    689 
            self.frame_stack[frame + pos] = self.load(self.value + default + 1) # skip header
 
 paul@190    690 
            default += 1
 
 paul@190    691 
            pos += 1
 
 paul@117    692 
 
 paul@430    693 
    def CopyExtra(self, start):
 
 paul@255    694 
 
 paul@255    695 
        # The frame is the source of the extra arguments.
 
 paul@255    696 
 
 paul@255    697 
        frame = self.local_sp_stack[-1]
 
 paul@255    698 
        nlocals = len(self.frame_stack[frame:])
 
 paul@255    699 
 
 paul@255    700 
        # Make a tuple to hold the arguments.
 
 paul@255    701 
 
 paul@255    702 
        ref = self._MakeObject(nlocals - start + 1, self.tuple_instance)
 
 paul@255    703 
 
 paul@255    704 
        extra = 0
 
 paul@255    705 
        pos = start
 
 paul@255    706 
 
 paul@255    707 
        while pos < nlocals:
 
 paul@255    708 
            self.save(ref + extra + 1, self.frame_stack[frame + pos]) # skip header when storing
 
 paul@255    709 
            extra += 1
 
 paul@255    710 
            pos += 1
 
 paul@255    711 
 
 paul@429    712 
        self.LoadContext(ref)
 
 paul@429    713 
        self.LoadValue(ref)
 
 paul@255    714 
 
 paul@430    715 
    def CheckInstance(self, operand=None):
 
 paul@285    716 
        # For the 'self' parameter in an invoked function, the proposed context
 
 paul@285    717 
        # ('self') is checked against the target's context.
 
 paul@429    718 
        self.status = self._CheckInstance(self.value, self.source_value)
 
 paul@308    719 
 
 paul@430    720 
    def JumpInFrame(self, operand=None):
 
 paul@230    721 
        codeaddr = self.callable
 
 paul@230    722 
        return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one
 
 paul@230    723 
 
 paul@430    724 
    def JumpWithFrame(self, operand=None):
 
 paul@219    725 
        codeaddr = self.callable
 
 paul@132    726 
        self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame
 
 paul@138    727 
        return self.jump(codeaddr, self.pc + 1) # return to the instruction after this one
 
 paul@98    728 
 
 paul@430    729 
    def JumpWithFrameDirect(self, addr):
 
 paul@215    730 
        self.local_sp_stack.append(self.invocation_sp_stack[-1]) # adopt the invocation frame
 
 paul@430    731 
        return self.jump(addr, self.pc + 1) # return to the instruction after this one
 
 paul@215    732 
 
 paul@430    733 
    def ExtendFrame(self, size):
 
 paul@430    734 
        self.frame_stack.extend([None] * size)
 
 paul@98    735 
 
 paul@430    736 
    def AdjustFrame(self, size):
 
 paul@430    737 
        self.invocation_sp_stack[-1] += size
 
 paul@137    738 
 
 paul@430    739 
    def Return(self, operand=None):
 
 paul@138    740 
        return self.pull_pc()
 
 paul@68    741 
 
 paul@430    742 
    def LoadResultIntoValue(self, operand=None):
 
 paul@429    743 
        self.LoadContext(self.result_context)
 
 paul@429    744 
        self.LoadValue(self.result_value)
 
 paul@117    745 
 
 paul@430    746 
    def LoadValueIntoResult(self, operand=None):
 
 paul@429    747 
        self.result_context = self.context
 
 paul@429    748 
        self.result_value = self.value
 
 paul@117    749 
 
 paul@430    750 
    def Jump(self, addr):
 
 paul@430    751 
        return addr
 
 paul@98    752 
 
 paul@430    753 
    def JumpIfTrue(self, addr):
 
 paul@117    754 
        if self.status:
 
 paul@430    755 
            return addr
 
 paul@68    756 
 
 paul@430    757 
    def JumpIfFalse(self, addr):
 
 paul@117    758 
        if not self.status:
 
 paul@430    759 
            return addr
 
 paul@68    760 
 
 paul@430    761 
    def LoadException(self, operand=None):
 
 paul@429    762 
        self.LoadContext(self.exception)
 
 paul@429    763 
        self.LoadValue(self.exception)
 
 paul@129    764 
 
 paul@430    765 
    def StoreException(self, operand=None):
 
 paul@429    766 
        self.exception = self.value
 
 paul@129    767 
 
 paul@430    768 
    def ClearException(self, operand=None):
 
 paul@232    769 
        self.exception = None
 
 paul@232    770 
 
 paul@430    771 
    def RaiseException(self, operand=None):
 
 paul@399    772 
        # NOTE: Adding the program counter as the first attribute after __class__.
 
 paul@401    773 
        self.save(self.exception + Library.instance_data_offset, self.pc)
 
 paul@221    774 
        # Jumping to the current handler.
 
 paul@246    775 
        if self.abort_upon_exception:
 
 paul@246    776 
            raise Exception
 
 paul@145    777 
        return self.handler_stack[-1]
 
 paul@129    778 
 
 paul@430    779 
    def PushHandler(self, addr):
 
 paul@430    780 
        self.handler_stack.append(addr)
 
 paul@145    781 
        self.handler_local_sp_stack.append(len(self.local_sp_stack))
 
 paul@398    782 
        self.handler_invocation_sp_stack.append(len(self.invocation_sp_stack))
 
 paul@145    783 
        self.handler_pc_stack.append(len(self.pc_stack))
 
 paul@129    784 
 
 paul@430    785 
    def PopHandler(self, nframes):
 
 paul@398    786 
        # Get the new local frame pointer and PC stack references.
 
 paul@398    787 
        local_sp_top = self.handler_local_sp_stack[-nframes]
 
 paul@398    788 
        invocation_sp_top = self.handler_invocation_sp_stack[-nframes]
 
 paul@398    789 
        pc_top = self.handler_pc_stack[-nframes]
 
 paul@145    790 
        # Reduce the local frame pointer stack to refer to the handler's frame.
 
 paul@398    791 
        del self.local_sp_stack[local_sp_top:]
 
 paul@398    792 
        # Reduce the invocation frame pointer stack to refer to an outer frame.
 
 paul@398    793 
        del self.invocation_sp_stack[invocation_sp_top:]
 
 paul@145    794 
        # Reduce the PC stack to discard all superfluous return addresses.
 
 paul@398    795 
        del self.pc_stack[pc_top:]
 
 paul@398    796 
        # Remove elements from the handler stacks.
 
 paul@398    797 
        del self.handler_pc_stack[-nframes:]
 
 paul@398    798 
        del self.handler_local_sp_stack[-nframes:]
 
 paul@398    799 
        del self.handler_invocation_sp_stack[-nframes:]
 
 paul@398    800 
        del self.handler_stack[-nframes:]
 
 paul@129    801 
 
 paul@430    802 
    def CheckException(self, operand=None):
 
 paul@429    803 
        self.status = self.exception is not None and self._CheckInstance(self.exception, self.value)
 
 paul@129    804 
 
 paul@430    805 
    def TestIdentity(self, operand=None):
 
 paul@429    806 
        self.status = self.value == self.source_value
 
 paul@129    807 
 
 paul@430    808 
    def TestIdentityAddress(self, addr):
 
 paul@430    809 
        self.status = self.value == addr
 
 paul@129    810 
 
 paul@129    811 
    # LoadBoolean is implemented in the generated code.
 
 paul@129    812 
    # StoreBoolean is implemented by testing against the True value.
 
 paul@68    813 
 
 paul@430    814 
    def InvertBoolean(self, operand=None):
 
 paul@132    815 
        self.status = not self.status
 
 paul@132    816 
 
 paul@145    817 
    # Common implementation details.
 
 paul@145    818 
 
 paul@145    819 
    def _CheckInstance(self, ref, cls):
 
 paul@182    820 
        data = self.load(ref)
 
 paul@182    821 
        target_data = self.load(cls)
 
 paul@145    822 
 
 paul@223    823 
        # Insist on instance vs. class.
 
 paul@223    824 
 
 paul@242    825 
        if data.attrcode is None: # absent attrcode == class/module
 
 paul@223    826 
            return 0
 
 paul@191    827 
 
 paul@207    828 
        if target_data.attrcode is not None: # present attrcode == instance
 
 paul@191    829 
            return 0
 
 paul@191    830 
 
 paul@145    831 
        # Find the table entry for the descendant.
 
 paul@145    832 
 
 paul@182    833 
        element = self.objlist[target_data.classcode + data.attrcode]
 
 paul@238    834 
 
 paul@220    835 
        if element is not None:
 
 paul@242    836 
            attr_index, static_attr, offset = element
 
 paul@220    837 
            return attr_index == data.attrcode
 
 paul@220    838 
        else:
 
 paul@220    839 
            return 0
 
 paul@181    840 
 
 paul@181    841 
    def _MakeObject(self, size, ref):
 
 paul@203    842 
        # Load the template.
 
 paul@182    843 
        data = self.load(ref)
 
 paul@181    844 
        addr = self.new(size)
 
 paul@203    845 
        # Save the header, overriding the size.
 
 paul@203    846 
        self.save(addr, data.with_size(size))
 
 paul@181    847 
        return addr
 
 paul@181    848 
 
 paul@336    849 
    def _MakeFragment(self, occupied, size):
 
 paul@336    850 
        addr = self.new(size)
 
 paul@246    851 
        # Save the header, overriding the size.
 
 paul@336    852 
        self.save(addr, FragmentObject(occupied, size))
 
 paul@246    853 
        return addr
 
 paul@246    854 
 
 paul@429    855 
    def _LoadAddressContextCond(self, context, value, inst_value):
 
 paul@191    856 
        # Check the instance context against the target's context.
 
 paul@230    857 
        # This provides the context overriding for methods.
 
 paul@429    858 
        if context is ReplaceableContext or context is not PlaceholderContext and self._CheckInstance(inst_value, context):
 
 paul@191    859 
            # Replace the context with the instance.
 
 paul@429    860 
            return DataValue(inst_value, value)
 
 paul@191    861 
        else:
 
 paul@429    862 
            return DataValue(context, value)
 
 paul@191    863 
 
 paul@429    864 
    def _StoreAddressContext(self, location, context, value, source_context, source_value):
 
 paul@429    865 
        if source_context is ReplaceableContext:
 
 paul@429    866 
            context = value
 
 paul@405    867 
        else:
 
 paul@429    868 
            context = source_context
 
 paul@429    869 
        self.save(location, DataValue(context, source_value))
 
 paul@405    870 
 
 paul@228    871 
# Convenience functions.
 
 paul@228    872 
 
 paul@246    873 
def machine(program, with_builtins=0, debug=0, abort_upon_exception=0):
 
 paul@228    874 
    print "Making the image..."
 
 paul@228    875 
    code = program.get_image(with_builtins)
 
 paul@228    876 
    print "Getting raw structures..."
 
 paul@228    877 
    ot = program.get_object_table()
 
 paul@228    878 
    pt = program.get_parameter_table()
 
 paul@228    879 
    objlist = ot.as_list()
 
 paul@228    880 
    paramlist = pt.as_list()
 
 paul@228    881 
    print "Getting raw image..."
 
 paul@228    882 
    rc = program.get_raw_image()
 
 paul@228    883 
    print "Initialising the machine..."
 
 paul@228    884 
    importer = program.get_importer()
 
 paul@354    885 
    constants = {}
 
 paul@354    886 
    for x in (True, False, NotImplemented):
 
 paul@354    887 
        constants[x] = importer.get_constant(x).location
 
 paul@248    888 
    rm = RSVPMachine(rc, objlist, paramlist, debug=debug, abort_upon_exception=abort_upon_exception)
 
 paul@354    889 
    library = Library(rm, constants)
 
 paul@248    890 
    rm.library = library
 
 paul@228    891 
    rm.pc = program.code_location
 
 paul@241    892 
    print "Returning program occupying %d locations." % len(rm.memory)
 
 paul@228    893 
    return rm
 
 paul@228    894 
 
 paul@68    895 
# vim: tabstop=4 expandtab shiftwidth=4