owl-basic 0.6.0__py3-none-any.whl

owl_basic/__init__.py

@@ -0,0 +1,3 @@
+"""OWL BASIC — a BBC BASIC compiler for the .NET CLR with pluggable backends."""
+
+__version__ = "0.6.0"

owl_basic/algorithms.py

@@ -0,0 +1,29 @@
+def all_equal(vals):
+    '''
+    Check if all elements of a list are equal.
+    :param vals: a sequence of items
+    '''
+    if vals:
+        i = iter(vals)
+        first = i.next()
+        for item in i:
+            if first != item:
+                return False
+    return True
+    
+def representative(s):
+	'''
+	Return an arbitrary value from the set s
+	:param s: A set
+	:returns: A representative value from s
+	'''
+	return iter(s).next()
+
+def all_indices(string, sub, listindex=[], offset=0):
+    # call as l = allindices(string, sub)
+    # http://code.activestate.com/recipes/499314-find-all-indices-of-a-substring-in-a-given-string/
+    i = string.find(sub, offset)
+    while i >= 0:
+        listindex.append(i)
+        i = string.find(sub, i + 1)
+    return listindex

owl_basic/ast_utils.py

@@ -0,0 +1,204 @@
+import logging
+from owl_basic import errors
+from owl_basic.utility import camelCaseToUnderscores
+
+def elideNode(node, liftFormalTypes=False):
+    """
+    Removes a node from the AST, assigning the contents of its only attribute
+    attribute to the owning attribute, thereby simplifying the AST structure. If
+    liftFormalTypes is true, the formal type of the child is propagates to the
+    new owner of the data.
+    """
+    # TODO: Refactor! D.R.Y.
+    assert len(node.child_infos) == 1
+    #print node
+    #print node.child_infos
+    if isinstance(node.child_infos.values()[0], list):
+        prop = node.child_infos.keys()[0] # TODO: Rename list_property
+        #print prop
+        
+        for item in getattr(node, prop):
+            if item is not None:
+                item.parent = node.parent
+                item.parent_property = node.parent_property
+                # Note: item.parent_index remains unchanged
+    else:
+        prop = node.child_infos.keys()[0]
+        assert not isinstance(prop, list)
+        item = getattr(node, prop)
+        if item is not None:
+            item.parent = node.parent
+            item.parent_property = node.parent_property
+            # Note: item.parent_index remains unchanged
+    assert hasattr(node.parent, node.parent_property)
+    if liftFormalTypes:
+        node.parent.child_infos[camelCaseToUnderscores(node.parent_property)] = node.child_infos[prop]
+    node.parent.setProperty(getattr(node, prop), node.parent_property)
+    
+def findFollowingStatement(statement):
+    """
+    Given a statement, locates the following statement or None
+    """
+    if statement.parent is None:
+        return None
+
+    if statement.parent_index is None:
+        return None
+    
+    parent_list = getattr(statement.parent, statement.parent_property)
+    
+    if isinstance(parent_list, list):
+        logging.debug("statement.parent_index = %s", statement.parent_index)
+        if statement.parent_index < (len(parent_list) - 1):
+            return parent_list[statement.parent_index + 1]
+    
+    return findFollowingStatement(statement.parent)
+
+def findRoot(node):
+    """
+    Given an AST node find the root node of the AST.
+    """
+    n = node
+    while n.parent is not None:
+        n = n.parent
+    return n
+
+def findNode(node, predicate):
+    """
+    Given an AST node, search up the tree until a node matching the
+    predicate function is found. Returns the Node or None
+    """
+    n = node
+    while n is not None:
+        if predicate(n):
+            return n
+        n = n.parent
+    return None
+
+def insertStatementBefore(statement, target):
+    """
+    Insert target before statement in the AST, and correct the AST and CFG references to match
+    """
+    # TODO: Does this need to correct incoming GOTOs or is that handled by adjusting the AST edges
+    
+    if statement.parent is None:
+        errors.fatalError("Cannot insert statement before %s at line %s" % (statement, statement.lineNum))
+    
+    parent_list = getattr(statement.parent, statement.parent_property)
+    
+    if isinstance(parent_list, list):
+        parent_list.insert(statement.parent_index, target)
+        target.parent = statement.parent
+        target.parent_property = statement.parent_property
+        target.parent_index = statement.parent_index
+        statement.parent_index += 1
+                  
+    else:
+        errors.fatalError("Cannot insert statement into non-list %s at line %s" % (statement, statement.lineNum))
+        return
+        
+    # Reconnect CFG
+    for prior_stmt in statement.inEdges:
+        assert statement in prior_stmt.outEdges
+        prior_stmt.outEdges.remove(statement)
+        prior_stmt.outEdges.add(target)
+        target.inEdges.add(prior_stmt)
+    
+    statement.clearInEdges()    
+    statement.addInEdge(target)
+    
+    target.clearOutEdges()
+    target.addOutEdge(statement)
+
+def insertStatementAfter(statement, target):
+    """
+    Insert target after statement in the AST, and correct the AST and CFG references to match
+    """
+    # TODO: Does this need to correct incoming GOTOs or is that handled by adjusting the AST edges
+    
+    if statement.parent is None:
+        errors.fatalError("Cannot insert statement before %s at line %s" % (statement, statement.lineNum))
+    
+    parent_list = getattr(statement.parent, statement.parent_property)
+    
+    if isinstance(parent_list, list):
+        target_index = statement.parent_index + 1
+        parent_list.insert(target_index, target)
+        target.parent = statement.parent
+        target.parent_property = statement.parent_property
+        target.parent_index = target_index
+                  
+    else:
+        errors.fatalError("Cannot insert statement into non-list %s at line %s" % (statement, statement.lineNum))
+        return
+            
+    # Reconnect CFG
+    for next_stmt in statement.outEdges:
+        assert statement in next_stmt.inEdges
+        next_statement.inEdges.remove(statement)
+        next_statement.inEdges.add(target)
+        target.outEdges.add(next_stmt)
+        
+    statement.clearOutEdges()
+    statement.addOutEdge(target)
+    
+    target.clearInEdges()
+    target.addInEdge(statement)
+
+def removeStatement(statement):
+    """
+    Remove the statement from the AST
+    """
+    if statement.parent is None:
+        errors.fatalError("Cannot remove statement %s at line %s" % (statement, statement.lineNum))
+        
+    # Remove from the parent list
+    parent_list = getattr(statement.parent, statement.parent_property)
+    parent_list.remove(statement)
+    
+    # Reconnect CFG
+    for prior_stmt in statement.inEdges:
+        assert statement in prior_stmt.outEdges
+        prior_stmt.outEdges.remove(statement)
+        prior_stmt.outEdges.update(statement.outEdges)
+        
+    for next_stmt in statement.outEdges:
+        assert statement in next_stmt.inEdges
+        next_stmt.inEdges.remove(statement)
+        next_stmt.inEdges.update(statement.inEdges)
+
+    statement.clearInEdges()
+    statement.clearOutEdges()
+
+def replaceStatement(old, new):
+    '''
+    Replace old with new in the AST and CFG
+    '''
+    insertStatementBefore(old, new)
+    removeStatement(old)
+
+def deParentNode(node):
+    '''
+    Disconnect a node from its parent
+    :returns: The node  
+    '''
+    raise "Not implemented"
+    
+def parentNode(node, parent, parent_property):
+    '''
+    Parent a node the the given property
+    '''
+    raise "Not implemented"
+    
+def reParentnode(node, new_parent, parent_property=None):
+    '''
+    :param node: The node to be reparented
+    :param new_parent: The new parent for node
+    :paraent_property: The property of the parent to which the node will be attached. If not
+                       supplied this will use the parent_property as the original parent.
+    '''
+    if parent_property is None:
+        parent_property = node.parent_property
+        
+    deParentNode(node)
+    parentNode(node, new_parent, parent_property)

