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 mpasparse
import sys
from errors import subscribe_errors
lexer = mpaslex.make_lexer()
parser = mpasparse.make_parser()
with subscribe_errors(lambda msg: sys.stderr.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
check_program(program)
def main():
import pasparser
import sys
from errors import subscribe_errors
lexer = paslex.make_lexer()
parser = pasparser.make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg+"\n")):
program = parser.parse(open(sys.argv[1]).read())
check_program(program)
def run_lexer(data):
import sys
from errors import subscribe_errors
lexer = make_lexer()
with subscribe_errors(lambda msg: sys.stderr.write(msg+"\n")):
lexer.input(data)
for tok in iter(lexer.token, None):
if tok:
print(tok)
def main():
import mpasparse
import sys
from errors import subscribe_errors
parser = mpasparse.parser
data = open("gcd.pas").read()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(data)
check_program(program)
def run_lexer(data):
import sys
from errors import subscribe_errors
lexer = make_lexer()
with subscribe_errors(lambda msg: sys.stderr.write(msg + "\n")):
lexer.input(data)
for tok in iter(lexer.token, None):
if tok:
print(tok)
def main():
import exprparse
import sys
from errors import subscribe_errors
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
check_program(program)
def main():
import gonelex
import sys
from errors import subscribe_errors
lexer = gonelex.make_lexer()
parser = make_parser()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(open(sys.argv[1]).read())
# Output the resulting parse tree structure
for depth, node in flatten(program):
print("%s%s" % (" " * (4 * depth), node))
def main():
import sys
from errors import subscribe_errors
if len(sys.argv) != 2:
sys.stderr.write("Usage: %s filename\n" % sys.argv[0])
raise SystemExit(1)
lexer = make_lexer()
with subscribe_errors(lambda msg: sys.stderr.write(msg + "\n")):
lexer.input(open(sys.argv[1]).read())
for tok in iter(lexer.token, None):
sys.stdout.write("%s\n" % tok)
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 check(file_name):
"""Realiza analisis semantico/sintactico y genera codigo ensamblador spark"""
f = open(str(file_name))
data = f.read()
with subscribe_errors(lambda msg: sys.stdout.write(msg + "\n")):
program = parser.parse(data)
check_program(program)
f.close()
outname = os.path.splitext(file_name)[0] + '.s'
if program:
import mpasgen
outfile = open(outname, "w")
mpasgen.generate(outfile, program)
outfile.close()
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 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))
elif (re.match(r'.*\.pas', sys.argv[-1])):
try:
filename = sys.argv[-1]
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)
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)
# goparser.py
# -*- coding: utf-8 -*-
from ply import yacc
from errors import error
from golex import tokens
from goast import *
precedence = (
('left', 'LOR'),
('left', 'LAND'),
('nonassoc', 'LT', 'LE', 'EQ', 'GT', 'GE', 'NE'),
('left', 'PLUS', "MINUS"),
('left', "TIMES", "DIVIDE", "MODULE"),
('nonassoc', 'LPAREN', 'RPAREN'),
('right',
'UNARY'), # operador ficticio para mantener la mas alta prioridad
)
# ----------------------------------------------------------------------
def p_program(p):
'''
program : statements
| empty
'''
p[0] = Program(p[1])
def p_statements(p):
'''
statements : statements statement
'''
p[0] = p[1]
# goparser.py
# -*- coding: utf-8 -*-
# ----------------------------------------------------------------------
# Los parsers son definidos usando el módulo yacc de PLY
#
# Vea http://www.dabeaz.com/ply/ply.html#ply_nn23
# ----------------------------------------------------------------------
from ply import yacc
# ----------------------------------------------------------------------
# El siguiente import carga la funcion error(lineno, msg) que debe ser
# usada para reportar todos los mensajes de error generados por su parser.
# Las pruebas Unitarias y otras caracteristicas del compilador se basaran
# en esta función. vea el archivo errors.py para una mayor documentación
# acerca del mecanismo de manejo de errores.
from errors import error
# ----------------------------------------------------------------------
# Obtener la lista de token definidos en el módulo lexer. Esto es
# necesario con el fin de validar y construir la tabla de sintaxis.
from golex import tokens
# ----------------------------------------------------------------------
# Obtener los nodos del AST.
# Lea las instrucciones en hocast.py
from goast import *
# ----------------------------------------------------------------------
# Tabla de precedencia de operadores. Los operadores deben de seguir
# las mismas reglas de precedencia que Python. Instrucciones que se
# dan el el proyecto.
# Vea http://www.dabeaz.com/ply/ply.html#ply_nn27
precedence = (
('right', 'ASSIGN', 'POSITIVEINCREASE', 'NEGATIVEINCREASE',
