def or_expr(self, idx):
try:
op, op_idx = self.consume(idx, TOKEN_IDS["||"])
except SileParseError, e:
# matches epsilon, the empty string
return Node("or_expr'"), idx
def test_comparison_no_compare():
tokens = lexer.tokenize("x + y")
want = Node("+").addkid(Node("NAME", "x")).addkid(Node("NAME", "y"))
got, out_idx = parser._Parser(tokens).comparison(0)
assert out_idx == 3
assert want == got
def test_and_expr_prime():
tokens = lexer.tokenize("&& x")
want = Node("and_expr'").addkid(Node("&&")).addkid(Node("NAME", "x"))
got, out_idx = parser._Parser(tokens).and_expr_prime(0)
assert out_idx == 2
assert want == got
def test_term_prime_mod():
tokens = lexer.tokenize("% x")
want = Node("term'").addkid(Node("%")).addkid(Node("NAME", "x"))
got, out_idx = parser._Parser(tokens).term_prime(0)
assert out_idx == 2
assert want == got
def test_arith_expr_prime_epsilon():
tokens = lexer.tokenize("x")
want = Node("expr'")
got, out_idx = parser._Parser(tokens).arith_expr_prime(0)
assert out_idx == 0
assert want == got
def test_factor():
tokens = lexer.tokenize("(400)")
want = Node("INTEGER", 400)
got, out_idx = parser._Parser(tokens).factor(0)
assert out_idx == 3
assert want == got
def test_unary_negate():
tokens = lexer.tokenize("- x")
want = Node("negate").addkid(Node("NAME", "x"))
got, out_idx = parser._Parser(tokens).unary(0)
assert out_idx == 2
assert want == got
def as_typed(n, t):
return Node(n.label, value=n.value, type=t)
def test_break_stmt():
tokens = lexer.tokenize("break")
want = Node("break")
got, out_idx = parser._Parser(tokens).break_stmt(0)
assert out_idx == 1
assert want == got
def factor_float(self, idx):
number, number_idx = self.consume(idx, TOKEN_IDS["FLOAT"])
n = Node("FLOAT", number.value)
return n, number_idx
def factor_int(self, idx):
number, number_idx = self.consume(idx, TOKEN_IDS["INTEGER"])
n = Node("INTEGER", number.value)
return n, number_idx
def expr_list(self, idx):
try:
expr, expr_idx = self.expr(idx)
except SileParseError, e:
# matches epsilon, the empty string
return Node("exprs"), idx
def call(self, idx):
_, open_paren_idx = self.consume(idx, TOKEN_IDS["("])
exprs, exprs_idx = self.expr_list(open_paren_idx)
_, close_paren_idx = self.consume(exprs_idx, TOKEN_IDS[")"])
n = Node("call").addkid(exprs)
return n, close_paren_idx
def arith_expr_prime(self, idx):
try:
op, op_idx = self.consume(idx, TOKEN_IDS["+"], TOKEN_IDS["-"])
except SileParseError, e:
# matches epsilon, the empty string
return Node("expr'"), idx
def test_factor_float():
tokens = lexer.tokenize("3.1")
want = Node("FLOAT", 3.1)
got, out_idx = parser._Parser(tokens).factor_float(0)
assert out_idx == 1
assert want == got
def test_continue_stmt():
tokens = lexer.tokenize("continue")
want = Node("continue")
got, out_idx = parser._Parser(tokens).continue_stmt(0)
assert out_idx == 1
assert want == got
def test_factor_paren():
tokens = lexer.tokenize("(2.0e0)")
want = Node("FLOAT", 2.0)
got, out_idx = parser._Parser(tokens).factor_paren(0)
assert out_idx == 3
assert want == got
def test_if_elseif_else_stmt():
tokens = lexer.tokenize('''
if x { print y } else if z { print a } else { print b }''')
want = (
Node("if")
.addkid(Node("NAME", "x"))
.addkid(Node("stmts")
.addkid(Node("print").addkid(Node("NAME", "y"))))
.addkid(Node("stmts")
.addkid(Node("if")
.addkid(Node("NAME", "z"))
.addkid(Node("stmts")
.addkid(Node("print").addkid(Node("NAME", "a"))))
.addkid(Node("stmts")
.addkid(Node("print").addkid(Node("NAME", "b")))))))
got, out_idx = parser._Parser(tokens).if_stmt(0)
assert out_idx == 18
assert want == got
def test_unary():
tokens = lexer.tokenize("x")
want = Node("NAME", "x")
got, out_idx = parser._Parser(tokens).unary(0)
assert out_idx == 1
assert want == got
def test_stmt_block_stmt():
tokens = lexer.tokenize("{ print x }")
want = Node("stmts").addkid(Node("print").addkid(Node("NAME", "x")))
got, out_idx = parser._Parser(tokens).stmt(0)
assert out_idx == 4
assert want == got
def test_term_prime_epsilon():
tokens = lexer.tokenize("x")
want = Node("term'")
got, out_idx = parser._Parser(tokens).term_prime(0)
assert out_idx == 0
assert want == got
def test_factor_name():
tokens = lexer.tokenize("wizard")
want = Node("NAME", "wizard")
got, out_idx = parser._Parser(tokens).factor_name(0)
assert out_idx == 1
assert want == got
def test_term():
tokens = lexer.tokenize("x * y")
want = Node("*").addkid(Node("NAME", "x")).addkid(Node("NAME", "y"))
got, out_idx = parser._Parser(tokens).term(0)
assert out_idx == 3
assert want == got
def test_call_no_args():
tokens = lexer.tokenize("()")
want = Node("call").addkid(Node("exprs"))
got, out_idx = parser._Parser(tokens).call(0)
assert out_idx == 2
assert want == got
def test_arith_expr_prime_sub():
tokens = lexer.tokenize("- x")
want = Node("expr'").addkid(Node("-")).addkid(Node("NAME", "x"))
got, out_idx = parser._Parser(tokens).arith_expr_prime(0)
assert out_idx == 2
assert want == got
def test_expr_list_trailing_comma():
tokens = lexer.tokenize("a,b,")
want = (Node("exprs").addkid(Node("NAME", "a")).addkid(Node("NAME", "b")))
got, out_idx = parser._Parser(tokens).expr_list(0)
assert out_idx == 4
assert want == got
def test_not_expr_nonot():
tokens = lexer.tokenize("x + y")
want = Node("+").addkid(Node("NAME", "x")).addkid(Node("NAME", "y"))
got, out_idx = parser._Parser(tokens).not_expr(0)
assert out_idx == 3
assert want == got
def test_factor_int():
tokens = lexer.tokenize("3")
want = Node("INTEGER", 3)
got, out_idx = parser._Parser(tokens).factor_int(0)
assert out_idx == 1
assert want == got
def test_or_expr():
tokens = lexer.tokenize("|| x")
want = Node("or_expr'").addkid(Node("||").addkid(Node("NAME", "x")))
got, out_idx = parser._Parser(tokens).or_expr(0)
assert out_idx == 2
assert want == got
def param(self, idx):
expr, expr_idx = self.expr(idx)
_, colon_idx = self.consume(expr_idx, TOKEN_IDS[":"])
type_expr, type_expr_idx = self.type_expr(colon_idx)
n = Node("param").addkid(expr).addkid(type_expr)
return n, type_expr_idx