owl_basic/basic_visitor.py

@@ -0,0 +1,55 @@
+from owl_basic.visitor import Visitor
+
+class BasicVisitor(Visitor):
+    """
+    AST visitor for converting the AST into back into OWL BASIC.
+    """
+    def __init__(self):
+        pass
+        
+    def visitLiteralInteger(self, integer):
+        sys.stdout.write(str(integer.value))
+        
+    def visitCircle(self, circle):
+        sys.stdout.write("CIRCLE ")
+        if circle.fill:
+            sys.stdout.write("FILL ")
+        self.visit(circle.xCoord)
+        sys.stdout.write(", ")
+        self.visit(circle.yCoord)
+        sys.stdout.write(", ")
+        self.visit(circle.radius)
+        sys.stdout.write('\n')
+        
+    def visitMidStrFunc(self, mid_str_func):
+        sys.stdout.write("MID$(")
+        self.visit(mid_str_func.source)
+        sys.stdout.write(", ")
+        self.visit(mid_str_func.position)
+        if mid_str_func.length is not None:
+            sys.stdout.write(", ")
+            self.visit(mid_str_func.length)
+        sys.stdout.write(")")
+        
+    def visitTrueFunc(self, true_func):
+        sys.stdout.write("TRUE ")
+
+    def visitAcsFunc(self, acs_func):
+        sys.stdout.write("ACS ")
+        
+    def visitAdvalFunc(self, adval_func):
+        sys.stdout.write("ADVAL ")
+        sys.stdout.write(adval_func.factor)
+        
+    def visitAsnFunc(self, Asn_func):
+        sys.stdout.write("ASN ")
+
+    def visitAtnFunc(self, atn_func):
+        sys.stdout.write("ATN ")
+
+    def visitStrStringFunc(self, str_string_func):
+        sys.stdout.write("STR$")
+        if str_string_func.base == 16:
+            sys.stdout.write("~")
+        self.visit(str_string_func.factor)
+        

