owl-basic 0.6.0__py3-none-any.whl

owl_basic/gml_visitor.py

@@ -0,0 +1,151 @@
+# A visitor implementation that creates an XML representation of the control flow graph
+
+from owl_basic.visitor import Visitor
+from owl_basic.syntax.ast import If, OnGoto
+
+class GmlVisitor(Visitor):
+    """
+    AST visitor for converting the CFG into an XML representation in GraphML.
+    We traverse the AST rather than the CFG to output the graph. We can more reliably
+    visit all nodes, since we know the AST is a single connected component.
+    """
+    def __init__(self, filename, out_edges=True, in_edges=False, back_edges=True):
+        # .NET Framework
+        import clr
+        clr.AddReference('System.Xml')
+        from System.Xml import XmlTextWriter, Formatting
+        
+        self.out_edges = out_edges
+        self.in_edges  = in_edges
+        self.back_edges = back_edges
+        
+        self.writer = XmlTextWriter(filename, None)
+        
+        self.writer.Formatting = Formatting.Indented
+        self.writer.WriteComment("GraphML representation of the Control Flow Graph")
+
+        self.writer.WriteStartElement("graphml")
+        self.writer.WriteAttributeString("xmlns", "http://graphml.graphdrawing.org/xmlns")
+        self.writer.WriteAttributeString("xmlns", "xsi", None, "http://www.w3.org/2001/XMLSchema-instance")
+        self.writer.WriteAttributeString("xmlns", "y", None, "http://www.yworks.com/xml/graphml")
+        self.writer.WriteAttributeString("xsi", "schemaLocation", "http://graphml.graphdrawing.org/xmlns/graphml", "http://www.yworks.com/xml/schema/graphml/1.0/ygraphml.xsd")
+        
+        self.writer.WriteStartElement("key")
+        self.writer.WriteAttributeString("id", "d0")
+        self.writer.WriteAttributeString("for", "node")
+        self.writer.WriteAttributeString("yfiles.type", "nodegraphics")
+        self.writer.WriteEndElement() # key
+        
+        self.writer.WriteStartElement("key")
+        self.writer.WriteAttributeString("id", "d1")
+        self.writer.WriteAttributeString("for", "node")
+        self.writer.WriteAttributeString("attr.name", "description")
+        self.writer.WriteAttributeString("attr.type", "string")
+        self.writer.WriteEndElement() # key
+        
+        self.writer.WriteStartElement("key")
+        self.writer.WriteAttributeString("id", "d3")
+        self.writer.WriteAttributeString("for", "edge")
+        self.writer.WriteAttributeString("yfiles.type", "edgegraphics")
+        self.writer.WriteEndElement() # key
+        
+        self.writer.WriteStartElement("key")
+        self.writer.WriteAttributeString("id", "d4")
+        self.writer.WriteAttributeString("for", "graphml")
+        self.writer.WriteAttributeString("yfiles.type", "resources")
+        self.writer.WriteEndElement() # key
+        
+        self.writer.WriteStartElement("graph")
+        self.writer.WriteAttributeString("id", "CFG")
+        self.writer.WriteAttributeString("edgedefault", "directed")
+        
+    def close(self):
+        self.writer.WriteEndElement() # graph
+        self.writer.WriteEndElement() # graphml
+        self.writer.Flush()
+        self.writer.Close()
+
+    def visitAstNode(self, node):
+        node.forEachChild(self.visit)
+        
+    def visitAstStatement(self, node):
+        self.writer.WriteStartElement("node")
+        self.writer.WriteAttributeString("id", str(node.id))
+        
+        self.writer.WriteStartElement("data")
+        self.writer.WriteAttributeString("key", "d0") # Shape and label
+        self.writer.WriteStartElement("y:ShapeNode")
+        self.writer.WriteStartElement("y:NodeLabel")
+        self.writer.WriteString(str(node.lineNum) + ": "+ str(node.description) + ": " + ';'.join(node.entryPoints))
+        self.writer.WriteEndElement() # y:NodeLabel
+        self.writer.WriteStartElement("y:Shape")
+        if hasattr(node, "entryPoint"):
+            self.writer.WriteAttributeString("type", "hexagon")
+        elif isinstance(node, If) or isinstance(node, OnGoto):
+            self.writer.WriteAttributeString("type", "diamond")
+        else:    
+            self.writer.WriteAttributeString("type", "roundrectangle")
+        self.writer.WriteEndElement() # y:Shape
+        self.writer.WriteEndElement() # y:ShapeNode
+        self.writer.WriteEndElement()
+        
+        self.writer.WriteStartElement("data")
+        self.writer.WriteAttributeString("key", "d1") # description
+        self.writer.WriteString(node.description)
+        self.writer.WriteEndElement()
+        
+        self.writer.WriteEndElement() # node
+        
+        if self.out_edges:
+            for target in node.outEdges:
+                self.writer.WriteStartElement("edge")
+                self.writer.WriteAttributeString("source", str(node.id))
+                self.writer.WriteAttributeString("target", str(target.id))
+                self.writer.WriteStartElement("data")
+                self.writer.WriteAttributeString("key", "d3")
+                self.writer.WriteStartElement("y:PolyLineEdge")
+                self.writer.WriteStartElement("y:Arrows")
+                self.writer.WriteAttributeString("source", "none")
+                self.writer.WriteAttributeString("target", "standard")
+                self.writer.WriteEndElement() # y:Arrows
+                self.writer.WriteEndElement() # y:PolyLineEdge
+                self.writer.WriteEndElement() # data
+                self.writer.WriteEndElement() # edge
+        
+        if self.in_edges:
+            for source in node.inEdges:
+                self.writer.WriteStartElement("edge")
+                self.writer.WriteAttributeString("source", str(source.id))
+                self.writer.WriteAttributeString("target", str(node.id))
+                self.writer.WriteStartElement("data")
+                self.writer.WriteAttributeString("key", "d3")
+                self.writer.WriteStartElement("y:PolyLineEdge")
+                self.writer.WriteStartElement("y:Arrows")
+                self.writer.WriteAttributeString("source", "none")
+                self.writer.WriteAttributeString("target", "standard")
+                self.writer.WriteEndElement() # y:Arrows
+                self.writer.WriteEndElement() # y:PolyLineEdge
+                self.writer.WriteEndElement() # data
+                self.writer.WriteEndElement() # edge
+        
+        if self.back_edges:
+             for target in node.loopBackEdges:
+                self.writer.WriteStartElement("edge")
+                self.writer.WriteAttributeString("source", str(node.id))
+                self.writer.WriteAttributeString("target", str(target.id))
+                self.writer.WriteStartElement("data")
+                self.writer.WriteAttributeString("key", "d3")
+                self.writer.WriteStartElement("y:PolyLineEdge")
+                self.writer.WriteStartElement("y:Arrows")
+                self.writer.WriteAttributeString("source", "none")
+                self.writer.WriteAttributeString("target", "standard")
+                self.writer.WriteEndElement() # y:Arrows
+                self.writer.WriteEndElement() # y:PolyLineEdge
+                self.writer.WriteEndElement() # data
+                self.writer.WriteEndElement() # edge
+                
+        node.forEachChild(self.visit)
+            
+        
+        
+        

