#!/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      # Native functionality.      def builtins_no_op(self):         pass      def native_int_arithmetic_op(self, op):         self.machine.LoadName(0) # left value         left_data = self.machine.value + self.instance_data_offset         self.machine.LoadName(1) # right value         right_data = self.machine.value + 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_context = addr         self.machine.result_value = addr      def native_logical_op(self, op):         self.machine.LoadName(0) # left value         left_data = self.machine.value + self.instance_data_offset         self.machine.LoadName(1) # right value         right_data = self.machine.value + 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_context = self.constants[True]             self.machine.result_value = self.constants[True]         else:             self.machine.result_context = self.constants[False]             self.machine.result_value = 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 native_int_add(self):         return self.native_int_arithmetic_op(operator.add)      def native_int_sub(self):         return self.native_int_arithmetic_op(operator.sub)      def native_int_pow(self):         return self.native_int_arithmetic_op(operator.pow)      def native_int_and(self):         return self.native_int_arithmetic_op(operator.and_)      def native_int_or(self):         return self.native_int_arithmetic_op(operator.or_)      def native_int_lt(self):         return self.native_logical_op(operator.lt)      def native_int_gt(self):         return self.native_logical_op(operator.gt)      def native_int_eq(self):         return self.native_logical_op(operator.eq)      def native_str_lt(self):         return self.native_logical_op(operator.lt)      def native_str_gt(self):         return self.native_logical_op(operator.gt)      def native_str_eq(self):         return self.native_logical_op(operator.eq)      # Specific operator methods.      def builtins_int_neg(self):         self.machine.LoadName(0) # left value         left_data = self.machine.value + 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_context = addr         self.machine.result_value = addr      # Various built-in methods.      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.          data = self.machine.load(fragment.ref + self.fragment_data_offset + item_pos)         self.machine.result_context = data.context         self.machine.result_value = data.ref      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_context = addr         self.machine.result_value = 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_context = obj_value.context             self.machine.result_value = obj_value.ref             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_context = addr         self.machine.result_value = 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_context = addr         self.machine.result_value = 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.          data = self.machine.load(obj_value.ref + self.instance_data_offset + item_pos)         self.machine.result_context = data.context         self.machine.result_value = data.ref      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_data = self.machine.load(offset) # offset is address of class/module attribute                     if data.attrcode is not None: # absent attrcode == class/module                         loaded_data = self.machine._LoadAddressContextCond(loaded_data.context, loaded_data.ref, obj_value.ref)                 else:                     loaded_data = self.machine.load(obj_value.ref + offset)                 self.machine.result_context = loaded_data.context                 self.machine.result_value = loaded_data.ref                 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_context = self.constants[True]             self.machine.result_value = self.constants[True]         else:             self.machine.result_context = self.constants[False]             self.machine.result_value = 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:          "native._int_add" : native_int_add,         "native._int_sub" : native_int_sub,         "native._int_pow" : native_int_pow,         "native._int_and" : native_int_and,         "native._int_or" : native_int_or,         "native._int_lt" : native_int_lt,         "native._int_gt" : native_int_gt,         "native._int_eq" : native_int_eq,         "native._str_lt" : native_str_lt,         "native._str_gt" : native_str_gt,         "native._str_eq" : native_str_eq,         "__builtins__.int.__neg__" : builtins_int_neg,         "__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__.BaseException.__init__" : builtins_no_op, # 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