def test_codeGen_11(self): tokelist = Lexer('B\/(C),A/\!B').tokenize() parse_tree = Parser().parse(tokelist) generator = CodeGen(tokelist, parse_tree) generator.generate() output = generator.runCode() self.assertEqual(output, 'True')
def test_codeGen_8(self): tokelist = Lexer('A/\((B/\(C\/D))),A\/C').tokenize() parse_tree = Parser().parse(tokelist) generator = CodeGen(tokelist, parse_tree) generator.generate() output = generator.runCode() self.assertEqual(output, 'True')
def test_codeGen_5(self): tokelist = Lexer('( P \/ Q ) , ( X => Y )').tokenize() parse_tree = Parser().parse(tokelist) generator = CodeGen(tokelist, parse_tree) generator.generate() output = generator.runCode() self.assertEqual(output, 'True')
def test_codeGen_17(self): tokelist = Lexer('!P, P').tokenize() parse_tree = Parser().parse(tokelist) generator = CodeGen(tokelist, parse_tree) generator.generate() output = generator.runCode() self.assertEqual(output, 'False')
def test_codeGen_10(self): tokelist = Lexer('(A/\B)\/C').tokenize() parse_tree = Parser().parse(tokelist) generator = CodeGen(tokelist, parse_tree) generator.generate() output = generator.runCode() # checks to see if the output has the same # error message as the parse tree self.assertEqual(output, parse_tree)
def main(): print("Mini Java Compiler") if len(sys.argv) < 2: sys.exit("Error: Compiler needs source file as argument.") with pathlib.Path(sys.argv[1]).resolve().open(mode="r") as f: buffer = f.read() target_dir = pathlib.Path(__file__).parent.joinpath("../dumps") target_dir.mkdir(parents=True, exist_ok=True) print(f"{'':-<50}\nLexer Test") lexer = Lexer(buffer) with target_dir.joinpath("./tokens.txt").open("w") as f: print(f"{'Position':10}{'Stream':<10}{'Token name':20}{'Value':20}", file=f) for token in lexer.tokens(): print(token, file=f) print("Lexing completed.") print(f"{'':-<50}\nSymbol Table Test") symtable = SymbolTable(lexer) with target_dir.joinpath("./symtable.json").open("w") as f: json.dump(symtable.data, f, indent=4) print("Symbol table completed.") print(f"{'':-<50}\nParser Test") parser = Parser(lexer) ast = parser.program() print("Parsing completed.") print(f"{'':-<50}\nCode Generator Test") code_gen = CodeGen(ast) code = code_gen.generate_code() with target_dir.joinpath("./output.c").open("w") as f: print(code, file=f) print("Code generation completed.")
def f(text_input): lexer = Lexer().get_lexer() tokens = lexer.lex(text_input) codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf pg = Parser(module, builder, printf) pg.parse() parser = pg.get_parser() parser.parse(tokens).eval()
def generate_code(ast, symtab, outfile): if verbose: print "generating code...", c = CodeGen() c.process(ast, symtab) c.construct(outfile) if verbose: print u'\u2713'
def scan_file(fname, test_name): print("-----------------------------Running " + test_name + "-----------------------------") # Read the file with open(os.path.join(dir, fname)) as f: code = f.read() # Lex the source code tokens = scanner.input(code) # Initialize the code generator codegen = CodeGen() parser = ProjectParser() global ast ast = parser.input(tokens) ast.eval() print("--------------------Declarations--------------------") for scope, item, line, item_type in declarations: print("%s: declare \"%s\", %s %s" % (line, item, scope, str(item_type))) print("--------------------Variable Usage--------------------") for scope, item, use_line, item_type, declared_line in usage: print("%s: use \"%s\", %s %s declared on %s" % (use_line, item, scope, str(item_type), declared_line)) print("--------------------Errors--------------------") for item in errors: print(item) # print("--------------------Standard Output--------------------") # for item in print_queue: # print(item) print("--------------------Generating IR--------------------") ast.ir_eval(codegen.module, codegen.builder, codegen.printf) codegen.create_ir() save_name = fname[0:-4] codegen.save_ir(save_name + ".ll") print("--------------------Compiling IR--------------------") os.system("llc -filetype=obj %s.ll" % save_name) os.system("gcc %s.o -static -o output" % save_name) print("--------------------Standard Output--------------------") os.system("./output") ast = None
def main(filename, output='output'): with open(filename) as f: text_input = f.read() lexer = Lexer().get_lexer() tokens = lexer.lex(text_input) codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf pg = Parser(module, builder, printf) pg.parse() parser = pg.get_parser() parser.parse(tokens).eval() codegen.create_ir() codegen.save_ir("{}.ll".format(output))
#!/usr/bin/env python from pprint import pprint from codegen import CodeGen import sys codegen = CodeGen() choice = input("you are about to overwrite everything, are you sure? (y/N)") if choice != "y": exit() count = codegen.doAllTheStuff(sys.argv[1]) print("files generated:", count) print("Bye")
from lexer import LEXER from parser import Parser from semantic_analysis import SemanticAnalyzer from codegen import CodeGen lex = LEXER() t_lists = lex.parse("main") parser = Parser() s_list = parser.parse(t_lists) #sm_a = SemanticAnalyzer() #sm_a.analyse_statement_list(s_list) cg = CodeGen() cg.generate_Statements(s_list)
def generateCode(self): # special case: for now, it should be passing parsed WuClass objects CodeGen.generate(self, open(COMPONENTXML_PATH).read(), ROOT_PATH)
def main(): print("JCOSIM: Java Compiler Simulator") try: if len(argv) < 2: raise GetoptError('ERROR: Input file must be specified') options, remainder = getopt(argv[1:], 'i:o:stuapgc:vh', [ 'input=', 'output=', 'symtable', 'token', 'use-gcc', 'analyzedtree', 'analy', 'gencode', 'clean=', 'verbose', 'help', ]) source = None exe = None symtable = False token = False parsetree = False analyzedtree = False gencode = False clean = False clean_path = '.' cc = False for opt, arg in options: if opt in ('-h', '--help'): raise GetoptError('') elif opt in ('-c', '--clean'): clean = True clean_path = arg elif opt in ('-i', '--input'): source = arg elif opt in ('-u', '--use-gcc'): cc = True elif opt in ('-o', '--output'): exe = arg elif opt in ('-s', '--symtable'): symtable = True elif opt in ('-t', '--token'): token = True elif opt in ('-p', '--parsetree'): parsetree = True elif opt in ('-a', '--analyzedtree'): analyzedtree = True elif opt in ('-g', '--gencode'): gencode = True elif opt in ('-v', '--verbose'): symtable = True token = True parsetree = True analyzedtree = True gencode = True # clean and exit if clean: if source: # Smartly get exe file name if not exe: exe = Path(source).stem else: exe = 'Main' files = [ 'tokens.txt', 'parsetree.png', 'analyzedtree.png', 'symtable.json', f'{exe}.c', f'{exe}.exe', f'{exe}', f'{exe}.o', f'{exe}.obj' ] section(*clean_display(files)) for file in files: _path = Path(clean_path).joinpath(file).resolve() if Path(_path).exists(): Path(_path).unlink() exit() # No source no life if not source: raise GetoptError('ERROR: Input file must be specified') # Smartly get exe file name if not exe: exe = Path(source).stem # Read Java source file with open(source, 'r') as f: buffer = f.read() # Lexing lexer = Lexer(buffer) # Parsing parser = Parser(lexer) program_tree = parser.program() # Generate symbol table lexer.reset() stb = SymbolTable(lexer) # Semantic semantic = Semantic(program_tree, stb) analyzed_tree = semantic.analyze() # Generate C code code_gen = CodeGen(analyzed_tree, stb) code = code_gen.generate_code() # Compile the code and output native binary section(*native_compile_display(code, exe, cc)) # do things based on flags if token: section(*token_display(lexer)) if symtable: section(*symtable_display(stb)) if parsetree: section(*parsetree_display(program_tree, 'parsetree.png')) if analyzedtree: section(*parsetree_display(analyzed_tree, 'analyzedtree.png')) if gencode: section(*gencode_display(code, exe)) except GetoptError as e: section(*help_text()) print(e)
#import another class from lexer import Lexer from parse import Parser from codegen import CodeGen #Deklarasi variabel fname = "nama file" fname = "input.lieca" with open(fname) as f: text_input = f.read() #baca input.lieca sebagai text #inisiasi lexer, codegenerator, dll lexer = Lexer().get_lexer() codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf pg = Parser(module, builder, printf) #Mengambil token dari lexer tokens = lexer.lex(text_input) print(tokens) #Parsing pg.parse() parser = pg.get_parser() parser.parse(tokens).eval() print(parser) #Code Generate
with open('toylang_ll1.lark', 'r') as myfile: toylang_grammar = myfile.read() print('starting') grammar = Lark(toylang_grammar) with open(args.input_path, 'r') as myfile: text = myfile.read() parse_tree = grammar.parse(text) print('parsing done') codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf ast_generator = TreeToAst(module, builder, printf, debug=args.debug) ast_generator.transform(parse_tree) for fn in ast_generator.function_definition_list: if args.debug: print('-I- Emitting Function {} '.format(fn)) ast_generator.function_map[fn].eval()
if __name__ == '__main__' and len(sys.argv) == 1: unittest.main() #else take the input file and run it through lexer and parser else: with open(sys.argv[1], 'r') as file: for index, line in enumerate(file): #Lexer l = Lexer(line) l.line = index + 1 tokelist = l.tokenize() l.line += 1 #Parser parse_tree = Parser().parse(tokelist) #Code Generator g = CodeGen(tokelist, parse_tree) generated = g.generate() if len(sys.argv) == 3 and str(sys.argv[2]) == '--more': print 'Input : \n' + line print 'Token List : \n' + str(tokelist.kind) + '\n' print 'Parser Output : \n' + str(parse_tree) + '\n' print generated + '\n' output = g.runCode() print output print "\n----------\n"
from lex import Lexer from parse import Parser from codegen import CodeGen fname = "input.toy" with open(fname) as f: text_input = f.read() lexer = Lexer().get_lexer() tokens = lexer.lex(text_input) codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf #~ pg = Parser(module, builder, printf) pg1 = Parser() pg1.parse() parser = pg1.get_parser() parser.parse(tokens) codegen.create_ir() #~ codegen.save_ir("output.ll")
id_params = list() #Para MODULE-VARS, guarda los id recibidos como parametros en los modulos assign_vars = list() #Para ASSIGN, almacena los tipos de variables encontrados en una asignacion pairs_idtype = list() #Almacena las variables en par id-tipo, utlizados para distincion entre variables locales/globales list_dims = list() #Almacena si las variables encontradas en las expresiones son de 0, 1 o 2 dimensiones flag_dim = list() #Indica si se encuentra una variable de dimension en la evaluacion de expresiones/asignaciones tab_constant = TabConst() #Instancia clase TabConst, tabla de constantes del codigo seleccionado tab_valores = TabVars(2000, 4000, 6000) #Instancia clase TabVars, tabla de variables del codigo seleccionado tab_lvalores = TabVars(12000, 14000, 16000) #Instancia clase TabVars, tabla de variables locales, distinta por cada modulo tab_temporal = TabVars(22000, 24000, 26000) #Instancia clase TabVars, tabla de variables temporales del codigo seleccionado tab_ltemporal = TabVars(32000, 34000, 36000) #Instancia clase TabVars, tabla de variables temporales locales del codigo seleccionado tab_pointer = TabPointer(40000) #Instancia clase TabPointer, guarda los apuntadores a direccion dentro de variables dimensionadas tab_lpointer = TabPointer(42000) #Instancia clase TabPointer, guarda los apuntadores locales a direccion dentro de variables dimensionadas dir_modulos = DirMods() #Instancia clase DirMods, directorio de modulos del programa tab_dims = TabDims() #Instancia clase TabDims, almaneca limites de variables dimensionadas tab_ldims = TabDims() #Instancia clase TabDims, almaneca limites de variables dimensionadas en modulos quads_gen = CodeGen() #Instancia clase CodeGen, generador de cuadruplos para codigo intermedio cont_vars = [0,0,0] #Contador de variables en modulos, en el orden entero/flotante/boleano work_vars = [0,0,0] #Contador de variables en el workspace, en el orden entero/flotante/boleano cont_tvars = [0,0,0] #Contador de variables en modulos, en el orden entero/flotante/boleano work_tvars = [0,0,0] #Contador de variables en el workspace, en el orden entero/flotante/boleano cont_offs = [0,0,0] #Contador de offsets en el modulo, en el orden entero/flotante/boleano work_offs = [0,0,0] #Contador de offsets en el workspace, en el orden entero/flotante/boleano cont_point = 0 #Contador de apuntadores en modulos work_point = 0 #Contador de apuntadores en el workspace list_params = [] #Lista que almacena el tipo de variables encontrado en los parametros de modulos lista_params = [] #Lista que almacena el tipo de variables encontrado en los parametros de invocacion quad_mod = 0 #Almacena el cuadruplo donde comienza un modulo line_mod = 0 #Almacena el numero de linea donde comienza un modulo id_mod = "work" #Guarda el id que sera registrado en el cuadruplo ERA xparam = 0 #Variable entera en funcion de apuntador de parametros flagTabTemp = False #Indica si almacena valores temporales globales o locales
cg("FormatDesc.init,") for fd in ((s.name, nf, s.packed) for s in surfaces for nf in s.numFmts): cg( "FormatDesc(SurfaceType.%s, NumFormat.%s, %s),", fd[0], fd[1], "true" if fd[2] else "false" ) cg("] );") cg("}") if __name__ == "__main__": from codegen import CodeGen codeGen = CodeGen() surfaces = parseSurfaces() issueSurfaceEnum(surfaces, codeGen) issueFormatEnum(surfaces, codeGen) issueSurfProps(surfaces, codeGen) issueSurfStructs(surfaces, codeGen) issueFormatStructs(surfaces, codeGen) issueFmtDescs(surfaces, codeGen) from os import path toolsDir = path.dirname(path.realpath(__file__)) gfxDir = path.dirname(toolsDir) inPath = path.join(toolsDir, "format.in.d")
# -*- coding:utf-8 -*- __author__ = 'kyc' import datetime from fox_ast import * from err import * from codegen import CodeGen alloc_map = dict() from llvmlite import ir codegen = CodeGen() global_var = None global_var_str = None def wrap_fun(func): def _warp(cmd): print("Now execute %s" % (cmd)) func(cmd) return _warp def exec_cmd_block(cmd_bolck): cmd_list = cmd_bolck.cmd_list rt = None for i in cmd_list: rt = exec_cmd(i) if rt in ("EXIT", "LOOP"): break def exec_cmd(cmd):
from codegen import CodeGen from lexer import Lexer from parser import Parser fname = "input.flc" print('\nCompiling "%s" zo IR...' % fname) with open(fname) as f: text_input = f.read().strip() lexer = Lexer().get_lexer() tokens = lexer.lex(text_input) codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf pg = Parser(module, builder, printf) pg.parse() parser = pg.get_parser() # print(list(tokens)) parser.parse(tokens).eval() codegen.create_ir() codegen.save_ir('output.ll')
from lexer import Lexer from parser import Parser from codegen import CodeGen import sys print sys.argv[1] fname, extension = sys.argv[1].split(".") with open(fname + "." + extension) as f: text_input = f.read() lexer = Lexer().get_lexer() tokens = lexer.lex(text_input) codegen = CodeGen() module = codegen.module builder = codegen.builder printf = codegen.printf pg = Parser(module, builder, printf) pg.parse() parser = pg.get_parser() parser.parse(tokens).eval() codegen.create_ir() codegen.save_ir(fname + ".ll")
cg("fmtDescs = assumeUnique( [") with cg.indentBlock(): cg("FormatDesc.init,") for fd in ((s.name, nf, s.packed) for s in surfaces for nf in s.numFmts): cg("FormatDesc(SurfaceType.%s, NumFormat.%s, %s),", fd[0], fd[1], "true" if fd[2] else "false") cg("] );") cg("}") if __name__ == "__main__": from codegen import CodeGen codeGen = CodeGen() surfaces = parseSurfaces() issueSurfaceEnum(surfaces, codeGen) issueFormatEnum(surfaces, codeGen) issueSurfProps(surfaces, codeGen) issueSurfStructs(surfaces, codeGen) issueFormatStructs(surfaces, codeGen) issueFmtDescs(surfaces, codeGen) from os import path toolsDir = path.dirname(path.realpath(__file__)) gfxDir = path.dirname(toolsDir) inPath = path.join(toolsDir, "format.in.d")