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
def generateCode(self):
# special case: for now, it should be passing parsed WuClass objects
CodeGen.generate(self, open(COMPONENTXML_PATH).read(), ROOT_PATH)
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")
