def main():
import gonelex
import goneparse
import gonecheck
import gonecode
import goneblock
import sys
import ctypes
from errors import subscribe_errors, errors_reported
from llvm.ee import ExecutionEngine
# Load the Gone runtime library (see Makefile)
ctypes._dlopen('./gonert.so', ctypes.RTLD_GLOBAL)
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
gonecheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
functions = gonecode.generate_code(program)
# Emit the code sequence
bv = LLVMBlockVisitor()
bv.generate_llvm(functions)
print(bv.llvm.module)
# Verify and run function that was created during code generation
print(":::: RUNNING ::::")
bv.llvm.function.verify()
llvm_executor = ExecutionEngine.new(bv.llvm.module)
llvm_executor.run_function(bv.llvm.vars['__start'], [])
def main():
import sys
from ircode import compile_ircode
from errors import errors_reported
if len(sys.argv) != 2:
sys.stderr.write('Usage: python3 -m minic.interp filename\n')
raise SystemExit(1)
source = open(sys.argv[1]).read()
code = compile_ircode(source)
if not errors_reported():
interpreter = Interpreter()
interpreter.execute(code)
def main():
import gonelex
import goneparse
import gonecheck
import gonecode
import sys
import ctypes
import time
import argparse
from errors import subscribe_errors, errors_reported
from llvm.ee import ExecutionEngine
global args
parser = argparse.ArgumentParser("Compile and run a Gone program from a .g file")
parser.add_argument('file', type=str, default='', nargs=1,
help="the file containing Gone source")
parser.add_argument('--verbose', '-v', action="store_true",
help="print verbose output")
parser.add_argument('--validate', '-c', action="store_true",
help="perform llvm bitcode validation prior to program execution")
args = parser.parse_args()
# Load the Gone runtime library (see Makefile)
ctypes._dlopen('./gonert.so', ctypes.RTLD_GLOBAL)
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(open(args.file[0]).read())
gonecheck.check_program(program)
if not errors_reported():
code = gonecode.generate_code(program)
g = GenerateLLVMBlockVisitor()
g.visit_functions(code.functions)
if args.verbose:
print("---- NATIVE ASSEMBLY ----")
print(g.generator.module.to_native_assembly())
print("---- END NATIVE ASSEMBLY ----")
if args.verbose:
print(":::: RUNNING ::::")
start = time.time()
llvm_executor = ExecutionEngine.new(g.generator.module)
llvm_executor.run_function(g.generator.main_func, [])
if args.verbose:
print(":::: FINISHED ::::")
print("execution time: {0:.15f}s".format(time.time() - start))
def main():
import gonelex
import goneparse
import gonecheck
import sys
from errors import subscribe_errors, errors_reported
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
gonecheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
code = generate_code(program)
code = EmitBlocksVisitor().loop(code.functions)
def compile_ircode(source):
"""
Genera código intermedio desde el fuente.
"""
from cparse import parse
from checker import check_program
from errors import errors_reported
ast = parse(source)
check_program(ast)
# Si no ocurrió error, genere código
if not errors_reported():
gen = GenerateCode()
gen.visit(ast)
return gen.functions
else:
return []
def main():
import gonelex
import goneparse
import gonecheck
import sys
from errors import subscribe_errors, errors_reported
from pprint import pformat
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
gonecheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
functions = generate_code(program)
for fn in functions:
print(fn, '\n')
def main():
import gonelex
import goneparse
import gonecheck
import gonecode
import sys
from errors import subscribe_errors, errors_reported
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
gonecheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
functions = gonecode.generate_code(program)
functions = list(functions) # just be sure it doesn't exhause
interpreter = Interpreter(functions)
interpreter.run(functions[0]) # first func is the place to start
def main():
import gonelex
import goneparse
import gonecheck
import gonecode
import sys
import time
from errors import subscribe_errors, errors_reported
lexer = gonelex.make_lexer()
parser = goneparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
gonecheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
code = gonecode.generate_code(program)
interpreter = Interpreter()
start = time.clock()
interpreter.run(code.code)
print(":::: FINISHED ::::")
print("execution time: {0:.15f}s".format(time.clock() - start))
outname = os.path.splitext(filename)[0] + '.s'
file = open(filename)
data = file.read()
file.close()
if ("-lex" in sys.argv):
paslex.run_lexer(data)
else:
parser = pasparser.make_parser()
clear_errors()
try:
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
root_ast = parser.parse(data)
check.check_program(root_ast);
errors = errors_reported();
if errors == 0:
if ("-ast" in sys.argv):
# dump_class_tree(root_ast)
dot = DotVisitor()
dot.generic_visit(root_ast)
print dot
# Generate code
outfile = open(outname, "w")
mpasgen.generate(outfile, root_ast)
outfile.close()
else:
sys.stderr.write("Number of errors: %d" % errors)
except parseError as e:
sys.stderr.write("Program couldn't be compiled\n")
# ----------------------------------------------------------------------
# DO NOT MODIFY ANYTHING BELOW
# ----------------------------------------------------------------------
def generate_code(node):
'''
Generate SSA code from the supplied AST node.
'''
gen = GenerateCode()
gen.visit(node)
return gen
if __name__ == '__main__':
import exprlex
import exprparse
import exprcheck
import sys
from errors import subscribe_errors, errors_reported
lexer = exprlex.make_lexer()
parser = exprparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
# Check the program
exprcheck.check_program(program)
# If no errors occurred, generate code
if not errors_reported():
code = generate_code(program)
# Emit the code sequence
exprblock.PrintBlocks().visit(code.start_block)
#for inst in code.code:
# print(inst)
def generate_code(node):
'''
Genera código SSA desde el nodo AST suministrados
'''
gen = GenerateCode()
gen.visit(node)
return gen
if __name__ == '__main__':
import lolalex
import lolaparse
import lolacheck
import sys
from errors import subscribe_errors, errors_reported
lexer = golex.make_lexer()
parser = goparse.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(open(sys.argv[1]).read())
# Comprueba el programa
gocheck.check_program(program)
# Si no se han producido errores, genere código
if not errors_reported():
code = generate_code(program)
# Emitir la secuencia de código
for inst in code.code:
print(inst)
file = open(filename)
data = file.read()
file.close()
if ("-lex" in sys.argv):
paslex.run_lexer(data)
else:
parser = pasparser.make_parser()
clear_errors()
try:
with subscribe_errors(
lambda msg: sys.stdout.write(msg + "\n")):
root_ast = parser.parse(data)
check.check_program(root_ast)
errors = errors_reported()
if errors == 0:
if ("-ast" in sys.argv):
# dump_class_tree(root_ast)
dot = DotVisitor()
dot.generic_visit(root_ast)
print dot
# Generate code
outfile = open(outname, "w")
mpasgen.generate(outfile, root_ast)
outfile.close()
else:
sys.stderr.write("Number of errors: %d" % errors)
except parseError as e:
sys.stderr.write("Program couldn't be compiled\n")
