owl-basic 0.6.0__py3-none-any.whl

owl_basic/syntax/parser.py

@@ -0,0 +1,77 @@
+import sys
+import logging
+
+import ply.lex as lex
+import ply.yacc as yacc
+
+from . import grammar
+from . import lexer
+
+__author__ = 'rjs'
+
+def buildLexer(options):
+    logging.debug("buildLexer")
+    if options.verbose:
+        sys.stderr.write("Building lexer...")
+    # Build the lexer and parser
+
+    lx = lex.lex(lexer)
+    if options.verbose:
+        sys.stderr.write("done\n")
+
+    return lx
+
+def tokenize(data, lexer):
+    '''Lex the data and exit.
+
+    Args:
+        data: The data to be lexed.
+        lexer: The lexer instance to do the lexing.
+    '''
+    # Give the lexer some input
+    lexer.input(data)
+
+    # Tokenize
+    while 1:
+        tok = lexer.token()
+        if not tok: break      # No more input
+        print(tok)
+    # Running the lexer twice on the same input screws up the line numbers, so stop here.
+    sys.exit(0) 
+
+# The LALR tables are expensive to build but identical for every parse, so the
+# parser is constructed once and cached. write_tables=False keeps construction
+# entirely in memory: when owl_basic is installed as a wheel the grammar module
+# lives in a possibly read-only site-packages, where writing parsetab/parser.out
+# would either fail or litter the install.
+_basic_parser = None
+
+def buildParser(options):
+    logging.debug("buildParser")
+    global _basic_parser
+    if _basic_parser is None:
+        if options.verbose:
+            sys.stderr.write("Building parser... ")
+        _basic_parser = yacc.yacc(module=grammar, write_tables=False, debug=False)
+        if options.verbose:
+            sys.stderr.write("done\n")
+
+    return _basic_parser
+
+def parse(data, options):
+    logging.debug("parse")
+    if options.verbose:
+        sys.stderr.write("Parsing...")
+
+    lexer = buildLexer(options)
+
+    if options.debug_lex:
+        tokenize(data, lexer)
+
+    parser = buildParser(options)
+
+    parse_tree = parser.parse(data, lexer=lexer, tracking=True)
+    if options.verbose:
+        sys.stderr.write("done\n")
+
+    return parse_tree

owl_basic/utility.py

@@ -0,0 +1,26 @@
+# Miscellaneous utility functions
+
+import re
+
+def underscoresToCamelCase(s):
+    "Converts 'text_separated_like_this' to 'textSeparatedLikeThis'"
+    t = s.replace('_', ' ').title().replace(' ', '')
+    u = t[0].lower() + t[1:]
+    return u
+
+def camelCaseToUnderscores(s):
+    "Converts 'textSeparatedLikeThis' to 'text_separated_like_this'"
+    return re.sub(r'([a-z])([A-Z])', r'\1_\2', s).lower()
+
+def hasprop(cls, name):
+    "Determines whether the supplied object has a property called 'name'"
+    (name in cls.__dict__ and isinstance(cls.__dict__[name], property))
+    
+    if name in cls.__dict__:
+        return isinstance(cls.__dict__[name], property)
+    for base in cls.__bases__:
+        if hasprop(base, name):
+            return True
+    return False
+    
+        

owl_basic/visitor.py

@@ -0,0 +1,43 @@
+# The Visitor base class
+
+class Visitor(object):
+    """
+    A base visitor class
+    """
+    
+    def visit(self, node):
+        """
+        Visits a given node by telling the node to call this Visitor's
+        class-specific visitor method. No-op if node is None.
+        """
+        if node is not None:
+            return node.accept(self)
+
+class Visitable(object):
+    """
+    A mixin for classes which are visitable
+    """    
+    def accept(self, visitor):
+        """
+        Accept method for visitor pattern.
+        """
+        return self._accept(self.__class__, visitor)
+    
+    def _accept(self, klass, visitor):
+        """
+        Recursive accept implementation that calls the right visitor
+        method 'overloaded' for the type of AstNode. This is done by
+        appending the class name to 'visit' so if the class name is AstNode
+        the method called is visitor.visitAstNode. If a method of that name
+        does not exist, then it recursively attempts to call the visitor
+        method on the superclass.
+        """
+        visitor_method = getattr(visitor, "visit%s" % klass.__name__, None)
+        if visitor_method is None:
+            bases = klass.__bases__
+            last = None
+            for i in bases:
+                last = self._accept(i, visitor)
+            return last
+        else:
+            return visitor_method(self)

