Add and test an interpreter

dwayne · dwayne · commit a24dba458ca8 · 2018-09-21T12:23:05.000-04:00
diff --git a/herbert/error.py b/herbert/error.py
@@ -4,3 +4,15 @@ class HerbertError(Exception):
 
 class SyntaxError(HerbertError):
     pass
+
+
+class RuntimeError(HerbertError):
+    pass
+
+
+class LookupError(RuntimeError):
+    pass
+
+
+class TypeError(RuntimeError):
+    pass
diff --git a/herbert/interpreter.py b/herbert/interpreter.py
@@ -0,0 +1,179 @@
+import numbers
+
+from .error import LookupError, TypeError
+from .util import pluralize
+
+
+class Interpreter:
+    def __call__(self, parse_tree):
+        assert parse_tree.data == 'h'
+
+        self._env = Env()
+        *self._pdefs, main = parse_tree.children
+
+        assert main.data == 'main'
+
+        return self._interp_seq(main.children)
+
+    def _interp_seq(self, seq):
+        allow_number = len(seq) == 1
+
+        for x in seq:
+            if hasattr(x, 'type') and x.type == 'PARAM':
+                yield from self._interp_param(x, allow_number)
+            else:
+                yield from self._interp_stmt(x)
+
+    def _interp_stmt(self, stmt):
+        if hasattr(stmt, 'type'):
+            assert stmt.type == 'COMMAND'
+            yield str(stmt)
+        else:
+            assert stmt.data == 'pcall'
+
+            try:
+                name, args = stmt.children
+            except ValueError:
+                name = stmt.children[0]
+                args = []
+            else:
+                assert name.type == 'PNAME'
+                assert args.data == 'args'
+                args = args.children
+            nargs = len(args)
+
+            pdef = self._lookup_pdef(str(name))
+            try:
+                params, body = pdef.children[1:]
+            except ValueError:
+                params = []
+                body = pdef.children[1]
+            else:
+                assert params.data == 'params'
+                assert body.data == 'body'
+                params = params.children
+            nparams = len(params)
+
+            if nargs == nparams:
+                try:
+                    bindings = self._bind(str(name), params, args)
+                except IgnoreCall:
+                    pass
+                else:
+                    self._env = Env(bindings=bindings, outer=self._env)
+                    try:
+                        yield from self._interp_seq(body.children)
+                    finally:
+                        self._env = self._env.outer
+            else:
+                argument = pluralize(nparams, 'argument', 'arguments')
+                was = pluralize(nargs, 'was', 'were')
+
+                raise TypeError('%s takes %d %s but %d %s given' % (name, nparams, argument, nargs, was))
+
+    def _interp_param(self, param, allow_number):
+        value = self._lookup(str(param))
+
+        if isinstance(value, Deferred):
+            prev_env, self._env = self._env, value.env
+            try:
+                yield from self._interp_seq(value.seq)
+            finally:
+                self._env = prev_env
+        else:
+            assert isinstance(value, numbers.Integral)
+            if allow_number:
+                yield value
+            else:
+                raise TypeError('parameter %s does not evaluate to a command s, l or r or a procedure call: %d' % (param, value))
+
+    def _interp_arg(self, arg, name, index):
+        if arg.data == 'var':
+            assert len(arg.children) == 1 and arg.children[0].type == 'PARAM'
+            return self._lookup(str(arg.children[0]))
+
+        if arg.data == 'sexpr':
+            return Deferred(self._env, arg.children)
+
+        assert arg.data == 'expr'
+        return self._interp_expr(arg.children)
+
+    def _interp_expr(self, expr):
+        assert expr
+
+        if expr[0].type == 'NEG':
+            sign = -1
+            terms = expr[1:]
+        else:
+            sign = 1
+            terms = expr
+
+        sum = 0
+        for term in expr:
+            if term.type == 'PLUS':
+                sign = 1
+            elif term.type == 'MINUS':
+                sign = -1
+            elif term.type == 'NUM':
+                sum += sign * int(str(term))
+            else:
+                assert term.type == 'PARAM'
+                value = self._lookup(str(term))
+
+                if isinstance(value, numbers.Integral):
+                    sum += sign * value
+                else:
+                    raise TypeError('parameter %s does not evaluate to a number: %s' % (term, value))
+
+        return sum
+
+    def _bind(self, name, params, args):
+        bindings = {}
+
+        for index, (param, arg) in enumerate(zip(params, args)):
+            value = self._interp_arg(arg, name, index)
+
+            if value == 0:
+                raise IgnoreCall
+
+            bindings[str(param)] = value
+
+        return bindings
+
+    def _lookup_pdef(self, name):
+        for pdef in self._pdefs:
+            pname = pdef.children[0]
+            assert pname.type == 'PNAME'
+
+            if name == pname:
+                return pdef
+
+        raise LookupError('missing procedure: %s' % name)
+
+    def _lookup(self, name):
+        return self._env.lookup(name)
+
+
+class Env:
+    def __init__(self, bindings=None, outer=None):
+        self.outer = outer
+        self.bindings = {} if bindings is None else bindings
+
+    def lookup(self, name):
+        try:
+            return self.bindings[name]
+        except KeyError:
+            raise LookupError('unbound parameter: %s' % name)
+
+
+class Deferred:
+    def __init__(self, env, seq):
+        self.env = env
+        self.seq = seq
+
+
+class IgnoreCall(Exception):
+    pass
+
+
+interp = Interpreter()
diff --git a/herbert/parser.py b/herbert/parser.py
@@ -17,7 +17,9 @@
            | PNAME [args] -> pcall
 
     args   : "(" arg ("," arg)* ")"
