def runTest(self):
scanner = lexer.MiniJavaScanner()
with open(p) as f: s = f.read()
tokens = scanner.tokenize(s)
javaParser = parser.ProgramParser()
tree = javaParser.parse(tokens)
typechecker.typecheck(tree)
if optimize:
for roundNum in range(optimize):
tree.optimize()
binpath = os.path.join('testbins', name + '.pyc')
codegen.codegen(binpath, tree, False)
with TempFile() as fout:
#run program
proc = subprocess.Popen(('python3', binpath),
stdout=fout.f,
stderr=subprocess.STDOUT)
#let the process run for a few seconds
failTime = time.time() + 3.0
while proc.poll() is None:
time.sleep(0.01)
if time.time() > failTime:
proc.kill()
raise Exception('Compiled program took too long to execute')
res = proc.wait()
self.assertEqual(0, res)
fout.flush()
self.diff(expected, fout.name)
def main(src):
try: # On test si le fichier existe bien
fo = open(src, "r")
fo.close()
except IOError:
print("Le fichier donné n'existe pas.")
return 0
with open(src) as file:
exp = file.read()
# On transforme la chaine d'entrée en une liste d'unité lexicale
ul = scanner(exp)
# On convertit cette liste en une liste contenant l'expression postfixé
postfix = parser(ul)
if postfix[0]:
print("Chaine valide\n") # A commenter pour la lisibilité lors des test
# On écrit dans un fichier, sous forme d'une pile, l'expression
codegen(postfix[1])
os.chmod("a.out", 0o744)
return True
else:
print("Erreur syntaxique à la position {}: {}.\nIl manque une partie "\
"de l'expression\n".format(postfix[1], exp[postfix[1]-1]))
return False
def compile_bytecode(name):
with open(name, 'r') as f:
text = f.read()
tokens = tokenize(text)
ast = parse(tokens)
fns, stack = codegen(ast)
return fns, stack
def actionExport(self):
if using_qt5:
export_as = QFileDialog.getSaveFileName(self, "Export as...")[0]
else:
export_as = QFileDialog.getSaveFileName(self, "Export as...")
create_code = codegen.codegen(self, "mynode", self.blocks, self.resolution)
if export_as != "":
create_code.writeToFile(export_as)
def krd_to_java(filename):
'''
Function to use the compiler object and generate java file
'''
pgm, symtab = MyCompiler().compile(filename)
java_filename = pgm.get_name() + "App.java"
java_file = open(java_filename, "w")
code = codegen(pgm, symtab, 0, kparser.wnum)
java_file.write(code)
java_file.close()
def compile(grammar):
grammar = grammar.replace('\r\n', '\n')
grammar += '\n'
prods = grammar.split('\n')
prods_tokens = []
for prod in prods:
prod = prod.strip()
if len(prod) == 0:
continue
tokens = lexer.lexer(prod)
if len(tokens) > 0:
prods_tokens.append(list(tokens))
tree = parse.parse(prods_tokens)
code = codegen.codegen(tree)
return code
def compile( grammar ):
grammar = grammar.replace( '\r\n' , '\n' )
grammar += '\n'
prods = grammar.split( '\n' )
prods_tokens = []
for prod in prods:
prod = prod.strip()
if len( prod ) == 0:
continue
tokens = lexer.lexer( prod )
if len( tokens ) > 0:
prods_tokens.append( list( tokens ) )
tree = parse.parse( prods_tokens )
code = codegen.codegen( tree )
return code
from regalloc import regalloc
from codegen import codegen
import json
import argparse
import sys
REG_PREFIX = "r_"
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='register allocation for bril json format')
parser.add_argument(
"--stats",
action="store_true",
help="print var to reg mapping instead of code generation")
parser.add_argument("--num",
type=int,
default=3,
help="number of registers")
args = parser.parse_args()
bril = json.load(sys.stdin)
regs = [REG_PREFIX + '%02d' % (i + 1) for i in range(args.num)]
for func in bril['functions']:
regmap, colored, spilled = regalloc(func['instrs'], regs)
print('%s {' % func['name'])
codegen(func['instrs'], regmap)
print('}')
def gen_java(self, filename):
'''
Function to call the code generation on the AST obtained after compiling.
'''
return codegen(self.compile(filename))
def main():
args = getArguments()
if not args:
sys.exit(1)
if len(args.files) > 1:
print("Only one input file is supported")
sys.exit(1)
outfile = args.out_file + '.pyc'
verbose = args.verbose
dumpbin = args.dump_binary
if args.pedantic:
settings.MODE_PEDANTIC = True
if args.no_fastgen:
settings.MODE_FASTGEN = False
settings.VERBOSITY = verbose
import lexer
import parser
import typechecker
import optimizer
import codegen
for inputFile in args.files:
with inputFile as f:
s = f.read()
#Lexical Analysis
scanner = lexer.MiniJavaScanner()
tokens = scanner.tokenize(s)
if args.phase == 'lex':
lexer.dump(tokens, sys.stdout)
break
#Parsing
p = parser.ProgramParser()
tree = p.parse(tokens)
if args.phase == 'parse':
parser.dump(tree, sys.stdout)
break
#Typecheck Parse Tree
try:
typechecker.typecheck(tree)
except typechecker.TypecheckException as ex:
print('Nope', file=sys.stderr)
if verbose:
print(ex, file=sys.stderr)
if verbose > 1:
raise ex
sys.exit(1)
if args.phase == 'typecheck':
print('Looks good')
break
#Optimization
if args.phase == 'optimize':
parser.dump(tree, sys.stdout)
print()
if args.phase == 'optimize' or args.optimize:
if args.phase == 'optimize' and args.optimize == 0:
args.optimize = 1
print("running", args.optimize, "rounds of optimize()")
for roundNum in range(args.optimize):
tree.optimize()
if args.phase == 'optimize':
parser.dump(tree, sys.stdout)
break
#Generate Code
codegen.codegen(outfile, tree, dumpbin)
if args.phase == 'codegen':
break
if args.phase == 'run':
import importlib
mod = importlib.import_module(args.out_file)
mod.main()
try:
listing = open(name + '.lis', 'w')
except:
print("Could not create listing file")
exit(-1)
try:
dest = open(name + '.s', 'w')
except:
print("Could not create file")
exit(-1)
symtab = MasterSymbolTable()
# this is a series of closures used to group functions
# which have some global state. This is done to
# avoid sharing globals between modules, at least as much
# as possible.
error, warning = error_handlers(symtab, listing, dest)
print_listing = lister(listing) # get the listing function
emit, emit_epilog, load, store = codegen(symtab, dest)
get = Token.Tokenizer(CharBuffer(src), warning)
parse(get, dest, print_listing, symtab, warning, error, emit, load, store)
listing.write('\n\n' + str(symtab))
emit_epilog()
listing.close()
dest.close()
print()
A_shape = [100, 200]
B_shape = [100, 200]
C_shape = [100, 200]
Z_shape = [100, 200]
# A = arrays.isl_array(isl_context, "A", A_shape)
# B = arrays.isl_array(isl_context, "B", B_shape)
# C = arrays.isl_array(isl_context, "C", C_shape)
# Z = arrays.isl_array(isl_context, "Z", Z_shape)
statements = {}
stmt = operations.add(isl_context, ("C", C_shape, [0, 0]),
("A", A_shape, [0, 1]), ("B", B_shape, [0, 0]))
name = statement.get_name(stmt)
statements[name] = stmt
stmt = operations.add(isl_context, ("Z", Z_shape, [0, 0]),
("C", C_shape, [0, 0]), ("B", B_shape, [0, 0]))
name = statement.get_name(stmt)
statements[name] = stmt
for stmt in statements.values():
print stmt
schedule = schedule.build_schedule(isl_context, statements)
print schedule
ast = codegen.codegen(isl_context, schedule, statements)
print
print emitter.emit_source(statements, ast)
#!/usr/bin/env python3
# jwbind.py is the entry python script to drive the backend
# part including parsing class description and code generation.
from parser import parse
from wparser import parseWasm
from codegen import codegen
import sys
# if len(sys.argv) < 2:
# print('Usage:\tjwbind <file>')
# sys.exit(1)
raw = parseWasm(sys.argv[1])
desc = parse(raw)
codegen(desc, sys.argv[1])
from tokenizer import TokenBuffer, tokenize
from parser import parse
from codegen import codegen
from llvm.core import *
from llvm.ee import *
tokens = TokenBuffer(tokenize(open("sample.cy", "r").read()))
ast = parse(tokens)
module = codegen(ast)
ex = ExecutionEngine.new(module, force_interpreter=True)
main = module.get_function_named('main')
result = ex.run_function(main, [])
print(result.as_real(Type.double()))