owl_basic/xml_blocks.py

@@ -0,0 +1,137 @@
+from itertools import chain
+
+from owl_basic.syntax.ast import If, OnGoto
+from owl_basic.flow.traversal import depthFirstSearch
+
+def dumpXmlBlocks(basic_blocks, filename, options):
+    import clr
+    clr.AddReference('System.Xml')
+    from System.Xml import XmlTextWriter, Formatting
+    
+    writer = XmlTextWriter(filename, None)
+    writer.Formatting = Formatting.Indented
+    writeHeader(writer)
+    
+    print(basic_blocks)
+    
+    for entry_block in basic_blocks.values():
+        for block in depthFirstSearch(entry_block):
+            writeBlock(writer, block)
+        
+    for entry_block in basic_blocks.values():
+        for block in depthFirstSearch(entry_block):    
+            for statement in block.statements:
+                writeStatementEdges(writer, statement)   
+        
+    writeFooter(writer)
+      
+def writeHeader(writer):
+    writer.WriteComment("GraphML representation of the Basic Block Graph")
+
+    writer.WriteStartElement("graphml")
+    writer.WriteAttributeString("xmlns", "http://graphml.graphdrawing.org/xmlns")
+    writer.WriteAttributeString("xmlns", "xsi", None, "http://www.w3.org/2001/XMLSchema-instance")
+    writer.WriteAttributeString("xmlns", "y", None, "http://www.yworks.com/xml/graphml")
+    writer.WriteAttributeString("xsi", "schemaLocation", "http://graphml.graphdrawing.org/xmlns/graphml", "http://www.yworks.com/xml/schema/graphml/1.0/ygraphml.xsd")
+    
+    writer.WriteStartElement("key")
+    writer.WriteAttributeString("id", "d0")
+    writer.WriteAttributeString("for", "node")
+    writer.WriteAttributeString("yfiles.type", "nodegraphics")
+    writer.WriteEndElement() # key
+    
+    writer.WriteStartElement("key")
+    writer.WriteAttributeString("id", "d1")
+    writer.WriteAttributeString("for", "node")
+    writer.WriteAttributeString("attr.name", "description")
+    writer.WriteAttributeString("attr.type", "string")
+    writer.WriteEndElement() # key
+    
+    writer.WriteStartElement("key")
+    writer.WriteAttributeString("id", "d3")
+    writer.WriteAttributeString("for", "edge")
+    writer.WriteAttributeString("yfiles.type", "edgegraphics")
+    writer.WriteEndElement() # key
+    
+    writer.WriteStartElement("key")
+    writer.WriteAttributeString("id", "d4")
+    writer.WriteAttributeString("for", "graphml")
+    writer.WriteAttributeString("yfiles.type", "resources")
+    writer.WriteEndElement() # key
+    
+    writer.WriteStartElement("graph")
+    writer.WriteAttributeString("id", "CFG")
+    writer.WriteAttributeString("edgedefault", "directed")
+
+def writeBlock(writer, block):
+    writer.WriteStartElement("node")
+    writer.WriteAttributeString("id", str(block.id))
+    
+    writer.WriteStartElement("data")
+    writer.WriteAttributeString("key", "d0") # Shape and label
+    writer.WriteStartElement("y:ShapeNode")
+    writer.WriteStartElement("y:NodeLabel")
+    writer.WriteString(str(block.topological_order))
+    writer.WriteEndElement() # y:NodeLabel
+    writer.WriteEndElement() # y:ShapeNode
+    writer.WriteEndElement() # data
+        
+    writer.WriteStartElement("graph")
+    writer.WriteAttributeString("edgedefault", "directed")
+    
+    for statement in block.statements:
+        writeStatementNode(writer, statement)
+    
+    writer.WriteEndElement() # graph  
+    writer.WriteEndElement() # node
+    
+def writeStatementNode(writer, statement):
+    writer.WriteStartElement("node")
+    writer.WriteAttributeString("id", str(statement.block.id) + '::' + str(statement.id))
+    
+    writer.WriteStartElement("data")
+    writer.WriteAttributeString("key", "d0") # Shape and label
+    writer.WriteStartElement("y:ShapeNode")
+    writer.WriteStartElement("y:NodeLabel")
+    writer.WriteString(str(statement.lineNum) + ": "+ str(statement.description))
+    writer.WriteEndElement() # y:NodeLabel
+    writer.WriteStartElement("y:Shape")
+    if hasattr(statement, "entryPoint"):
+        writer.WriteAttributeString("type", "hexagon")
+    elif isinstance(statement, If) or isinstance(statement, OnGoto):
+        writer.WriteAttributeString("type", "diamond")
+    else:    
+        writer.WriteAttributeString("type", "roundrectangle")
+    writer.WriteEndElement() # y:Shape
+    writer.WriteEndElement() # y:ShapeNode
+    writer.WriteEndElement()
+    
+    writer.WriteStartElement("data")
+    writer.WriteAttributeString("key", "d1") # description
+    writer.WriteString(statement.description)
+    writer.WriteEndElement()
+        
+    writer.WriteEndElement() # node
+
+def writeStatementEdges(writer, statement):
+    for target in chain(statement.outEdges, statement.loopBackEdges):
+        writer.WriteStartElement("edge")
+        writer.WriteAttributeString("source", str(statement.block.id) + '::' + str(statement.id))
+        writer.WriteAttributeString("target", str(target.block.id) + '::' + str(target.id))
+        writer.WriteStartElement("data")
+        writer.WriteAttributeString("key", "d3")
+        writer.WriteStartElement("y:PolyLineEdge")
+        writer.WriteStartElement("y:Arrows")
+        writer.WriteAttributeString("source", "none")
+        writer.WriteAttributeString("target", "standard")
+        writer.WriteEndElement() # y:Arrows
+        writer.WriteEndElement() # y:PolyLineEdge
+        writer.WriteEndElement() # data
+        writer.WriteEndElement() # edge
+    
+def writeFooter(writer):
+    writer.WriteEndElement() # graph
+    writer.WriteEndElement() # graphml
+    writer.Flush()
+    writer.Close()
+     

