91 lines
3.4 KiB
Plaintext
91 lines
3.4 KiB
Plaintext
import io:*
|
|
import grammer:*
|
|
import parser:*
|
|
import ast_transformation:*
|
|
import string:*
|
|
import util:*
|
|
import symbol:*
|
|
import tree:*
|
|
import serialize:*
|
|
import c_generator:*
|
|
import os:*
|
|
|
|
fun main(argc: int, argv: **char):int {
|
|
|
|
/*var gram.construct(): grammer*/
|
|
// delay construction until we either load it or copy construct it
|
|
var gram: grammer
|
|
var base_dir = string("/").join(string(argv[0]).split('/').slice(0,-2))
|
|
/*println(base_dir)*/
|
|
var file_name = base_dir + "/krakenGrammer.kgm"
|
|
/*println(file_name)*/
|
|
|
|
var compiled_name = file_name + string(".comp_new")
|
|
var compiled_version = 1
|
|
var file_contents = read_file(file_name)
|
|
var loaded_and_valid = false
|
|
|
|
if (file_exists(compiled_name)) {
|
|
/*println("cached file exists")*/
|
|
var pos = 0
|
|
var binary = read_file_binary(compiled_name)
|
|
/*println("read file!")*/
|
|
var saved_version = 0
|
|
unpack(saved_version, pos) = unserialize<int>(binary, pos)
|
|
if (saved_version == compiled_version) {
|
|
var cached_contents = string()
|
|
unpack(cached_contents, pos) = unserialize<string>(binary, pos)
|
|
if (cached_contents == file_contents) {
|
|
/*println("loaded_and_valid, using cached version!")*/
|
|
loaded_and_valid = true
|
|
/*unpack(gram, pos) = unserialize<grammer>(binary, pos)*/
|
|
// skip unnecessary copies this way
|
|
pos = gram.unserialize(binary, pos)
|
|
/*println("finished unserializeing!!")*/
|
|
} else println("contents different")
|
|
} else println("version number different")
|
|
} else {
|
|
println("cached file does not exist")
|
|
}
|
|
if (!loaded_and_valid) {
|
|
println("Not loaded_and_valid, re-generating and writing out")
|
|
/*gram = load_grammer(file_contents)*/
|
|
// since we now don't construct before hand
|
|
gram.copy_construct(&load_grammer(file_contents))
|
|
println("grammer loaded, calculate_first_set")
|
|
gram.calculate_first_set()
|
|
println("grammer loaded, calculate_state_automaton")
|
|
gram.calculate_state_automaton()
|
|
println("calculated, writing out")
|
|
write_file_binary(compiled_name, serialize(compiled_version) + serialize(file_contents) + serialize(gram))
|
|
println("done writing")
|
|
}
|
|
|
|
if (argc <= 1) {
|
|
error("No input file!\n Call with one argument (the input file), or two arguments (input file and output name)")
|
|
}
|
|
var kraken_file_name = string(argv[1])
|
|
var parse.construct(gram): parser
|
|
var ast_pass.construct(): ast_transformation
|
|
var importer.construct(parse, ast_pass, vector(string(), base_dir + "/stdlib/")): importer
|
|
/*print("parsing: ")*/
|
|
importer.import(kraken_file_name)
|
|
println("Generating C")
|
|
/*println("NOW DOING C_GENERATOR")*/
|
|
var c_generator.construct(): c_generator
|
|
var c_output_pair = c_generator.generate_c(importer.name_ast_map)
|
|
var kraken_c_output_name = kraken_file_name + ".c"
|
|
write_file(kraken_c_output_name, c_output_pair.first)
|
|
/*println(string("linker string: ") + c_output_pair.second)*/
|
|
|
|
var executable_name = string(".").join(kraken_file_name.split('.').slice(0,-2))
|
|
if (argc == 3)
|
|
executable_name = string(argv[2])
|
|
var compile_string = "cc -g -O3 -std=c99 " + c_output_pair.second + " " + kraken_c_output_name + " -o " + executable_name
|
|
println(compile_string)
|
|
system(compile_string)
|
|
|
|
return 0
|
|
}
|
|
|