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

Transition to new pass/poset setup

Browse Source
This commit is contained in:
Nathan Braswell
2018-08-26 21:45:38 -04:00
parent 1cae1b1504
commit 87bc88cde4
5 changed files with 103 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
stdlib/bytecode_generator.krak
View File

@@ -11,7 +11,6 @@ import symbol:*
import ast_nodes:*
// for error with syntax tree
import pass_common:*
import poset:*
fun type_size(t: *type): ulong
return type_size_and_alignment(t).first

8
stdlib/c_generator.krak
View File

@@ -177,22 +177,22 @@ obj c_generator (Object) {
match (*node) {
ast_node::function(backing) generate_function_definition(node)
ast_node::type_def(backing) {
type_poset.add_vertex(node)
type_poset.add_job(node)
backing.variables.for_each(fun(i: *ast_node) {
var var_type = get_ast_type(i->declaration_statement.identifier)
if (!var_type->indirection && var_type->type_def)
type_poset.add_relationship(node, var_type->type_def)
type_poset.add_open_dep(node, var_type->type_def)
})
}
}
})
}
ast_node::type_def(backing) {
type_poset.add_vertex(child)
type_poset.add_job(child)
backing.variables.for_each(fun(i: *ast_node) {
var var_type = get_ast_type(i->declaration_statement.identifier)
if (!var_type->indirection && var_type->type_def)
type_poset.add_relationship(child, var_type->type_def)
type_poset.add_open_dep(child, var_type->type_def)
})
}
ast_node::adt_def(backing) error("ADT remaining!")

4
stdlib/map.krak
View File

@@ -111,5 +111,9 @@ obj map<T,U> (Object, Serializable) {
for (var i = 0; i < keys.size; i++;)
func(keys[i], values[i])
}
fun for_each(func: fun(ref T, ref U):void) {
for (var i = 0; i < keys.size; i++;)
func(keys[i], values[i])
}
}

127
stdlib/poset.krak
View File

@@ -10,98 +10,81 @@ fun poset<T>(): poset<T> {
}
obj poset<T> (Object) {
var adj_matrix: map<T, set<T>>
var open_deps: map<T, set<T>>
var close_deps: map<T, set<T>>
var opened: set<T>
var closed: set<T>
fun construct(): *poset<T> {
adj_matrix.construct()
open_deps.construct()
close_deps.construct()
opened.construct()
closed.construct()
return this
}
fun copy_construct(old: *poset<T>) {
adj_matrix.copy_construct(&old->adj_matrix)
open_deps.copy_construct(&old->open_deps)
close_deps.copy_construct(&old->close_deps)
opened.copy_construct(&old->opened)
closed.copy_construct(&old->closed)
}
fun operator=(other: ref poset<T>) {
destruct()
copy_construct(&other)
}
fun destruct() {
adj_matrix.destruct()
open_deps.destruct()
close_deps.destruct()
opened.destruct()
closed.destruct()
}
fun size(): int {
return adj_matrix.size()
return open_deps.size()
}
fun add_relationship(first: T, second: T) {
if (!adj_matrix.contains_key(first))
add_vertex(first)
if (!adj_matrix.contains_key(second))
add_vertex(second)
adj_matrix[first].add(second)
fun add_open_dep(first: T, second: T) {
add_job(first)
add_job(second)
open_deps[first].add(second)
}
fun add_vertex(vertex: T) {
if (adj_matrix.contains_key(vertex))
fun add_close_dep(first: T, second: T) {
add_job(first)
add_job(second)
close_deps[first].add(second)
}
fun add_job(vertex: T) {
if (open_deps.contains_key(vertex))
return;
adj_matrix.set(vertex, set<T>())
open_deps.set(vertex, set<T>())
close_deps.set(vertex, set<T>())
}
fun get_depends_on(vertex: T): set<T> {
var depends_on = set<T>()
adj_matrix.for_each(fun(key: T, value: set<T>) {
if (value.contains(vertex))
depends_on.add(key)
})
return depends_on
fun done(job: T): bool {
return closed.contains(job)
}
fun top(): T {
for (var i = 0; i < adj_matrix.keys.size; i++;) {
if (adj_matrix.values[i].size() == 0) {
return adj_matrix.keys[i]
}
}
error("Nothing to top")
}
fun remove(x: ref T) {
var dependencies = adj_matrix.get_ptr_or_null(x)
if (dependencies == null<set<T>>())
error("Trying to remove item from poset that doesn't contain it!")
if (dependencies->size() != 0)
error("Trying to remove item from poset that still has dependencies on it!")
for (var j = 0; j < adj_matrix.keys.size; j++;) {
// remove is ok if it doesn't exist
adj_matrix.values[j].remove(x)
}
adj_matrix.remove(x)
}
fun pop(): T {
for (var i = 0; i < adj_matrix.keys.size; i++;) {
if (adj_matrix.values[i].size() == 0) {
var to_ret = adj_matrix.keys[i]
for (var j = 0; j < adj_matrix.keys.size; j++;) {
// remove is ok if it doesn't exist
/*if (adj_matrix.values[i].contains(to_ret)) {*/
adj_matrix.values[j].remove(to_ret)
/*}*/
fun run(f: fun(T): void) {
opened = set<T>()
closed = set<T>()
while closed.size() != size() {
// intentionally not refs, as it can change out from under us
open_deps.for_each(fun(v: T, ods: set<T>) {
if !closed.contains(v) && closed.contains(ods) {
if !opened.contains(v) {
f(v)
if closed.contains(open_deps[v]) {
opened.add(v)
}
}
if closed.contains(open_deps[v]) && closed.contains(close_deps[v]) {
closed.add(v)
}
}
adj_matrix.remove(to_ret)
return to_ret
}
}
error("Nothing to pop")
}
fun get_sorted(): vec<T> {
var sorted = vec<T>()
var to_do = queue<T>()
// because we're going to destructivly update
var temp_adj_matrix = adj_matrix
temp_adj_matrix.for_each(fun(key: T, value: set<T>)
if (temp_adj_matrix[key].size() == 0) to_do.push(key);)
while (!to_do.empty()) {
var current = to_do.pop()
sorted.add(current)
get_depends_on(current).for_each(fun(vert: T) {
temp_adj_matrix[vert].remove(current)
if (temp_adj_matrix[vert].size() == 0)
to_do.push(vert)
})
}
return sorted
}
fun get_sorted(): vec<T> {
var to_ret = vec<T>()
run(fun(i: T) {
to_ret.add(i)
})
return to_ret
}
}