owl-basic 0.6.0__py3-none-any.whl

owl_basic/owltyping/type_system.py

@@ -0,0 +1,220 @@
+'''
+Created on 28 Mar 2010
+
+@author: rjs
+'''
+
+from owl_basic.visitor import Visitable
+
+class OwlTypeSingleton(type):
+    def __init__(cls, name, bases, dict):
+        super(OwlTypeSingleton, cls).__init__(name, bases, dict)
+        cls.instance = None
+ 
+    def __call__(cls, *args, **kw):
+        if cls.instance is None:
+            cls.instance = super(OwlTypeSingleton, cls).__call__(*args, **kw)
+ 
+        return cls.instance
+
+class OwlType(Visitable, metaclass=OwlTypeSingleton):
+    "OwlType"
+    
+    def isArray(self):
+        return False
+    
+    def arrayRank(self):
+        return None
+    
+    def makeArrayType(self, rank=1):
+        '''
+        Returns a OwlType object that represents an array
+        of the current type.
+        '''
+        return ArrayOwlType(self, rank)
+    
+    def elementType(self):
+        return None
+    
+    def isA(self, other):
+        #assert not isinstance(other, type)
+        return isinstance(self, type(other))
+    
+    def isConvertibleTo(self, other):
+        '''
+        Determines whether an instance of the current OwlType
+        can be converted to an instance of the specified OwlType.
+        '''
+        assert not isinstance(other, type)
+        return other.isAssignableFrom(self)
+        
+    def isAssignableFrom(self, other):
+        '''
+        Determines whether an instance of the current OwlType
+        can be assigned from an instance of the specified OwlType.
+        '''
+        assert not isinstance(other, type)
+        return type(other) == type(self)
+    
+    def bitsIntegerPrecision(self):
+        return 0
+    
+    def isDefined(self):
+        return False
+    
+    def __str__(self):
+        return self.__doc__
+    
+    def __repr__(self):
+        return self.__doc__
+
+class PendingOwlType(OwlType, metaclass=OwlTypeSingleton):
+    "Pending"
+    
+    def isAssignableFrom(self, other):
+        # TODO: Is this correct?
+        assert not isinstance(other, type)
+        return True
+
+class VoidOwlType(OwlType, metaclass=OwlTypeSingleton):
+    "Void"
+    
+    def isDefined(self):
+        return True
+    
+class ScalarOwlType(OwlType, metaclass=OwlTypeSingleton):
+    "Scalar"
+    
+class ObjectOwlType(ScalarOwlType, metaclass=OwlTypeSingleton):
+    "Object"
+    # OWL BASIC only - object reference
+    
+    def isConvertibleTo(self, other):
+        assert not isinstance(other, type)
+        return True
+    
+    def isAssignableFrom(self, other):
+        assert not isinstance(other, type)
+        return True
+    
+    def isDefined(self):
+        return True
+
+class NumericOwlType(ScalarOwlType, metaclass=OwlTypeSingleton):
+    "Numeric"
+    
+    def isConvertibleTo(self, other):
+        assert not isinstance(other, type)
+        return other.isAssignableFrom(self)
+    
+    def isAssignableFrom(self, other):
+        assert not isinstance(other, type)
+        return isinstance(other, NumericOwlType) 
+    
+class IntegerOwlType(NumericOwlType, metaclass=OwlTypeSingleton):
+    "Integer"
+    
+    def bitsIntegerPrecision(self):
+        return 32
+    
+    def isDefined(self):
+        return True
+    
+class AddressOwlType(NumericOwlType, metaclass=OwlTypeSingleton):
+    "Address"
+    
+    def bitsIntegerPrecision(self):
+        return 32 # What about this 32/64?
+    
+    def isDefined(self):
+        return True
+
+class ChannelOwlType(IntegerOwlType):
+    "Channel"
+    
+class FloatOwlType(NumericOwlType, metaclass=OwlTypeSingleton):
+    "Float"
+    def bitsIntegerPrecision(self):
+        "Representing a double precision float with 52 (+ 1 implied) bits in the mantissa."
+        return 53
+    
+    def isDefined(self):
+        return True
+    
+class StringOwlType(ObjectOwlType, metaclass=OwlTypeSingleton):
+    "String"
+    # TODO: Assigning StringOwlType to ObjectOwlType should be possible
+    
+class ByteOwlType(NumericOwlType, metaclass=OwlTypeSingleton):
+    "Byte"
+    
+    def bitsIntegerPrecision(self):
+        return 8
+    
+    def isDefined(self):
+        return True
+    
+class ArrayOwlType(ObjectOwlType):
+    
+    def __init__(self, element_type=None, rank=None):
+        self.element_type = element_type # None = Unknown or unspecified
+        self.rank = rank # None = Unknown or unspecified
+        
+    def isArray(self):
+        return True
+          
+    def elementType(self):
+        return self.element_type
+    
+    def arrayRank(self):
+        return self.rank
+    
+    def __eq__(self, rhs):
+        if (hasattr(rhs, "elementType") and hasattr(rhs, "arrayRank")):
+            return ((self.elementType() == rhs.elementType())
+                    and (self.arrayRank() == rhs.arrayRank()))
+        else:
+            return False
+        
+    def __ne__(self, rhs):
+        return not (self == rhs)
+    
+    def isDefined(self):
+        return self.element_type is not None and self.rank is not None
+        
+    def __repr__(self):
+        rank_desc = ""
+        if rank is not None:
+            rank_desc = ";" + str(self.arrayRank())
+        return "Array[" + str(self.elementType()) + rank_desc + "]" 
+        
+class ByteArrayOwlType(ArrayOwlType):
+    "Array[Byte]"
+    
+    def __init__(self, rank=None):
+        super(ByteArrayOwlType, self).__init__(ByteOwlType(), rank)
+        
+class IntegerArrayOwlType(ArrayOwlType):
+    "Array[Integer]"
+    
+    def __init__(self, rank=None):
+        super(IntegerArrayOwlType, self).__init__(IntegerOwlType(), rank)
+   
+class FloatArrayOwlType(ArrayOwlType):
+    "Array[Integer]"
+    
+    def __init__(self, rank=None):
+        super(FloatArrayOwlType, self).__init__(FloatOwlType(), rank)
+
+class StringArrayOwlType(ArrayOwlType):
+    "Array[String]"
+    
+    def __init__(self, rank=None):
+        super(StringArrayOwlType, self).__init__(StringOwlType(), rank)
+
+class ObjectArrayOwlType(ArrayOwlType):
+    "Array[Object]"
+    
+    def __init__(self, rank=None):
+        super(ObjectArrayOwlType, self).__init__(ObjectOwlType(), rank)
+   