owl_basic/xml_visitor.py

@@ -0,0 +1,101 @@
+# A visitor implementation that creates an XML representation of the abstract syntax tree
+
+from owl_basic.visitor import Visitor
+
+class XmlVisitor(Visitor):
+    """
+    AST visitor for converting the AST into an XML representation.
+    """
+    def __init__(self, filename):
+        # .NET Framework
+        import clr
+        clr.AddReference('System.Xml')
+        from System.Xml import XmlTextWriter, Formatting
+        
+        self.writer = XmlTextWriter(filename, None)
+        self.writer.Formatting = Formatting.Indented
+        self.writer.WriteComment("XML Parse Tree")
+        
+    def close(self):
+        self.writer.Flush()
+        self.writer.Close()
+
+    def beginElement(self, node):
+        name = node.__class__.__name__
+        self.writer.WriteStartElement(name)
+        
+    def endElement(self):
+        self.writer.WriteEndElement()
+    
+    def childElement(self, name, node):
+        self.writer.WriteStartElement(name)
+        if node is None:
+            self.childNoneElement()
+        else:
+            self.visit(node)
+        self.writer.WriteEndElement()
+    
+    def childNodeElement(self, name, node):
+        self.writer.WriteStartElement(name)
+        if node is None:
+            self.childNoneElement()
+        else:
+            if name in node.parent.child_infos:
+                #print "node = %s, name = %s" % (node, name)
+                #print "node.parent.child_infos = %s" % str(node.parent.child_infos)
+                # TODO: Next if is temporary
+                if not isinstance(node.parent.child_infos[name], list):
+                    if node.parent.child_infos[name].nodeType is not None:
+                        self.childAttribute("node_type", str(node.parent.child_infos[name].nodeType))
+                    if node.parent.child_infos[name].formalType is not None:
+                        self.childAttribute("formal_type", str(node.parent.child_infos[name].formalType))
+            self.visit(node)
+        self.writer.WriteEndElement()
+    
+    def childListElement(self, name, nodes):
+        self.writer.WriteStartElement(name)
+        for node in nodes:
+            if node is None:
+                self.childNoneElement()
+            else:
+                self.visit(node)
+        self.writer.WriteEndElement()
+    
+    def childTextElement(self, name, text):
+        self.writer.WriteStartElement(name)
+        self.writer.WriteString(str(text))
+        self.writer.WriteEndElement()
+    
+    def childNoneElement(self):
+        self.writer.WriteStartElement("None")
+        self.writer.WriteEndElement()
+    
+    def childAttribute(self, name, value):
+        self.writer.WriteStartAttribute(name)
+        if isinstance(value, type):
+            if hasattr(value, '__doc__'):
+                self.writer.WriteString(value.__doc__)
+            else:
+                self.writer.WriteString(value.__name__)
+        else:
+            if not isinstance(value, basestring):
+                # TODO: Yuck rebinding!
+                value = str(value)
+            self.writer.WriteString(value.encode('ascii', 'xmlcharrefreplace'))
+        self.writer.WriteEndAttribute()
+
+    def visitAstNode(self, node):
+        self.beginElement(node)
+        for name, value in node.options.items():
+            if value is not None:
+                self.childAttribute(name, value)
+        for name, child in node.children.items():
+            #print "child = %s" % child
+            if isinstance(child, list):
+                #print "child!"
+                self.childListElement(name, child)
+            else:    
+                #print "node!"
+                self.childNodeElement(name, child)
+        self.endElement()
+        

