micropython

Annotated rsvplib.py

530:0f9aa4c4d92c
460:f78fbedff1b0
2012-06-09 Paul Boddie file changeset files shortlog Added an __iter__ method for strings.
paul@261 1 
#!/usr/bin/env python
paul@261 2 
 
 paul@261      3 
"""
 
 paul@261      4 
A native function library for a really simple virtual processor.
 
 paul@450      5 
NOTE: Ultimately, this should only implement only operations at the lowest
 
 paul@450      6 
NOTE: possible level, with generated native methods providing the functionality
 
 paul@450      7 
NOTE: instead.
 
 paul@261      8 
 
 paul@401      9 
Copyright (C) 2007, 2008, 2009, 2010, 2011 Paul Boddie <paul@boddie.org.uk>
 
 paul@261     10 
 
 paul@261     11 
This program is free software; you can redistribute it and/or modify it under
 
 paul@261     12 
the terms of the GNU General Public License as published by the Free Software
 
 paul@261     13 
Foundation; either version 3 of the License, or (at your option) any later
 
 paul@261     14 
version.
 
 paul@261     15 
 
 paul@261     16 
This program is distributed in the hope that it will be useful, but WITHOUT
 
 paul@261     17 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
 paul@261     18 
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 
 paul@261     19 
details.
 
 paul@261     20 
 
 paul@261     21 
You should have received a copy of the GNU General Public License along with
 
 paul@261     22 
this program.  If not, see <http://www.gnu.org/licenses/>.
 
 paul@261     23 
"""
 
 paul@261     24 
 
 paul@264     25 
from micropython.program import DataValue
 
 paul@261     26 
import operator
 
 paul@261     27 
 
 paul@261     28 
