def test_var(self):
line = 'var beverage = "espresso";\nprint beverage;'
scanner = Scanner(line)
tokens = scanner.scan_tokens()
parser = Parser(tokens, "")
statements = parser.parse()
Interpreter().interpret(statements)
def run_prompt(prompt: str = "lox> ") -> None:
while True:
global gHadError
gHadError = False
try:
line = input(prompt)
except EOFError:
break
scanner = Scanner(line)
tokens = scanner.scan_tokens()
parser = Parser(tokens)
syntax = parser.parse_repl()
# Ignore it if there was a syntax error.
if gHadError:
continue
if isinstance(syntax, list):
gInterpreter.interpret(syntax)
elif isinstance(syntax, Expr):
result = gInterpreter.interpret_repl(syntax)
if result is not None:
print(f"= {result}")
def run(self, line):
""" Runs the input
:param line: line to tokenize and eval
"""
scanner = Scanner(line)
tokens = scanner.scan_tokens()
parser = Parser(tokens, self.error)
statements = parser.parse()
self.interpreter.interpret(statements)
if self.had_error:
return
def run(source: str) -> None:
scanner = Scanner(source)
tokens = scanner.scan_tokens()
parser = Parser(tokens)
statements = parser.parse()
if gHadError:
return
gInterpreter.interpret(statements)
def try_read_and_evaluate(self, source):
tokens = Scanner(source, verbose=self.verbose).scan_tokens()
if self.verbose:
print(" tokens -> {}".format(tokens))
parser = Parser(tokens)
try:
statements = parser.parse()
except Exception as e:
print("Error parsing statements: {}".format(e))
return
if self.verbose:
print(" statements -> {}".format(statements))
self.interpreter.interpret(statements)
def test_literal_expression(self):
# 5;
tokens = [
Token(TokenType.NUMBER, "5", 5.0, 0),
Token(TokenType.SEMICOLON, ";", None, 0),
Token(TokenType.EOF, "", None, 0),
]
parser = Parser(tokens)
statements = parser.parse()
self.assertEqual(len(statements), 1, "Expected 1 statement")
expression_statement = statements[0]
self.assertTrue(isinstance(expression_statement, Expression))
literal_expression = expression_statement.expression
self.assertTrue(isinstance(literal_expression, LiteralExpr))
self.assertEqual(literal_expression.value, 5)
def test_print_statement(self):
# print 20;
tokens = [
Token(TokenType.PRINT, "print", None, 0),
Token(TokenType.NUMBER, "20", 20.0, 0),
Token(TokenType.SEMICOLON, ";", None, 0),
Token(TokenType.EOF, "", None, 0),
]
parser = Parser(tokens)
statements = parser.parse()
self.assertEqual(len(statements), 1, "Expected 1 statement")
self.assertTrue(isinstance(statements[0], Print))
expression = statements[0].expression
self.assertTrue(isinstance(expression, LiteralExpr))
self.assertEqual(expression.value, 20)
def test_binary_expression(self):
# 10 <= 20;
tokens = [
Token(TokenType.NUMBER, "10", 10.0, 0),
Token(TokenType.LESS_EQUAL, "<=", None, 0),
Token(TokenType.NUMBER, "20", 20.0, 0),
Token(TokenType.SEMICOLON, ";", None, 0),
Token(TokenType.EOF, "", None, 0),
]
parser = Parser(tokens)
statements = parser.parse()
self.assertEqual(len(statements), 1, "Expected 1 statement")
expression = statements[0].expression
self.assertTrue(isinstance(expression, BinaryExpr))
self.assertEqual(expression.left.value, 10)
self.assertEqual(expression.operator.token_type, TokenType.LESS_EQUAL)
self.assertEqual(expression.right.value, 20)
def test_sub(self):
"""
test subtraction
:return: None
"""
line = '9 - 8;'
scanner = Scanner(line)
tokens = scanner.scan_tokens()
ast = Parser(tokens, "").parse()
assert ast[0].expression.left.value == 9
assert ast[0].expression.operator.lexeme == '-'
assert ast[0].expression.right.value == 8
def test_negative(self):
"""
test negative number
:return: None
"""
line = '2 * -8;'
scanner = Scanner(line)
tokens = scanner.scan_tokens()
ast = Parser(tokens, "").parse()
print(ast)
assert ast[0].expression.left.value == 2
assert ast[0].expression.operator.lexeme == '*'
assert ast[0].expression.right.operator.lexeme == '-'
assert ast[0].expression.right.right.value == 8
def test_add(self):
"""
test addition
:return: None
"""
line = '3 + 4;'
scanner = Scanner(line)
tokens = scanner.scan_tokens()
ast = Parser(tokens, "").parse()
print(ast)
assert isinstance(ast[0], stmt.Expression)
assert ast[0].expression.left.value == 3
assert ast[0].expression.operator.lexeme == '+'
assert ast[0].expression.right.value == 4
def test_paren(self):
"""
test paren
:return: None
"""
line = '2 * (5 + 8);'
scanner = Scanner(line)
tokens = scanner.scan_tokens()
ast = Parser(tokens, "").parse()
assert ast[0].expression.left.value == 2
assert ast[0].expression.operator.lexeme == '*'
assert ast[0].expression.right.__class__ == expr.Grouping
assert ast[0].expression.right.expression.left.value == 5
assert ast[0].expression.right.expression.operator.lexeme == '+'
assert ast[0].expression.right.expression.right.value == 8