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'
