miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add basis for types in k, and move to new poset setup (depend on individual imports, functions, types, and global variables)

Browse Source
This commit is contained in:
Nathan Braswell
2018-06-22 20:58:47 -04:00
parent 6ffe7aee46
commit e851d0eac5
6 changed files with 354 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
k.krak
View File

@@ -1,4 +1,3 @@
import io:*
import grammer:*
import lexer:*
@@ -12,6 +11,7 @@ import vec_literals:*
import poset:*
import util:*
import ast:*
import type2:*
import tree:*
import symbol:*
@@ -19,6 +19,7 @@ fun main(argc: int, argv: **char): int {
// delay construction until we either load it or copy construct it
var gram: grammer
var base_dir = str("/").join(str(argv[0]).split('/').slice(0,-2))
var import_paths = vec(str(), base_dir + "/stdlib/")
var file_name = base_dir + "/krakenGrammer.kgm"
var compiled_name = file_name + str(".comp_new")
var compiled_version = 1
@@ -82,59 +83,56 @@ fun main(argc: int, argv: **char): int {
if (positional_args.size > 1)
executable_name = positional_args[1]
var pass_poset = poset<pair<str, int>>()
var pass_poset = poset<pair<*ast, str>>()
var name_ast_map = map<str, *tree<ast>>()
var import_paths = vec(str(), base_dir + "/stdlib/")
var passes = vec<fun(str): *tree<ast>>()
passes = vec(
fun(file_name: str): *tree<ast> {
var file = str()
for (var i = 0; i < import_paths.size; i++;) {
if (file_exists(import_paths[i] + file_name)) {
if (file != "")
error("File: " + file_name + ", found in multiple import paths - at least two of [" + str(",").join(import_paths) + "]")
file = read_file(import_paths[i] + file_name)
}
}
if (file == "")
error("File: " + file_name + ", not found in any import path - none of [" + str(",").join(import_paths) + "]")
printerr(file_name + ", ")
var parse_tree = parse.parse_input(file, file_name)
var passes = map<str, fun(*ast): bool>()
// resolves a single import
passes[str("import_resolver")] = fun(import_binding: *ast): bool {
var file_path = binding_str(import_binding)
println("Running import resolver for" + file_path)
if (!name_ast_map.contains_key(file_path)) {
printerr(file_path + ", ")
var parse_tree = parse.parse_input(read_file(file_path), file_path)
trim(parse_tree)
return syntax_to_ast(file_name, parse_tree)
},
fun(file_name: str): *tree<ast> {
println("Checking for imports in " + file_name)
name_ast_map[file_name]->children.for_each(fun(n: *tree<ast>) {
match (n->data) {
ast::_import(b) {
var imported_file_name = n->children[0]->data._identifier.first + ".krak"
for (var i = 0; i < passes.size; i++;) {
if (i == 0)
pass_poset.add_relationship(make_pair(file_name, 2), make_pair(imported_file_name, 0))
else
pass_poset.add_relationship(make_pair(imported_file_name, i), make_pair(imported_file_name, i-1))
}
name_ast_map[file_path] = syntax_to_ast(file_path, parse_tree, import_paths)
}
set_bindings(import_binding, name_ast_map[file_path])
return true
}
// ensures that all imports reachable from this one are resolved
passes[str("import_checker")] = fun(import_binding: *ast): bool {
var all_resolved = true
var file_path = binding_str(import_binding)
println("Running import checker for " + file_path)
name_ast_map[file_path]->children.for_each(fun(n: *tree<ast>) {
match (n->data) {
ast::_import(b) {
if (!bound(b.first)) {
all_resolved = false
pass_poset.add_relationship(make_pair(import_binding, str("import_checker")), make_pair(b.first, str("import_resolver")))
println(to_string(*b.first) + " is not bound!")
} else {
println(to_string(*b.first) + " is bound!")
}
}
})
return name_ast_map[file_name]
},
fun(file_name: str): *tree<ast> {
println("Doing thing 3 to " + file_name)
return name_ast_map[file_name]
}
)
for (var i = 0; i < passes.size; i++;) {
if (i == 0)
pass_poset.add_vertex(make_pair(kraken_file_name, i))
else
pass_poset.add_relationship(make_pair(kraken_file_name, i), make_pair(kraken_file_name, i-1))
}
})
return all_resolved
}
var top_binding = make_binding(kraken_file_name)
pass_poset.add_relationship(make_pair(top_binding, str("import_checker")), make_pair(top_binding, str("import_resolver")))
while (pass_poset.size() != 0) {
var file_pass = pass_poset.pop()
printlnerr("doing pass " + to_string(file_pass.second) + " on " + file_pass.first)
name_ast_map[file_pass.first] = passes[file_pass.second](file_pass.first)
var file_pass = pass_poset.top()
printlnerr("doing pass " + file_pass.second + " on " + to_string(*file_pass.first))
var done = passes[file_pass.second](file_pass.first)
if (done)
pass_poset.remove(file_pass)
}
println()
@@ -160,11 +158,65 @@ fun main(argc: int, argv: **char): int {
return 0
}
fun syntax_to_ast(file_name: str, syntax: *tree<symbol>): *tree<ast> {
var bindings: *vec<*ast>
fun make_binding(s: str): *ast {
var binding = new<ast>()->copy_construct(&ast::_binding(make_triple(s, vec<*type>(), null<tree<ast>>())))
if (bindings == null<vec<*ast>>())
bindings = new<vec<*ast>>()->construct()
bindings->add(binding)
return binding
}
fun set_bindings(binding: *tree<ast>, to: *tree<ast>) {
set_bindings(&binding->data, to)
}
fun set_bindings(binding: *ast, to: *tree<ast>) {
match(*binding) {
ast::_binding(b) {
var from = binding->_binding.third
// don't set null, that will set all unbound ones
if (from == null<tree<ast>>()) {
binding->_binding.third = to
return
}
for (var i = 0; i < bindings->size; i++;)
if (bindings->get(i)->_binding.third == from)
bindings->get(i)->_binding.third = to
return
}
}
error("trying to set bindings on not a binding")
}
fun bound(binding: *ast): bool {
match(*binding) {
ast::_binding(b) return b.third != null<tree<ast>>()
}
error("Trying to check bound for not a binding")
}
fun binding_str(binding: *ast): str {
match(*binding) {
ast::_binding(b) return b.first
}
error("Trying to get name for not a binding")
}
fun syntax_to_ast(file_name: str, syntax: *tree<symbol>, import_paths: ref vec<str>): *tree<ast> {
var resolve_import_file = fun(file_name: str): str {
var file_path = str()
for (var i = 0; i < import_paths.size; i++;) {
if (file_exists(import_paths[i] + file_name)) {
if (file_path != "")
error("File: " + file_name + ", found in multiple import paths - at least two of [" + str(",").join(import_paths) + "]")
file_path = import_paths[i] + file_name
}
}
if (file_path == "")
error("File: " + file_name + ", not found in any import path - none of [" + str(",").join(import_paths) + "]")
return file_path
}
var syntax_to_ast_helper: fun(*tree<symbol>): *tree<ast> = fun(syntax: *tree<symbol>): *tree<ast> {
printlnerr("syntax_to_ast " + syntax->data.name)
if (syntax->data.name == "import") {
return _import(from_vector(syntax->children.slice(2,-1).filter(fun(s:*tree<symbol>):bool {
return _import(make_binding(resolve_import_file(concat(syntax->children[1]) + ".krak")), from_vector(syntax->children.slice(2,-1).filter(fun(s:*tree<symbol>):bool {
return s->data.name == "identifier" || s->data.data == "*"
}).map(concat)), vec(syntax_to_ast_helper(syntax->children[1])))
} else if (syntax->data.name == "function")