class Library:
 
 paul@261     29 
 
 paul@261     30 
    "Native function implementations."
 
 paul@261     31 
 
 paul@395     32 
    # NOTE: These attributes need changing if the instance layout changes.
 
 paul@395     33 
 
 paul@401     34 
    instance_template_size = instance_data_offset = 1
 
 paul@401     35 
    instance_size = instance_template_size + 1
 
 paul@408     36 
    fragment_data_offset = 1
 
 paul@395     37 
 
 paul@354     38 
    def __init__(self, machine, constants):
 
 paul@261     39 
 
 paul@261     40 
        """
 
 paul@354     41 
        Initialise the library with the 'machine' and the 'constants' addresses
 
 paul@354     42 
        dictionary.
 
 paul@261     43 
        """
 
 paul@261     44 
 
 paul@261     45 
        self.machine = machine
 
 paul@354     46 
        self.constants = constants
 
 paul@261     47 
 
 paul@261     48 
        # Native class constants.
 
 paul@261     49 
 
 paul@412     50 
        self.int_class, self.int_instance = self._get_builtin_class_and_template("int")
 
 paul@412     51 
        self.list_class, self.list_instance = self._get_builtin_class_and_template("list")
 
 paul@412     52 
        self.index_error, self.index_error_instance = self._get_builtin_class_and_template("IndexError")
 
 paul@412     53 
        self.str_class, self.str_instance = self._get_builtin_class_and_template("basestring")
 
 paul@412     54 
        self.accessor_class, self.accessor_instance = self._get_builtin_class_and_template("_accessor")
 
 paul@261     55 
 
 paul@261     56 
        self.tuple_class = self.machine.tuple_class
 
 paul@408     57 
        self.tuple_instance = self.machine.tuple_instance
 
 paul@412     58 
 
 paul@412     59 
        self.attr_error_instance = self.machine.attr_error_instance
 
 paul@261     60 
        self.type_error_instance = self.machine.type_error_instance
 
 paul@261     61 
 
 paul@412     62 
    def _get_builtin_class_and_template(self, name):
 
 paul@412     63 
        cls = self.machine._get_class("__builtins__", name)
 
 paul@412     64 
        if cls is not None:
 
 paul@412     65 
            return cls.location, cls.instance_template_location
 
 paul@412     66 
        else:
 
 paul@412     67 
            return None, None
 
 paul@412     68 
 
 paul@391     69 
    def _check_index(self, pos, nelements):
 
 paul@391     70 
        return pos >= 0 and pos < nelements
 
 paul@390     71 
 
 paul@431     72 
    # Native functionality.
 
 paul@261     73 
 
 paul@431     74 
    def builtins_no_op(self):
 
 paul@431     75 
        pass
 
 paul@261     76 
 
 paul@431     77 
    def native_int_arithmetic_op(self, op):
 
 paul@450     78 
        left = self.machine.load_from_frame(0)
 
 paul@450     79 
        left_data = left.ref + self.instance_data_offset
 
 paul@450     80 
        right = self.machine.load_from_frame(1)
 
 paul@450     81 
        right_data = right.ref + self.instance_data_offset
 
 paul@261     82 
 
 paul@261     83 
        # Make a new object.
 
 paul@261     84 
 
 paul@395     85 
        addr = self.machine._MakeObject(self.instance_size, self.int_instance)
 
 paul@261     86 
 
 paul@261     87 
        # Store the result.
 
 paul@261     88 
        # NOTE: The data is considered ready to use.
 
 paul@261     89 
 
 paul@395     90 
        self.machine.save(addr + self.instance_data_offset, op(self.machine.load(left_data), self.machine.load(right_data)))
 
 paul@261     91 
 
 paul@261     92 
        # Return the new object.
 
 paul@261     93 
        # Introduce object as context for the new object.
 
 paul@261     94 
 
 paul@455     95 
        self.machine.LoadImmediate(addr, "working_context")
 
 paul@455     96 
        self.machine.LoadImmediate(addr, "working")
 
 paul@261     97 
 
 paul@431     98 
    def native_logical_op(self, op):
 
 paul@450     99 
        left = self.machine.load_from_frame(0)
 
 paul@450    100 
        left_data = left.ref + self.instance_data_offset
 
 paul@450    101 
        right = self.machine.load_from_frame(1)
 
 paul@450    102 
        right_data = right.ref + self.instance_data_offset
 
 paul@262    103 
 
 paul@262    104 
        # Test the data.
 
 paul@262    105 
        # NOTE: The data is considered ready to use.
 
 paul@262    106 
 
 paul@262    107 
        if op(self.machine.load(left_data), self.machine.load(right_data)):
 
 paul@455    108 
            self.machine.LoadImmediate(self.constants[True], "working_context")
 
 paul@455    109 
            self.machine.LoadImmediate(self.constants[True], "working")
 
 paul@262    110 
        else:
 
 paul@455    111 
            self.machine.LoadImmediate(self.constants[False], "working_context")
 
 paul@455    112 
            self.machine.LoadImmediate(self.constants[False], "working")
 
 paul@262    113 
 
 paul@262    114 
    # Operators.
 
 paul@262    115 
    # Although this takes a short-cut by using the operator module, testing is
 
 paul@262    116 
    # still performed on the operands to ensure that they qualify for these
 
 paul@262    117 
    # native operations.
 
 paul@262    118 
 
 paul@431    119 
    def native_int_add(self):
 
 paul@431    120 
        return self.native_int_arithmetic_op(operator.add)
 
 paul@262    121 
 
 paul@431    122 
    def native_int_sub(self):
 
 paul@431    123 
        return self.native_int_arithmetic_op(operator.sub)
 
 paul@262    124 
 
 paul@431    125 
    def native_int_pow(self):
 
 paul@431    126 
        return self.native_int_arithmetic_op(operator.pow)
 
 paul@262    127 
 
 paul@431    128 
    def native_int_and(self):
 
 paul@431    129 
        return self.native_int_arithmetic_op(operator.and_)
 
 paul@262    130 
 
 paul@431    131 
    def native_int_or(self):
 
 paul@431    132 
        return self.native_int_arithmetic_op(operator.or_)
 
 paul@262    133 
 
 paul@431    134 
    def native_int_lt(self):
 
 paul@431    135 
        return self.native_logical_op(operator.lt)
 
 paul@262    136 
 
 paul@431    137 
    def native_int_gt(self):
 
 paul@431    138 
        return self.native_logical_op(operator.gt)
 
 paul@262    139 
 
 paul@431    140 
    def native_int_eq(self):
 
 paul@431    141 
        return self.native_logical_op(operator.eq)
 
 paul@262    142 
 
 paul@431    143 
    def native_str_lt(self):
 
 paul@431    144 
        return self.native_logical_op(operator.lt)
 
 paul@262    145 
 
 paul@431    146 
    def native_str_gt(self):
 
 paul@431    147 
        return self.native_logical_op(operator.gt)
 
 paul@262    148 
 
 paul@431    149 
    def native_str_eq(self):
 
 paul@431    150 
        return self.native_logical_op(operator.eq)
 
 paul@262    151 
 
 paul@262    152 
    # Specific operator methods.
 
 paul@262    153 
 
 paul@261    154 
    def builtins_int_neg(self):
 
 paul@450    155 
        left = self.machine.load_from_frame(0)
 
 paul@450    156 
        left_data = left.ref + self.instance_data_offset
 
 paul@261    157 
 
 paul@261    158 
        # Make a new object.
 
 paul@261    159 
 
 paul@395    160 
        addr = self.machine._MakeObject(self.instance_size, self.int_instance)
 
 paul@261    161 
 
 paul@261    162 
        # Store the result.
 
 paul@261    163 
        # NOTE: The data is considered ready to use.
 
 paul@261    164 
 
 paul@395    165 
        self.machine.save(addr + self.instance_data_offset, -self.machine.load(left_data))
 
 paul@261    166 
 
 paul@261    167 
        # Return the new object.
 
 paul@261    168 
        # Introduce object as context for the new object.
 
 paul@261    169 
 
 paul@455    170 
        self.machine.LoadImmediate(addr, "working_context")
 
 paul@455    171 
        self.machine.LoadImmediate(addr, "working")
 
 paul@261    172 
 
 paul@262    173 
    # Various built-in methods.
 
 paul@261    174 
 
 paul@261    175 
    def builtins_list_new(self):
 
 paul@450    176 
        list_value = self.machine.load_from_frame(0)
 
 paul@450    177 
        list_addr = list_value.ref + self.instance_data_offset
 
 paul@261    178 
 
 paul@332    179 
        # Make a new sequence.
 
 paul@332    180 
        # NOTE: Using an arbitrary size.
 
 paul@261    181 
 
 paul@408    182 
        new_fragment = self.machine._MakeFragment(self.fragment_data_offset, 5) # include the header
 
 paul@261    183 
 
 paul@332    184 
        # Complete the list instance by saving the fragment reference.
 
 paul@336    185 
        # NOTE: This requires an attribute in the list structure.
 
 paul@261    186 
 
 paul@450    187 
        self.machine.save(list_addr, DataValue(None, new_fragment))
 
 paul@261    188 
 
 paul@390    189 
    def builtins_list_get_single_item(self):
 
 paul@450    190 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    191 
        fragment_member = obj_value.ref + self.instance_data_offset
 
 paul@450    192 
        item_value = self.machine.load_from_frame(1)
 
 paul@450    193 
        item_pos_member = item_value.ref + self.instance_data_offset
 
 paul@261    194 
 
 paul@261    195 
        # Get the fragment address.
 
 paul@261    196 
 
 paul@450    197 
        fragment = self.machine.load(fragment_member)
 
 paul@261    198 
 
 paul@261    199 
        # Get the fragment header.
 
 paul@261    200 
 
 paul@264    201 
        header = self.machine.load(fragment.ref)
 
 paul@408    202 
        nelements = header.occupied_size - self.fragment_data_offset
 
 paul@261    203 
 
 paul@395    204 
        # Get the item position.
 
 paul@261    205 
 
 paul@450    206 
        item_pos = self.machine.load(item_pos_member)
 
 paul@261    207 
 
 paul@391    208 
        if not self._check_index(item_pos, nelements):
 
 paul@450    209 
            self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.index_error_instance), "exception")
 
 paul@261    210 
            return self.machine.RaiseException()
 
 paul@261    211 
 
 paul@395    212 
        # Get the item itself.
 
 paul@261    213 
 
 paul@429    214 
        data = self.machine.load(fragment.ref + self.fragment_data_offset + item_pos)
 
 paul@455    215 
        self.machine.LoadImmediate(data.context, "working_context")
 
 paul@455    216 
        self.machine.LoadImmediate(data.ref, "working")
 
 paul@261    217 
 
 paul@261    218 
    def builtins_list_len(self):
 
 paul@450    219 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    220 
        fragment_member = obj_value.ref + self.instance_data_offset
 
 paul@261    221 
 
 paul@261    222 
        # Get the fragment address.
 
 paul@261    223 
 
 paul@450    224 
        fragment = self.machine.load(fragment_member)
 
 paul@261    225 
 
 paul@261    226 
        # Get the fragment header.
 
 paul@261    227 
 
 paul@264    228 
        header = self.machine.load(fragment.ref)
 
 paul@408    229 
        nelements = header.occupied_size - self.fragment_data_offset
 
 paul@261    230 
 
 paul@261    231 
        # Make a new object.
 
 paul@261    232 
 
 paul@395    233 
        addr = self.machine._MakeObject(self.instance_size, self.int_instance)
 
 paul@261    234 
 
 paul@261    235 
        # Store the result.
 
 paul@261    236 
        # NOTE: The data is considered ready to use.
 
 paul@261    237 
 
 paul@395    238 
        self.machine.save(addr + self.instance_data_offset, nelements)
 
 paul@261    239 
 
 paul@261    240 
        # Return the new object.
 
 paul@261    241 
        # Introduce object as context for the new object.
 
 paul@261    242 
 
 paul@455    243 
        self.machine.LoadImmediate(addr, "working_context")
 
 paul@455    244 
        self.machine.LoadImmediate(addr, "working")
 
 paul@261    245 
 
 paul@261    246 
    def builtins_list_append(self):
 
 paul@450    247 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    248 
        fragment_member = obj_value.ref + self.instance_data_offset
 
 paul@450    249 
        arg_value = self.machine.load_from_frame(1)
 
 paul@261    250 
 
 paul@261    251 
        # Get the fragment address.
 
 paul@261    252 
 
 paul@450    253 
        fragment = self.machine.load(fragment_member)
 
 paul@261    254 
 
 paul@261    255 
        # Get the fragment header.
 
 paul@261    256 
 
 paul@264    257 
        header = self.machine.load(fragment.ref)
 
 paul@261    258 
 
 paul@261    259 
        # Attempt to add the reference.
 
 paul@261    260 
 
 paul@261    261 
        if header.occupied_size < header.allocated_size:
 
 paul@264    262 
            self.machine.save(fragment.ref + header.occupied_size, arg_value)
 
 paul@261    263 
            header.occupied_size += 1
 
 paul@261    264 
        else:
 
 paul@261    265 
 
 paul@261    266 
            # Make a new fragment, maintaining more space than currently
 
 paul@261    267 
            # occupied in order to avoid reallocation.
 
 paul@261    268 
 
 paul@337    269 
            new_fragment = self.machine._MakeFragment(header.occupied_size + 1, header.occupied_size * 2)
 
 paul@261    270 
 
 paul@261    271 
            # Copy existing elements.
 
 paul@261    272 
 
 paul@408    273 
            for i in range(self.fragment_data_offset, header.occupied_size):
 
 paul@264    274 
                self.machine.save(new_fragment + i, self.machine.load(fragment.ref + i))
 
 paul@261    275 
 
 paul@336    276 
            self.machine.save(new_fragment + header.occupied_size, arg_value)
 
 paul@261    277 
 
 paul@261    278 
            # Set the new fragment in the object.
 
 paul@261    279 
            # NOTE: The old fragment could be deallocated.
 
 paul@261    280 
 
 paul@450    281 
            self.machine.save(fragment_member, DataValue(None, new_fragment))
 
 paul@261    282 
 
 paul@422    283 
    def builtins_tuple_new(self):
 
 paul@422    284 
 
 paul@422    285 
        # Get the sequence address.
 
 paul@426    286 
        # The first argument should be empty since this function acts as an
 
 paul@426    287 
        # instantiator, and in instantiators the first argument is reserved so
 
 paul@426    288 
        # that it can be filled in for the call to an initialiser without
 
 paul@426    289 
        # allocating a new frame.
 
 paul@422    290 
 
 paul@450    291 
        obj_value = self.machine.load_from_frame(1)
 
 paul@422    292 
        return self._builtins_tuple(obj_value)
 
 paul@422    293 
 
 paul@408    294 
    def builtins_tuple(self):
 
 paul@408    295 
 
 paul@422    296 
        # Get the sequence address.
 
 paul@408    297 
 
 paul@450    298 
        obj_value = self.machine.load_from_frame(0)
 
 paul@422    299 
        return self._builtins_tuple(obj_value)
 
 paul@408    300 
 
 paul@422    301 
    def _builtins_tuple(self, obj_value):
 
 paul@450    302 
        fragment_member = obj_value.ref + self.instance_data_offset
 
 paul@422    303 
 
 paul@422    304 
        if self.machine._CheckInstance(obj_value.ref, self.tuple_class):
 
 paul@455    305 
            self.machine.LoadImmediate(obj_value.context, "working_context")
 
 paul@455    306 
            self.machine.LoadImmediate(obj_value.ref, "working")
 
 paul@422    307 
            return
 
 paul@422    308 
 
 paul@422    309 
        # Reject non-list, non-tuple types.
 
 paul@422    310 
        # NOTE: This should probably accept any sequence.
 
 paul@422    311 
 
 paul@422    312 
        elif not self.machine._CheckInstance(obj_value.ref, self.list_class):
 
 paul@450    313 
            self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.type_error_instance), "exception")
 
 paul@408    314 
            return self.machine.RaiseException()
 
 paul@408    315 
 
 paul@408    316 
        # Get the fragment address.
 
 paul@408    317 
 
 paul@450    318 
        fragment = self.machine.load(fragment_member)
 
 paul@408    319 
 
 paul@408    320 
        # Get the fragment header.
 
 paul@408    321 
 
 paul@408    322 
        header = self.machine.load(fragment.ref)
 
 paul@408    323 
 
 paul@408    324 
        # Make a new object.
 
 paul@408    325 
 
 paul@408    326 
        addr = self.machine._MakeObject(self.instance_data_offset + header.occupied_size - self.fragment_data_offset, self.tuple_instance)
 
 paul@408    327 
 
 paul@408    328 
        # Copy the fragment contents into the tuple.
 
 paul@408    329 
        # NOTE: This might be done by repurposing the fragment in some situations.
 
 paul@408    330 
 
 paul@408    331 
        for i in range(self.fragment_data_offset, header.occupied_size):
 
 paul@408    332 
            self.machine.save(addr + self.instance_data_offset + i - self.fragment_data_offset, self.machine.load(fragment.ref + i))
 
 paul@408    333 
 
 paul@408    334 
        # Return the new object.
 
 paul@408    335 
        # Introduce object as context for the new object.
 
 paul@408    336 
 
 paul@455    337 
        self.machine.LoadImmediate(addr, "working_context")
 
 paul@455    338 
        self.machine.LoadImmediate(addr, "working")
 
 paul@408    339 
 
 paul@261    340 
    def builtins_tuple_len(self):
 
 paul@450    341 
        obj_value = self.machine.load_from_frame(0)
 
 paul@261    342 
 
 paul@261    343 
        # Get the header.
 
 paul@261    344 
 
 paul@264    345 
        header = self.machine.load(obj_value.ref)
 
 paul@395    346 
        nelements = header.size - self.instance_data_offset
 
 paul@261    347 
 
 paul@261    348 
        # Make a new object.
 
 paul@261    349 
 
 paul@395    350 
        addr = self.machine._MakeObject(self.instance_size, self.int_instance)
 
 paul@261    351 
 
 paul@261    352 
        # Store the result.
 
 paul@261    353 
        # NOTE: The data is considered ready to use.
 
 paul@261    354 
 
 paul@395    355 
        self.machine.save(addr + self.instance_data_offset, nelements)
 
 paul@261    356 
 
 paul@261    357 
        # Return the new object.
 
 paul@261    358 
        # Introduce object as context for the new object.
 
 paul@261    359 
 
 paul@455    360 
        self.machine.LoadImmediate(addr, "working_context")
 
 paul@455    361 
        self.machine.LoadImmediate(addr, "working")
 
 paul@261    362 
 
 paul@390    363 
    def builtins_tuple_get_single_item(self):
 
 paul@450    364 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    365 
        fragment_member = obj_value.ref + self.instance_data_offset
 
 paul@450    366 
        item_value = self.machine.load_from_frame(1)
 
 paul@450    367 
        item_pos_member = item_value.ref + self.instance_data_offset
 
 paul@261    368 
 
 paul@261    369 
        # Get the header.
 
 paul@261    370 
 
 paul@264    371 
        header = self.machine.load(obj_value.ref)
 
 paul@395    372 
        nelements = header.size - self.instance_data_offset
 
 paul@261    373 
 
 paul@261    374 
        # NOTE: Assume single location for data and header.
 
 paul@261    375 
 
 paul@450    376 
        item_pos = self.machine.load(item_pos_member)
 
 paul@261    377 
 
 paul@391    378 
        if not self._check_index(item_pos, nelements):
 
 paul@450    379 
            self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.index_error_instance), "exception")
 
 paul@261    380 
            return self.machine.RaiseException()
 
 paul@261    381 
 
 paul@395    382 
        # Get the item.
 
 paul@261    383 
 
 paul@450    384 
        data = self.machine.load(fragment_member + item_pos)
 
 paul@455    385 
        self.machine.LoadImmediate(data.context, "working_context")
 
 paul@455    386 
        self.machine.LoadImmediate(data.ref, "working")
 
 paul@261    387 
 
 paul@412    388 
    def builtins_getattr(self):
 
 paul@450    389 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    390 
        name_value = self.machine.load_from_frame(1)
 
 paul@450    391 
        index_member = name_value.ref + self.instance_data_offset + 1
 
 paul@412    392 
 
 paul@412    393 
        if not self.machine._CheckInstance(name_value.ref, self.accessor_class):
 
 paul@450    394 
            self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.attr_error_instance), "exception")
 
 paul@412    395 
            return self.machine.RaiseException()
 
 paul@412    396 
 
 paul@412    397 
        # Get the object table index from the name. It is a bare integer, not a reference.
 
 paul@412    398 
 
 paul@450    399 
        index = self.machine.load(index_member)
 
 paul@412    400 
 
 paul@416    401 
        # NOTE: This is very much like LoadAttrIndexContextCond.
 
 paul@412    402 
 
 paul@412    403 
        data = self.machine.load(obj_value.ref)
 
 paul@460    404 
        element = self.machine.load(self.machine.registers["objlist"] + data.classcode + index)
 
 paul@412    405 
 
 paul@412    406 
        if element is not None:
 
 paul@412    407 
            attr_index, static_attr, offset = element
 
 paul@412    408 
            if attr_index == index:
 
 paul@412    409 
                if static_attr:
 
 paul@429    410 
                    loaded_data = self.machine.load(offset) # offset is address of class/module attribute
 
 paul@429    411 
                    if data.attrcode is not None: # absent attrcode == class/module
 
 paul@429    412 
                        loaded_data = self.machine._LoadAddressContextCond(loaded_data.context, loaded_data.ref, obj_value.ref)
 
 paul@412    413 
                else:
 
 paul@429    414 
                    loaded_data = self.machine.load(obj_value.ref + offset)
 
 paul@455    415 
                self.machine.LoadImmediate(loaded_data.context, "working_context")
 
 paul@455    416 
                self.machine.LoadImmediate(loaded_data.ref, "working")
 
 paul@412    417 
                return
 
 paul@412    418 
 
 paul@450    419 
        self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.attr_error_instance), "exception")
 
 paul@412    420 
        return self.machine.RaiseException()
 
 paul@412    421 
 
 paul@377    422 
    def builtins_isinstance(self):
 
 paul@450    423 
        obj_value = self.machine.load_from_frame(0)
 
 paul@450    424 
        cls_value = self.machine.load_from_frame(1)
 
 paul@377    425 
 
 paul@377    426 
        if self.machine._CheckInstance(obj_value.ref, cls_value.ref):
 
 paul@455    427 
            self.machine.LoadImmediate(self.constants[True], "working_context")
 
 paul@455    428 
            self.machine.LoadImmediate(self.constants[True], "working")
 
 paul@377    429 
        else:
 
 paul@455    430 
            self.machine.LoadImmediate(self.constants[False], "working_context")
 
 paul@455    431 
            self.machine.LoadImmediate(self.constants[False], "working")
 
 paul@377    432 
 
 paul@402    433 
    def builtins_print(self):
 
 paul@402    434 
        # NOTE: Do nothing for now.
 
 paul@402    435 
        pass
 
 paul@402    436 
 
 paul@402    437 
    def builtins_printnl(self):
 
 paul@402    438 
        # NOTE: Do nothing for now.
 
 paul@402    439 
        pass
 
 paul@402    440 
 
 paul@261    441 
    native_functions = {
 
 paul@261    442 
 
 paul@261    443 
        # Native method implementations:
 
 paul@261    444 
 
 paul@450    445 
        "native._int_add"                           : native_int_add,
 
 paul@450    446 
        "native._int_sub"                           : native_int_sub,
 
 paul@450    447 
        "native._int_pow"                           : native_int_pow,
 
 paul@450    448 
        "native._int_and"                           : native_int_and,
 
 paul@450    449 
        "native._int_or"                            : native_int_or,
 
 paul@450    450 
        "native._int_lt"                            : native_int_lt,
 
 paul@450    451 
        "native._int_gt"                            : native_int_gt,
 
 paul@450    452 
        "native._int_eq"                            : native_int_eq,
 
 paul@450    453 
        "native._str_lt"                            : native_str_lt,
 
 paul@450    454 
        "native._str_gt"                            : native_str_gt,
 
 paul@450    455 
        "native._str_eq"                            : native_str_eq,
 
 paul@450    456 
        "__builtins__.int.__neg__"                  : builtins_int_neg,
 
 paul@450    457 
        "__builtins__.list.__get_single_item__"     : builtins_list_get_single_item,
 
 paul@450    458 
        "__builtins__.list.__len__"                 : builtins_list_len,
 
 paul@450    459 
        "__builtins__.list.append"                  : builtins_list_append,
 
 paul@450    460 
        "__builtins__.tuple"                        : builtins_tuple_new,
 
 paul@450    461 
        "__builtins__.tuple.__len__"                : builtins_tuple_len,
 
 paul@450    462 
        "__builtins__.tuple.__get_single_item__"    : builtins_tuple_get_single_item,
 
 paul@261    463 
 
 paul@261    464 
        # Native initialisers:
 
 paul@261    465 
 
 paul@450    466 
        "__builtins__.BaseException.__init__"       : builtins_no_op, # NOTE: To be made distinct, potentially in the builtins module.
 
 paul@261    467 
 
 paul@412    468 
        # Native functions:
 
 paul@412    469 
 
 paul@450    470 
        "__builtins__._getattr"                     : builtins_getattr,
 
 paul@412    471 
 
 paul@332    472 
        # Native instantiator helpers:
 
 paul@261    473 
 
 paul@450    474 
        "__builtins__.list.__new__"                 : builtins_list_new,
 
 paul@377    475 
 
 paul@377    476 
        # Native helper functions:
 
 paul@377    477 
 
 paul@450    478 
        "__builtins__._isinstance"                  : builtins_isinstance,
 
 paul@450    479 
        "__builtins__._print"                       : builtins_print,
 
 paul@450    480 
        "__builtins__._printnl"                     : builtins_printnl,
 
 paul@450    481 
        "__builtins__._tuple"                       : builtins_tuple,
 
 paul@261    482 
        }
 
 paul@261    483 
 
 paul@261    484 
# vim: tabstop=4 expandtab shiftwidth=4