-    ?arg   : (stmt | PARAM)+ -> sexpr
+    ?arg   : PARAM -> var
+           | PARAM (stmt | PARAM)+ -> sexpr
+           | stmt (stmt | PARAM)* -> sexpr
            | expr
 
     expr   : NEG PARAM
diff --git a/tests/test_interpreter.py b/tests/test_interpreter.py
@@ -0,0 +1,169 @@
+import itertools
+import unittest
+
+from herbert.error import LookupError, TypeError
+from herbert.interpreter import interp
+from herbert.parser import parse
+
+
+def run(program, upper_bound=None):
+    commands = interp(parse(program))
+
+    if upper_bound:
+        commands = itertools.islice(commands, upper_bound)
+
+    return ''.join(commands)
+
+
+class ExamplesTestCase(unittest.TestCase):
+    def test_example1(self):
+        program = 'sssssrsssssrsssssrsssssr'
+
+        self.assertEqual(run(program), 'sssssrsssssrsssssrsssssr')
+
+    def test_example2(self):
+        program = 'a:sssssr\naaaa'
+
+        self.assertEqual(run(program), 'sssssrsssssrsssssrsssssr')
+
+    def test_example3(self):
+        program = 'a:sssssra\na'
+
+        self.assertEqual(run(program, 24), 'sssssrsssssrsssssrsssssr')
+
+    def test_example4(self):
+        program = 'a(A):sssssra(A-1)\na(4)'
+
+        self.assertEqual(run(program), 'sssssrsssssrsssssrsssssr')
+
+    def test_example5(self):
+        program = 'a(A,B):f(B)ra(A-1,B)\nf(A):sf(A-1)\na(4,5)'
+
+        self.assertEqual(run(program), 'sssssrsssssrsssssrsssssr')
+
+    def test_example6(self):
+        program = 'a(A,B,C):f(B)Ca(A-1,B,C)\nf(A):sf(A-1)\na(4,5,r)'
+
+        self.assertEqual(run(program), 'sssssrsssssrsssssrsssssr')
+
+    def test_example7(self):
+        program = 'a(A):ArAa(AA)\na(s)'
+
+        self.assertEqual(run(program, 17), 'srsssrssssssrssss')
+
+    def test_example8(self):
+        program = 'a(A,B,C):f(B)Ca(A-1,B,C)\nb(A):a(4,5,r)lb(A-1)\nf(A):sf(A-1)\nb(4)'
+
+        self.assertEqual(
+            run(program, 100),
+            'sssssrsssssrsssssrsssssrl'
+            'sssssrsssssrsssssrsssssrl'
+            'sssssrsssssrsssssrsssssrl'
+            'sssssrsssssrsssssrsssssrl'
+        )
+
+    def test_example9(self):
+        program = 'a(A,B,C):f(B)Ca(A-1,B,C)\nb(A):a(4,A,r)b(A-1)\nf(A):sf(A-1)\nb(10)'
+
+        self.assertEqual(
+            run(program, 260),
+            'ssssssssssrssssssssssrssssssssssrssssssssssr'  # 40 + 4 = 44
+            'sssssssssrsssssssssrsssssssssrsssssssssr'      # 40
+            'ssssssssrssssssssrssssssssrssssssssr'          # 36
+            'sssssssrsssssssrsssssssrsssssssr'              # 32
+            'ssssssrssssssrssssssrssssssr'                  # 28
+            'sssssrsssssrsssssrsssssr'                      # 24
+            'ssssrssssrssssrssssr'                          # 20
+            'sssrsssrsssrsssr'                              # 16
+            'ssrssrssrssr'                                  # 12
+            'srsrsrsr'                                      # 8
+        )
+
+    def test_example10(self):
+        program = 'a(A,B,C):f(B)Ca(A-1,B,C)\nb(A):a(2,11-A,r)b(A-1)\nf(A):sf(A-1)\nb(10)'
+
+        self.assertEqual(
+            run(program, 130),
+            'srsr'                   # 4
+            'ssrssr'                 # 6
+            'sssrsssr'               # 8
+            'ssssrssssr'             # 10
+            'sssssrsssssr'           # 12
+            'ssssssrssssssr'         # 14
+            'sssssssrsssssssr'       # 16
+            'ssssssssrssssssssr'     # 18
+            'sssssssssrsssssssssr'   # 20
+            'ssssssssssrssssssssssr' # 22
+        )
+
+    def test_example11(self):
+        program = 'a(A,B,C):f(B)Ca(A-1,B,C)\nf(A):sf(A-1)\na(4,5,rslsr)'
+
+        self.assertEqual(run(program, 40), 'sssssrslsrsssssrslsrsssssrslsrsssssrslsr')
+
+
+class InfiniteRecursionTestCase(unittest.TestCase):
+    """These test cases illustrate that some programs that should be able to run
+    infinitely long aren't able to do so and cause the Python runtime to raise
+    a RecursionError exception. This points to a need to improve my
+    implementation of the interpreter.
+
+    Would tail-call optimization help?
+
+    Notice how the program in test_example3 has the same runtime effect as that
+    of the program in test_example1 but the one in test_example1 raises a
+    RecursionError.
+    """
+    def test_example1(self):
+        program = 'a:sa\na'
+
+        with self.assertRaises(RecursionError):
+            run(program, 10000)
+
+    def test_example2(self):
+        program = 'a(A):ArAa(AA)\na(s)'
+
+        run(program, 10000)
+
+    def test_example3(self):
+        program = 'a(A):Aa(AA)\na(s)'
+
+        run(program, 10000)
+
+
+class RuntimeErrorTestCase(unittest.TestCase):
+    def test_missing_procedure(self):
+        program = 'f'
+
+        with self.assertRaisesRegex(LookupError, 'missing procedure: f'):
+            run(program)
+
+    def test_unbound_parameter(self):
+        program = 'a:Aa\na'
+
+        with self.assertRaisesRegex(LookupError, 'unbound parameter: A'):
+            run(program)
+
+    def test_too_few_arguments(self):
+        program = 'a(A):Aa\na(s)'
+
+        with self.assertRaisesRegex(TypeError, 'a takes 1 argument but 0 were given'):
+            run(program)
+
+    def test_too_many_arguments(self):
+        program = 'a(A,B):ABa(A,B,B)\na(s,r)'
+
+        with self.assertRaisesRegex(TypeError, 'a takes 2 arguments but 3 were given'):
+            run(program)
+
+    def test_expected_command_or_procedure_call(self):
+        program = 'a(A):Aa(A)\na(1)'
+
+        with self.assertRaisesRegex(TypeError, 'parameter A does not evaluate to a command .* or a procedure call: 1'):
+            run(program)
+
+    def test_expected_number(self):
+        program = 'a(A):sa(A-1)\na(r)'
+
+        with self.assertRaisesRegex(TypeError, 'parameter A does not evaluate to a number'):
+            run(program)
diff --git a/tests/test_parser.py b/tests/test_parser.py
@@ -109,7 +109,7 @@ def test_with_params(self):
         self.assertEqual(args.data, 'args')
         self.assertEqual(len(args.children), 6)
         self.assertEqual(args.children[0].data, 'sexpr')
-        self.assertEqual(args.children[1].data, 'sexpr')
+        self.assertEqual(args.children[1].data, 'var')
         self.assertEqual(args.children[2].data, 'expr')
         self.assertEqual(args.children[3].data, 'expr')
         self.assertEqual(args.children[4].data, 'expr')