owl_basic-0.6.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: owl-basic
+Version: 0.6.0
+Summary: A BBC BASIC compiler for the .NET CLR, with pluggable code-generation backends.
+Author-email: Robert Smallshire <rob@sixty-north.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/rob-smallshire/owl-basic
+Project-URL: Issues, https://github.com/rob-smallshire/owl-basic/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: THIRD-PARTY-NOTICES.md
+Requires-Dist: ply>=3.11
+Dynamic: license-file
+
+A BBC BASIC compiler for the .NET CLR and Mono, written in IronPython and C#.
+
+What it does
+============
+
+Allows you to write BBC BASIC code and run it with a similar performance profile to C#.
+
+Is it finished?
+===============
+
+No. OWL BASIC compiles some simple programs and some complex commercial programs,
+including Acornsoft's Sphinx adventure. There are still many features to be added, bugs
+to be fixed and improvements to be made.

owl_basic-0.6.0.dist-info/RECORD

@@ -0,0 +1,69 @@
+owl_basic/__init__.py,sha256=j2K_xIyPSRComPNYyMZymf15Q1z1par3rKOzkIHqdqs,106
+owl_basic/algorithms.py,sha256=qHpsjHz8bzZ4L99uRPGm_u74YTilFbi1aiD-T0RdX_k,773
+owl_basic/ast_utils.py,sha256=mtmmNB0VD37uEwItf84HxSOFdWI8y4VbEEgUPmAwhpo,6938
+owl_basic/basic_visitor.py,sha256=h0N8Jp3_cEDGtnlFJAkCFACSnyF4skWO66Uph7Zu_Oc,1621
+owl_basic/cfg_vertex.py,sha256=Uw11v5afx7NDDWP782oRvHfmyYymQppmqvKHyf1_6V0,2131
+owl_basic/correlation_visitor.py,sha256=HlOtaCnKRoWnRqZKqFGHkZ1n3GFwA8QYFCZblVky64o,5207
+owl_basic/data_visitor.py,sha256=rnvcIaqTrDLRc1ngx2el04ZTfYf7hiUTQzswSVijZ-U,2325
+owl_basic/decoder.py,sha256=aZFqkdWhhOLDDFYEjHbUDkVa1i2C8SUEfU-_GVNhd8c,13467
+owl_basic/errors.py,sha256=hZbu7K_XeqApPXV7JYQJNsdt6V8COnW32nmnxfw2AB4,430
+owl_basic/gml_visitor.py,sha256=XpeHIw1lVQoKxMGPT9V1gzgSAR2l_JcOmZFROw6Rfpo,7203
+owl_basic/line_mapper.py,sha256=kM-ANszawPrpyzfEIXoF3tznmVMSowIm0TDXVLTrkeY,1991
+owl_basic/line_number_visitor.py,sha256=zhToYoGEvJctCtWiKidl-0yZWTj1O628_hgwFKfo2JU,2005
+owl_basic/main.py,sha256=EJZWkxyxwmLmRqBKZRofUwLFikzLdC7kHSjV9lzHzxg,14271
+owl_basic/node.py,sha256=S0mPDq4wJ05C_2Zsuiuh6ynVJIsfB3AgB7vxSapV2Mg,563
+owl_basic/options.py,sha256=fTzQmaRKS1zQHmo0FQqw95j0H7MImal-JIsEzE76zaI,514
+owl_basic/parent_visitor.py,sha256=quLYU7Ef67uBnC5PC12jnisD9rb4z1Gb146DAGamdgM,1393
+owl_basic/process.py,sha256=siQF_hIUtit4xNBpvKubkwuHE26Cid3l1N4ynWt9XT8,1120
+owl_basic/separation_visitor.py,sha256=ES1tKOv9jCffRYEIWSt7AtOCD6vRgmPGPzRNdJDP9W0,4134
+owl_basic/sigil.py,sha256=ela67wnNiPSmgdb5XmuMaHHOiPjazFLuu2xQiruL9tQ,1022
+owl_basic/simplify_visitor.py,sha256=Le3Q_Lammt-4H19Ty_RSMF_q6cYrsxtckcaUcdhmlWY,8319
+owl_basic/singleton.py,sha256=TFCnU3WlNLZeiHgRpsPgcx7qBQM6jEYijtLf9uax9xA,4771
+owl_basic/source_debugging.py,sha256=cbTZF2t6oJdIZb12QpalfelpP52yEuvEE65IY10Rzdw,5702
+owl_basic/symbol_table_visitor.py,sha256=jwY0S3p6uHWmC0TFKYx7SdfhsMBEEAhFOQ4D_M6dXSw,10483
+owl_basic/symbol_tables.py,sha256=ZX23shJnZwn2H9puSQoOVUWhOUzeeZTUQNbl06hKfb0,8675
+owl_basic/utility.py,sha256=Z78ayx8LvBc8YYsID1dkehU8Ven7xlGKw9_KWbi70Js,779
+owl_basic/visitor.py,sha256=IRlzo3uzxWfJNnp5znyjC0gkqE8TXn3c5Cp_gNyyByY,1375
+owl_basic/xml_blocks.py,sha256=YG_NbiRCBz5zCYsr6PrZ-2tfGAw3TyOfbgFMqc3MgpA,5416
+owl_basic/xml_visitor.py,sha256=MxOa6iqW0mAllg5LOBj-uOit_hBCmnIw2QLPzyopEGw,3677
+owl_basic/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owl_basic/codegen/clr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owl_basic/codegen/clr/cil_visitor.py,sha256=4_wWxEEqJpIglVeciUh4eupg37WOGwL4oF5YkkNeUWI,63051
+owl_basic/codegen/clr/cts.py,sha256=aEuItTmiYu9k-Ivv_FR7xTXjUKygMFqhIA_2BZdcUl0,1835
+owl_basic/codegen/clr/emitters.py,sha256=VFe2SNubR06JsuZBJBPhTwLIrrusOCkKSZNNtjA3znE,2966
+owl_basic/codegen/clr/generate.py,sha256=w-SmuDkO-uzhkucoU0nhHyVng6IWsE3fODuSUXSoK8I,26741
+owl_basic/flow/__init__.py,sha256=XFq1bAcVKnS4PqpDFe1d18baJROQ14MRFyoeGosmyfk,607
+owl_basic/flow/basic_block.py,sha256=f-ZS8euYsW_qtoxJdnNK8m1BBZe_tDpsoitsTlh5O9M,1161
+owl_basic/flow/basic_block_identifier.py,sha256=-Y8V4TQdSnrnedrlgJSdLqYmQducCfB3xF8Yy1gK4bE,3287
+owl_basic/flow/basic_block_orderer.py,sha256=PDQu-k6zUVPfNKyNflgfDrX9hAobb3VNnIP61GcB584,975
+owl_basic/flow/connectors.py,sha256=tzJiA3m9UUQazUE5ch2XPTvYGUAaVQsrra78NAVatto,549
+owl_basic/flow/convert_sub_visitor.py,sha256=0PEgs8H6IJS_nVoXzfyHrx1sfbPAopMssf_Q-PH6EVc,977
+owl_basic/flow/entry_point_locator.py,sha256=XJq-WZ3QTAIWaUoh-SobYDwyJ8vun3YcUQJtvKPBmLU,2541
+owl_basic/flow/entry_point_visitor.py,sha256=vvsbE81cBd6mEqGq_WuaMZ96KnOiq8Zf7RWlMWml27o,1625
+owl_basic/flow/flow_analysis.py,sha256=2SEAHz_eELAGJJqcfeen0nijcRxdS1HPK__kDXn4-T8,1879
+owl_basic/flow/flow_graph_creator.py,sha256=01MJse23VraUszfBLWsToVIhuyB74MEjs_SIxr5pSV8,388
+owl_basic/flow/flowgraph_visitor.py,sha256=9TxWnLvz2BoI1PQOI4Pg81QBPqjdLe09lgwb2P-6wNE,7265
+owl_basic/flow/longjump_converter.py,sha256=_xDSGW_I_19PyZu1BDHlJHS7MBp6WrHoUdf9Z3nFxNw,596
+owl_basic/flow/longjump_visitor.py,sha256=_hRpaJzi8fSK4o1pNk-p_Zpo038_yYmS1JIDqWrC1Kk,1843
+owl_basic/flow/subroutine_converter.py,sha256=8zeHrbdKCn4OVPyP0fYCav0WbfurM3Y346u9x1QYFbo,1532
+owl_basic/flow/traversal.py,sha256=tmddMP9wBOxu8krW8dY5lrC8zL6g3hg3K2u7IDtSaDc,4340
+owl_basic/owltyping/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+owl_basic/owltyping/function_type_inferer.py,sha256=VQceiUDetKHvFj7oLIvpQo6Kn2EgJc_eXnMQ06dCbnw,2259
+owl_basic/owltyping/hindley_milner.py,sha256=3y69sAyQtnU_Z-aXFoxi7Hb_jaJgPg-h989CUDz7UHw,15477
+owl_basic/owltyping/set_function_type_visitor.py,sha256=VoHE2tc47SMG-eVWlgW4_1TJqydHerFSll6hd2-ls7c,886
+owl_basic/owltyping/type_system.py,sha256=HNWq71v0lTTsVCVep8L4Gosy95Dgsdsluy-w0DU-710,5910
+owl_basic/owltyping/typecheck.py,sha256=4QRuCy-V90gt04YUgo6UEWj-X9H1NP8L4F-1WUarRZw,2169
+owl_basic/owltyping/typecheck_visitor.py,sha256=SPow5jg3vA121JrX-EOi162MDrJBiz-FZInRieG3b8o,21529
+owl_basic/syntax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owl_basic/syntax/ast.py,sha256=o8kbg9aeJjeU_b3CKnoANKfry4hfNJyz0X4jl7tEOfI,29058
+owl_basic/syntax/ast_meta.py,sha256=Fij-7qognPVFiPnEjCY7o9xW7KN-RVkhC6seEKkeb-8,8445
+owl_basic/syntax/grammar.py,sha256=leolpm9CSgqsXLwMMB9CmvoheLnJw3KNG92GyPrrvV4,62946
+owl_basic/syntax/lexer.py,sha256=ORCyQm2tkHLwE4bBem6mQiu-s9m3qsOcEeUX6XmkbjQ,13806
+owl_basic/syntax/parser.py,sha256=xnJ5DzDPzz01_pRy631-5Pv5-DNq8FeqQoAwbHwW2fE,2064
+owl_basic-0.6.0.dist-info/licenses/LICENSE,sha256=teoepIpqtwcGjmw82_JHvgVr8p_PhvGnNpG5aveFOoY,1106
+owl_basic-0.6.0.dist-info/licenses/THIRD-PARTY-NOTICES.md,sha256=asX4kTzwW3shbySl2H_HWmNO5M5DQGqrRZvHW2CTR8w,2630
+owl_basic-0.6.0.dist-info/METADATA,sha256=gnsZB3s_88rjlTggdme_N7xHKI8W57C1OfezOZL3xwE,1398
+owl_basic-0.6.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+owl_basic-0.6.0.dist-info/entry_points.txt,sha256=lf0ZrIHD8y9C4W3C75siJwQinxAROMM2h1nCo4Mqbpg,50
+owl_basic-0.6.0.dist-info/top_level.txt,sha256=BXtZ-rUkfzavlVA6Gb8vK_nrn5C7Z_LcWeTotgucxDk,10
+owl_basic-0.6.0.dist-info/RECORD,,

