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 __init__(self, path): archive = open(path, 'r').read() lex = Lexer(archive) tokens = lex.tokenize() parser = Parser(tokens) parser.parse()
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_parser(self): for path in glob.glob("test/grader/*/src.pas"): with open(path, 'r') as source: try: text = source.read() lexer = Lexer(text) tokens = lexer.lex() parser = Parser(tokens) parser.parse() except: ex = sys.exc_info()[0] self.fail("Failed to parse " + path + "\n" + ex) self.assertTrue(True)
def main(): if (len(sys.argv) < 2): print("Enter assembler file name") print("Example: ") print(f"{os.path.basename(sys.argv[0])} file.asm") input("Press Enter to exit...") asmFile = open(sys.argv[1], 'r') asmFileName = os.path.splitext(sys.argv[1])[0] asmProg = asmFile.readlines() asmFile.close() myParser = Parser(asmFileName) myParser.addData(asmProg) myParser.parse()
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_assignment(self): # x := 5\ny := not b + 7\ny := 'asd' # '123' tokens = [ MyToken(TokenType.IDENT, 'x', 'x', 1), MyToken(TokenType.ASSIGN, ':=', None, 1), MyToken(TokenType.NUMBER, '5', 5, 1), MyToken(TokenType.EOL, 'None', None, 1), MyToken(TokenType.IDENT, 'y', 'y', 2), MyToken(TokenType.ASSIGN, ':=', None, 2), MyToken(TokenType.NOT, 'not', None, 2), MyToken(TokenType.IDENT, 'b', 'b', 2), MyToken(TokenType.PLUS, '+', None, 2), MyToken(TokenType.NUMBER, '7', 7, 2), MyToken(TokenType.EOL, 'None', None, 2), MyToken(TokenType.IDENT, 'y', 'y', 3), MyToken(TokenType.ASSIGN, ':=', None, 3), MyToken(TokenType.STRING, 'asd', 'asd', 3), MyToken(TokenType.HASH, '#', None, 3), MyToken(TokenType.STRING, '123', '123', 3) ] parser = Parser(tokens) tree = \ Program([Assign(Identifier('x'), Literal(5)), Assign(Identifier('y'), Binary(LogicalUnary(TokenType.NOT, Identifier('b')), TokenType.PLUS, Literal(7))), Assign(Identifier('y'), StringBinary(Literal('asd'), TokenType.HASH, Literal('123')))]) self.assertEqual(tree, parser.parse())
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_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 run(self): """ Запускает парсер и музыку """ parser = Parser(self.file) self.track_name = os.path.basename(self.file) self.play(self.file) self.words_with_timings, self.sentences = parser.parse()
def print_valid_syntax(): for example in examples: # sentence = "(~(P) => (P | R))" # parser = Parser(sentence) parser = Parser(example) sentence = parser.parse() print(f"{example} is parsed as:", sentence) print(f" Sentence formula : {sentence.formula()}") print(f" CNF Form : {convert_to_cnf(sentence)}")
def testFixtureTwo(self): parser = Parser() fixture2 = parser.fixture2() (address, suite, postcode, description) = parser.parse(fixture2) expectedAddress = "329 bracknell, Doncastle Road, Bracknell, Berkshire" self.assertEquals(address, expectedAddress) self.assertEquals(postcode, None) self.assertEquals(suite, None)
def test_if(): source = """ b jest równe 5. Wypisz na ekranie b. Jeżeli b równa się b to wypisz na ekranie "jestem w body" oraz wypisz na ekranie "dalej w body" oraz wypisz na ekranie "chyba bangla". Tyle. Wypisz na ekranie "już poza body". """ lexer = Lexer().get_lexer() tokens = lexer.lex(source) pg = Parser() pg.parse() parser = pg.get_parser() context = {} parser.parse(tokens).eval(context)
def testFixtureOne(self): parser = Parser() fixture1 = parser.fixture1() (address, suite, postcode, description) = parser.parse(fixture1) expectedAddress = "Crown House, Toutley Road, Wokingham, Berkshire" self.assertEquals(address, expectedAddress) self.assertEquals(postcode, "RG41 1QW") self.assertEquals(suite, "Suite 2")
def test_advanced_if(): source = """ Jeżeli 5 jest wieksze od 3 to jeżeli 5 jest wieksze od 4 to wypisz na ekranie "jestem w zagnieżdżonym ifie" oraz wypisz na ekranie "5 jest większe od 3 i 4". Tyle. Tyle. Wypisz na ekranie "zagnieżdzony if 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 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 process(filename): with open(filename) as file: text = file.read() if not text: raise Exception("Cannot read text from file") tokenizer = Tokenizer(text) parser = Parser(tokenizer.create_tokens()) tree = parser.parse() symbol_table_builder = SemanticAnalyzer() symbol_table_builder.visit(tree)
def test_parser_with_adjectives_wrong(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "take the key rusty from the table" tree = parser.parse(src) self.assertFalse(tree)
def test_verb(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "move" tree = parser.parse(src) self.assertTrue(tree) self.assertEqual(tree.verb.verb.word, "move")
def test_expr_stmt(self): # 5 = 7\n x 3 + 2 tokens = \ [MyToken(TokenType.NUMBER, '5', 5, 1), MyToken(TokenType.EQUAL, '=', None, 1), MyToken(TokenType.NUMBER, '7', 7, 1), MyToken(TokenType.EOL, 'None', None, 1), MyToken(TokenType.IDENT, 'x', 'x', 2), MyToken(TokenType.NUMBER, '3', 3, 2), MyToken(TokenType.PLUS, '+', None, 2), MyToken(TokenType.NUMBER, '2', 2, 2)] parser = Parser(tokens) tree = \ Program([ExprStmt(Comparison(Literal(5), TokenType.EQUAL, Literal(7))), ExprStmt(Identifier('x')), ExprStmt(Binary(Literal(3), TokenType.PLUS, Literal(2)))]) self.assertEqual(tree, parser.parse())
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_parser_with_adjectives(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "take the rusty key from the table" tree = parser.parse(src) self.assertTrue(tree) self.assertTrue(tree.noun_phrase) self.assertEqual(tree.noun_phrase.modifier.adjective.word, "rusty")
def test_parser_phrasal_verb(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "pick up the torch" tree = parser.parse(src) self.assertTrue(tree) self.assertEqual(tree.verb.verb.word, "pick up") self.assertEqual(tree.noun_phrase.noun.word, "torch")
def show_text(self): """ Открывает диалоговое окно с тектом песни """ path = ( self.get_path() if not self.last_selected else self.last_selected ) if not self.check_path(path): return parser = Parser(path) text = parser.parse()[1] msgBox = QMessageBox() msgBox.setText("\n".join(text)) msgBox.exec()
def test_parser_complex(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "take the torch from the table" tree = parser.parse(src) self.assertTrue(tree) self.assertTrue(tree.prep_phrase) self.assertEqual(tree.prep_phrase.prep.prep.word, "from") self.assertEqual(tree.prep_phrase.noun_phrase.noun.word, "table")
def test_visitor_simple(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "move" tree = parser.parse(src) visitor = Visitor() command = tree.accept(visitor) self.assertTrue(command) self.assertEqual(command["verb"], "move")
def test_parser_with_adverb(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "move north" tree = parser.parse(src) self.assertTrue(tree) self.assertTrue(isinstance(tree, VerbPhrase)) self.assertTrue(isinstance(tree.verb.verb.word, str)) self.assertTrue(tree.verb.verb.word, "move") self.assertTrue(tree.adverb_phrase.adverb.word, "north")
def test_parser_simple(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "take the torch" tree = parser.parse(src) self.assertTrue(tree) self.assertTrue(isinstance(tree, VerbPhrase)) self.assertTrue(isinstance(tree.verb.verb.word, str)) self.assertTrue(tree.verb.verb.word, "take") self.assertTrue(tree.noun_phrase.noun.word, "torch")
def test_parser_phrasal_verb_complex(self): dictionary = Dictionary() filedir = os.path.dirname(os.path.realpath('__file__')) filename = os.path.join(filedir, "tests/dictionary.json") dictionary.load_words(filename) parser = Parser(dictionary) src = "pick up the rusty key from the table" tree = parser.parse(src) self.assertTrue(tree) self.assertEqual(tree.verb.verb.word, "pick up") self.assertEqual(tree.noun_phrase.modifier.adjective.word, "rusty") self.assertEqual(tree.noun_phrase.noun_phrase.noun.word, "key") self.assertEqual(tree.prep_phrase.prep.prep.word, "from") self.assertEqual(tree.prep_phrase.noun_phrase.noun.word, "table")
class ParserTest(unittest.TestCase): TESTDATA = os.path.join(os.path.dirname(__file__), "testing.kar") def setUp(self): self.parser = Parser(self.TESTDATA) def test_remove_comments(self): self.parser.syllables.extend(["@1", "@2", "@3", "4"]) self.parser.delta_times.extend([1, 2, 3, 4]) self.parser.remove_comments() self.assertEqual(["4"], self.parser.syllables) self.assertEqual([10], self.parser.delta_times) def test_make_words_with_timings(self): self.parser.syllables.extend(["1", "2 ", "/3", "4 "]) self.parser.delta_times.extend([1, 2, 3, 4]) result = self.parser.make_words_with_timings() self.assertEqual([("12 ", 3), ("/34 ", 7)], result) def test_split_words_by_sentences(self): result = self.parser.split_words_by_sentences([("/12", 3), ("34 ", 7), ("/33", 8), ("22", 90)]) self.assertEqual([[("12", 3), ("34", 7)], [("33", 8), ("22", 90)]], result) def test_make_sentences(self): result = self.parser.make_sentences([[("12", 3), ("34", 7)], [("33", 8), ("22", 90)]]) self.assertEqual(["12 34 ", "33 22 "], result) def test_process(self): self.parser.process() self.assertEqual(330, len(self.parser.syllables)) self.assertEqual(330, len(self.parser.delta_times)) def test_parse(self): words, sentences = self.parser.parse() self.assertEqual(42, len(words)) self.assertEqual(42, len(sentences))
import sys from src.assembler import Assembler from src.parser import Parser if __name__ == '__main__': program_name = sys.argv[1] hex = "" with open(program_name, 'r') as program: parser = Parser(program.read()) parsed_output = parser.parse() assembler = Assembler() hex = assembler.assemble(parsed_output) with open(program_name + '.hex', 'w') as hex_file: hex_file.write(hex) print "Written to " + program_name + '.hex'