pitybas 0.1.0__tar.gz

pitybas-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Ryan Hileman
+
+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.

pitybas-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pitybas
+Version: 0.1.0
+Summary: A TI-BASIC interpreter written in Python
+Author: Ryan Hileman
+Maintainer-email: Thomas Roten <tsr@thomasroten.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tsroten/pitybas
+Project-URL: Repository, https://github.com/tsroten/pitybas
+Project-URL: Issues, https://github.com/tsroten/pitybas/issues
+Keywords: ti-basic,interpreter,calculator,ti-83,ti-84
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+pitybas
+=======
+A working TI-BASIC interpreter, written in Python.
+
+## Installation
+
+    pip install pitybas
+
+## Usage
+
+Use `pb -i vt100` to run programs which need a working home screen.
+
+If you run `pb` with no filename, it launches an interactive shell.
+
+    Usage: pb [options] filename
+
+    Options:
+        -h, --help        show this help message and exit
+        -a, --ast         parse, print ast, and quit
+        -d, --dump        dump variables in stacktrace
+        -s, --stacktrace  always stacktrace
+        -v, --verbose     verbose output
+        -i IO, --io=IO    select an IO system: simple (default), vt100
+
+You can also run it as a module without installing the console script:
+
+    python -m pitybas -i vt100
+
+## Known Limitations
+
+- **Graph screen functions are not supported.** Commands that draw to the TI-83/84 graph screen (e.g. `Circle`, `Line`, `DrawF`) are not implemented. Programs that use them will fail or produce no output.
+
+## Development
+
+Clone the repository and install it in editable mode with the test extras:
+
+    pip install -e .[test]
+    pytest

pitybas-0.1.0/README.md

@@ -0,0 +1,38 @@
+pitybas
+=======
+A working TI-BASIC interpreter, written in Python.
+
+## Installation
+
+    pip install pitybas
+
+## Usage
+
+Use `pb -i vt100` to run programs which need a working home screen.
+
+If you run `pb` with no filename, it launches an interactive shell.
+
+    Usage: pb [options] filename
+
+    Options:
+        -h, --help        show this help message and exit
+        -a, --ast         parse, print ast, and quit
+        -d, --dump        dump variables in stacktrace
+        -s, --stacktrace  always stacktrace
+        -v, --verbose     verbose output
+        -i IO, --io=IO    select an IO system: simple (default), vt100
+
+You can also run it as a module without installing the console script:
+
+    python -m pitybas -i vt100
+
+## Known Limitations
+
+- **Graph screen functions are not supported.** Commands that draw to the TI-83/84 graph screen (e.g. `Circle`, `Line`, `DrawF`) are not implemented. Programs that use them will fail or produce no output.
+
+## Development
+
+Clone the repository and install it in editable mode with the test extras:
+
+    pip install -e .[test]
+    pytest

