def main():
from io import StringIO
testprog = StringIO('''
Int a = 5 + -2;
''')
tokenstream = tokenize(testprog)
tokenlist = list(tokenstream)
ast = SPL.parse_strict(tokenlist, testprog)
# Build symbol table
ERROR_HANDLER.setSourceMapping(testprog)
symbol_table = buildSymbolTable(ast)
ERROR_HANDLER.checkpoint()
# Normalize table
normalizeAllTypes(symbol_table)
ERROR_HANDLER.checkpoint()
# Resolve Expr names
resolveNames(symbol_table)
ERROR_HANDLER.checkpoint()
# Parse expression
op_table = buildOperatorTable()
fixExpression(ast, op_table)
print(ast)
ERROR_HANDLER.checkpoint()
def main():
from io import StringIO
module_name = "test"
testprog = StringIO('''
Bool x = -5;
prefix - (x) :: Int -> Bool {
return True;
}
prefix ! (x) :: Int -> Bool {
return False;
}
/*infixl 7 ++ (a, b) :: Int Int -> Int {
return a + b + 2;
}*/
main() :: -> Int {
Bool x = !(-(5));
x = True;
}
''')
# Tokenize / parse
tokenstream = tokenize(testprog)
tokenlist = list(tokenstream)
ast = SPL.parse_strict(tokenlist, testprog)
# Build symbol table
ERROR_HANDLER.setSourceMapping(testprog)
symbol_table = buildSymbolTable(ast)
ERROR_HANDLER.checkpoint()
# Normalize table
normalizeAllTypes(symbol_table)
ERROR_HANDLER.checkpoint()
# Resolve Expr names
resolveNames(symbol_table)
ERROR_HANDLER.checkpoint()
# Build operator table
op_table = buildOperatorTable()
mergeCustomOps(op_table, symbol_table, module_name)
builtin_funcs = generateBuiltinFuncs()
# Parse expressions
fixExpression(ast, op_table)
ERROR_HANDLER.checkpoint()
# Type check
typecheck_globals(symbol_table, op_table)
typecheck_functions(symbol_table, op_table, builtin_funcs)
ERROR_HANDLER.checkpoint()
}
}
'''
if __name__ == "__main__":
from argparse import ArgumentParser
from lib.parser.lexer import tokenize
argparser = ArgumentParser(description="SPL Parser")
argparser.add_argument("infile",
metavar="INPUT",
help="Input file",
nargs="?",
default="../../example programs/p1_example.spl")
args = argparser.parse_args()
with open(args.infile, "r") as infile:
tokenstream = tokenize(infile)
tokenlist = list(tokenstream)
#print(tokenlist)
x = SPL.parse_strict(tokenlist, infile)
#print(x)
#print(x.tree_string())
print(printAST(x))
exit()
test1 = [
Token(None, TOKEN.TYPESYN, None),
Token(None, TOKEN.TYPE_IDENTIFIER, "String"),
Token(None, TOKEN.OP_IDENTIFIER, "="),
]
test2 = [
Token(None, TOKEN.BRACK_OPEN, None),
def main():
from argparse import ArgumentParser
from lib.parser.lexer import tokenize
argparser = ArgumentParser(description="TESTCODEGEN")
argparser.add_argument("infile",
metavar="INPUT",
help="Input file",
nargs="?",
default=None)
argparser.add_argument("--lp",
metavar="PATH",
help="Directory to import libraries from",
nargs="?",
type=str)
argparser.add_argument(
"--im",
metavar="LIBNAME:PATH,...",
help=
"Comma-separated library_name:path mapping list, to explicitly specify import paths",
type=str)
args = argparser.parse_args()
if not args.infile is None:
if not args.infile.endswith(SOURCE_EXT):
print("Input file needs to be {}".format(SOURCE_EXT))
exit()
else:
infile = open(args.infile, "r")
tokenstream = tokenize(infile)
ast = parseTokenStream(tokenstream, infile)
ERROR_HANDLER.setSourceMapping(infile)
import_mapping = list(
map(lambda x: x.split(":"),
args.im.split(","))) if args.im is not None else []
if not (all(map(lambda x: len(x) == 2, import_mapping)) and all(
map(lambda x: all(map(lambda y: len(y) > 0, x)),
import_mapping))):
print("Invalid import mapping")
exit()
# print(import_mapping)
import_mapping = {
a: os.path.splitext(b)[0]
for (a, b) in import_mapping
}
main_mod_path = os.path.splitext(args.infile)[0]
module_name = os.path.basename(main_mod_path)
else:
from io import StringIO
module_name = "tuples"
testprog = StringIO('''
''')
# Tokenize / parse
tokenstream = tokenize(testprog)
tokenlist = list(tokenstream)
ast = SPL.parse_strict(tokenlist, testprog)
ERROR_HANDLER.setSourceMapping(testprog)
module_name = "testing"
# Build external table
headerfiles, type_headers = getHeaders(
ast,
module_name,
HEADER_EXT,
os.path.dirname(args.infile),
file_mapping_arg=import_mapping,
lib_dir_path=args.lp,
lib_dir_env=os.environ[IMPORT_DIR_ENV_VAR_NAME]
if IMPORT_DIR_ENV_VAR_NAME in os.environ else None)
# Get all external symbols
external_table, dependencies = getExternalSymbols(ast, headerfiles,
type_headers)
external_table = enrichExternalTable(external_table)
print(external_table)
ERROR_HANDLER.checkpoint()
# Build symbol table
symbol_table, external_table = buildSymbolTable(
ast,
module_name,
just_for_headerfile=False,
ext_symbol_table=external_table)
ERROR_HANDLER.checkpoint()
# Normalize table
#normalizeAllTypes(symbol_table, external_table)
#ERROR_HANDLER.checkpoint()
#forbid_illegal_types(symbol_table)
#ERROR_HANDLER.checkpoint()
# Resolve Expr names
resolveNames(symbol_table, external_table)
ERROR_HANDLER.checkpoint()
# Parse expressions
fixExpression(ast, symbol_table, external_table)
ERROR_HANDLER.checkpoint()
# Function control flow analysis
analyseFunc(symbol_table)
ERROR_HANDLER.checkpoint()
# Typechecking
typecheck_globals(symbol_table, external_table)
typecheck_functions(symbol_table, external_table)
ERROR_HANDLER.checkpoint()
# Code gen
gen_code = generate_object_file(symbol_table, module_name, dependencies)
#print(gen_code)
with open('example programs/demo/' + module_name + '.splo', 'w+') as fh:
fh.write(gen_code)
metavar="INPUT",
help="Input file",
nargs="?",
default="./example programs/p1_example.spl")
args = argparser.parse_args()
'''
for rule, content in RULES.items():
print("{}:".format(rule))
print(content)
print()
exit()
'''
print(expandRule(RULES[ROOT_RULE]))
print("DONE")
exit()
with open(args.infile, "r") as infile:
tokenstream = tokenize(infile)
parseTokenStream(tokenstream)
'''
tokenlist = list(tokenstream)
import random
randtoken = random.choice(tokenlist)
print(randtoken)
print(pointToPosition(infile, randtoken.pos))
'''
print("DONE")
def main():
argparser = ArgumentParser(description="SPL Compiler")
argparser.add_argument("infile", metavar="INPUT", help="Input file", nargs="?", default="./example programs/p1_example.spl")
argparser.add_argument("--lp", metavar="PATH", help="Directory to import header files from", nargs="?", type=str)
argparser.add_argument("--im", metavar="LIBNAME:PATH,...", help="Comma-separated object_file:path mapping list, to explicitly specify import header paths", type=str)
argparser.add_argument("-o", metavar="OUTPUT", help="Output file")
argparser.add_argument("-C", help="Produce an object file instead of an executable", action="store_true")
argparser.add_argument("-H", help="Produce a header file instead of an executable", action="store_true")
argparser.add_argument("--stdout", help="Output to stdout", action="store_true")
args = argparser.parse_args()
import_mapping = make_import_mapping(args.im)
if not args.infile.endswith(SOURCE_EXT):
ERROR_HANDLER.addError(ERR.CompInputFileExtension, [SOURCE_EXT])
if not os.path.isfile(args.infile):
ERROR_HANDLER.addError(ERR.CompInputFileNonExist, [args.infile])
main_mod_path = os.path.splitext(args.infile)[0]
main_mod_name = os.path.basename(main_mod_path)
validate_modname(main_mod_name)
if args.o:
outfile_base = args.o
validate_modname(os.path.basename(outfile_base))
else:
outfile_base = main_mod_path
compiler_target = {
'header' : args.H,
'object' : args.C,
'binary' : not (args.H or args.C)
}
if args.H and args.C and args.stdout:
ERROR_HANDLER.addError(ERR.CompInvalidArguments, ["Cannot output to stdout when creating both a headerfile and an object file!\n(-H and -C and --stdout)"])
if args.o and args.stdout:
ERROR_HANDLER.addError(ERR.CompInvalidArguments, ["Cannot write to specified path when outputting to stdout!\n(-o and --stdout)"])
ERROR_HANDLER.checkpoint()
try:
infile = open(args.infile, "r")
except Exception as e:
ERROR_HANDLER.addError(ERR.CompInputFileException, [args.infile, "{} {}".format(e.__class__.__name__, str(e))], fatal=True)
ERROR_HANDLER.setSourceMapping(infile)
tokenstream = tokenize(infile)
ast = parseTokenStream(tokenstream, infile)
#print("Are there imports?",bool(ast.imports))
#print(ast)
if compiler_target['header']: # Generate a headerfile
symbol_table, ext_table = buildSymbolTable(ast, main_mod_name, just_for_headerfile=True)
#print(ext_table)
#resolveTypeSyns(symbol_table, ext_table)
mod_dependencies = get_type_dependencies(ast)
header_json = export_headers(symbol_table, main_mod_name, mod_dependencies, ext_table)
if not args.stdout:
outfile_name = outfile_base + HEADER_EXT
write_out(header_json, outfile_name, "headerfile")
else:
print(header_json)
if compiler_target['object']: # Generate an object file
gen_code = generateObjectFile(ast, args, main_mod_name, import_mapping)
if not args.stdout:
outfile_name = outfile_base + OBJECT_EXT
write_out(gen_code, outfile_name, "objectfile")
else:
print(gen_code)
if compiler_target['binary']: # Generate a binary
gen_code = generateObjectFile(ast, args, main_mod_name, import_mapping)
from io import StringIO
pseudo_file_code = StringIO(gen_code)
mod_dicts = getObjectFiles(
pseudo_file_code,
args.infile,
os.path.dirname(args.infile),
file_mapping_arg=import_mapping,
lib_dir_path=args.lp,
lib_dir_env=os.environ[IMPORT_DIR_ENV_VAR_NAME] if IMPORT_DIR_ENV_VAR_NAME in os.environ else None
)
result = linkObjectFiles(mod_dicts, main_mod_name)
if not args.stdout:
outfile_name = outfile_base + TARGET_EXT
write_out(result, outfile_name, "executable")
else:
print(result)
# Final cleanup
infile.close()