owl_basic/line_mapper.py

@@ -0,0 +1,43 @@
+class LineMapper(object):
+    def __init__(self, physical_to_logical_map, line_to_stmt_map):
+        self.physical_to_logical_map = physical_to_logical_map
+        self.line_to_stmt_map = line_to_stmt_map
+        
+    def physicalToLogical(self, physical_line_number):
+        if self.physical_to_logical_map is not None and physical_line_number is not None:
+            return self.physical_to_logical_map[physical_line_number]
+        else:
+            return physical_line_number
+    
+    def logicalToPhysical(self, logical_line_number):
+        if self.physical_to_logical_map is not None:
+            
+            return self.physical_to_logical_map.index(logical_line_number)
+        else:
+            return logical_line_number
+        
+    def logicalStatement(self, logical_line_number):
+        physical_line_number = self.logicalToPhysical(logical_line_number)
+        #print "physical_line_number = %s" % physical_line_number
+        if physical_line_number in self.line_to_stmt_map:
+            return self.line_to_stmt_map[physical_line_number]
+        return None
+    
+    def firstStatement(self):
+        statement_lines = sorted([line for line in self.line_to_stmt_map.keys() if line is not None])
+        #for s in statement_lines:
+        #    print "%s : %s" % (s, lnv.line_to_stmt[s])
+        first_statement_line = statement_lines[0]
+        #print "first_statement_line = %s" % first_statement_line
+        first_statement = self.line_to_stmt_map[first_statement_line]
+        return first_statement
+    
+    def statementOnLine(self, integer_node):
+        '''
+        :param integer_node: A LiteralInteger node containing a logical line number
+        :returns: The first AstStatement node on that logical source code line
+        '''
+        logical_line_number = integer_node.value
+        statement = self.logicalStatement(logical_line_number)
+        #print "logical_line_number = %d, statement = %s" % (logical_line_number, statement)
+        return statement