pitybas-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pitybas"
+dynamic = ["version"]
+description = "A TI-BASIC interpreter written in Python"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Ryan Hileman" },
+]
+maintainers = [
+    { name = "Thomas Roten", email = "tsr@thomasroten.com" },
+]
+requires-python = ">=3.9"
+keywords = ["ti-basic", "interpreter", "calculator", "ti-83", "ti-84"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Interpreters",
+]
+
+[project.urls]
+Homepage = "https://github.com/tsroten/pitybas"
+Repository = "https://github.com/tsroten/pitybas"
+Issues = "https://github.com/tsroten/pitybas/issues"
+
+[project.scripts]
+pb = "pitybas.cli:main"
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools.dynamic]
+version = { attr = "pitybas.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pitybas-0.1.0/setup.cfg

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

pitybas-0.1.0/src/pitybas/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pitybas-0.1.0/src/pitybas/__main__.py

@@ -0,0 +1,4 @@
+from pitybas.cli import main
+
+if __name__ == '__main__':
+    main()

pitybas-0.1.0/src/pitybas/cli.py

@@ -0,0 +1,68 @@
+import sys
+import traceback
+from optparse import OptionParser
+
+from .interpret import Interpreter, Repl
+from .common import Error
+from pitybas.io.vt100 import IO as vt100
+
+
+def main(argv=None):
+    parser = OptionParser(usage='Usage: pb [options] filename')
+    parser.add_option('-a', '--ast', dest="ast", action="store_true", help="parse, print ast, and quit")
+    parser.add_option('-d', '--dump', dest="vardump", action="store_true", help="dump variables in stacktrace")
+    parser.add_option('-s', '--stacktrace', dest="stacktrace", action="store_true", help="always stacktrace")
+    parser.add_option('-v', '--verbose', dest="verbose", action="store_true", help="verbose output")
+    parser.add_option('-i', '--io', dest="io", help="select an IO system: simple (default), vt100")
+
+    (options, args) = parser.parse_args(argv)
+
+    if len(args) > 1:
+        parser.print_help()
+        sys.exit(1)
+
+    io = None
+    if options.io == 'vt100':
+        io = vt100
+
+    if args:
+        vm = Interpreter.from_file(args[0], history=20, io=io)
+    else:
+        print('Welcome to pitybas. Press Ctrl-D to exit.')
+        print()
+        vm = Repl(history=20, io=io)
+
+    if options.verbose:
+        vm.print_tokens()
+        print()
+        if args:
+            print('-===[ Running %s ]===-' % args[0])
+
+    if options.ast:
+        vm.print_ast()
+        sys.exit(0)
+
+    try:
+        vm.execute()
+        if options.stacktrace:
+            vm.print_stacktrace(options.vardump)
+    except KeyboardInterrupt:
+        print()
+        vm.print_stacktrace(options.vardump)
+    except Exception as e:
+        print()
+        print()
+        vm.print_stacktrace(options.vardump)
+
+        print('%s on line %i:' % (e.__class__.__name__, vm.line), end=' ')
+
+        if isinstance(e, Error):
+            print(e.msg)
+        else:
+            print()
+            print('-===[ Python traceback ]===-')
+            print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    main()

pitybas-0.1.0/src/pitybas/common.py

@@ -0,0 +1,41 @@
+class Error(Exception):
+       def __init__(self, msg):
+           self.msg = msg
+
+       def __str__(self):
+           return self.msg
+
+class StopError(Exception): pass
+class ReturnError(Exception): pass
+
+class ParseError(Error): pass
+class ExecutionError(Error): pass
+class ExpressionError(Error): pass
+
+class Pri:
+    # evaluation happens in the following order:
+    # skip: expressions, functions, variables
+    # 1. exponents, factorials
+    # 2. multiplication, division
+    # 3. addition, subtraction
+    # 4. logic operators
+    # 5. boolean operators
+    # 6. variable setting
+
+    # these won't be parsed into expressions at all
+    INVALID = -2
+    # NONE means store but don't execute directly
+    # used for variables, lazy loading functions and expressions
+    NONE = -1
+
+    PROB = 0
+    EXPONENT = 1
+    MULTDIV = 2
+    ADDSUB = 3
+
+    LOGIC = 4
+    BOOL = 5
+    SET = 6
+
+def is_number(num):
+    return str(num).lstrip('-').replace('.', '', 1).isdigit()

pitybas-0.1.0/src/pitybas/expression.py

@@ -0,0 +1,285 @@
+from . import tokens
+from .common import ExpressionError, Pri, is_number
+
+class Base:
+    priority = Pri.NONE
+
+    can_run = False
+    can_set = False
+    can_get = True
+    can_fill_left = False
+    can_fill_right = False
+    absorbs = ()
+
+    end = None
+
+    def __init__(self, *elements):
+        self.contents = []
+        self.raw = []
+        self.finished = False
+
+        for e in elements:
+            self.append(e)
+
+    def append(self, token):
+        if self.contents:
+            prev = self.contents[-1]
+
+            # the minus sign implies a * -1 when used by itself
+            if isinstance(prev, tokens.Minus):
+                # TODO: fix this the rest of the way
+                if len(self.contents) == 1:
+                    self.contents.pop()
+                    self.contents += [tokens.Value(-1), tokens.Mult()]
+
+            # absorb: tokens can absorb the next token from the expression if it matches a list of types
+            elif isinstance(token, prev.absorbs):
+                if isinstance(token, Base):
+                    token = token.flatten()
+
+                prev.absorb(token)
+                return
+
+            # implied multiplication
+            elif prev.priority == token.priority == tokens.Pri.NONE:
+
+                # negative numbers actually have implied addition
+                if isinstance(token, tokens.Value)\
+                    and is_number(token.value) and int(token.value) < 0:
+                        self.contents.append(tokens.Plus())
+                else:
+                    self.contents.append(tokens.Mult())
+
+        self.raw.append(token)
+        self.contents.append(token)
+
+    def extend(self, array):
+        for x in array:
+            self.append(x)
+
+    def flatten(self):
+        if len(self.contents) == 1:
+            first = self.contents[0]
+            if isinstance(first, Base):
+                return first.flatten()
+            elif first.can_get:
+                return first
+
+        return self
+
+    def fill(self):
+        # TODO: instead of this system, perhaps tokens should be able to specify whether they need/want left/right params
+        if not self.contents: return
+
+        # if we don't have a proper variable:token:variable pairing in the token list,
+        # this method will allow tokens to fill in an implied variable to their left or right
+        new = []
+        for i in range(len(self.contents)):
+            t = self.contents[i]
+            if (i % 2 == 0 and not t.can_get):
+                left = None
+                right = None
+
+                if i > 0:
+                    left = self.contents[i-1]
+                    if not left.can_fill_right:
+                        left = None
+
+                right = self.contents[i]
+                if not right.can_fill_left:
+                    right = None
+
+                if left is not None and right is not None:
+                    if left < right:
+                        left = None
+                    else:
+                        right = None
+
+                if left is not None:
+                    new.append(left.fill_right())
+                elif right is not None:
+                    new.append(right.fill_left())
+
+            new.append(t)
+
+        last = new[-1]
+        if not last.can_get:
+            if last.can_fill_right:
+                new.append(last.fill_right())
+
+        self.contents = new
+
+    def validate(self):
+        if not self.contents: return
+
+        # figure out how to handle in-place tokens like the symbol for ^3
+        # perhaps replace it with a ^3 so we can enforce (value, token, value)
+        # or we can pad "in-place" tokens with a null to be passed as right
+
+        # make sure expression is ordered (value, token, value, token, value)
+        for i in range(len(self.contents)):
+            t = self.contents[i]
+
+            if (i % 2 == 0 and not t.can_get) or ( i % 2 == 1 and not t.can_run):
+                raise ExpressionError('bad token order: %s' % self)
+
+        # determine whether we have any tokens after a ->
+        found_stor = False
+        for i in range(len(self.contents)):
+            t = self.contents[i]
+            odd = i % 2
+
+            if isinstance(t, tokens.Store):
+                found_stor = True
+                stor_odd = odd
+            elif found_stor and (odd == stor_odd):
+                raise ExpressionError('Store cannot be followed by non-Store tokens in expression: %s' % self)
+
+    def order(self):
+        # this step returns a list of ordered indicies
+        # to help reduce tokens to a single value
+        # see common.Pri for an ordering explanation
+
+        order = {}
+
+        for i in range(len(self.contents)):
+            token = self.contents[i]
+            p = token.priority
+            if p >= 0:
+                # anything below zero is to be ignored
+                if p in order:
+                    order[p].append(i)
+                else:
+                    order[p] = [i]
+
+        ret = []
+        for p in sorted(order):
+            ret += order[p]
+
+        return ret
+
+    def get(self, vm):
+        self.fill()
+        self.validate()
+
+        sub = []
+        expr = self.contents[:]
+        for i in self.order():
+            n = 0
+            for s in sub:
+                if s < i:
+                    n += 1
+
+            sub += [i, i+1]
+            i -= n
+
+            right = expr.pop(i+1)
+            left = expr.pop(i-1)
+
+            token = expr[i-1]
+            expr[i-1] = tokens.Value(token.run(vm, left, right))
+
+        return vm.get(expr[0])
+
+    def finish(self):
+        self.finished = True
+
+    def close(self, char):
+        for stack in reversed(self.contents):
+            if isinstance(stack, Base):
+                if stack.close(char):
+                    return False
+
+        if char == self.end and not self.finished:
+            self.finish()
+            return True
+
+    def __str__(self):
+        return ''.join([a.token for a in self.raw])
+
+    def __len__(self):
+        return len(self.contents)
+
+    def __repr__(self):
+        return 'E(%s)' % (' '.join(repr(token) for token in self.contents))
+
+bracket_map = {'(':')', '{':'}', '[':']'}
+
+class Expression(Base):
+    def set(self, vm, value):
+        if len(self.contents) == 1:
+            self.contents[0].set(vm, value)
+
+class Bracketed(Base):
+    def __init__(self, end):
+        self.end = bracket_map[end]
+        Base.__init__(self)
+
+    def __repr__(self):
+        return 'B(%s)' % (' '.join(repr(token) for token in self.contents))
+
+class ParenExpr(Bracketed):
+    end = ')'
+
+class Tuple(Base):
+    priority = Pri.INVALID
+
+    def __init__(self):
+        Base.__init__(self)
+
+    def append(self, expr):
+        if isinstance(expr, Base):
+            expr = expr.flatten()
+
+        if self.contents:
+            last = self.contents[-1]
+            if isinstance(last, Base) and not last.finished:
+                last.append(expr)
+                return
+
+        expr = Expression(expr)
+        self.contents.append(expr)
+
+    def sep(self):
+        if self.contents:
+            self.contents[-1].finish()
+
+    def get(self, vm):
+        return [vm.get(arg) for arg in self.contents]
+
+    def __len__(self):
+        return len(self.contents)
+
+    def __repr__(self):
+        def expr_repr(e):
+            if not isinstance(e, Expression):
+                return '({})'.format(e)
+            else:
+                return repr(e)
+
+        return 'T(%s)' % (', '.join(expr_repr(expr) for expr in self.contents))
+
+class Arguments(Tuple, Bracketed):
+    def __init__(self, end):
+        Bracketed.__init__(self, end)
+
+    def __repr__(self):
+        return 'A(%s)' % (', '.join(repr(expr) for expr in self.contents))
+
+class FunctionArgs(Arguments):
+    end = ')'
+
+class ListExpr(Arguments):
+    priority = Pri.NONE
+    end = '}'
+
+    def __repr__(self):
+        return 'L{%s}' % (', '.join(repr(expr) for expr in self.contents))
+
+class MatrixExpr(Arguments):
+    priority = Pri.NONE
+    end = ']'
+
+    def __repr__(self):
+        return 'M[%s]' % (', '.join(repr(expr) for expr in self.contents))
+