owl_basic-0.6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

owl_basic-0.6.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+owl-basic = owl_basic.main:main

owl_basic-0.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2007-2026 Robert Smallshire and OWL BASIC contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

owl_basic-0.6.0.dist-info/licenses/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,57 @@
+# Third-Party Notices
+
+OWL BASIC is licensed under the MIT License (see `LICENSE`). It additionally
+incorporates, or derives from, third-party material whose attribution and
+licensing terms are preserved below. Nothing here imposes copyleft; each item
+is compatible with OWL BASIC's permissive licensing, subject to the credit
+being retained.
+
+## BBC BASIC detokenizer — `src/owl_basic/decoder.py`
+
+```
+(c) 2007 Matt Godbolt.
+Updated 2008 Ian Smallshire.
+Original: http://xania.org/200711/bbc-basic-v-format
+"Use however you like, as long as you put credit where credit's due."
+```
+
+The detokenizer that converts tokenized BBC BASIC programs to plain text
+originates with Matt Godbolt and was extended by Ian Smallshire (and later
+Robert Smallshire). It is used here under its stated terms, which require that
+credit be preserved. Some of the token-table information was, per the original
+header, obtained from RISC OS Open source code (see below).
+
+## Singleton metaclass — `src/owl_basic/singleton.py`
+
+By Gary Robinson (grobinson@transpose.com). Explicitly placed in the **public
+domain** ("No rights reserved"). See
+http://www.garyrobinson.net/2004/03/python_singleto.html — no obligations.
+
+## RISC OS Open
+
+Interface and factual information used by the compiler and runtime — BBC BASIC
+token values, and SWI / VDU variable numbers in the OwlRuntime runtime library
+— was informed by RISC OS Open material (https://www.riscosopen.org/), much of
+which is published under the Apache License 2.0 / Castle shared-source terms.
+These items are interface facts rather than copied code.
+
+## Hindley–Milner type inference — `src/owl_basic/owltyping/hindley_milner.py`
+
+A Python implementation by Robert Smallshire, based on the Scala code by Andrew
+Forrest, the Perl code by Nikita Borisov, and the paper "Basic Polymorphic
+Typechecking" by Luca Cardelli. This module is currently unused; if it is
+retained in the compiler, the licensing of the upstream example code should be
+confirmed (or the module replaced with a clean-room implementation).
+
+## Acorn system font — `OwlRuntime/OwlRuntime/platform/riscos/AcornFont.cs`
+
+The 8×8 bitmap glyph data reproduces the appearance of the Acorn / BBC system
+font for VDU emulation. Bitmap font data of this kind derives from Acorn's
+original ROM font. This affects only the .NET (CIL) backend's runtime library,
+not the compiler. It may be retained with this provenance noted, or replaced
+with a freely-licensed equivalent.
+
+## PLY (Python Lex-Yacc)
+
+Used as a normal dependency (not vendored). PLY is distributed under the BSD
+License. See https://github.com/dabeaz/ply.

owl_basic-0.6.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+owl_basic