owl_basic/line_number_visitor.py

@@ -0,0 +1,65 @@
+from owl_basic.visitor import Visitor
+from owl_basic.ast_utils import *
+
+class LineNumberVisitor(Visitor):
+    """
+    This visitor builds a map from logical line numbers to the first statement
+    to appear on that line. It is used for resolving the targets of GOTO, GOSUB, etc.
+    """
+    
+    # TODO: This could be made into a much more useful in-order traversal visitor
+    
+    def __init__(self):
+        # TODO: This should locate its own root, finding it on demand
+        self.line_to_stmt = {}
+
+    def registerStatement(self, statement):
+        if statement.lineNum is not None:
+            line_num = statement.lineNum
+            #print "line_num = %s" % line_num
+            if line_num not in self.line_to_stmt:
+                #print line_num, " ===> ", statement
+                self.line_to_stmt[line_num] = statement
+
+    def firstStatementOnLine(self, line_number):
+        return self.line_to_stmt[line_number]
+            
+    def visitAstNode(self, node):
+        "Visit all children in order"
+        node.forEachChild(self.visit)
+                    
+    def visitAstStatement(self, statement):
+        self.registerStatement(statement)
+            
+    def visitIf(self, iff):
+        """
+        Process an IF statement. The true clause always precedes
+        the false clause so we process that first
+        """
+        self.registerStatement(iff)
+        
+        if iff.trueClause is not None:
+            if isinstance(iff.trueClause, list):
+                for node in iff.trueClause:
+                    self.visit(node)
+            else:
+                self.visit(iff.trueClause)
+       
+        if iff.falseClause is not None:
+            if isinstance(iff.falseClause, list):
+                for node in iff.falseClause:
+                    self.visit(node)
+            else:
+                self.visit(iff.falseClause)
+                   
+    # TODO: Need BASIC IV and BASIC V statements here.
+    
+    
+    
+    
+    
+    
+        
+        
+            
+        

owl_basic/main.py

