owl-basic 0.6.0__tar.gz

owl_basic-0.6.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,13 @@
+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/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/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "owl-basic"
+dynamic = ["version"]
+authors = [
+    { name = "Robert Smallshire", email = "rob@sixty-north.com" },
+]
+description = "A BBC BASIC compiler for the .NET CLR, with pluggable code-generation backends."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE", "THIRD-PARTY-NOTICES.md"]
+requires-python = ">=3.14"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Compilers",
+]
+dependencies = [
+    "ply>=3.11",
+]
+
+[project.urls]
+Repository = "https://github.com/rob-smallshire/owl-basic"
+Issues = "https://github.com/rob-smallshire/owl-basic/issues"
+
+[project.scripts]
+owl-basic = "owl_basic.main:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.dynamic]
+version = { attr = "owl_basic.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+
+[dependency-groups]
+test = [
+    "pytest>=8",
+    "approvaltests>=14",
+]
+dev = [
+    "bump-my-version>=0.28",
+    { include-group = "test" },
+]
+
+[tool.bumpversion]
+# Single source of truth for the version is owl_basic.__version__, which
+# pyproject reads dynamically. `bump-my-version bump {patch,minor,major}`
+# rewrites it, commits, and tags v{new_version}; pushing that tag triggers
+# release.yml.
+current_version = "0.6.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+commit = true
+tag = true
+message = "Bump version: {current_version} → {new_version}"
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+files = [
+    { filename = "src/owl_basic/__init__.py" },
+]

owl_basic-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

owl_basic-0.6.0/src/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-0.6.0/src/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-0.6.0/src/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-0.6.0/src/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-0.6.0/src/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))
+