pitybas 0.1.0__py3-none-any.whl

pitybas/__init__.py

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

pitybas/__main__.py

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

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/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/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))
+

pitybas/interpret.py

@@ -0,0 +1,269 @@
+from collections import defaultdict
+import decimal
+import os
+import time
+import traceback
+
+from .parse import Parser, ParseError
+from .tokens import EOF, Value, REPL
+from .common import ExecutionError, StopError, ReturnError
+
+from pitybas.io.simple import IO
+from .expression import Base
+
+class Interpreter(object):
+    @classmethod
+    def from_string(cls, string, *args, **kwargs):
+        code = Parser(string).parse()
+        return Interpreter(code, *args, **kwargs)
+
+    @classmethod
+    def from_file(cls, filename, *args, **kwargs):
+        string = open(filename, 'r', encoding='utf8').read()
+        vm = Interpreter.from_string(string, *args, **kwargs)
+        vm.name = os.path.basename(filename)
+        return vm
+
+    def __init__(self, code, history=10, io=None, name=None):
+        if not io: io = IO
+        self.io = io(self)
+
+        self.name = name
+        self.code = code
+        self.code.append([EOF()])
+        self.line = 0
+        self.col = 0
+        self.expression = None
+        self.blocks = []
+        self.running = []
+        self.history = []
+        self.hist_len = history
+
+        self.vars = {}
+        self.lists = defaultdict(list)
+        self.matrix = {}
+        self.fixed = -1
+
+        self.serial = 0
+        self.repl_serial = 0
+
+    def cur(self):
+        return self.code[self.line][self.col]
+
+    def inc(self):
+        self.col += 1
+        if self.col >= len(self.code[self.line]):
+            self.col = 0
+            return self.inc_row()
+
+        return self.cur()
+
+    def inc_row(self):
+        self.line = min(self.line+1, len(self.code)-1)
+        self.expression = None
+        return self.cur()
+
+    def get_var(self, var, default=None):
+        if var not in self.vars and default is not None:
+            return default
+        return self.vars[var]
+
+    def set_var(self, var, value):
+        if isinstance(value, (Value, Base)):
+            value = value.get(self)
+
+        self.vars[var] = value
+        return value
+
+    def get_matrix(self, name):
+        return self.matrix[name]
+
+    def set_matrix(self, name, value):
+        self.matrix[name] = value
+
+    def get_list(self, name):
+        return self.lists[name]
+
+    def set_list(self, name, value):
+        self.lists[name] = value
+
+    def push_block(self, block=None):
+        if not block and self.running:
+            block = self.running[-1]
+
+        if block:
+            self.blocks.append(block)
+        else:
+            raise ExecutionError('tried to push an invalid block to the stack')
+
+    def pop_block(self):
+        if self.blocks:
+            return self.blocks.pop()
+        else:
+            raise ExecutionError('tried to pop an empty block stack')
+
+    def find(self, *types, **kwargs):
+        if 'wrap' in kwargs:
+            wrap = kwargs['wrap']
+        else:
+            wrap = False
+
+        if 'pos' in kwargs:
+            pos = kwargs['pos']
+        else:
+            pos = self.line
+
+        def y(i):
+            line = self.code[i]
+            if line:
+                cur = line[0]
+                if isinstance(cur, types):
+                    return i, 0, cur
+
+        for i in range(pos, len(self.code)):
+            ret = y(i)
+            if ret: yield ret
+
+        if wrap:
+            for i in range(0, pos):
+                ret = y(i)
+                if ret: yield ret
+
+    def goto(self, row, col):
+        if row >= 0 and row < len(self.code)\
+            and col >= 0 and col < len(self.code[row]):
+                self.line = row
+                self.col = col
+        else:
+            raise ExecutionError('cannot goto (%i, %i)' % (row, col))
+
+    def get(self, *var):
+        ret = []
+        for v in var:
+            val = v.get(self)
+            if isinstance(val, complex):
+                if not val.imag:
+                    val = val.real
+
+            if isinstance(val, (float)):
+                # TODO: perhaps limit precision here
+                i = int(val)
+                if val == i:
+                    val = i
+
+            ret.append(val)
+
+        if len(ret) == 1:
+            return ret[0]
+
+        return ret
+
+    def disp_round(self, num):
+        if not isinstance(num, (decimal.Decimal, int, float, complex)):
+            return num
+
+        if self.fixed < 0:
+            return num
+        else:
+            return round(num, self.fixed)
+
+    def run(self, cur):
+        self.history.append((self.line, self.col, cur))
+        self.history = self.history[-self.hist_len:]
+
+        cur.line, cur.col = self.line, self.col
+
+        if cur.can_run:
+            self.running.append((self.line, self.col, cur))
+            self.inc()
+            cur.run(self)
+            self.running.pop()
+        elif cur.can_get:
+            self.inc()
+            self.set_var('Ans', cur.get(self))
+            self.serial = time.time()
+        else:
+            raise ExecutionError('cannot seem to run token: %s' % cur)
+
+    def execute(self):
+        with self.io:
+            try:
+                while not isinstance(self.cur(), EOF):
+                    cur = self.cur()
+                    self.run(cur)
+            except StopError as e:
+                if e.args:
+                    print()
+                    print('Stopped:', e.args[0])
+            except ReturnError as e:
+                if e.args:
+                    print()
+                    print('Returned:', e.args[0])
+
+    def print_tokens(self):
+        for line in self.code:
+            print((', '.join(repr(n) for n in line)).replace("u'", "'"))
+
+    def print_ast(self, start=0, end=None, highlight=None):
+        if end is None:
+            end = len(self.code)
+
+        for i in range(max(start, 0), min(end, len(self.code))):
+            line = self.code[i]
+            if highlight is not None and i == highlight - 1:
+                print('>>>> {}'.format(line))
+            else:
+                print('{:3}: {}'.format(i, line))
+
+    def print_stacktrace(self, num=None, vardump=False):
+        if not num:
+            num = self.hist_len
+
+        if self.name:
+            print('-===[ Dumping {} ]===-'.format(self.name))
+
+        if self.history:
+            print()
+            print('-===[ Stacktrace ]===-')
+
+        for row, col, cur in self.history[-num:]:
+            print(('[{}, {}]:'.format(row, col)).ljust(9), repr(cur).replace("u'", '').replace("'", ''))
+
+        if self.history:
+            print()
+
+        print('-===[ Code (row {}, col {}) ]===-'.format(self.line, self.col))
+        h = num // 2
+        self.print_ast(self.line - h, self.line + h, highlight=self.line)
+        print()
+
+        if vardump:
+            print()
+            print('-===[ Variable Dump ]===-')
+            import pprint
+            pprint.pprint(self.vars)
+            print()
+
+    def run_pgrm(self, name):
+        for ref in os.listdir('.'):
+            if ref.endswith('.bas'):
+                test = ref.rsplit('.', 1)[0]
+                if test.lower() == name.lower():
+                    sub = Interpreter.from_file(ref)
+                    sub.execute()
+                    return
+        raise ExecutionError('pgrm{} not found'.format(name))
+
+class Repl(Interpreter):
+    def __init__(self, code=[], **kwargs):
+        super(Repl, self).__init__(code, **kwargs)
+        self.code.insert(-2, [REPL()])
+
+    def execute(self):
+        while not isinstance(self.cur(), EOF):
+            try:
+                super(Repl, self).execute()
+            except ParseError as e:
+                print(e)
+            except:
+                print(traceback.format_exc())