#!/usr/bin/env python  """ A native function library for a really simple virtual processor.  Copyright (C) 2007, 2008, 2009, 2010, 2011 Paul Boddie <paul@boddie.org.uk>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>. """  from micropython.program import DataValue import operator  class Library:      "Native function implementations."      # NOTE: These attributes need changing if the instance layout changes.      instance_template_size = instance_data_offset = 1     instance_size = instance_template_size + 1     fragment_data_offset = 1      def __init__(self, machine, constants):          """         Initialise the library with the 'machine' and the 'constants' addresses         dictionary.         """          self.machine = machine         self.constants = constants          # Native class constants.          self.int_class, self.int_instance = self._get_builtin_class_and_template("int")         self.list_class, self.list_instance = self._get_builtin_class_and_template("list")         self.index_error, self.index_error_instance = self._get_builtin_class_and_template("IndexError")         self.str_class, self.str_instance = self._get_builtin_class_and_template("basestring")         self.accessor_class, self.accessor_instance = self._get_builtin_class_and_template("_accessor")          self.tuple_class = self.machine.tuple_class         self.tuple_instance = self.machine.tuple_instance          self.attr_error_instance = self.machine.attr_error_instance         self.type_error_instance = self.machine.type_error_instance          self.frame_stack = self.machine.frame_stack         self.local_sp_stack = self.machine.local_sp_stack      def _get_builtin_class_and_template(self, name):         cls = self.machine._get_class("__builtins__", name)         if cls is not None:             return cls.location, cls.instance_template_location         else:             return None, None      def _check_index(self, pos, nelements):         return pos >= 0 and pos < nelements      def builtins_int_arithmetic_op(self, op):         frame = self.local_sp_stack[-1]          # Get operands addresses.          left_value = self.frame_stack[frame]         right_value = self.frame_stack[frame + 1]          # Test operand suitability.         # NOTE: Support other types.          if not (self.machine._CheckInstance(left_value.ref, self.int_class) and             self.machine._CheckInstance(right_value.ref, self.int_class)):              self.machine.exception = self.machine._MakeObject(self.instance_size, self.type_error_instance)             return self.machine.RaiseException()          left_data = left_value.ref + self.instance_data_offset         right_data = right_value.ref + self.instance_data_offset          # Make a new object.          addr = self.machine._MakeObject(self.instance_size, self.int_instance)          # Store the result.         # NOTE: The data is considered ready to use.          self.machine.save(addr + self.instance_data_offset, op(self.machine.load(left_data), self.machine.load(right_data)))          # Return the new object.         # Introduce object as context for the new object.          self.machine.result = DataValue(addr, addr)      def builtins_logical_op(self, operand_class, op):         frame = self.local_sp_stack[-1]          # Get operands addresses.          left_value = self.frame_stack[frame]         right_value = self.frame_stack[frame + 1]          # Test operand suitability.         # NOTE: Handle comparisons of incompatible types more appropriately.         # NOTE: Return NotImplemented.          if not (self.machine._CheckInstance(left_value.ref, operand_class) and             self.machine._CheckInstance(right_value.ref, operand_class)):              notimpl = self.constants[NotImplemented]             self.machine.result = DataValue(notimpl, notimpl)             return          left_data = left_value.ref + self.instance_data_offset         right_data = right_value.ref + self.instance_data_offset          # Test the data.         # NOTE: The data is considered ready to use.          if op(self.machine.load(left_data), self.machine.load(right_data)):             self.machine.result = DataValue(self.constants[True], self.constants[True])         else:             self.machine.result = DataValue(self.constants[False], self.constants[False])      # Operators.     # Although this takes a short-cut by using the operator module, testing is     # still performed on the operands to ensure that they qualify for these     # native operations.      def builtins_int_add(self):         return self.builtins_int_arithmetic_op(operator.add)      def builtins_int_sub(self):         return self.builtins_int_arithmetic_op(operator.sub)      def builtins_int_pow(self):         return self.builtins_int_arithmetic_op(operator.pow)      def builtins_int_lt(self):         return self.builtins_logical_op(self.int_class, operator.lt)      def builtins_int_le(self):         return self.builtins_logical_op(self.int_class, operator.le)      def builtins_int_gt(self):         return self.builtins_logical_op(self.int_class, operator.gt)      def builtins_int_ge(self):         return self.builtins_logical_op(self.int_class, operator.ge)      def builtins_int_eq(self):         return self.builtins_logical_op(self.int_class, operator.eq)      def builtins_int_ne(self):         return self.builtins_logical_op(self.int_class, operator.ne)      def builtins_str_lt(self):         return self.builtins_logical_op(self.str_class, operator.lt)      def builtins_str_le(self):         return self.builtins_logical_op(self.str_class, operator.le)      def builtins_str_gt(self):         return self.builtins_logical_op(self.str_class, operator.gt)      def builtins_str_ge(self):         return self.builtins_logical_op(self.str_class, operator.ge)      def builtins_str_eq(self):         return self.builtins_logical_op(self.str_class, operator.eq)      def builtins_str_ne(self):         return self.builtins_logical_op(self.str_class, operator.ne)      def builtins_int_and(self):         return self.builtins_int_arithmetic_op(operator.and_)      def builtins_int_or(self):         return self.builtins_int_arithmetic_op(operator.or_)      # Specific operator methods.      def builtins_int_bool(self):         frame = self.local_sp_stack[-1]          # Get operands addresses.          left_value = self.frame_stack[frame]          # Test operand suitability.          if not self.machine._CheckInstance(left_value.ref, self.int_class):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.type_error_instance)             return self.machine.RaiseException()          left_data = left_value.ref + self.instance_data_offset          # Test the data.         # NOTE: The data is considered ready to use.          if self.machine.load(left_data) != 0:             self.machine.result = DataValue(self.constants[True], self.constants[True])         else:             self.machine.result = DataValue(self.constants[False], self.constants[False])      def builtins_int_neg(self):         frame = self.local_sp_stack[-1]          # Get operands addresses.          left_value = self.frame_stack[frame]          # Test operand suitability.          if not self.machine._CheckInstance(left_value.ref, self.int_class):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.type_error_instance)             return self.machine.RaiseException()          left_data = left_value.ref + self.instance_data_offset          # Make a new object.          addr = self.machine._MakeObject(self.instance_size, self.int_instance)          # Store the result.         # NOTE: The data is considered ready to use.          self.machine.save(addr + self.instance_data_offset, -self.machine.load(left_data))          # Return the new object.         # Introduce object as context for the new object.          self.machine.result = DataValue(addr, addr)      # Various built-in methods.      def builtins_bool_bool(self):         frame = self.local_sp_stack[-1]          # Get operands addresses.          left_value = self.frame_stack[frame]         self.machine.result = DataValue(left_value.ref, left_value.ref)      def builtins_list_new(self):         frame = self.local_sp_stack[-1]          # The first parameter should be the instance.          list_value = self.frame_stack[frame]          # Make a new sequence.         # NOTE: Using an arbitrary size.          new_fragment = self.machine._MakeFragment(self.fragment_data_offset, 5) # include the header          # Complete the list instance by saving the fragment reference.         # NOTE: This requires an attribute in the list structure.          addr = list_value.ref + self.instance_data_offset         self.machine.save(addr, DataValue(None, new_fragment))      def builtins_list_get_single_item(self):         frame = self.local_sp_stack[-1]          # Get the operand address.          item_value = self.frame_stack[frame + 1]          # Get the list address.          obj_value = self.frame_stack[frame]          # Get the fragment address.          fragment = self.machine.load(obj_value.ref + self.instance_data_offset)          # Get the fragment header.          header = self.machine.load(fragment.ref)         nelements = header.occupied_size - self.fragment_data_offset          # Get the item position.          item_pos = self.machine.load(item_value.ref + self.instance_data_offset)          if not self._check_index(item_pos, nelements):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.index_error_instance)             return self.machine.RaiseException()          # Get the item itself.          self.machine.result = self.machine.load(fragment.ref + self.fragment_data_offset + item_pos)      def builtins_list_len(self):         frame = self.local_sp_stack[-1]          # Get the list address.          obj_value = self.frame_stack[frame]          # Get the fragment address.          fragment = self.machine.load(obj_value.ref + self.instance_data_offset)          # Get the fragment header.          header = self.machine.load(fragment.ref)         nelements = header.occupied_size - self.fragment_data_offset          # Make a new object.          addr = self.machine._MakeObject(self.instance_size, self.int_instance)          # Store the result.         # NOTE: The data is considered ready to use.          self.machine.save(addr + self.instance_data_offset, nelements)          # Return the new object.         # Introduce object as context for the new object.          self.machine.result = DataValue(addr, addr)      def builtins_list_append(self):         frame = self.local_sp_stack[-1]          # Get operand address.          arg_value = self.frame_stack[frame + 1]          # Get the list address.          obj_value = self.frame_stack[frame]          # Get the fragment address.          fragment = self.machine.load(obj_value.ref + self.instance_data_offset)          # Get the fragment header.          header = self.machine.load(fragment.ref)          # Attempt to add the reference.          if header.occupied_size < header.allocated_size:             self.machine.save(fragment.ref + header.occupied_size, arg_value)             header.occupied_size += 1         else:              # Make a new fragment, maintaining more space than currently             # occupied in order to avoid reallocation.              new_fragment = self.machine._MakeFragment(header.occupied_size + 1, header.occupied_size * 2)              # Copy existing elements.              for i in range(self.fragment_data_offset, header.occupied_size):                 self.machine.save(new_fragment + i, self.machine.load(fragment.ref + i))              self.machine.save(new_fragment + header.occupied_size, arg_value)              # Set the new fragment in the object.             # NOTE: The old fragment could be deallocated.              self.machine.save(obj_value.ref + self.instance_data_offset, DataValue(None, new_fragment))      def builtins_tuple_new(self):         frame = self.local_sp_stack[-1]          # Get the sequence address.         # The first argument should be empty since this function acts as an         # instantiator, and in instantiators the first argument is reserved so         # that it can be filled in for the call to an initialiser without         # allocating a new frame.          obj_value = self.frame_stack[frame + 1]         return self._builtins_tuple(obj_value)      def builtins_tuple(self):         frame = self.local_sp_stack[-1]          # Get the sequence address.          obj_value = self.frame_stack[frame]         return self._builtins_tuple(obj_value)      def _builtins_tuple(self, obj_value):          if self.machine._CheckInstance(obj_value.ref, self.tuple_class):             self.machine.result = obj_value             return          # Reject non-list, non-tuple types.         # NOTE: This should probably accept any sequence.          elif not self.machine._CheckInstance(obj_value.ref, self.list_class):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.type_error_instance)             return self.machine.RaiseException()          # Get the fragment address.          fragment = self.machine.load(obj_value.ref + self.instance_data_offset)          # Get the fragment header.          header = self.machine.load(fragment.ref)          # Make a new object.          addr = self.machine._MakeObject(self.instance_data_offset + header.occupied_size - self.fragment_data_offset, self.tuple_instance)          # Copy the fragment contents into the tuple.         # NOTE: This might be done by repurposing the fragment in some situations.          for i in range(self.fragment_data_offset, header.occupied_size):             self.machine.save(addr + self.instance_data_offset + i - self.fragment_data_offset, self.machine.load(fragment.ref + i))          # Return the new object.         # Introduce object as context for the new object.          self.machine.result = DataValue(addr, addr)      def builtins_tuple_len(self):         frame = self.local_sp_stack[-1]          # Get the tuple address.          obj_value = self.frame_stack[frame]          # Get the header.          header = self.machine.load(obj_value.ref)         nelements = header.size - self.instance_data_offset          # Make a new object.          addr = self.machine._MakeObject(self.instance_size, self.int_instance)          # Store the result.         # NOTE: The data is considered ready to use.          self.machine.save(addr + self.instance_data_offset, nelements)          # Return the new object.         # Introduce object as context for the new object.          self.machine.result = DataValue(addr, addr)      def builtins_tuple_get_single_item(self):         frame = self.local_sp_stack[-1]          # Get the operand address.          item_value = self.frame_stack[frame + 1]          # Get the tuple address.          obj_value = self.frame_stack[frame]          # Get the header.          header = self.machine.load(obj_value.ref)         nelements = header.size - self.instance_data_offset          # NOTE: Assume single location for data and header.          item_pos = self.machine.load(item_value.ref + self.instance_data_offset)          if not self._check_index(item_pos, nelements):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.index_error_instance)             return self.machine.RaiseException()          # Get the item.          self.machine.result = self.machine.load(obj_value.ref + self.instance_data_offset + item_pos)      def builtins_object_init(self):         pass      def builtins_getattr(self):         frame = self.local_sp_stack[-1]          # Get the object, attribute name.          obj_value = self.frame_stack[frame]         name_value = self.frame_stack[frame + 1]          if not self.machine._CheckInstance(name_value.ref, self.accessor_class):             self.machine.exception = self.machine._MakeObject(self.instance_size, self.attr_error_instance)             return self.machine.RaiseException()          # Get the object table index from the name. It is a bare integer, not a reference.          index = self.machine.load(name_value.ref + self.instance_data_offset + 1)          # NOTE: This is very much like LoadAttrIndexContextCond.          data = self.machine.load(obj_value.ref)         element = self.machine.objlist[data.classcode + index]          if element is not None:             attr_index, static_attr, offset = element             if attr_index == index:                 if static_attr:                     loaded_value = self.machine.load(offset) # offset is address of class/module attribute                     if data.attrcode is None: # absent attrcode == class/module                         self.machine.result = loaded_value                     else:                         self.machine.result = self.machine._LoadAddressContextCond(loaded_value.context, loaded_value.ref, obj_value.ref)                 else:                     self.machine.result = self.machine.load(obj_value.ref + offset)                 return          self.machine.exception = self.machine._MakeObject(self.instance_size, self.attr_error_instance)         return self.machine.RaiseException()      def builtins_isinstance(self):         frame = self.local_sp_stack[-1]          # Get the operand addresses.          obj_value = self.frame_stack[frame]         cls_value = self.frame_stack[frame + 1]          if self.machine._CheckInstance(obj_value.ref, cls_value.ref):             self.machine.result = DataValue(self.constants[True], self.constants[True])         else:             self.machine.result = DataValue(self.constants[False], self.constants[False])      def builtins_print(self):         # NOTE: Do nothing for now.         pass      def builtins_printnl(self):         # NOTE: Do nothing for now.         pass      native_functions = {          # Native method implementations:          "__builtins__.basestring.__lt__" : builtins_str_lt,         "__builtins__.basestring.__le__" : builtins_str_le,         "__builtins__.basestring.__gt__" : builtins_str_gt,         "__builtins__.basestring.__ge__" : builtins_str_ge,         "__builtins__.basestring.__eq__" : builtins_str_eq,         "__builtins__.basestring.__ne__" : builtins_str_ne,         "__builtins__.bool.__bool__" : builtins_bool_bool,         "__builtins__.int.__add__" : builtins_int_add,         "__builtins__.int.__radd__" : builtins_int_add,               # NOTE: To be made distinct.         "__builtins__.int.__sub__" : builtins_int_sub,         "__builtins__.int.__pow__" : builtins_int_pow,         "__builtins__.int.__iadd__" : builtins_int_add,         "__builtins__.int.__bool__" : builtins_int_bool,         "__builtins__.int.__neg__" : builtins_int_neg,         "__builtins__.int.__lt__" : builtins_int_lt,         "__builtins__.int.__le__" : builtins_int_le,         "__builtins__.int.__gt__" : builtins_int_gt,         "__builtins__.int.__ge__" : builtins_int_ge,         "__builtins__.int.__eq__" : builtins_int_eq,         "__builtins__.int.__ne__" : builtins_int_ne,         "__builtins__.int.__and__" : builtins_int_and,         "__builtins__.int.__rand__" : builtins_int_and,         "__builtins__.int.__or__" : builtins_int_or,         "__builtins__.int.__ror__" : builtins_int_or,         "__builtins__.list.__get_single_item__" : builtins_list_get_single_item,         "__builtins__.list.__len__" : builtins_list_len,         "__builtins__.list.append" : builtins_list_append,         "__builtins__.tuple" : builtins_tuple_new,         "__builtins__.tuple.__len__" : builtins_tuple_len,         "__builtins__.tuple.__get_single_item__" : builtins_tuple_get_single_item,          # Native initialisers:          "__builtins__.object.__init__" : builtins_object_init,        # NOTE: A no-operation.         "__builtins__.BaseException.__init__" : builtins_object_init, # NOTE: To be made distinct, potentially in the builtins module.          # Native functions:          "__builtins__._getattr" : builtins_getattr,          # Native instantiator helpers:          "__builtins__.list.__new__" : builtins_list_new,          # Native helper functions:          "__builtins__._isinstance" : builtins_isinstance,         "__builtins__._print" : builtins_print,         "__builtins__._printnl" : builtins_printnl,         "__builtins__._tuple" : builtins_tuple,         }  # vim: tabstop=4 expandtab shiftwidth=4