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

Move functions to use a pointer to a map for closures instead of a raw map, as we cannot currently ensure that the object is made with the right size (type_size doesn't do padding, etc)

Browse Source
This commit is contained in:
Nathan Braswell
2016-06-30 17:06:34 -04:00
parent 76e78a2ac0
commit 4bf8572d21
1 changed files with 34 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
stdlib/interpreter.krak
View File

@@ -31,7 +31,7 @@ adt value {
pointer: pair<*void,*type>, pointer: pair<*void,*type>,
object_like: pair<*void,*type>, object_like: pair<*void,*type>,
variable: pair<*void,*type>, variable: pair<*void,*type>,
function: pair<*ast_node,map<*ast_node,value>> function: pair<*ast_node,*map<*ast_node,value>>
} }
adt control_flow { adt control_flow {
nor, nor,
@@ -295,7 +295,7 @@ fun store_into_variable(to: ref value, from: value) {
// TODO - check to make sure that we don't have to cast pre assign (perhaps alwyas send through the cast?) // TODO - check to make sure that we don't have to cast pre assign (perhaps alwyas send through the cast?)
match (variable.second->base) { match (variable.second->base) {
base_type::object() { assert(is_object_like(from), "mismatching assignemnt types - from is not object"); memmove(variable.first, from.object_like.first, type_size(from.object_like.second)); } base_type::object() { assert(is_object_like(from), "mismatching assignemnt types - from is not object"); memmove(variable.first, from.object_like.first, type_size(from.object_like.second)); }
base_type::function() { assert(is_function(from), "mismatching assignemnt types - from is not function"); *(variable.first) cast *pair<*ast_node, map<*ast_node,value>> = from.function; } base_type::function() { assert(is_function(from), "mismatching assignemnt types - from is not function"); *(variable.first) cast *pair<*ast_node, *map<*ast_node,value>> = from.function; }
base_type::boolean() { assert(is_boolean(from), "mismatching assignemnt types - from is not boolean"); *(variable.first) cast *bool = from.boolean; } base_type::boolean() { assert(is_boolean(from), "mismatching assignemnt types - from is not boolean"); *(variable.first) cast *bool = from.boolean; }
base_type::character() { assert(is_character(from), "mismatching assignemnt types - from is not character"); *(variable.first) cast *char = from.character; } base_type::character() { assert(is_character(from), "mismatching assignemnt types - from is not character"); *(variable.first) cast *char = from.character; }
base_type::ucharacter() { assert(is_ucharacter(from), "mismatching assignemnt types - from is not ucharacter"); *(variable.first) cast *uchar = from.ucharacter; } base_type::ucharacter() { assert(is_ucharacter(from), "mismatching assignemnt types - from is not ucharacter"); *(variable.first) cast *uchar = from.ucharacter; }
@@ -332,7 +332,7 @@ fun get_real_value(v: value): value {
base_type::ulong_int() return value::ulong_int(*(var_ptr) cast *ulong) base_type::ulong_int() return value::ulong_int(*(var_ptr) cast *ulong)
base_type::floating() return value::floating(*(var_ptr) cast *float) base_type::floating() return value::floating(*(var_ptr) cast *float)
base_type::double_precision() return value::double_precision(*(var_ptr) cast *double) base_type::double_precision() return value::double_precision(*(var_ptr) cast *double)
base_type::function() return value::function(*(var_ptr) cast *pair<*ast_node,map<*ast_node,value>>) base_type::function() return value::function(*(var_ptr) cast *pair<*ast_node,*map<*ast_node,value>>)
} }
error(string("Cannot get real value from variable: ") + variable.second->to_string()) error(string("Cannot get real value from variable: ") + variable.second->to_string())
} }
@@ -343,9 +343,9 @@ fun wrap_into_variable(v: value): value {
return value::variable(make_pair(v.object_like.first, v.object_like.second)) return value::variable(make_pair(v.object_like.first, v.object_like.second))
var variable_type = get_type_from_primitive_value(v) var variable_type = get_type_from_primitive_value(v)
var to_ret = value::variable(make_pair(malloc(type_size(variable_type)), variable_type)) var to_ret = value::variable(make_pair(malloc(type_size(variable_type)), variable_type))
if (is_function(v)) /*if (is_function(v))*/
(to_ret.variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->copy_construct(&v.function) /*(to_ret.variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->copy_construct(&v.function)*/
else /*else*/
store_into_variable(to_ret, v) store_into_variable(to_ret, v)
return to_ret return to_ret
} }
@@ -467,7 +467,7 @@ fun type_size(t: *type): ulong {
}) })
return size return size
} }
base_type::function() return #sizeof<pair<*ast_node,map<*ast_node,value>>> base_type::function() return #sizeof<pair<*ast_node,*map<*ast_node,value>>>
base_type::boolean() return #sizeof<bool> base_type::boolean() return #sizeof<bool>
base_type::character() return #sizeof<char> base_type::character() return #sizeof<char>
base_type::ucharacter() return #sizeof<uchar> base_type::ucharacter() return #sizeof<uchar>
@@ -591,11 +591,11 @@ obj interpreter (Object) {
/*println(string("func_call_func is not a function: ") + get_ast_name(func_call_func))*/ /*println(string("func_call_func is not a function: ") + get_ast_name(func_call_func))*/
var func_value = get_real_value(interpret(func_call_func, var_stack, enclosing_object, enclosing_func).first) var func_value = get_real_value(interpret(func_call_func, var_stack, enclosing_object, enclosing_func).first)
func_call_func = func_value.function.first func_call_func = func_value.function.first
possible_closure_map = func_value.function.second possible_closure_map = *func_value.function.second
println("possible_closure_map is") /*println("possible_closure_map is")*/
possible_closure_map.for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");) /*possible_closure_map.for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");)*/
println() /*println()*/
println("end pcm") /*println("end pcm")*/
/*println(string("calling func we got from interpreting: ") + get_ast_name(func_call_func))*/ /*println(string("calling func we got from interpreting: ") + get_ast_name(func_call_func))*/
} }
// note here also that this is likely not a foolproof method // note here also that this is likely not a foolproof method
@@ -693,13 +693,13 @@ obj interpreter (Object) {
// start out with the possible closure map as the highest scope (gloabals checked seperately) // start out with the possible closure map as the highest scope (gloabals checked seperately)
var new_var_stack = stack(possible_closure_map) var new_var_stack = stack(possible_closure_map)
new_var_stack.push(map<*ast_node,value>()) new_var_stack.push(map<*ast_node,value>())
println("stack after pcm and new m is") /*println("stack after pcm and new m is")*/
for (var i = 0; i < new_var_stack.size(); i++;) { /*for (var i = 0; i < new_var_stack.size(); i++;) {*/
println(string("level: ") + i) /*println(string("level: ") + i)*/
new_var_stack.from_top(i).for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");) /*new_var_stack.from_top(i).for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");)*/
println() /*println()*/
} /*}*/
println("end stack after") /*println("end stack after")*/
// if this is a value based call, pull from parameters // if this is a value based call, pull from parameters
if (parameter_sources.size == 0) { if (parameter_sources.size == 0) {
/*println(func_name + " being called with parameter values")*/ /*println(func_name + " being called with parameter values")*/
@@ -716,8 +716,8 @@ obj interpreter (Object) {
} else { } else {
new_var_stack.top()[param_ident] = value::variable(make_pair(malloc(type_size(param_type)), param_type)) new_var_stack.top()[param_ident] = value::variable(make_pair(malloc(type_size(param_type)), param_type))
//HERE //HERE
if (param_type->indirection == 0 && param_type->is_function()) /*if (param_type->indirection == 0 && param_type->is_function())*/
(new_var_stack.top()[param_ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct() /*(new_var_stack.top()[param_ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct()*/
store_into_variable(new_var_stack.top()[param_ident], get_real_value(parameters[i])) store_into_variable(new_var_stack.top()[param_ident], get_real_value(parameters[i]))
} }
} }
@@ -740,8 +740,8 @@ obj interpreter (Object) {
} else { } else {
new_var_stack.top()[param_ident] = value::variable(make_pair(malloc(type_size(param_type)), param_type)) new_var_stack.top()[param_ident] = value::variable(make_pair(malloc(type_size(param_type)), param_type))
//HERE //HERE
if (param_type->indirection == 0 && param_type->is_function()) /*if (param_type->indirection == 0 && param_type->is_function())*/
(new_var_stack.top()[param_ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct() /*(new_var_stack.top()[param_ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct()*/
store_into_variable(new_var_stack.top()[param_ident], get_real_value(interpret(parameter_sources[i], var_stack, enclosing_object, enclosing_func).first)) store_into_variable(new_var_stack.top()[param_ident], get_real_value(interpret(parameter_sources[i], var_stack, enclosing_object, enclosing_func).first))
} }
} }
@@ -825,15 +825,15 @@ obj interpreter (Object) {
return value::void_nothing() return value::void_nothing()
} }
fun interpret_function(function: *ast_node, var_stack: *stack<map<*ast_node, value>>, enclosing_object: value, enclosing_func: *ast_node): pair<value, control_flow> { fun interpret_function(function: *ast_node, var_stack: *stack<map<*ast_node, value>>, enclosing_object: value, enclosing_func: *ast_node): pair<value, control_flow> {
var possible_closure_map = map<*ast_node,value>() var possible_closure_map = new<map<*ast_node,value>>()->construct()
function->function.closed_variables.for_each(fun(v: *ast_node) { function->function.closed_variables.for_each(fun(v: *ast_node) {
possible_closure_map[v] = interpret_identifier(v, var_stack, enclosing_object, enclosing_func).first (*possible_closure_map)[v] = interpret_identifier(v, var_stack, enclosing_object, enclosing_func).first
println(string("closing over ") + get_ast_name(v)) /*println(string("closing over ") + get_ast_name(v))*/
}) })
println("in interpret function possible_closure_map is") /*println("in interpret function possible_closure_map is")*/
possible_closure_map.for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");) /*possible_closure_map->for_each(fun(key: *ast_node, v: value) print(get_ast_name(key) + " ");)*/
println() /*println()*/
println("end in inteprret function pcm") /*println("end in inteprret function pcm")*/
return make_pair(value::function(make_pair(function, possible_closure_map)), control_flow::nor()) return make_pair(value::function(make_pair(function, possible_closure_map)), control_flow::nor())
} }
fun interpret_statement(stmt: *ast_node, var_stack: *stack<map<*ast_node, value>>, enclosing_object: value, enclosing_func: *ast_node): pair<value, control_flow> { fun interpret_statement(stmt: *ast_node, var_stack: *stack<map<*ast_node, value>>, enclosing_object: value, enclosing_func: *ast_node): pair<value, control_flow> {
@@ -925,8 +925,8 @@ obj interpreter (Object) {
} else { } else {
to_ret = value::variable(make_pair(malloc(type_size(return_type)), return_type)) to_ret = value::variable(make_pair(malloc(type_size(return_type)), return_type))
//HERE //HERE
if (return_type->indirection == 0 && return_type->is_function()) /*if (return_type->indirection == 0 && return_type->is_function())*/
(to_ret.variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct() /*(to_ret.variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct()*/
var ret_val = interpret(return_expression, var_stack, enclosing_object, enclosing_func).first var ret_val = interpret(return_expression, var_stack, enclosing_object, enclosing_func).first
store_into_variable(to_ret, get_real_value(ret_val)) store_into_variable(to_ret, get_real_value(ret_val))
} }
@@ -937,8 +937,8 @@ obj interpreter (Object) {
var ident_type = ident->identifier.type var ident_type = ident->identifier.type
var_stack->top()[ident] = value::variable(make_pair(malloc(type_size(ident_type)),ident_type)) var_stack->top()[ident] = value::variable(make_pair(malloc(type_size(ident_type)),ident_type))
//HERE //HERE
if (ident_type->indirection == 0 && ident_type->is_function()) /*if (ident_type->indirection == 0 && ident_type->is_function())*/
(var_stack->top()[ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct() /*(var_stack->top()[ident].variable.first) cast *pair<*ast_node,map<*ast_node,value>> ->construct()*/
// NOTE: store_into_variable takes to in as a ref because it might change it in the special case ref = ptr // NOTE: store_into_variable takes to in as a ref because it might change it in the special case ref = ptr
if (stmt->declaration_statement.expression) { if (stmt->declaration_statement.expression) {
store_into_variable(var_stack->top()[ident], get_real_value(interpret(stmt->declaration_statement.expression, var_stack, enclosing_object, enclosing_func).first)) store_into_variable(var_stack->top()[ident], get_real_value(interpret(stmt->declaration_statement.expression, var_stack, enclosing_object, enclosing_func).first))