def test_update(self): st = SymbolTable() self.assertRaises(AssertionError, st.update, "a", 1) st.store("a", Expression(Type.int(), 1)) st.update("a", 2) self.assertEqual(Type.int(), st.get_expression("a").type) self.assertEqual(2, st.get_expression("a").value)
def test_store(self): st = SymbolTable() st.store("a", Expression(Type.int(), 1)) self.assertTrue("a" in st) self.assertEqual(Type.int(), st.get_expression("a").type) self.assertEqual(1, st.get_expression("a").value) self.assertRaises(AssertionError, st.store, "a", Expression(Type.int(), 1))
def test_declare_int_should_change_symbol_table(self): actual = SymbolTable() generate_commands(""" main () { int a; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.int(), 0, ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_boolean_should_change_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { boolean a <- true; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.boolean(), True, ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_decimal_should_change_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { decimal a <- 1.0; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.decimal(), 1.0, ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_vector_should_change_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { vector a <- (1.0, 2.0, -3.0); } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.vector(), [1, 2, -3], ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_string_should_change_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { string a <- "\0a"; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.string(), "\0a", ident="a")) self.assertEqual(expected, actual)
def test_str(self): st = SymbolTable() st.store("a", Expression(Type.int(), 0)) st.store("b", Expression(Type.list_of(Type.boolean()), [True])) expected = "SymbolTable: {\n" + \ " a -> Expression: { type: int, value: 0, ident: None }\n" + \ " b -> Expression: { type: list[boolean], value: [True], ident: None }\n" + \ "}" self.assertEqual(expected, str(st))
def test_eq(self): st1 = SymbolTable() st2 = SymbolTable() self.assertTrue(st1 == st2) st1.store("a", Expression(Type.int(), 0)) self.assertFalse(st1 == st2) st2.store("a", Expression(Type.int(), 0)) self.assertTrue(st1 == st2) self.assertNotEqual(SymbolTable(), None)
def test_declare_and_assign_list_should_change_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { list[int] a <- [1, 2, -3]; } """, actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.int()), [1, 2, -3], ident="a")) self.assertEqual(expected, actual)
def test_assign_ident_decimal_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { decimal a; a <- -1.5e10; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.decimal(), -1.5e10, ident="a")) self.assertEqual(expected, actual)
def test_assign_ident_vector_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { vector a; a <- (1.0, -1.0, +1.0); } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.vector(), [1, -1, 1], ident="a")) self.assertEqual(expected, actual)
def test_assign_ident_string_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { string a; a <- "1"; } """, actual) expected = SymbolTable() expected.store("a", Expression(Type.string(), "1", ident="a")) self.assertEqual(expected, actual)
def test_assign_ident_list_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { list[int] a; a <- [1, -1, +1]; } """, actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.int()), [1, -1, 1], ident="a")) self.assertEqual(expected, actual)
def test_declare_with_different_variable_name_should_change_symbol_table( self): for name in [ "a", "A", "_a", "_1", "_A", "abc", "Abc", "a12", "aA1", "_aA1" ]: actual = SymbolTable() generate_commands( """ main () {{ int {}; }} """.format(name), actual) expected = SymbolTable() expected.store(name, Expression(Type.int(), 0, ident=name)) self.assertEqual(expected, actual)
def test_assign_list_elem_to_variable_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { list[int] a <- [0, 1, 2]; a[0] <- 1; a[2] <- a[0]; } """, actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.int()), [1, 1, 1], ident="a")) self.assertEqual(expected, actual)
def test_assign_vector_elem_to_variable_should_update_symbol_table(self): for index, vector in zip(["x", "y", "z"], [[-1.0, 0, 0], [0, -2.0, 0], [0, 0, -3.0]]): actual = SymbolTable() generate_commands( """ main () {{ vector a; a.{} <- (-1.0, -2.0, -3.0).{}; }} """.format(index, index), actual) expected = SymbolTable() expected.store("a", Expression(Type.vector(), vector, ident="a")) self.assertEqual(expected, actual)
def test_assign_list_elem_with_vector_should_update_symbol_table(self): actual = SymbolTable() generate_commands( """ main () { list[vector] a <- [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)]; a[0] <- (7.0, 8.0, 9.0); a[1].x <- 10.0; a[1].y <- 11.0; a[1].z <- 12.0; } """, actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.vector()), [[7, 8, 9], [10, 11, 12]], ident="a")) self.assertEqual(expected, actual)
def test_assign_list_elem_to_variable_nested_should_update_symbol_table( self): actual = SymbolTable() generate_commands( """ main () { list[list[int]] a <- [[0, 1], [2, 3]]; a[0] <- [4, 5]; a[1][0] <- 6; a[1][1] <- 7; } """, actual) expected = SymbolTable() expected.store( "a", Expression(Type.list_of(Type.list_of(Type.int())), [[4, 5], [6, 7]], ident="a")) self.assertEqual(expected, actual)
def test_declare_and_assign_ident_empty_list_should_update_symbol_table( self): types = [ Type.int(), Type.decimal(), Type.string(), Type.boolean(), Type.vector(), Type.list_of(Type.int()), Type.list_of(Type.list_of(Type.int())) ] for type in types: actual = SymbolTable() generate_commands( """ main () {{ list[{}] a <- []; }} """.format(type.type_name), actual) expected = SymbolTable() expected.store("a", Expression(Type.list_of(type), [], ident="a")) self.assertEqual(expected, actual)
def test_contains(self): st = SymbolTable() self.assertFalse("a" in st) st.store("a", Expression(Type.int(), 0)) self.assertTrue("a" in st)
def test_get_expression(self): st = SymbolTable() st.store("a", Expression(Type.list_of(Type.int()), [1])) self.assertEqual([1], st.get_expression("a").value) self.assertEqual(1, st.get_expression("a").value[0]) self.assertEqual(Type.list_of(Type.int()), st.get_expression("a").type)
class Interpreter(Transformer): def __init__(self, symbol_table): super().__init__() self.symbol_table = SymbolTable( ) if symbol_table is None else symbol_table # def __default__(self, command, children, meta): # logging.error("Ignoring unsupported command %s with children %s" % (command, children)) # raise Discard() ######## prog ######## def prog(self, children): return children ######## commands ######## def commands(self, children): return children ######## command ######## def takeoff(self, children) -> List[Command]: return [Command.takeoff()] def land(self, children) -> List[Command]: return [Command.land()] def up(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.up(expr.value)] def down(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.down(expr.value)] def left(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.left(expr.value)] def right(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.right(expr.value)] def forward(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.forward(expr.value)] def backward(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.backward(expr.value)] def rotate_left(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.rotate_left(radians(expr.value))] def rotate_right(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.rotate_right(radians(expr.value))] def wait(self, children) -> List[Command]: expr, = children if expr.type != Type.int() and expr.type != Type.decimal(): raise CompileError( "Expression {} should have type int or decimal, but is {}". format(expr.value, expr.type)) return [Command.wait(expr.value)] def declare(self, children) -> List[Command]: type, identifier = children ident = identifier.ident if ident in self.symbol_table: raise CompileError("Identifier {} already declared".format(ident)) self.symbol_table.store( ident, Expression(type, type.default_value, ident=ident)) return [] def declare_assign(self, children) -> List[Command]: type, identifier, expr = children ident = identifier.ident if ident in self.symbol_table: raise CompileError("Identifier {} already declared".format(ident)) if expr.type != type: raise CompileError( "Identifier {} has been declared as {}, but assigned as {}". format(ident, type, expr.type)) expr_with_ident = Expression(expr.type, expr.value, ident) self.symbol_table.store(ident, expr_with_ident) return [] def assign_ident(self, children) -> List[Command]: identifier, expr = children ident = identifier.ident if ident not in self.symbol_table: raise CompileError( "Identifier {} has not been declared".format(ident)) assigned_type = expr.type declared_type = self.symbol_table.get_expression(ident).type if assigned_type != declared_type: raise CompileError( "Identifier {} has been declared as {}, but assigned as {}". format(ident, declared_type, assigned_type)) self.symbol_table.update(ident, expr.value) return [] def _update_nested_ident(self, ident, expr, index) -> None: if ident is not None: if "[" in ident: tokens = ident.split("[") ident = tokens[0] indices = [int(token.replace("]", "")) for token in tokens[1:]] else: indices = [] assert ident in self.symbol_table new_list = self.symbol_table.get_expression(ident).value curr = new_list for i in indices: curr = curr[i] curr[index] = expr.value self.symbol_table.update(ident, new_list) def assign_list_elem(self, children) -> List[Command]: list_elem, expr = children ident = list_elem.ident list = list_elem.container index = list_elem.index assigned_type = expr.type declared_type = list.type.elem_type if assigned_type != declared_type: raise CompileError( "Assigned value {} should have type {}, but is {}".format( expr.value, declared_type, assigned_type)) self._update_nested_ident(ident, expr, index) return [] def assign_vector_elem(self, children) -> List[Command]: vector_elem, expr = children ident = vector_elem.ident vector = vector_elem.container index = vector_elem.index if expr.type != Type.decimal(): raise CompileError( "Assigned value {} should have type decimal, but is {}".format( expr.value, expr.type)) self._update_nested_ident(ident, expr, index) return [] def repeat(self, children) -> List[Command]: expr = children[0] commands = children[1:] if expr.type != Type.int(): raise CompileError( "Expression {} should have type int, but is {}".format( expr.value, expr.type)) times = expr.value return commands * times ######## func ######## # TODO ######## func_command ######## # TODO ######## param_list ######## # TODO ######## func_call ######## # TODO ######## arg_list ######## # TODO ######## ident ######## def ident(self, children) -> Identifier: ident = "".join([str(child) for child in children]) if ident in self.symbol_table: return Identifier(str(ident), self.symbol_table.get_expression(ident)) return Identifier(str(ident), None) ######## list_elem ######## def list_elem(self, children) -> ListElem: expr1, expr2 = children if not isinstance(expr1.type, ListType): raise CompileError( "Expression {} has type {} is not a list".format( expr1, expr1.type)) if expr2.type != Type.int(): raise CompileError( "Expression {} should have type int, but is {}".format( expr2, expr2.type)) if expr2.value >= len(expr1.value): raise CompileError( "List {} has length {}, but has been assessed with out-of-range index {}" .format(expr1.ident, len(expr1.value), expr2.value)) return ListElem(expr1.ident, expr1, expr2.value) ######## vector_elem ######## def vector_x(self, children) -> VectorElem: expr, = children if expr.type != Type.vector(): raise CompileError( "Expression {} should have type vector, but is {}".format( expr, expr.type)) return VectorElem(expr.ident, expr, 0) def vector_y(self, children) -> VectorElem: expr, = children if expr.type != Type.vector(): raise CompileError( "Expression {} should have type vector, but is {}".format( expr, expr.type)) return VectorElem(expr.ident, expr, 1) def vector_z(self, children) -> VectorElem: expr, = children if expr.type != Type.vector(): raise CompileError( "Expression {} should have type vector, but is {}".format( expr, expr.type)) return VectorElem(expr.ident, expr, 2) ######## type ######## def int_type(self, children) -> Type: return Type.int() def decimal_type(self, children) -> Type: return Type.decimal() def string_type(self, children) -> Type: return Type.string() def boolean_type(self, children) -> Type: return Type.boolean() def vector_type(self, children) -> Type: return Type.vector() def list_type(self, children) -> Type: elem_type, = children return Type.list_of(elem_type) ######## expr ######## def expr(self, children) -> Expression: child, = children assert isinstance(child, AbstractExpression) if isinstance(child, Identifier) and child.ident not in self.symbol_table: # child.expression is None iff child.ident not in self.symbol_table raise CompileError("Identifier {} has not been declared".format( child.ident)) expr = child.to_expression() assert expr is not None and isinstance(expr, Expression) return expr def int_expr(self, children) -> Expression: signed_int, = children return Expression(Type.int(), int(signed_int)) def decimal_expr(self, children) -> Expression: signed_float, = children return Expression(Type.decimal(), float(signed_float)) def string_expr(self, children) -> Expression: escaped_string, = children quotation_removed = str(escaped_string)[1:-1] return Expression(Type.string(), quotation_removed) def true_expr(self, children) -> Expression: return Expression(Type.boolean(), True) def false_expr(self, children) -> Expression: return Expression(Type.boolean(), False) def list(self, children) -> Expression: exprs = children if len(exprs) == 0: return Expression(Type.empty_list(), []) if not all(e.type == exprs[0].type for e in exprs): raise CompileError( "Elements in list {} should have the same type".format(exprs)) return Expression(Type.list_of(exprs[0].type), [e.value for e in exprs]) def vector(self, children) -> Expression: expr1, expr2, expr3 = children for expr in [expr1, expr2, expr3]: if expr.type != Type.decimal(): raise CompileError( "Expression {} should have type decimal, but is {}".format( expr, expr.type)) return Expression(Type.vector(), [expr1.value, expr2.value, expr3.value])