def tree(text): lexer = Lexer(text) parser = Parser(lexer) tree = parser.parse() sem_an = SemanticAnalyzer(tree) sem_an.analyse() return tree
def test_parser_expr_assign(): text = 'a: int = (12 + 2) * 2;' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() assert isinstance(node1, Block) assert len(node1.children) == 2 node2 = node1.children[0] assert isinstance(node2, Assign) assert isinstance(node2.name, Variable) assert node2.type.type == 'TYPE' # TYPE Token as type assert node2.type.value == 'int' assert isinstance(node2.value, BinOp) node3 = node2.value assert isinstance(node3.left, BinOp) assert node3.op.value == '*' assert isinstance(node3.right, Number) node4 = node3.left assert isinstance(node4.left, Number) assert node4.op.value == '+' assert isinstance(node4.right, Number)
def test_parser_func_decl3(): text = """ function function_name(a: int, b: int) { return (b + a); } """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() func_decl = block.children[0] assert isinstance(func_decl, FuncDecl) # Params params = func_decl.formal_params assert isinstance(params, list) assert len(params) == 2 first_param = params[0] assert isinstance(first_param, Param) assert first_param.var_node.value == 'a' assert first_param.type_node.value == 'int' second_param = params[1] assert isinstance(second_param, Param) assert second_param.var_node.value == 'b' assert second_param.type_node.value == 'int' # Block func_block = func_decl.block_node assert isinstance(func_block, Block)
def testPrintVisitor(self): src = Source('./tests/test.minipl') scanner = Scanner(src) parser = Parser(scanner) ast = parser.program() pv = PrintVisitor() ast.accept(pv)
def testTypeCheckVisitor(self): return src = Source('./tests/test.minipl') scanner = Scanner(src) parser = Parser(scanner) ast = parser.program() tc = TypeCheck() ast.accept(tc)
def __createAstAndVisitor__(self, lines): src = MockSource(lines) scanner = Scanner(src) parser = Parser(scanner) ast = parser.program() tc = TypeCheck() ast.accept(tc) iv = InterpretingVisitor(tc.symbolTable) return ast, iv
def testInterpretingVisitorWithAFile(self, output, input): src = Source('./tests/test.minipl') scanner = Scanner(src) parser = Parser(scanner) ast = parser.program() tc = TypeCheck() ast.accept(tc) iv = InterpretingVisitor(tc.symbolTable) ast.accept(iv) output.assert_called_with('120')
def test_parser_function_call1(): text = """ some_function(); """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() func_call = block.children[0] assert isinstance(func_call, FuncCall) assert func_call.params == [] assert func_call.func_name == 'some_function' assert func_call.token.value == 'some_function'
def interpret(expression): try: parser = Parser(expression) node = parser.parse() result = node.traverse() namespace.set("_", result) return result except KeyError as key_error: print("Error: name {} is not defined".format(key_error)) except Exception as exception: print("{}: {}".format(type(exception).__name__, str(exception)))
def test_parser_statement_after_if(): text = """ if (a > 2) { print('yo'); } b: int = 4; """ lexer = Lexer(text) parser = Parser(lexer) main_block = parser.parse() if_node = main_block.children[0] assert isinstance(if_node, IfStatement) assgn_node = main_block.children[1] assert isinstance(assgn_node, Assign)
def main(): while True: try: text = input('rafmath: ') except (EOFError, KeyboardInterrupt): break if not text: continue if (text.lower() == 'exit'): break try: lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() if isinstance(result, int): print(result) if isinstance(result, float): result *= 1000 result = int(result) result = result / 1000 print(result) except: print('ERROR') pass
def test_parser_statement_before_if(): text = """ a: str = "hey"; if (a == 2) { print('yes'); } """ lexer = Lexer(text) parser = Parser(lexer) main_block = parser.parse() assign_node = main_block.children[0] assert isinstance(assign_node, Assign) if_node = main_block.children[1] assert isinstance(if_node, IfStatement)
def test_parser_print_bool(): text = 'print(True);' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() # First node should be Block assert isinstance(node1, Block) assert len(node1.children) == 2 # Print node and Empty node node2 = node1.children[0] assert isinstance(node2, Print) assert len(node2.args) == 1 node3 = node2.args[0] assert isinstance(node3, Boolean) assert node3.value == True
def test_parser_print_str(): text = 'print("Hello");' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() # First node should be Block assert isinstance(node1, Block) assert len(node1.children) == 2 # Print node and Empty node node2 = node1.children[0] assert isinstance(node2, Print) assert len(node2.args) == 1 node3 = node2.args[0] assert isinstance(node3, String) assert node3.value == 'Hello'
def test_parser_int_assign(): text = 'a: int = 46;' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() assert isinstance(node1, Block) assert len(node1.children) == 2 node2 = node1.children[0] assert isinstance(node2, Assign) assert isinstance(node2.name, Variable) assert node2.type.type == 'TYPE' # TYPE Token as type assert node2.type.value == 'int' assert isinstance(node2.value, Number) node3 = node2.value assert node3.value == 46
def test_parser_nested_func_call(): text = """ function some_function(a: int) { b: int = a + 1; return (b); } print(some_function(2)); """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() func_decl = block.children[0] assert isinstance(func_decl, FuncDecl) assert len(func_decl.formal_params) == 1 assert func_decl.func_name.value == 'some_function' print_statement = block.children[1] assert isinstance(print_statement, Print)
def test_parser_str_assign(): text = 'a: str = "string";' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() assert isinstance(node1, Block) assert len(node1.children) == 2 node2 = node1.children[0] assert isinstance(node2, Assign) assert isinstance(node2.name, Variable) assert node2.type.type == 'TYPE' # TYPE Token as type assert node2.type.value == 'str' assert isinstance(node2.value, String) node3 = node2.value assert node3.value == 'string'
def test_parser_bool_assign(): text = 'variable: bool = True;' lexer = Lexer(text) parser = Parser(lexer) node1 = parser.parse() assert isinstance(node1, Block) assert len(node1.children) == 2 node2 = node1.children[0] assert isinstance(node2, Assign) assert isinstance(node2.name, Variable) assert node2.type.type == 'TYPE' # TYPE Token as type assert node2.type.value == 'bool' assert isinstance(node2.value, Boolean) node3 = node2.value assert node3.value == True
def visit_TukuyinAccessNode(self, node): func_name = node.func_name tukuyin = self.conductor.use_tukuyin(func_name) params = tukuyin[0] body = tukuyin[1] parser = Parser(body, split=False).parse(from_main=False) isolated_interpreter = Interpreter(parser, self.conductor) isolated_interpreter.interpret()
def test_parser_if_comparison2(): text = """ if (a <= 2) { print('yo'); } """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() if_node = block.children[0] assert isinstance(if_node, IfStatement) assert isinstance(if_node.value, Comparison) assert isinstance(if_node.block, Block) assert if_node.elseblock is None comp_node = if_node.value assert isinstance(comp_node.left, Variable) assert comp_node.op.value == '<=' assert isinstance(comp_node.right, Number)
def run_interpreter(text): result = {} result['output'] = [] with Capturing() as output: try: lexer = Lexer(text) parser = Parser(lexer) tree = parser.parse() sem_an = SemanticAnalyzer(tree) sem_an.analyse() interpreter = Interpreter(tree) result['final_result'] = interpreter.interpret() except Exception as exc: result['exception'] = str(exc) if output: result['output'] = output return result
def evaluate(code: str, tape_size: int = 1000) -> str: """ Helper function which combines the process of lexing, syntax analysis, and parsing/evaluation to return either the finaly output or an error message. Parameters: code : str the brainfxck code to be evaluated. Returns: str """ # Pass the input code to the lexer, then to the syntax analyser # where if the is_faulty parameter is true, then the error messages # generated by the analyser method are returned, otherwise the # token stream is passed to the parser and the output generated # is returned # Lexical analysis to generate a token stream lexer = Lexer(code) token_stream = lexer.lex() syntax_analyser = SyntaxAnalyser(token_stream) error_dic = syntax_analyser.analyse() if error_dic["is_faulty"]: # Adding a newline character to the beginning of the error message op_string = "\n" # Traversing throught the faulty tokens in the token list for token in error_dic["faulty_token_list"]: op_string += ( f"Error for {token.op_name} at :: line : {token.line_number} position : {token.posn_number}\n" ) return op_string # Parsing the token stream to generate output parser = Parser(token_stream, tape_size) parser.parse() output = parser.output_string return output
def test_parser_function_call_with_params(): text = """ some_function(12 + 4, 'string', 78); """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() func_call = block.children[0] assert isinstance(func_call, FuncCall) assert len(func_call.params) == 3 assert func_call.func_name == 'some_function' assert func_call.token.value == 'some_function' first_param = func_call.params[0] assert isinstance(first_param, BinOp) second_param = func_call.params[1] assert isinstance(second_param, String) third_param = func_call.params[2] assert isinstance(third_param, Number)
def main(): argparser = argparse.ArgumentParser( description='Generate an AST DOT file.') argparser.add_argument('fname', help='Pascal source file') args = argparser.parse_args() fname = args.fname text = open(fname, 'r').read() lexer = Lexer(text) parser = Parser(lexer) viz = ASTVisualizer(parser) content = viz.gendot() print(content)
def test_parser_if_true(): text = """ if (True) { print('yo'); } """ lexer = Lexer(text) parser = Parser(lexer) block = parser.parse() if_node = block.children[0] assert isinstance(if_node, IfStatement) assert isinstance(if_node.value, Comparison) comparison = if_node.value assert comparison.left.value == True assert comparison.op is None assert comparison.right is None assert isinstance(if_node.block, Block) assert if_node.elseblock is None block_node = if_node.block assert isinstance(block_node.children[0], Print)
def main(): arg = sys.argv[1] processtime_in_ms = time.time() * 1000 with open(arg) as fs: # Generate Tokens lexer = Lexer(fs.read()) tokens = lexer.generate_tokens() # Generate AST parser = Parser(tokens) ast = parser.parse() # Global conductor instance conductor = Conductor() # Interpret AST interpreter = Interpreter(ast, conductor) interpreter.interpret() print(f"\nPROCESS TIME: {time.time() * 1000 - processtime_in_ms}ms")
def visit_KungNode(self, node): expressions = node.expressions condition = node.condition body = node.body exprs = [] for expression in expressions: expr = self.visit(expression) exprs.append(expr) if condition == TokenTypes.EQUALS: if exprs[0] == exprs[1]: parser = Parser(body, split=False).parse(from_main=False) isolated_interpreter = Interpreter(parser, self.conductor) isolated_interpreter.interpret()
def main(): while True: try: text = input('rafmath: ') except (EOFError, KeyboardInterrupt): break if text == 'exit': exit('Goodbye') if not text: continue text += ' ' lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() print(result)
def main(): while True: try: text = input('>>>RAFMATH ') except (EOFError, KeyboardInterrupt): break if not text: continue lexer = Lexer(text) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret() if result in (True, False): print(result) elif float(result).is_integer(): print("%.0f" % result) else: print("%.3f" % result)
def interpret(expression): """Interpret expression and return the result.""" lexer = Lexer(expression) parser = Parser(lexer) interpreter = Interpreter(parser) return interpreter.interpret()