owl_basic/owltyping/typecheck.py

@@ -0,0 +1,60 @@
+'''
+Created on 5 Jan 2010
+
+@author: rjs
+'''
+
+import logging
+
+from owl_basic.syntax.ast import DefineFunction
+
+from .typecheck_visitor import TypecheckVisitor
+from .function_type_inferer import inferTypeOfFunction
+from .set_function_type_visitor import SetFunctionTypeVisitor
+from owl_basic.owltyping.type_system import PendingOwlType
+
+
+def typecheck(parse_tree, entry_points, options):
+    '''
+    :param parse_tree: The parse_tree to be type checked
+    :param entry_points: A dictionary of entry point names to AstStatements
+    :param options: Command line options.
+    '''
+    logging.debug("Type checking... ")
+    
+    # TODO: Need to iteratively resolve types here.
+    #       while (pending_types_remaining):
+    parse_tree.accept(TypecheckVisitor(entry_points))
+    pending = True
+    while pending:
+        pending = inferUserFunctionTypes(parse_tree, entry_points, options)  
+
+def inferUserFunctionTypes(parse_tree, entry_points, options):
+    """
+    Iteratively examine the return types of user defined function calls
+    and assign the actual type.
+    :returns: True if any function types are still pending, otherwise False.
+    """
+    logging.debug("Infer user function types")
+    pending = False
+    for entry_point in entry_points.values():
+        if isinstance(entry_point, DefineFunction):
+            function_type = inferTypeOfFunction(entry_point)
+            if function_type != PendingOwlType():
+                setFunctionType(parse_tree, entry_point.name, function_type)
+            else:
+                pending = True
+    return pending
+
+def setFunctionType(parse_tree, function_name, function_type):
+    '''
+    Given a function name such as 'FNx' set the actual type of all
+    calls to that function.
+    :param function_name: The name of a function including the FN prefix
+    :param type: The type to which the actualType of call should be set
+    '''
+    assert function_name.startswith('FN')
+    # TODO: Visit each function call and the the type of those that match
+    print("Setting type of %s to %s" % (function_name, function_type))
+    sftv = SetFunctionTypeVisitor(function_name, function_type)
+    parse_tree.accept(sftv)