owl_basic/cfg_vertex.py

@@ -0,0 +1,65 @@
+# Control Flow Graph Node
+
+class CfgVertex(object):
+    __counter = 0
+    
+    def __init__(self):
+        self.__in_edges  = set()
+        self.__out_edges = set()
+        self.__come_from_gosub_edges = set()
+        self.__loop_back_edges = set()
+        self.__loop_from_edges = set()
+        self.__entry_points = set()
+        
+        CfgVertex.__counter += 1
+        self.__id = CfgVertex.__counter
+        
+        self.block = None
+        
+    id                 = property(lambda self: self.__id)  
+    inEdges            = property(lambda self: self.__in_edges)
+    outEdges           = property(lambda self: self.__out_edges)
+    comeFromGosubEdges = property(lambda self: self.__come_from_gosub_edges)
+    loopBackEdges      = property(lambda self: self.__loop_back_edges)
+    loopFromEdges      = property(lambda self: self.__loop_from_edges)
+    entryPoints        = property(lambda self: self.__entry_points)
+    
+    def clearInEdges(self):
+        self.__in_edges = set()
+    
+    def clearOutEdges(self):
+        self.__out_edges = set()
+    
+    def clearComeFromGosubEdges(self):
+        self.__come_from_gosub_edges = set()
+    
+    def clearLoopBackEdges(self):
+        self.__loop_back_edges = set()
+        
+    def clearLoopFromEdges(self):
+        self.__loop_from_edges = set()
+    
+    def clearEntryPoints(self):
+        self.__entry_points.clear()
+        
+    def addInEdge(self, from_vertex):
+        self.inEdges.add(from_vertex)
+        
+    def addOutEdge(self, to_vertex):
+        self.outEdges.add(to_vertex)
+        
+    def addComeFromGosubEdge(self, from_vertex):
+        self.comeFromGosubEdges.add(from_vertex)
+    
+    def addLoopBackEdge(self, to_vertex):
+        self.loopBackEdges.add(to_vertex)
+        
+    def addLoopFromEdge(self, to_vertex):
+        self.loopFromEdges.add(to_vertex)
+        
+    def addEntryPoint(self, name):
+        self.entryPoints.add(name)
+        
+    inDegree  = property(lambda self: len(self.inEdges) + len(self.comeFromGosubEdges) + len(self.loopFromEdges))
+    outDegree = property(lambda self: len(self.outEdges) + len(self.loopBackEdges))
+