#!/usr/bin/env python  """ A native function library for a really simple virtual processor. NOTE: Ultimately, this should only implement only operations at the lowest NOTE: possible level, with generated native methods providing the functionality NOTE: instead.  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      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):         left = self.machine.load_from_frame(0)         left_data = left.ref + self.instance_data_offset         right = self.machine.load_from_frame(1)         right_data = right.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.LoadImmediate(addr, "working_context")         self.machine.LoadImmediate(addr, "working")      def native_logical_op(self, op):         left = self.machine.load_from_frame(0)         left_data = left.ref + self.instance_data_offset         right = self.machine.load_from_frame(1)         right_data = right.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.LoadImmediate(self.constants[True], "working_context")             self.machine.LoadImmediate(self.constants[True], "working")         else:             self.machine.LoadImmediate(self.constants[False], "working_context")             self.machine.LoadImmediate(self.constants[False], "working")      # 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):         left = self.machine.load_from_frame(0)         left_data = left.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.LoadImmediate(addr, "working_context")         self.machine.LoadImmediate(addr, "working")      # Various built-in methods.      def builtins_list_new(self):         list_value = self.machine.load_from_frame(0)         list_addr = list_value.ref + self.instance_data_offset          # 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.          self.machine.save(list_addr, DataValue(None, new_fragment))      def builtins_list_get_single_item(self):         obj_value = self.machine.load_from_frame(0)         fragment_member = obj_value.ref + self.instance_data_offset         item_value = self.machine.load_from_frame(1)         item_pos_member = item_value.ref + self.instance_data_offset          # Get the fragment address.          fragment = self.machine.load(fragment_member)          # 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_pos_member)          if not self._check_index(item_pos, nelements):             self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.index_error_instance), "exception")             return self.machine.RaiseException()          # Get the item itself.          data = self.machine.load(fragment.ref + self.fragment_data_offset + item_pos)         self.machine.LoadImmediate(data.context, "working_context")         self.machine.LoadImmediate(data.ref, "working")      def builtins_list_len(self):         obj_value = self.machine.load_from_frame(0)         fragment_member = obj_value.ref + self.instance_data_offset          # Get the fragment address.          fragment = self.machine.load(fragment_member)          # 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.LoadImmediate(addr, "working_context")         self.machine.LoadImmediate(addr, "working")      def builtins_list_append(self):         obj_value = self.machine.load_from_frame(0)         fragment_member = obj_value.ref + self.instance_data_offset         arg_value = self.machine.load_from_frame(1)          # Get the fragment address.          fragment = self.machine.load(fragment_member)          # 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(fragment_member, DataValue(None, new_fragment))      def builtins_tuple_new(self):          # 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.machine.load_from_frame(1)         return self._builtins_tuple(obj_value)      def builtins_tuple(self):          # Get the sequence address.          obj_value = self.machine.load_from_frame(0)         return self._builtins_tuple(obj_value)      def _builtins_tuple(self, obj_value):         fragment_member = obj_value.ref + self.instance_data_offset          if self.machine._CheckInstance(obj_value.ref, self.tuple_class):             self.machine.LoadImmediate(obj_value.context, "working_context")             self.machine.LoadImmediate(obj_value.ref, "working")             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.LoadImmediate(self.machine._MakeObject(self.instance_size, self.type_error_instance), "exception")             return self.machine.RaiseException()          # Get the fragment address.          fragment = self.machine.load(fragment_member)          # 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.LoadImmediate(addr, "working_context")         self.machine.LoadImmediate(addr, "working")      def builtins_tuple_len(self):         obj_value = self.machine.load_from_frame(0)          # 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.LoadImmediate(addr, "working_context")         self.machine.LoadImmediate(addr, "working")      def builtins_tuple_get_single_item(self):         obj_value = self.machine.load_from_frame(0)         fragment_member = obj_value.ref + self.instance_data_offset         item_value = self.machine.load_from_frame(1)         item_pos_member = item_value.ref + self.instance_data_offset          # 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_pos_member)          if not self._check_index(item_pos, nelements):             self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.index_error_instance), "exception")             return self.machine.RaiseException()          # Get the item.          data = self.machine.load(fragment_member + item_pos)         self.machine.LoadImmediate(data.context, "working_context")         self.machine.LoadImmediate(data.ref, "working")      def builtins_getattr(self):         obj_value = self.machine.load_from_frame(0)         name_value = self.machine.load_from_frame(1)         index_member = name_value.ref + self.instance_data_offset + 1          if not self.machine._CheckInstance(name_value.ref, self.accessor_class):             self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.attr_error_instance), "exception")             return self.machine.RaiseException()          # Get the object table index from the name. It is a bare integer, not a reference.          index = self.machine.load(index_member)          # NOTE: This is very much like LoadAttrIndexContextCond.          data = self.machine.load(obj_value.ref)         element = self.machine.load(self.machine.registers["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.LoadImmediate(loaded_data.context, "working_context")                 self.machine.LoadImmediate(loaded_data.ref, "working")                 return          self.machine.LoadImmediate(self.machine._MakeObject(self.instance_size, self.attr_error_instance), "exception")         return self.machine.RaiseException()      def builtins_isinstance(self):         obj_value = self.machine.load_from_frame(0)         cls_value = self.machine.load_from_frame(1)          if self.machine._CheckInstance(obj_value.ref, cls_value.ref):             self.machine.LoadImmediate(self.constants[True], "working_context")             self.machine.LoadImmediate(self.constants[True], "working")         else:             self.machine.LoadImmediate(self.constants[False], "working_context")             self.machine.LoadImmediate(self.constants[False], "working")      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