@@ -0,0 +1,381 @@
+#!ipy
+
+import logging
+logging._srcfile = None
+logging.basicConfig(level=logging.DEBUG,
+                    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+# Python Standard Library
+import sys
+import os   
+import re
+import atexit
+import StringIO
+from optparse import OptionParser
+
+from owl_basic.decoder import decode
+from owl_basic.syntax import parser as syntax_parser
+from owl_basic import xml_visitor
+from owl_basic.source_debugging import SourceDebuggingVisitor
+from owl_basic import parent_visitor
+from owl_basic import separation_visitor
+from owl_basic import simplify_visitor
+from owl_basic import line_number_visitor
+from owl_basic.flow import locateEntryPoints
+from owl_basic.flow import createForwardControlFlowGraph
+from owl_basic.flow import convertLongjumpsToExceptions
+from owl_basic.flow import convertSubroutinesToProcedures
+from owl_basic.flow import identifyBasicBlocks
+from owl_basic.flow import orderBasicBlocks
+from owl_basic.owltyping.typecheck import typecheck
+from owl_basic import data_visitor
+from owl_basic import gml_visitor
+from owl_basic.xml_blocks import dumpXmlBlocks
+from owl_basic.line_mapper import LineMapper
+from owl_basic import symbol_table_visitor
+from owl_basic.symbol_tables import SymbolTable
+from owl_basic import correlation_visitor
+from owl_basic.algorithms import all_indices
+from owl_basic import process
+
+def readFile(filename):
+    logging.debug("readFile")
+    # Read the file - processing it for line numbers if necessary
+    f = open(filename, 'rb')
+    data = f.read()
+    f.close()
+    return data
+
+def detokenize(data, options):
+    logging.debug("detokenize")
+    if options.verbose:
+        sys.stderr.write("Detokenizing...")
+    
+    detokenized = StringIO.StringIO()
+    decode(data, detokenized)
+    if options.verbose:
+        sys.stderr.write("done\n")
+    
+    detokenHandle = StringIO.StringIO(detokenized.getvalue())
+    return detokenHandle
+
+def indexLineNumbers(detokenHandle, options):
+    logging.debug("indexLineNumbers")
+    if options.verbose:
+        sys.stderr.write("Mapping physical to logical line numbers... ")
+    
+    line_number_regex = re.compile(r'(\s*\d+\s*)(.*)') # TODO: Factor this out of here and decoder
+    physical_line = 0
+    logical_line = 0
+    physical_to_logical_map = []
+    line_bodies = []
+    line_number_prefixes = []
+    #line_offsets = [] # Offsets to the start of the line
+    while True:
+        #line_offsets.append(detokenHandle.tell())
+        line = detokenHandle.readline()
+        if not line:
+            break
+        m = line_number_regex.match(line)
+        if not m:
+            raise CompileException("Missing line number at physical line %d (after logical line %d)" % (physical_line, logical_line))
+        
+        logical_line_string = m.group(1)
+        logical_line = int(logical_line_string)
+        line_number_prefix_length = len(logical_line_string)
+        line_number_prefixes.append(line_number_prefix_length)
+        physical_to_logical_map.append(logical_line)
+        line_bodies.append(m.group(2))
+        physical_line += 1
+    
+    data = '\n'.join(line_bodies)
+    detokenHandle.close()
+    cr_indices = all_indices(data, '\n')
+    line_indices = [index + 1 for index in cr_indices]
+    line_offsets = [0]
+    line_offsets.extend(line_indices)
+    #for i, offset in enumerate(line_offsets):
+    #    print "%d ==> %s" % (i, data[offset:offset + 5])
+    #print data
+    return data, physical_to_logical_map, line_offsets , line_number_prefixes
+
+def warnOnMissingNewline(data):
+    logging.debug("warnOnMissingNewline")
+    if not data.endswith('\n'):
+        logging.warning("Missing newline at end of file")
+        data += '\n'  
+    return data
+
+def setSourceDebugging(data, line_offsets, line_number_prefixes, parse_tree):
+    logging.debug("Set source debugging")
+    # Read through the data and set character column information
+    sdv = SourceDebuggingVisitor(data, line_offsets, line_number_prefixes)
+    parse_tree.accept(sdv)
+
+def setParents(parse_tree, options):
+    logging.debug("setParents")
+    if options.verbose:
+        sys.stderr.write("Setting parents... ")
+    
+    parse_tree.accept(parent_visitor.ParentVisitor())
+    if options.verbose:
+        sys.stderr.write("done\n")
+
+def splitComplexNodes(parse_tree, options):
+    logging.debug("splitComplexNodes")
+    if options.verbose:
+        sys.stderr.write("Separating complex Abstract Syntax Tree nodes... ")
+    
+    parse_tree.accept(separation_visitor.SeparationVisitor())
+    if options.verbose:
+        sys.stderr.write("done\n")
+
+def simplifyAst(parse_tree, options):
+    logging.debug("simplifyAst")
+    if options.verbose:
+        sys.stderr.write("Simplifying Abstract Syntax Tree... ")
+    
+    parse_tree.accept(simplify_visitor.SimplificationVisitor())
+    if options.verbose:
+        sys.stderr.write("done\n")
+
+def createLineMapper(parse_tree, physical_to_logical_map):
+    logging.debug("createLineMapper")
+    lnv = line_number_visitor.LineNumberVisitor()
+    parse_tree.accept(lnv)
+    line_mapper = LineMapper(physical_to_logical_map, lnv.line_to_stmt)
+    return line_mapper
+
+def dumpXmlAst(parse_tree, output_filename, options):
+    logging.debug("dumpXmlAst")
+    if options.use_clr:
+        if options.verbose:
+            sys.stderr.write("Creating XML AST... ")
+        
+        xmlAst(parse_tree, output_filename)
+        if options.verbose:
+            sys.stderr.write("done\n")
+           
+def correlateLoops(entry_points, options):
+    logging.debug("correlateLoops")
+    if options.verbose:
+        sys.stderr.write("Correlate opening and closing loop constructs")
+
+    for entry_point in entry_points.values():
+        # Depth first search from this entry point through the CFG
+        # maintaining a stack of loops as we go. Mark nodes that we
+        cv = correlation_visitor.CorrelationVisitor()
+        cv.start(entry_point)
+        
+def buildSymbolTables(entry_points, options):
+    logging.debug("buildSymbolTables")    
+    # Attach symbol tables to each statement
+    if options.verbose:
+        sys.stderr.write("Building symbol tables")
+    
+    stv = symbol_table_visitor.SymbolTableVisitor()
+    
+    # Set the global symbol table for the main program entry point, if there is one
+    if '__owl__main' in entry_points:
+        entry_points['__owl__main'].symbolTable = stv.globalSymbols
+    
+    for entry_point in entry_points.values():
+        entry_point.accept(stv)
+    
+    for table in SymbolTable.symbol_tables:
+        title = "Symbol table '%s'" % table.name
+        if table.parent is not None:
+            parent_title = " with parent '%s'" % table.parent.name
+        else:
+            parent_title = "is the root symbol table"
+        width = max(len(title), len(parent_title))
+        print("-" * width)
+        print(title)
+        print(parent_title)
+        print("-" * width)
+        
+        symbols = table.symbols.keys()
+        symbols.sort()
+        for symbol in symbols:
+            print("%-10s %-10s %s" % (symbol, table.symbols[symbol].type.__doc__, table.symbols[symbol].modifier))
+        print("-" * width)
+        print()
+    return stv
+            
+def extractData(parse_tree, options):
+    """
+    Extract all information from DATA statements
+    """
+    # All DATA is stored as strings, and is converted at run-time by the
+    # READ statement
+    logging.debug("extracting DATA")
+    dv = data_visitor.DataVisitor()
+    parse_tree.accept(dv)
+    return dv   
+    
+def dumpXmlCfg(parse_tree, filename, options):
+    logging.debug("dumpXmlCfg")   
+    if options.use_clr:
+        if options.verbose:
+            sys.stderr.write("Creating XML CFG... ")
+        xmlCfg(parse_tree, filename)
+        if options.verbose:
+            sys.stderr.write("done\n") 
+
+def xmlAst(tree, filename):
+    xmlv = xml_visitor.XmlVisitor(filename)
+    tree.accept(xmlv)
+    xmlv.close()
+    
+def xmlCfg(tree, filename):
+    gmlv = gml_visitor.GmlVisitor(filename)
+    tree.accept(gmlv)
+    gmlv.close()
+
+class Usage(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+
+class CompileException(Exception):
+    def __init__(self, msg):
+        self.msg = msg
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
+    try:
+        usage = "usage: %prog [options] source-file"
+        version = "%prog 0.5"
+        parser = OptionParser(usage=usage, version=version)
+        parser.add_option("-x", "--debug-lex", action='store_true', dest='debug_lex', default=False)
+        parser.add_option("-c", "--debug-no-clr", action='store_false', dest='use_clr', default=(sys.platform == 'cli'))
+        parser.add_option("-v", "--verbose", action='store_true', dest='verbose', default=False)
+        parser.add_option("-i", "--il", action='store_true', dest='create_il', default=False)
+        parser.add_option("-p", "--peverify", action='store_true', dest='peverify', default=False)
+
+        (options, args) = parser.parse_args()
+        if len(args) != 1:
+            parser.error("No source file name supplied")
+        compile(args[0], options)
+    except Usage as err:
+        parser.err(err.msg)
+        return 2
+    except CompileException as err:
+        print(err.msg, file=sys.stderr)
+        return 1
+ 
+def compile(filename, options):   
+    if options.use_clr:
+        # .NET Framework
+        import clr
+        clr.AddReference('System.Xml')
+        from System.Xml import XmlTextWriter, Formatting
+    
+    if not options.use_clr:
+        # TODO: Use non-recursive code for the flowgraph
+        sys.setrecursionlimit(2000)
+    
+    data = readFile(filename)
+    detokenHandle = detokenize(data, options)
+    data, physical_to_logical_map, line_offsets, line_number_prefixes = indexLineNumbers(detokenHandle, options)
+    data = warnOnMissingNewline(data)
+
+    parse_tree = syntax_parser.parse(data, options)
+    setSourceDebugging(data, line_offsets, line_number_prefixes, parse_tree)
+    setParents(parse_tree, options)
+    splitComplexNodes(parse_tree, options)
+    simplifyAst(parse_tree, options)
+    line_mapper = createLineMapper(parse_tree, physical_to_logical_map)
+    dv = extractData(parse_tree, options)
+    createForwardControlFlowGraph(parse_tree, line_mapper, options)
+    entry_points = locateEntryPoints(parse_tree, line_mapper, options)  
+    convertLongjumpsToExceptions(parse_tree, line_mapper, options)
+    convertSubroutinesToProcedures(parse_tree, entry_points, line_mapper, options)
+    correlateLoops(entry_points, options)
+    basic_blocks = identifyBasicBlocks(entry_points, options)
+    ordered_basic_blocks = orderBasicBlocks(basic_blocks, options)
+    typecheck(parse_tree, entry_points, options)
+    # Array visitor - rewrite array expressions
+    stv = buildSymbolTables(entry_points, options)
+    
+    dumpXmlAst(parse_tree, filename + "_ast.xml", options)
+    dumpXmlCfg(parse_tree, filename + "_cfg.graphml", options)
+    dumpXmlBlocks(basic_blocks, filename + "_blocks.graphml", options)
+
+    output_name = os.path.splitext(os.path.basename(filename))[0]
+    source_path = os.path.abspath(filename)
+
+    if options.use_clr:
+        from owl_basic.codegen.clr.generate import AssemblyGenerator
+        ag = AssemblyGenerator(line_mapper)
+        exe_filename = ag.generateAssembly(source_path, output_name, stv.globalSymbols, dv, ordered_basic_blocks)
+        if options.peverify:
+            # Run PEVerify on the resulting executable
+            logging.debug("Verifying")
+            peverify_exe = r'C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\PEVerify.exe'
+            process.execute(peverify_exe, exe_filename)
+        if options.create_il:
+            # Create debuggable CIL files by disassebling and reassembling the
+            # executable
+            # Run ILDASM on the produced file
+            logging.debug("Disassembling to CIL")
+
+            ildasm_exe = r"C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\x64\ildasm.exe"
+            logging.debug("ILDAsm.exe  from %s", ildasm_exe)
+            il_filename = exe_filename[:-3] + 'il'
+            process.execute(ildasm_exe, '/OUT=%s' % il_filename, exe_filename)
+            
+            logging.debug("Reassembling with CIL debug info")
+            clr.AddReference("Microsoft.Build.Utilities")
+            from Microsoft.Build.Utilities import ToolLocationHelper, TargetDotNetFrameworkVersion
+            ilasm_exe = ToolLocationHelper.GetPathToDotNetFrameworkFile("ILAsm.exe", TargetDotNetFrameworkVersion.VersionLatest)
+            logging.debug("ILAsm.exe  from %s", ilasm_exe)
+            process.execute(ilasm_exe, '/EXE', '/DEBUG', il_filename)
+                                      
+    # Structural analysis
+
+    #splitBasicBlock(parse_tree)
+
+    # Type checking and casting
+    # Have we finished type-checking?
+    # == Optimisation ==
+    # Remove basic blocks containing only GOTO. Is this the same as replacing all GOTOs
+    #  with edges in the CFG?
+    # constant folding
+    # constant propagation
+    # Note - during constant propagation we can
+    # eliminate some redundant casts by changing the
+    # type of the constant at compile time
+    # for example A = 5 can become A = 5.0 and
+    # A% = 6.0 can become A% = 6
+    # String Concatenation using the different forms
+    # of String.Concat
+    # eliminate locals
+    # static single assignment form
+    # TODO: Inline single-entry GOSUB
+    # Optimise by combining conditions and branches better
+    # rather than relying on Brtrue and Brfalse.  
+    #
+    # Trace back from RETURN statements - if only one
+    # GOSUB is reached - move the code in the GOSUB to the call site
+    # of the GOSUB
+    # Locate nodes with no inbound edges and trace unreachable code
+    # from them. Remove unreachable code from the CFG and the AST. This
+    # will need to be traced from program and procedure entry points
+        
+    # TODO: Replace Goto -> ReturnFromProcedure with ReturnFromProcedure
+    #elimiateCommonSubexpressions(parse_tree    opti
+
+
+
+def printProfile():
+    import clr
+    for p in sorted(clr.GetProfilerData(), key=lambda p: p.ExclusiveTime):
+        print('%s\t%d\t%d\t%d' % (p.Name, p.InclusiveTime, p.ExclusiveTime, p.Calls))
+
+
+if __name__ == "__main__":
+    import clr
+    clr.EnableProfiler(False)
+    atexit.register(printProfile)
+    sys.exit(main())

owl_basic/node.py

@@ -0,0 +1,21 @@
+class Node(object):
+    def __init__(self, nodeType=None, formalType=None, description="A parameter"):
+        self._node_type = nodeType
+        self._formal_type = formalType
+        self._description = description
+    
+    def _getNodeType(self):
+        return self._node_type
+    
+    nodeType = property(_getNodeType)
+        
+    def _getFormalType(self):
+        return self._formal_type
+    
+    formalType = property(_getFormalType)
+    
+    def _getDescription(self):
+        return self._description
+    
+    description = property(_getDescription)
+  

owl_basic/options.py

@@ -0,0 +1,22 @@
+class Option(object):
+    pass
+
+class BoolOption(Option):
+    def __init__(self, default=None):
+        self.value = default
+        
+class IntegerOption(Option):
+    def __init__(self, default=None):
+        self.value = default
+
+class FloatOption(Option):
+    def __init__(self, default=None):
+        self.value = default
+
+class StringOption(Option):
+    def __init__(self, default=None):
+        self.value = default
+
+class TypeOption(Option):
+    def __init__(self, default=None):
+        self.value = default

owl_basic/owltyping/__init__.py

@@ -0,0 +1 @@
+