def test_set_cardinality(self): lexer = Lexer('#{1}') self.assertEqual(lexer.get_next_token(), Token(Type.CARD, '#')) self.assertEqual(lexer.get_next_token(), Token(Type.OPENC, '{')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 1)) self.assertEqual(lexer.get_next_token(), Token(Type.CLOSEC, '}')) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_functions(self): lexer = Lexer( 'fun f(x) {ret x}\nfun f2(x, y,z) {\nx - y\n}\nf() + 3 - g(x, y)(3)' ) expected = \ [MyToken(TokenType.FUN, 'fun', None, 1), MyToken(TokenType.IDENT, 'f', 'f', 1), MyToken(TokenType.LPAREN, '(', None, 1), MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.RPAREN, ')', None, 1), MyToken(TokenType.LBRACE, '{', None, 1), MyToken(TokenType.RET, 'ret', None, 1), MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.RBRACE, '}', None, 1), MyToken(TokenType.EOL, None, None, 1), MyToken(TokenType.FUN, 'fun', None, 2), MyToken(TokenType.IDENT, 'f2', 'f2', 2), MyToken(TokenType.LPAREN, '(', None, 2), MyToken(TokenType.IDENT, 'x', 'x', 2), MyToken(TokenType.COMMA, ',', None, 2), MyToken(TokenType.IDENT, 'y', 'y', 2), MyToken(TokenType.COMMA, ',', None, 2), MyToken(TokenType.IDENT, 'z', 'z', 2), MyToken(TokenType.RPAREN, ')', None, 2), MyToken(TokenType.LBRACE, '{', None, 2), MyToken(TokenType.EOL, None, None, 2), MyToken(TokenType.IDENT, 'x', 'x', 3), MyToken(TokenType.MINUS, '-', None, 3), MyToken(TokenType.IDENT, 'y', 'y', 3), MyToken(TokenType.EOL, None, None, 3), MyToken(TokenType.RBRACE, '}', None, 4), MyToken(TokenType.EOL, None, None, 4), MyToken(TokenType.IDENT, 'f', 'f', 5), MyToken(TokenType.LPAREN, '(', None, 5), MyToken(TokenType.RPAREN, ')', None, 5), MyToken(TokenType.PLUS, '+', None, 5), MyToken(TokenType.NUMBER, '3', 3, 5), MyToken(TokenType.MINUS, '-', None, 5), MyToken(TokenType.IDENT, 'g', 'g', 5), MyToken(TokenType.LPAREN, '(', None, 5), MyToken(TokenType.IDENT, 'x', 'x', 5), MyToken(TokenType.COMMA, ',', None, 5), MyToken(TokenType.IDENT, 'y', 'y', 5), MyToken(TokenType.RPAREN, ')', None, 5), MyToken(TokenType.LPAREN, '(', None, 5), MyToken(TokenType.NUMBER, '3', 3, 5), MyToken(TokenType.RPAREN, ')', None, 5)] self.assertEqual(expected, lexer.lex())
def test_vector_transposition(self): lexer = Lexer('(1)**T') self.assertEqual(lexer.get_next_token(), Token(Type.OPENP, '(')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 1)) self.assertEqual(lexer.get_next_token(), Token(Type.CLOSEP, ')')) self.assertEqual(lexer.get_next_token(), Token(Type.TPOSE, '**T')) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_real_must_have_fraction_again(self): lexer = Lexer('1.0 + 1.') self.assertEqual(lexer.get_next_token(), Token(Type.REAL, 1.0)) self.assertEqual(lexer.get_next_token(), Token(Type.UNION, '+')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 1)) self.assertEqual(lexer.get_next_token(), Token(Type.PERIOD, '.')) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_real_no_leading_zeros(self): lexer = Lexer('0.00 + 00.0') self.assertEqual(lexer.get_next_token(), Token(Type.REAL, 0.00)) self.assertEqual(lexer.get_next_token(), Token(Type.UNION, '+')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 0)) self.assertEqual(lexer.get_next_token(), Token(Type.REAL, 0.0)) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_integer_no_leading_zeros(self): lexer = Lexer('0 + 00') self.assertEqual(lexer.get_next_token(), Token(Type.INT, 0)) self.assertEqual(lexer.get_next_token(), Token(Type.UNION, '+')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 0)) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 0)) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def main(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument('read_path') arg_parser.add_argument('write_path') args = arg_parser.parse_args() with open(args.read_path, 'r') as source: text = source.read() lexer = Lexer(text) tokens = lexer.lex() parser = Parser(tokens) ast = parser.parse() symbolizer = Symbolizer(ast) symbolizer.symbolize() optimizer = Optimizer(ast) optimizer.optimize() grapher = Grapher(ast) grapher.graph() generator = Generator(ast) generator.generate(args.write_path) runner = Runner(ast) runner.run()
def test_test(): source = """a jest równe 2. Zwiększ a o 5. Wypisz na ekranie a. b jest równe 4+a-(2-a). Zmniejsz b o b+1. c jest równe "jestem sobie zmienna c". Wypisz na ekranie b+b. Wypisz na ekranie "ELO :P". Wypisz na ekranie "Wpisałem w puste miejsca _, _, _!", w puste miejsce wpisz "siema",1,(2-5). Wypisz na ekranie "Wpisałem w puste miejsce _, _!", w puste miejsce wpisz "elo", "siemano". Wypisz na ekranie "zmienna a = _, zmienna b = _, zmienna c = _!", w puste miejsce wpisz a,b,c. Wypisz na ekranie b jest wieksze od b. Wypisz na ekranie b jest mniejsze od b. Wypisz na ekranie b równa się b. Wypisz na ekranie b jest różne od b. Jeżeli b jest mniejsze od b to wypisz na ekranie "b<b". Tyle. Jeżeli a jest mniejsze od b to wypisz na ekranie "a<b". Tyle. Jeżeli b jest mniejsze od a to wypisz na ekranie "b<a". Tyle. """ lexer = Lexer().get_lexer() tokens = lexer.lex(source) pg = Parser() pg.parse() parser = pg.get_parser() context = {} parser.parse(tokens).eval(context)
def test_generator(self): for path in glob.glob("test/grader/*/src.pas"): dir = os.path.dirname(path) should_fail = not dir.endswith('16') with open(path, 'r') as source: print(f"testing {path}") text = source.read() lexer = Lexer(text) tokens = lexer.lex() parser = Parser(tokens) ast = parser.parse() symbolizer = Symbolizer(ast) symbolizer.symbolize() grapher = Generator(ast, symbolizer) grapher.generate() sol = os.path.join(dir, 'src.c') out = os.path.join(dir, 'out') if os.path.exists(sol): os.remove(sol) if os.path.exists(out): os.remove(out) grapher.write(sol) p = None try: p = sp.Popen(['gcc', sol, '-o', out], stdout=sp.PIPE) retCode = p.wait() self.assertTrue(retCode == 0) p.stdout.close() #s = str(p.stdout.read()) #self.assertTrue(s == '') except Exception: self.assertFalse(should_fail) for i in range(1, 5): inFile = os.path.join(dir, str(i) + '.in') outFile = os.path.join(dir, str(i) + '.out') with open(inFile, 'r') as inText: with open(outFile, 'r') as outText: inText = inText.read() outText = outText.read() try: of = sp.Popen([out], stdin=sp.PIPE, stdout=sp.PIPE) of.stdin.write(inText.encode('utf-8')) of.stdin.close() rc = of.wait() self.assertTrue(rc == 0) b = of.stdout.read() s = b.decode('utf-8') of.stdout.close() if (not should_fail): self.assertEqual(s, str(outText)) except Exception: self.assertFalse(should_fail) self.assertTrue(True) #Tests().test_grapher()
def __init__(self, path): archive = open(path, 'r').read() lex = Lexer(archive) tokens = lex.tokenize() parser = Parser(tokens) parser.parse()
def Test_number(self): l = Lexer() caso1 = False for token in l.tokenize("10"): if token.type == "NUMBER": caso1 = True self.assertAlmostEqual(caso1, True) self.assertAlmostEqual(False, True)
def test_vector_norm(self): lexer = Lexer('|| (1) ||') self.assertEqual(lexer.get_next_token(), Token(Type.NORM, '||')) self.assertEqual(lexer.get_next_token(), Token(Type.OPENP, '(')) self.assertEqual(lexer.get_next_token(), Token(Type.INT, 1)) self.assertEqual(lexer.get_next_token(), Token(Type.CLOSEP, ')')) self.assertEqual(lexer.get_next_token(), Token(Type.NORM, '||')) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_reserved_values(self): lexer = Lexer('e false null pi true') self.assertEqual(lexer.get_next_token(), Token(Type.REAL, math.e)) self.assertEqual(lexer.get_next_token(), Token(Type.BOOL, False)) self.assertEqual(lexer.get_next_token(), Token(Type.NULL, None)) self.assertEqual(lexer.get_next_token(), Token(Type.REAL, math.pi)) self.assertEqual(lexer.get_next_token(), Token(Type.BOOL, True)) self.assertEqual(lexer.get_next_token(), Token(Type.EOF, ''))
def test_should_properly_tokenize_a_full_method_definition(self): lexer = Lexer('func add(a: Int, b: Int): Int = {\n' + ' a + b\n' + '}') tokens = lexer.tokenize(); self.assertEqual(21, len(tokens)) self.assertEqual(tokens[0].type, TokenType.FUNC) self.assertEqual(tokens[1].type, TokenType.IDENTIFIER) self.assertEqual(tokens[1].value, 'add') self.assertEqual(tokens[2].type, TokenType.LEFT_PAREN) self.assertEqual(tokens[3].type, TokenType.IDENTIFIER) self.assertEqual(tokens[3].value, 'a') self.assertEqual(tokens[4].type, TokenType.COLON) self.assertEqual(tokens[5].type, TokenType.IDENTIFIER) self.assertEqual(tokens[5].value, 'Int') self.assertEqual(tokens[6].type, TokenType.COMMA) self.assertEqual(tokens[7].type, TokenType.IDENTIFIER) self.assertEqual(tokens[7].value, 'b') self.assertEqual(tokens[8].type, TokenType.COLON) self.assertEqual(tokens[9].type, TokenType.IDENTIFIER) self.assertEqual(tokens[9].value, 'Int') self.assertEqual(tokens[10].type, TokenType.RIGHT_PAREN) self.assertEqual(tokens[11].type, TokenType.COLON) self.assertEqual(tokens[12].type, TokenType.IDENTIFIER) self.assertEqual(tokens[12].value, 'Int') self.assertEqual(tokens[13].type, TokenType.EQUAL) self.assertEqual(tokens[14].type, TokenType.LEFT_BRACE) self.assertEqual(tokens[15].type, TokenType.NEWLINE) self.assertEqual(tokens[16].type, TokenType.IDENTIFIER) self.assertEqual(tokens[16].value, 'a') self.assertEqual(tokens[17].type, TokenType.PLUS) self.assertEqual(tokens[18].type, TokenType.IDENTIFIER) self.assertEqual(tokens[18].value, 'b') self.assertEqual(tokens[19].type, TokenType.NEWLINE) self.assertEqual(tokens[20].type, TokenType.RIGHT_BRACE)
def test_keyword(self): lexer = Lexer('if x {}\nelse elses i ifs} while{ print printx _print') expected = \ [MyToken(TokenType.IF, 'if', None, 1), MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.LBRACE, '{', None, 1), MyToken(TokenType.RBRACE, '}', None, 1), MyToken(TokenType.EOL, None, None, 1), MyToken(TokenType.ELSE, 'else', None, 2), MyToken(TokenType.IDENT, 'elses', 'elses', 2), MyToken(TokenType.IDENT, 'i', 'i', 2), MyToken(TokenType.IDENT, 'ifs', 'ifs', 2), MyToken(TokenType.RBRACE, '}', None, 2), MyToken(TokenType.WHILE, 'while', None, 2), MyToken(TokenType.LBRACE, '{', None, 2), MyToken(TokenType.IDENT, 'print', 'print', 2), MyToken(TokenType.IDENT, 'printx', 'printx', 2), MyToken(TokenType.IDENT, '_print', '_print', 2)] self.assertEqual(expected, lexer.lex())
def test_with_spaces(self): lexer = Lexer(" </ tag > ") open_token = lexer.get_next_token() id = lexer.get_next_token() close_token = lexer.get_next_token() self.assertIsInstance(open_token, OpenOfTagWithSlashToken) self.assertIsInstance(id, IdToken) self.assertEqual(id.value, "tag") self.assertIsInstance(close_token, CloseOfTagToken)
def __init__(self): """ The class needs: the Environment instance for storing variables, the Parser and Lexer instances for parsing and lexing the input. """ self.__env = Environment() self.__parser = Parser(self.__env) self.__lexer = Lexer()
def run(file_name, text): lexer = Lexer(file_name, text) tokens, error = lexer.makeTokens() if error: return None, error parser = Parser(tokens) ast = parser.parse() # ast => Abstract Syntax Tree return ast.node, ast.error
def test_empty(): source = "" lexer = Lexer().get_lexer() tokens = lexer.lex(source) pg = Parser() pg.parse() parser = pg.get_parser() context = {} parser.parse(tokens).eval(context)
def test_strings(self): lexer = Lexer('\'try\' try \'if}\'#\' asd\' \'\'') expected = [ MyToken(TokenType.STRING, 'try', 'try', 1), MyToken(TokenType.IDENT, 'try', 'try', 1), MyToken(TokenType.STRING, 'if}', 'if}', 1), MyToken(TokenType.HASH, '#', None, 1), MyToken(TokenType.STRING, ' asd', ' asd', 1), MyToken(TokenType.STRING, '', '', 1) ] self.assertEqual(expected, lexer.lex())
def test_floats(self): lexer = Lexer('4 + 12.3 - 3. .1') expected = [ MyToken(TokenType.NUMBER, '4', 4, 1), MyToken(TokenType.PLUS, '+', None, 1), MyToken(TokenType.NUMBER, '12.3', 12.3, 1), MyToken(TokenType.MINUS, '-', None, 1), MyToken(TokenType.NUMBER, '3.', 3., 1), MyToken(TokenType.NUMBER, '.1', .1, 1) ] self.assertEqual(expected, lexer.lex())
def _test_with_params(self, params): for i in range(len(params)): expr, lex_expected = params[i] lex_actual = Lexer(expr).lex() # Every lexer result ends with this token. It is nicer and # more performant to remove it from the result instead of # mutating data or creating new lex_expected (using + on arrays) self.assertEqual(('TERMINATE_TOKEN', ''), lex_actual.pop()) self.assertEqual( lex_expected, lex_actual, f'Error on the {i} param set with the expression "{expr}"')
def test_lexer(self): for path in glob.glob("test/grader/*/src.pas"): with open(path, 'r') as source: try: text = source.read() lexer = Lexer(text) lexer.lex() except: ex = sys.exc_info()[0] self.fail("Failed to lex " + path + "\n" + ex) self.assertTrue(True)
def test_assignment(self): lexer = Lexer('x:= 7\nx = 7') expected = [ MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.ASSIGN, ':=', None, 1), MyToken(TokenType.NUMBER, '7', 7, 1), MyToken(TokenType.EOL, None, None, 1), MyToken(TokenType.IDENT, 'x', 'x', 2), MyToken(TokenType.EQUAL, '=', None, 2), MyToken(TokenType.NUMBER, '7', 7, 2) ] self.assertEqual(expected, lexer.lex())
def test_oneline_computation(self): text = "print: 4 * var + 1" lexer = Lexer() tokens = lexer.get_tokens(text) expect = [ Token(token_type=TokenType.identifier, value='print'), Token(token_type=TokenType.operator, value=':'), Token(token_type=TokenType.number, value='4'), Token(token_type=TokenType.operator, value='*'), Token(token_type=TokenType.identifier, value='var'), Token(token_type=TokenType.operator, value='+'), Token(token_type=TokenType.number, value='1')] self.assertEqual(tokens, expect)
def test_symbolizer(self): for path in glob.glob("test/grader/*/src.pas"): with open(path, 'r') as source: print(f"testing {path}") text = source.read() lexer = Lexer(text) tokens = lexer.lex() parser = Parser(tokens) ast = parser.parse() symbolizer = Symbolizer(ast) symbolizer.symbolize() self.assertTrue(True)
def test_booleans(self): lexer = Lexer( 'true false trues = true 7 < 12 <= > y>=x or xor and not_ < not true' ) expected = \ [MyToken(TokenType.TRUE, 'true', True, 1), MyToken(TokenType.FALSE, 'false', False, 1), MyToken(TokenType.IDENT, 'trues', 'trues', 1), MyToken(TokenType.EQUAL, '=', None, 1), MyToken(TokenType.TRUE, 'true', True, 1), MyToken(TokenType.NUMBER, '7', 7, 1), MyToken(TokenType.L, '<', None, 1), MyToken(TokenType.NUMBER, '12', 12, 1), MyToken(TokenType.LE, '<=', None, 1), MyToken(TokenType.G, '>', None, 1), MyToken(TokenType.IDENT, 'y', 'y', 1), MyToken(TokenType.GE, '>=', None, 1), MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.OR, 'or', None, 1), MyToken(TokenType.IDENT, 'xor', 'xor', 1), MyToken(TokenType.AND, 'and', None, 1), MyToken(TokenType.IDENT, 'not_', 'not_', 1), MyToken(TokenType.L, '<', None, 1), MyToken(TokenType.NOT, 'not', None, 1), MyToken(TokenType.TRUE, 'true', True, 1)] self.assertEqual(expected, lexer.lex())
def test_should_tokenize_a_simple_expression(self): lexer = Lexer('42 + 21') tokens = lexer.tokenize() self.assertEqual(3, len(tokens)) self.assertEqual(tokens[0].type, TokenType.INTEGER) self.assertEqual(tokens[0].value, '42') self.assertEqual(tokens[1].type, TokenType.PLUS) self.assertEqual(tokens[1].value, '+') self.assertEqual(tokens[2].type, TokenType.INTEGER) self.assertEqual(tokens[2].value, '21')
def test_if_else(): source = """ Jeżeli 2 jest wieksze od 3 to wypisz na ekranie "jestem w ifie". W przeciwnym razie wypisz na ekranie "jestem w elsie". Tyle. Wypisz na ekranie "ifelse działa". """ lexer = Lexer().get_lexer() tokens = lexer.lex(source) pg = Parser() pg.parse() parser = pg.get_parser() context = {} parser.parse(tokens).eval(context)
def test_identifiers(self): lexer = Lexer('x + 7 - test123( 18 x x18 /_try-') expected = [ MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.PLUS, '+', None, 1), MyToken(TokenType.NUMBER, '7', 7, 1), MyToken(TokenType.MINUS, '-', None, 1), MyToken(TokenType.IDENT, 'test123', 'test123', 1), MyToken(TokenType.LPAREN, '(', None, 1), MyToken(TokenType.NUMBER, '18', 18, 1), MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.IDENT, 'x18', 'x18', 1), MyToken(TokenType.DIV, '/', None, 1), MyToken(TokenType.IDENT, '_try', '_try', 1), MyToken(TokenType.MINUS, '-', None, 1) ] self.assertEqual(expected, lexer.lex())
def __init__(self, text): self.lexer = Lexer(text) self.token = self.lexer.get_next_token() self.ae()
class Interpreter: def __init__(self, text): self.lexer = Lexer(text) self.token = self.lexer.get_next_token() self.ae() @staticmethod def is_first_of_term(type): return type == Type.UNION or type == Type.DIFF or \ type == Type.NOT or type == Type.CARD or \ type == Type.ID or type == Type.NULL or \ type == Type.INT or type == Type.REAL or \ type == Type.BOOL or type == Type.STRING or \ type == Type.OPENP or type == Type.OPENB or \ type == Type.OPENC def ae(self): if Interpreter.is_first_of_term(self.token.type): self.c5e() else: raise if self.token.type != Type.EOF: raise def c5e(self): if Interpreter.is_first_of_term(self.token.type): self.c4e() self.c5e_prime() else: raise def c5e_prime(self): if self.token.type == Type.EQ or self.token.type == Type.NEQ or \ self.token.type == Type.GT or self.token.type == Type.GTEQ or \ self.token.type == Type.LT or self.token.type == Type.LTEQ: self.c5o() self.c5e() def c5o(self): if self.token.type == Type.EQ: self.token = self.lexer.get_next_token() elif self.token.type == Type.NEQ: self.token = self.lexer.get_next_token() elif self.token.type == Type.GT: self.token = self.lexer.get_next_token() elif self.token.type == Type.GTEQ: self.token = self.lexer.get_next_token() elif self.token.type == Type.LT: self.token = self.lexer.get_next_token() elif self.token.type == Type.LTEQ: self.token = self.lexer.get_next_token() else: raise def c4e(self): if Interpreter.is_first_of_term(self.token.type): self.c3e() self.c4e_prime() else: raise def c4e_prime(self): if self.token.type == Type.UNION or self.token.type == Type.DIFF: self.c4o() self.c4e() def c4o(self): if self.token.type == Type.UNION: self.token = self.lexer.get_next_token() elif self.token.type == Type.DIFF: self.token = self.lexer.get_next_token() else: raise def c3e(self): if Interpreter.is_first_of_term(self.token.type): self.c2e() self.c3e_prime() else: raise def c3e_prime(self): if self.token.type == Type.AND or self.token.type == Type.XOR: self.c3o() self.c3e() def c3o(self): if self.token.type == Type.AND: self.token = self.lexer.get_next_token() elif self.token.type == Type.XOR: self.token = self.lexer.get_next_token() else: raise def c2e(self): if Interpreter.is_first_of_term(self.token.type): self.c1e() self.c2e_prime() else: raise def c2e_prime(self): if self.token.type == Type.COMPOSE or self.token.type == Type.DIV or \ self.token.type == Type.MOD: self.c2o() self.c2e() def c2o(self): if self.token.type == Type.COMPOSE: self.token = self.lexer.get_next_token() elif self.token.type == Type.DIV: self.token = self.lexer.get_next_token() elif self.token.type == Type.MOD: self.token = self.lexer.get_next_token() else: raise def c1e(self): if Interpreter.is_first_of_term(self.token.type): self.c0e() self.c1e_prime() else: raise def c1e_prime(self): if self.token.type == Type.TPOSE or self.token.type == Type.POW: self.c1o() self.c1e() def c1o(self): if self.token.type == Type.TPOSE: self.token = self.lexer.get_next_token() elif self.token.type == Type.POW: self.token = self.lexer.get_next_token() else: raise def c0e(self): if Interpreter.is_first_of_term(self.token.type): self.term() else: raise def term(self): if self.token.type == Type.UNION or self.token.type == Type.DIFF: self.unary_op() self.var_num_term() elif self.token.type == Type.NOT: self.token = self.lexer.get_next_token() if self.token.type == Type.BOOL or self.token.type == Type.NULL: self.bool_term() elif self.token.type == Type.ID: self.token = self.lexer.get_next_token() else: raise elif self.token.type == Type.ID or self.token.type == Type.INT or \ self.token.type == Type.REAL or self.token.type == Type.CARD: self.var_num_term() elif self.token.type == Type.BOOL or self.token.type == Type.NULL or \ self.token.type == Type.OPENP or self.token.type == type.OPENB or \ self.token.type == Type.OPENC or self.token.type == Type.STRING: self.constant_term() else: raise def unary_op(self): if self.token.type == Type.UNION: self.token = self.lexer.get_next_token() elif self.token.type == Type.DIFF: self.token = self.lexer.get_next_token() else: raise def var_num_term(self): if self.token.type == Type.ID: self.token = self.lexer.get_next_token() self.fact() elif self.token.type == Type.INT or self.token.type == Type.REAL or \ self.token.type == Type.CARD: self.num_term() else: raise def num_term(self): if self.token.type == Type.INT: self.token = self.lexer.get_next_token() self.fact() elif self.token.type == Type.REAL: self.token = self.lexer.get_next_token() elif self.token.type == Type.CARD: self.card_term() self.fact() else: raise def card_term(self): if self.token.type == Type.CARD: self.token = self.lexer.get_next_token() if self.token.type == Type.ID: self.token = self.lexer.get_next_token() elif self.token.type == Type.OPENP or self.token.type == Type.OPENB or \ self.token.type == Type.OPENC: self.struct_term() else: raise else: raise def fact(self): if self.token.type == Type.FACT: self.token = self.lexer.get_next_token() def struct_term(self): if self.token.type == Type.OPENP: self.token = self.lexer.get_next_token() self.e_list() if self.token.type == Type.CLOSEP: self.token = self.lexer.get_next_token() else: raise elif self.token.type == Type.OPENB: self.token = self.lexer.get_next_token() self.e_list() if self.token.type == Type.CLOSEB: self.token = self.lexer.get_next_token() else: raise elif self.token.type == Type.OPENC: self.token = self.lexer.get_next_token() self.e_list() if self.token.type == Type.CLOSEC: self.token = self.lexer.get_next_token() else: raise else: raise def e_list(self): if Interpreter.is_first_of_term(self.token.type): self.c5e() self.e_list_tail() else: raise def e_list_tail(self): if self.token.type == Type.COMMA: self.token = self.lexer.get_next_token() self.e_list() def bool_term(self): if self.token.type == Type.BOOL: self.token = self.lexer.get_next_token() elif self.token.type == Type.NULL: self.token = self.lexer.get_next_token() else: raise def constant_term(self): if self.token.type == Type.BOOL or self.token.type == Type.NULL: self.bool_term() elif self.token.type == Type.OPENP or self.token.type == Type.OPENB or \ self.token.type == Type.OPENC: self.struct_term() elif self.token.type == Type.STRING: self.token = self.lexer.get_next_token() else: raise