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

Moved copy_constructing into functions and destructing the results into obj_lower. Removed all defer_stack from c_generator. The last thing should be to move ref handling into obj_lower or maybe a pass after, then the rest of c_generator can be cleaned up and fixing interpreter (except for closures) should be easy.

Browse Source
This commit is contained in:
Nathan Braswell
2016-06-26 04:44:54 -07:00
parent 4cc0d26c4c
commit 15fe2aeba4
7 changed files with 140 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
stdlib/c_generator.krak
View File

@@ -193,7 +193,7 @@ obj c_generator (Object) {
linker_string.destruct() linker_string.destruct()
} }
fun get_id(): string return to_string(id_counter++); fun get_id(): string return to_string(id_counter++);
fun generate_function_prototype_and_header(child: *ast_node, enclosing_object: *ast_node, is_lambda: bool, defer_stack: *stack<pair<bool,stack<*ast_node>>>):pair<string,string> { fun generate_function_prototype_and_header(child: *ast_node, enclosing_object: *ast_node, is_lambda: bool):pair<string,string> {
var backing = child->function var backing = child->function
var parameter_types = string() var parameter_types = string()
@@ -245,14 +245,12 @@ obj c_generator (Object) {
var backing = child->function var backing = child->function
// stack-stack thing // this could be a stack of strings too, maybe // stack-stack thing // this could be a stack of strings too, maybe
// start out with one stack on the stack // start out with one stack on the stack
var defer_stack = stack<pair<bool,stack<*ast_node>>>(make_pair(false, stack<*ast_node>())) var prototype_and_header = generate_function_prototype_and_header(child, enclosing_object, is_lambda)
var prototype_and_header = generate_function_prototype_and_header(child, enclosing_object, is_lambda, &defer_stack)
function_prototypes += prototype_and_header.first function_prototypes += prototype_and_header.first
if (!backing.is_extern) if (!backing.is_extern)
function_definitions += prototype_and_header.second function_definitions += prototype_and_header.second
if (backing.body_statement) { if (backing.body_statement) {
function_definitions += string(" {\n") + generate_statement(backing.body_statement, enclosing_object, child, &defer_stack).one_string() function_definitions += string(" {\n") + generate_statement(backing.body_statement, enclosing_object, child).one_string()
function_definitions += generate_from_defer_stack(&defer_stack, -1, enclosing_object, child).one_string()
function_definitions += "}\n" function_definitions += "}\n"
} else if (!backing.is_extern) { } else if (!backing.is_extern) {
error("Empty function statement and not extern - no ADTs anymore!") error("Empty function statement and not extern - no ADTs anymore!")
@@ -283,7 +281,7 @@ obj c_generator (Object) {
top_level_c_passthrough += generate_simple_passthrough(backing.statement->statement.child, true) top_level_c_passthrough += generate_simple_passthrough(backing.statement->statement.child, true)
} }
ast_node::simple_passthrough(backing) top_level_c_passthrough += generate_simple_passthrough(child, true) ast_node::simple_passthrough(backing) top_level_c_passthrough += generate_simple_passthrough(child, true)
ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null<ast_node>(), null<ast_node>(), null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ";\n" // false - don't do defer ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null<ast_node>(), null<ast_node>(), false).one_string() + ";\n" // false - don't do defer
// shouldn't need to do anything with return, as the intrinsic should be something like link // shouldn't need to do anything with return, as the intrinsic should be something like link
ast_node::compiler_intrinsic(backing) generate_compiler_intrinsic(child) ast_node::compiler_intrinsic(backing) generate_compiler_intrinsic(child)
ast_node::function(backing) { ast_node::function(backing) {
@@ -332,7 +330,7 @@ obj c_generator (Object) {
plain_typedefs += base_name + "_dummy " + base_name + ";\n" plain_typedefs += base_name + "_dummy " + base_name + ";\n"
structs += base_name + "_dummy {\n" structs += base_name + "_dummy {\n"
if (is_type_def(vert)) { if (is_type_def(vert)) {
vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null<ast_node>(), null<ast_node>(), null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ";\n";) // also no defer stack vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null<ast_node>(), null<ast_node>(), false).one_string() + ";\n";) // also no defer stack
// generate the methods (note some of these may be templates) // generate the methods (note some of these may be templates)
vert->type_def.methods.for_each(fun(method: *ast_node) { vert->type_def.methods.for_each(fun(method: *ast_node) {
if (is_template(method)) if (is_template(method))
@@ -362,9 +360,9 @@ obj c_generator (Object) {
} }
return closure_struct_map[closed_variables] return closure_struct_map[closed_variables]
} }
fun generate_if_comp(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_if_comp(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
if (node->if_comp.wanted_generator == "__C__") if (node->if_comp.wanted_generator == "__C__")
return generate(node->if_comp.statement, enclosing_object, enclosing_func, defer_stack, false) return generate(node->if_comp.statement, enclosing_object, enclosing_func, false)
return code_triple() return code_triple()
} }
fun generate_simple_passthrough(node: *ast_node, is_top_level: bool): string { fun generate_simple_passthrough(node: *ast_node, is_top_level: bool): string {
@@ -391,9 +389,8 @@ obj c_generator (Object) {
return pre + result + post return pre + result + post
return pre + "{" + result + "}" + post return pre + "{" + result + "}" + post
} }
fun generate_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple return generate(node->statement.child, enclosing_object, enclosing_func, defer_stack, false) + ";\n"; fun generate_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple return generate(node->statement.child, enclosing_object, enclosing_func, false) + ";\n";
fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>, add_to_defer: bool): code_triple { fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, add_to_defer: bool): code_triple {
// add destruct to defer_stack
var identifier = node->declaration_statement.identifier var identifier = node->declaration_statement.identifier
var ident_type = identifier->identifier.type var ident_type = identifier->identifier.type
// we do the declaration in the pre now so that we can take it's address to close over it for things like recursive closures // we do the declaration in the pre now so that we can take it's address to close over it for things like recursive closures
@@ -403,69 +400,50 @@ obj c_generator (Object) {
pre_stuff = string("extern ") + pre_stuff pre_stuff = string("extern ") + pre_stuff
var to_ret = code_triple(pre_stuff, string(), string()) var to_ret = code_triple(pre_stuff, string(), string())
if (node->declaration_statement.expression) { if (node->declaration_statement.expression) {
if (ident_type->indirection == 0 && (ident_type->is_object() && has_method(ident_type->type_def, "copy_construct", vector(get_ast_type(node->declaration_statement.expression)->clone_with_increased_indirection())))) {
to_ret.pre += ";\n"
to_ret += generate(ast_statement_ptr(make_method_call(identifier, "copy_construct", vector(make_operator_call("&", vector(node->declaration_statement.expression))))), enclosing_object, enclosing_func, defer_stack, false)
} else {
if (ident_type->is_function()) { if (ident_type->is_function()) {
to_ret.pre += string(";\n") to_ret.pre += string(";\n")
to_ret += code_triple() + get_name(identifier) + " = " + generate(node->declaration_statement.expression, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) to_ret += code_triple() + get_name(identifier) + " = " + generate(node->declaration_statement.expression, enclosing_object, enclosing_func, false)
} else { } else {
// some shifting around to get it to work in all cases // some shifting around to get it to work in all cases
// what cases? // what cases?
to_ret.value = to_ret.pre to_ret.value = to_ret.pre
to_ret.pre = "" to_ret.pre = ""
to_ret += code_triple() + string(" = ") + generate(node->declaration_statement.expression, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) to_ret += code_triple() + string(" = ") + generate(node->declaration_statement.expression, enclosing_object, enclosing_func, false)
}
} }
} }
if (node->declaration_statement.init_method_call) { if (node->declaration_statement.init_method_call) {
to_ret.pre += ";\n" to_ret.pre += ";\n"
to_ret += code_triple() + generate(node->declaration_statement.init_method_call, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) to_ret += code_triple() + generate(node->declaration_statement.init_method_call, enclosing_object, enclosing_func, false)
} }
return to_ret return to_ret
} }
fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple { fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
return generate(node->assignment_statement.to, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + " = " + generate(node->assignment_statement.from, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) return generate(node->assignment_statement.to, enclosing_object, enclosing_func, false) + " = " + generate(node->assignment_statement.from, enclosing_object, enclosing_func, false)
} }
fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
var if_str = code_triple("if (") + generate(node->if_statement.condition, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + ") {\n" + generate(node->if_statement.then_part, enclosing_object, enclosing_func, defer_stack, false).one_string() + "}" var if_str = code_triple("if (") + generate(node->if_statement.condition, enclosing_object, enclosing_func, false) + ") {\n" + generate(node->if_statement.then_part, enclosing_object, enclosing_func, false).one_string() + "}"
if (node->if_statement.else_part) if (node->if_statement.else_part)
if_str += code_triple(" else {\n") + generate(node->if_statement.else_part, enclosing_object, enclosing_func, defer_stack, false).one_string() + "}" if_str += code_triple(" else {\n") + generate(node->if_statement.else_part, enclosing_object, enclosing_func, false).one_string() + "}"
return if_str + "\n" return if_str + "\n"
} }
fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
// stick another stack on var to_ret = code_triple("while (" + generate(node->while_loop.condition, enclosing_object, enclosing_func, false).one_string() + ")\n"
defer_stack->push(make_pair(true, stack<*ast_node>())) + generate(node->while_loop.statement, enclosing_object, enclosing_func, false).one_string())
var to_ret = code_triple("while (" + generate(node->while_loop.condition, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ")\n"
+ generate(node->while_loop.statement, enclosing_object, enclosing_func, defer_stack, false).one_string())
defer_stack->pop()
return to_ret return to_ret
} }
fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
// stick another stack on
defer_stack->push(make_pair(true, stack<*ast_node>()))
// gotta take off last semicolon // gotta take off last semicolon
/*var init = generate(node->for_loop.init, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false)*/
var init = code_triple(";") var init = code_triple(";")
if (node->for_loop.init) if (node->for_loop.init)
init = generate(node->for_loop.init, enclosing_object, enclosing_func, defer_stack, false) init = generate(node->for_loop.init, enclosing_object, enclosing_func, false)
var cond = code_triple(";") var cond = code_triple(";")
if (node->for_loop.condition) if (node->for_loop.condition)
cond = generate(node->for_loop.condition, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) cond = generate(node->for_loop.condition, enclosing_object, enclosing_func, false)
var update = code_triple() var update = code_triple()
if (node->for_loop.update) if (node->for_loop.update)
update = generate(node->for_loop.update, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) update = generate(node->for_loop.update, enclosing_object, enclosing_func, false)
/*var do_update_name = string("do_update") + get_id()*/
/*var to_ret = string("{\n") + init.one_string() + "bool " + do_update_name + " = false;\nfor (;;) {\n"*/
/*to_ret += string("if (") + do_update_name + ") {" + update.one_string() + "}\n" + do_update_name + " = true;\n"*/
/*to_ret += cond.pre + "if (!" + cond.value + ") {" + cond.post + "break;}" + cond.post*/
var to_ret = string("for (") + init.one_string() + cond.one_string() + "; " + update.one_string().slice(0,-2) + ")\n" + var to_ret = string("for (") + init.one_string() + cond.one_string() + "; " + update.one_string().slice(0,-2) + ")\n" +
generate(node->for_loop.body, enclosing_object, enclosing_func, defer_stack, false).one_string() generate(node->for_loop.body, enclosing_object, enclosing_func, false).one_string()
/*to_ret += generate(node->for_loop.body, enclosing_object, enclosing_func, defer_stack, false).one_string()*/
/*to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object, enclosing_func).one_string()*/
defer_stack->pop()
//to_ret += "}/*end inner for*/}/*end for's enclosing block*/\n"
return code_triple(to_ret) return code_triple(to_ret)
} }
fun generate_identifier(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple { fun generate_identifier(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
@@ -483,7 +461,7 @@ obj c_generator (Object) {
return code_triple(pre + "(this->" + get_name(node) + ")" + post) return code_triple(pre + "(this->" + get_name(node) + ")" + post)
return code_triple(pre + get_name(node) + post) return code_triple(pre + get_name(node) + post)
} }
fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
var return_value = node->return_statement.return_value var return_value = node->return_statement.return_value
var function_return_type = get_ast_type(enclosing_func)->return_type var function_return_type = get_ast_type(enclosing_func)->return_type
var to_ret = code_triple() var to_ret = code_triple()
@@ -493,63 +471,25 @@ obj c_generator (Object) {
if (function_return_type->is_ref) if (function_return_type->is_ref)
refamp = "&" refamp = "&"
if (return_value) if (return_value)
to_ret += code_triple(" ") + refamp + generate(return_value, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) to_ret += code_triple(" ") + refamp + generate(return_value, enclosing_object, enclosing_func, false)
to_ret.pre += generate_from_defer_stack(defer_stack, -1, enclosing_object, enclosing_func).one_string()
return to_ret return to_ret
} }
fun generate_branching_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_branching_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
// -2 means generate up through loop
var to_ret = generate_from_defer_stack(defer_stack, -2, enclosing_object, enclosing_func)
match(node->branching_statement.b_type) { match(node->branching_statement.b_type) {
branching_type::break_stmt() return to_ret + string("break") branching_type::break_stmt() return code_triple("break")
branching_type::continue_stmt() return to_ret + string("continue") branching_type::continue_stmt() return code_triple("continue")
} }
} }
fun generate_from_defer_stack(defer_stack: *stack<pair<bool,stack<*ast_node>>>, num: int, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple { fun generate_defer_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
var to_ret = code_triple()
if (num == -1)
num = defer_stack->size()
if (num == -2) {
num = 1
for (var i = 0; i < defer_stack->size(); i++;)
if (defer_stack->from_top(i).first)
break
else
num++
}
for (var i = 0; i < num; i++;) {
defer_stack->push(make_pair(false, stack<*ast_node>()))
defer_stack->from_top(i+1).second.for_each_reverse(fun(node: *ast_node) to_ret += generate(node, enclosing_object, enclosing_func, defer_stack, false);)
if (defer_stack->top().second.size())
to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object, enclosing_func);
defer_stack->pop()
}
return to_ret
}
fun generate_defer_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple {
error("Unremoved defer!") error("Unremoved defer!")
} }
fun generate_match_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_match_statement(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
error("remaining match")
var to_ret = code_triple("/* begin match */") var to_ret = code_triple("/* begin match */")
var matching_value = generate(node->match_statement.value, enclosing_object, enclosing_func, defer_stack, true)
to_ret.pre += matching_value.pre
to_ret.post += matching_value.post
node->match_statement.cases.for_each(fun(case_node: *ast_node) {
var option_str = generate(case_node->case_statement.option, enclosing_object, enclosing_func, defer_stack, false).one_string()
var to_ret_case = code_triple("/*case ") + option_str + "*/ if(" + matching_value.value + ".flag == " + string("enum_opt_") + option_str + ") {\n"
if (case_node->case_statement.unpack_ident) {
to_ret_case += generate_declaration_statement(ast_declaration_statement_ptr(case_node->case_statement.unpack_ident, null<ast_node>(), false), null<ast_node>(), null<ast_node>(), null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string()
to_ret_case += string(" = ") + matching_value.value + ".data." + option_str + ";\n"
} else {
to_ret_case += "/*no unpack_ident*/\n"
}
to_ret_case += generate(case_node->case_statement.statement, enclosing_object, enclosing_func, defer_stack, false).one_string() + "\n}\n"
to_ret += to_ret_case.one_string()
})
return to_ret return to_ret
} }
fun generate_cast(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>, need_variable: bool): code_triple { fun generate_cast(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
return code_triple("((") + type_to_c(node->cast.to_type) + ")(" + generate(node->cast.value, enclosing_object, enclosing_func, defer_stack, false) + "))" return code_triple("((") + type_to_c(node->cast.to_type) + ")(" + generate(node->cast.value, enclosing_object, enclosing_func, false) + "))"
} }
fun generate_value(node: *ast_node, need_variable: bool): code_triple { fun generate_value(node: *ast_node, need_variable: bool): code_triple {
var value = node->value.string_value var value = node->value.string_value
@@ -578,19 +518,15 @@ obj c_generator (Object) {
var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false) var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false)
// have to pass false to the declaration generator, so can't do it through generate_statement // have to pass false to the declaration generator, so can't do it through generate_statement
var trip_ret = code_triple() var trip_ret = code_triple()
trip_ret.pre += generate_declaration_statement(declaration, null<ast_node>(), null<ast_node>(), null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + " = " + to_ret + ";\n" trip_ret.pre += generate_declaration_statement(declaration, null<ast_node>(), null<ast_node>(), false).one_string() + " = " + to_ret + ";\n"
trip_ret.value = generate_identifier(temp_ident, null<ast_node>(), null<ast_node>()).one_string() trip_ret.value = generate_identifier(temp_ident, null<ast_node>(), null<ast_node>()).one_string()
return trip_ret return trip_ret
} }
return code_triple(to_ret) return code_triple(to_ret)
} }
fun generate_code_block(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>): code_triple { fun generate_code_block(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node): code_triple {
var to_ret = code_triple("{\n") var to_ret = code_triple("{\n")
// stick another stack on node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object, enclosing_func, false).one_string();)
defer_stack->push(make_pair(false, stack<*ast_node>()))
node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object, enclosing_func, defer_stack, false).one_string();)
to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object, enclosing_func)
defer_stack->pop()
return to_ret + "}" return to_ret + "}"
} }
// this generates the function as a value, not the actual function // this generates the function as a value, not the actual function
@@ -606,7 +542,7 @@ obj c_generator (Object) {
closed_vars.for_each(fun(i: *ast_node) { closed_vars.for_each(fun(i: *ast_node) {
// note that we get/have gotten rid of refs here, or maybe more accurately, everything is a ref // note that we get/have gotten rid of refs here, or maybe more accurately, everything is a ref
// should be a variable anyway? // should be a variable anyway?
to_ret.pre += string(".") + get_name(i) + "=(void*)&" + generate(i, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), true).one_string() + "," to_ret.pre += string(".") + get_name(i) + "=(void*)&" + generate(i, enclosing_object, enclosing_func, true).one_string() + ","
}) })
to_ret.pre += "};\n" to_ret.pre += "};\n"
return to_ret + string("((") + type_to_c(node->function.type) + "){(void*)&" + temp_closure_struct + ",(void*)" + get_name(node) + "})" return to_ret + string("((") + type_to_c(node->function.type) + "){(void*)&" + temp_closure_struct + ",(void*)" + get_name(node) + "})"
@@ -634,7 +570,7 @@ obj c_generator (Object) {
// XXX should it? wouldn't function calls be a problem? // XXX should it? wouldn't function calls be a problem?
// should this be true if ref? // should this be true if ref?
call_string += generate(node->function_call.func->function_call.parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), true) call_string += generate(node->function_call.func->function_call.parameters[0], enclosing_object, enclosing_func, true)
} else if (is_identifier(node->function_call.func) || is_function(node->function_call.func)) { } else if (is_identifier(node->function_call.func) || is_function(node->function_call.func)) {
// we handle the case when it's not this later, i.e. it's a lambda returned from another function or something // we handle the case when it's not this later, i.e. it's a lambda returned from another function or something
func_name = generate_function(node->function_call.func, enclosing_object, enclosing_func, false, false).one_string() func_name = generate_function(node->function_call.func, enclosing_object, enclosing_func, false, false).one_string()
@@ -655,25 +591,25 @@ obj c_generator (Object) {
|| func_name == "==" || func_name == "!=" || func_name == "%" || func_name == "^" || func_name == "==" || func_name == "!=" || func_name == "%" || func_name == "^"
|| func_name == "|" || func_name == "&" || func_name == "|" || func_name == "&"
)) ))
return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + func_name + generate(parameters[1], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + string(")") return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, false) + func_name + generate(parameters[1], enclosing_object, enclosing_func, false) + string(")")
if ( parameters.size == 2 && (func_name == "||" || func_name == "&&")) { if ( parameters.size == 2 && (func_name == "||" || func_name == "&&")) {
error("Remaining || or &&") error("Remaining || or &&")
} }
// don't propegate enclosing function down right of access // don't propegate enclosing function down right of access
// XXX what about enclosing object? should it be the thing on the left? // XXX what about enclosing object? should it be the thing on the left?
if (func_name == "." || func_name == "->") { if (func_name == "." || func_name == "->") {
return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + func_name + generate(parameters[1], null<ast_node>(), null<ast_node>(), null<stack<pair<bool,stack<*ast_node>>>>(), false) + string(")") return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, false) + func_name + generate(parameters[1], null<ast_node>(), null<ast_node>(), false) + string(")")
} }
if (func_name == "[]") if (func_name == "[]")
return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + "[" + generate(parameters[1], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + string("])") return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, false) + "[" + generate(parameters[1], enclosing_object, enclosing_func, false) + string("])")
// the post ones need to be post-ed specifically, and take the p off // the post ones need to be post-ed specifically, and take the p off
if (func_name == "++p" || func_name == "--p") if (func_name == "++p" || func_name == "--p")
return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) + ")" + func_name.slice(0,-2) return code_triple("(") + generate(parameters[0], enclosing_object, enclosing_func, false) + ")" + func_name.slice(0,-2)
// So we don't end up copy_constructing etc, we just handle the unary operators right here // So we don't end up copy_constructing etc, we just handle the unary operators right here
// note also the passing down need_variable for & // note also the passing down need_variable for &
if (func_name == "*" || func_name == "&") if (func_name == "*" || func_name == "&")
return code_triple("(") + func_name + generate(parameters[0], enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), func_name == "&") + ")" return code_triple("(") + func_name + generate(parameters[0], enclosing_object, enclosing_func, func_name == "&") + ")"
// for checking if we pass in a ref // for checking if we pass in a ref
var func_type = get_ast_type(node->function_call.func) var func_type = get_ast_type(node->function_call.func)
@@ -694,30 +630,17 @@ obj c_generator (Object) {
call_string += "&" call_string += "&"
var param_type = get_ast_type(param) var param_type = get_ast_type(param)
if (!in_function_param_type->is_ref && param_type->indirection == 0 && (param_type->is_object() && has_method(param_type->type_def, "copy_construct", vector(param_type->clone_with_indirection(1))))) { call_string += generate(param, enclosing_object, enclosing_func, in_function_param_type->is_ref)
var temp_ident = ast_identifier_ptr(string("temporary_param")+get_id(), param_type->clone_without_ref(), null<ast_node>())
var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false)
// have to pass false to the declaration generator, so can't do it through generate_statement
call_string.pre += generate_declaration_statement(declaration, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ";\n"
call_string.pre += generate_statement(ast_statement_ptr(make_method_call(temp_ident, "copy_construct", vector(make_operator_call("&", vector(param))))), enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>()).one_string()
call_string += generate(temp_ident, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false)
} else {
call_string += generate(param, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), in_function_param_type->is_ref)
}
} }
var pre_call = string() var pre_call = string()
// temporary returns if we're asked for them or we need them for destruct // temporary returns if we're asked for them or we need them for destruct
var needs_temp_for_destruct = func_return_type->indirection == 0 && (func_return_type->is_object() && has_method(func_return_type->type_def, "destruct", vector<*type>())) if (!func_return_type->is_ref && !func_return_type->is_void() && need_variable) {
if (!func_return_type->is_ref && (needs_temp_for_destruct || (!func_return_type->is_void() && need_variable)) ) {
// kind of ugly combo here of // kind of ugly combo here of
var temp_ident = ast_identifier_ptr(string("temporary_return")+get_id(), func_return_type, null<ast_node>()) var temp_ident = ast_identifier_ptr(string("temporary_return")+get_id(), func_return_type, null<ast_node>())
var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false) var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false)
// have to pass false to the declaration generator, so can't do it through generate_statement // have to pass false to the declaration generator, so can't do it through generate_statement
call_string.pre += generate_declaration_statement(declaration, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ";\n" call_string.pre += generate_declaration_statement(declaration, enclosing_object, enclosing_func, false).one_string() + ";\n"
pre_call = generate_identifier(temp_ident, enclosing_object, enclosing_func).one_string() pre_call = generate_identifier(temp_ident, enclosing_object, enclosing_func).one_string()
// move destruct condition inside
if (needs_temp_for_destruct)
call_string.post += generate_statement(ast_statement_ptr(make_method_call(temp_ident, "destruct", vector<*ast_node>())), enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>()).one_string()
} }
var ref_pre = string() var ref_pre = string()
var ref_post = string() var ref_post = string()
@@ -733,10 +656,10 @@ obj c_generator (Object) {
var temp_ident = ast_identifier_ptr(string("temporary_return")+get_id(), func_return_type, null<ast_node>()) var temp_ident = ast_identifier_ptr(string("temporary_return")+get_id(), func_return_type, null<ast_node>())
var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false) var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false)
// have to pass false to the declaration generator, so can't do it through generate_statement // have to pass false to the declaration generator, so can't do it through generate_statement
call_string.pre += generate_declaration_statement(declaration, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false).one_string() + ";\n" call_string.pre += generate_declaration_statement(declaration, enclosing_object, enclosing_func, false).one_string() + ";\n"
pre_call = generate_identifier(temp_ident, enclosing_object, enclosing_func).one_string() pre_call = generate_identifier(temp_ident, enclosing_object, enclosing_func).one_string()
} }
var name_temp = generate(node->function_call.func, enclosing_object, enclosing_func, null<stack<pair<bool,stack<*ast_node>>>>(), false) var name_temp = generate(node->function_call.func, enclosing_object, enclosing_func, false)
call_string.pre += name_temp.pre call_string.pre += name_temp.pre
call_string.post += name_temp.post call_string.post += name_temp.post
func_name = name_temp.value func_name = name_temp.value
@@ -787,26 +710,26 @@ obj c_generator (Object) {
} }
// for now, anyway // for now, anyway
fun generate(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, defer_stack: *stack<pair<bool,stack<*ast_node>>>, need_variable: bool): code_triple { fun generate(node: *ast_node, enclosing_object: *ast_node, enclosing_func: *ast_node, need_variable: bool): code_triple {
if (!node) return code_triple("/*NULL*/") if (!node) return code_triple("/*NULL*/")
match (*node) { match (*node) {
ast_node::if_comp(backing) return generate_if_comp(node, enclosing_object, enclosing_func, defer_stack) ast_node::if_comp(backing) return generate_if_comp(node, enclosing_object, enclosing_func)
ast_node::simple_passthrough(backing) return code_triple() + generate_simple_passthrough(node, false) ast_node::simple_passthrough(backing) return code_triple() + generate_simple_passthrough(node, false)
ast_node::statement(backing) return generate_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::statement(backing) return generate_statement(node, enclosing_object, enclosing_func)
ast_node::declaration_statement(backing) return generate_declaration_statement(node, enclosing_object, enclosing_func, defer_stack, true) ast_node::declaration_statement(backing) return generate_declaration_statement(node, enclosing_object, enclosing_func, true)
ast_node::assignment_statement(backing) return generate_assignment_statement(node, enclosing_object, enclosing_func) ast_node::assignment_statement(backing) return generate_assignment_statement(node, enclosing_object, enclosing_func)
ast_node::if_statement(backing) return generate_if_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::if_statement(backing) return generate_if_statement(node, enclosing_object, enclosing_func)
ast_node::while_loop(backing) return generate_while_loop(node, enclosing_object, enclosing_func, defer_stack) ast_node::while_loop(backing) return generate_while_loop(node, enclosing_object, enclosing_func)
ast_node::for_loop(backing) return generate_for_loop(node, enclosing_object, enclosing_func, defer_stack) ast_node::for_loop(backing) return generate_for_loop(node, enclosing_object, enclosing_func)
ast_node::function(backing) return generate_function(node, enclosing_object, enclosing_func, true, need_variable) ast_node::function(backing) return generate_function(node, enclosing_object, enclosing_func, true, need_variable)
ast_node::function_call(backing) return generate_function_call(node, enclosing_object, enclosing_func, need_variable) ast_node::function_call(backing) return generate_function_call(node, enclosing_object, enclosing_func, need_variable)
ast_node::compiler_intrinsic(backing) return generate_compiler_intrinsic(node) ast_node::compiler_intrinsic(backing) return generate_compiler_intrinsic(node)
ast_node::code_block(backing) return generate_code_block(node, enclosing_object, enclosing_func, defer_stack) ast_node::code_block(backing) return generate_code_block(node, enclosing_object, enclosing_func)
ast_node::return_statement(backing) return generate_return_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::return_statement(backing) return generate_return_statement(node, enclosing_object, enclosing_func)
ast_node::branching_statement(backing) return generate_branching_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::branching_statement(backing) return generate_branching_statement(node, enclosing_object, enclosing_func)
ast_node::defer_statement(backing) return generate_defer_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::defer_statement(backing) return generate_defer_statement(node, enclosing_object, enclosing_func)
ast_node::match_statement(backing) return generate_match_statement(node, enclosing_object, enclosing_func, defer_stack) ast_node::match_statement(backing) return generate_match_statement(node, enclosing_object, enclosing_func)
ast_node::cast(backing) return generate_cast(node, enclosing_object, enclosing_func, defer_stack, need_variable) ast_node::cast(backing) return generate_cast(node, enclosing_object, enclosing_func)
ast_node::value(backing) return generate_value(node, need_variable) ast_node::value(backing) return generate_value(node, need_variable)
ast_node::identifier(backing) return generate_identifier(node, enclosing_object, enclosing_func) ast_node::identifier(backing) return generate_identifier(node, enclosing_object, enclosing_func)
} }

32
stdlib/hash_map.krak
View File

@@ -22,29 +22,17 @@ obj hash_map<T,U> (Object, Serializable) {
data.construct() data.construct()
data.add(map::map<T,U>()) data.add(map::map<T,U>())
size = 0 size = 0
/*io::print("Constructed hash_map, this: ")*/
/*io::println((this) cast int)*/
/*io::print("size of data:")*/
/*io::println(data.size)*/
return this return this
} }
fun copy_construct(old: *hash_map<T,U>) { fun copy_construct(old: *hash_map<T,U>) {
data.copy_construct(&old->data) data.copy_construct(&old->data)
size = old->size size = old->size
/*io::print("Copy constructed hash_map, this: ")*/
/*io::println((this) cast int)*/
/*io::print("new size of data:")*/
/*io::println(data.size)*/
/*io::print("old size of data:")*/
/*io::println(old->data.size)*/
} }
fun operator=(rhs: ref hash_map<T,U>) { fun operator=(rhs: ref hash_map<T,U>) {
data = rhs.data data = rhs.data
size = rhs.size size = rhs.size
} }
fun destruct() { fun destruct() {
/*io::print("destructed hash_map, this: ")*/
/*io::println((this) cast int)*/
data.destruct() data.destruct()
} }
fun serialize(): vector::vector<char> { fun serialize(): vector::vector<char> {
@@ -61,32 +49,26 @@ obj hash_map<T,U> (Object, Serializable) {
return data == other.data return data == other.data
} }
fun set(key: ref T, value: ref U) { fun set(key: ref T, value: ref U) {
/*io::print("doing set! this:")*/ var key_hash = util::hash(key)
/*io::println((this) cast int)*/ if (!data[(key_hash%data.size) cast int].contains_key(key)) {
/*io::print("size of data:")*/
/*io::println(data.size)*/
var key_hash = (util::hash(key)) cast int
if (!data[key_hash%data.size].contains_key(key)) {
size++ size++
if (size > data.size) { if (size > data.size) {
/*io::print("rehashing to: ")*/
/*io::println(size*2)*/
var new_data = vector::vector<map::map<T,U>>() var new_data = vector::vector<map::map<T,U>>()
for (var i = 0; i < size*2; i++;) for (var i = 0; i < size*2; i++;)
new_data.addEnd(map::map<T,U>()) new_data.addEnd(map::map<T,U>())
for_each(fun(key: T, value: U) { for_each(fun(key: T, value: U) {
new_data[(util::hash(key)) cast int%new_data.size].set(key, value) new_data[(util::hash(key)%new_data.size) cast int].set(key, value)
}) })
data = new_data data = new_data
} }
} }
data[key_hash%data.size].set(key, value) data[(key_hash%data.size) cast int].set(key, value)
} }
fun get(key: ref T): ref U { fun get(key: ref T): ref U {
return data[(util::hash(key)) cast int%data.size].get(key) return data[(util::hash(key)%data.size) cast int].get(key)
} }
fun contains_key(key: ref T): bool { fun contains_key(key: ref T): bool {
return data[(util::hash(key)) cast int%data.size].contains_key(key) return data[(util::hash(key)%data.size) cast int].contains_key(key)
} }
fun contains_value(value: ref U): bool { fun contains_value(value: ref U): bool {
for (var i = 0; i < data.size; i++;) { for (var i = 0; i < data.size; i++;) {
@@ -103,7 +85,7 @@ obj hash_map<T,U> (Object, Serializable) {
io::println("trying to reverse get a value that is not in the hash_map") io::println("trying to reverse get a value that is not in the hash_map")
} }
fun remove(key: ref T) { fun remove(key: ref T) {
data[(util::hash(key)) cast int%data.size].remove(key) data[(util::hash(key)%data.size) cast int].remove(key)
} }
fun for_each(func: fun(T, U):void) { fun for_each(func: fun(T, U):void) {
for (var i = 0; i < data.size; i++;) for (var i = 0; i < data.size; i++;)

52
stdlib/obj_lower.krak
View File

@@ -110,6 +110,49 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
// Pass 3 // Pass 3
var construct_in_destruct_out = fun(node: *ast_node, parent_chain: *stack<*ast_node>) { var construct_in_destruct_out = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
match(*node) { match(*node) {
ast_node::function_call(backing) {
if (is_function(backing.func)) {
var func_name = backing.func->function.name
if (func_name == "+" || func_name == "-" || func_name == "*" || func_name == "/"
|| func_name == "<" || func_name == ">" || func_name == "<=" || func_name == ">="
|| func_name == "==" || func_name == "!=" || func_name == "%" || func_name == "^"
|| func_name == "|" || func_name == "&" || func_name == "." || func_name == "->"
|| func_name == "." || func_name == "->" || func_name == "[]" || func_name == "++p" || func_name == "--p"
|| func_name == "*" || func_name == "&" || func_name == "||" || func_name == "&&"
|| func_name == "!"
)
return
}
var enclosing_block_idx = parent_chain->index_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i);)
var func_type = get_ast_type(backing.func)
for (var i = 0; i < backing.parameters.size; i++;) {
var param = backing.parameters[i]
var in_function_param_type = null<type>()
// grab type from param itself if we're out of param types (because variadic function)
if (i < func_type->parameter_types.size)
in_function_param_type = func_type->parameter_types[i]
else
in_function_param_type = get_ast_type(param)->clone_without_ref()
var param_type = get_ast_type(param)
if (!in_function_param_type->is_ref && param_type->indirection == 0 && (param_type->is_object() && has_method(param_type->type_def, "copy_construct", vector(param_type->clone_with_indirection(1))))) {
var temp_ident = ast_identifier_ptr("temporary_param_boom", param_type->clone_without_ref(), null<ast_node>())
var declaration = ast_statement_ptr(ast_declaration_statement_ptr(temp_ident, null<ast_node>(), false))
var copy_in = ast_statement_ptr(make_method_call(temp_ident, "copy_construct", vector(make_operator_call("&", vector(param)))))
add_before_in(declaration, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
add_before_in(copy_in, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
backing.parameters[i] = temp_ident
}
}
var func_return_type = func_type->return_type
if (!func_return_type->is_ref && func_return_type->indirection == 0 && (func_return_type->is_object() && has_method(func_return_type->type_def, "destruct", vector<*type>()))) {
var temp_return = ast_identifier_ptr("temporary_return_boomchaka", func_return_type, null<ast_node>())
var declaration = ast_statement_ptr(ast_declaration_statement_ptr(temp_return, node, false))
add_before_in(declaration, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
add_before_in(ast_statement_ptr(ast_defer_statement_ptr(ast_statement_ptr(make_method_call(temp_return, "destruct", vector<*ast_node>())))),
parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
replace_with_in(node, temp_return, parent_chain)
}
}
ast_node::function(backing) { ast_node::function(backing) {
var order = 0; var order = 0;
backing.parameters.for_each(fun(param: *ast_node) { backing.parameters.for_each(fun(param: *ast_node) {
@@ -125,7 +168,13 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
var ident_type = get_ast_type(backing.identifier) var ident_type = get_ast_type(backing.identifier)
if (is_translation_unit(parent_chain->top()) || is_type_def(parent_chain->top())) if (is_translation_unit(parent_chain->top()) || is_type_def(parent_chain->top()))
return; return;
if (!ident_type->is_ref && ident_type->indirection == 0 && (ident_type->is_object() && has_method(ident_type->type_def, "destruct", vector<*type>()))) { if (!ident_type->is_ref && ident_type->indirection == 0 && ident_type->is_object()) {
if (backing.expression && has_method(ident_type->type_def, "copy_construct", vector(get_ast_type(backing.expression)->clone_with_increased_indirection()))) {
add_after_in(ast_statement_ptr(make_method_call(backing.identifier, "copy_construct", vector(make_operator_call("&", vector(backing.expression))))),
parent_chain->top(), parent_chain->from_top(1))
backing.expression = null<ast_node>()
}
if (has_method(ident_type->type_def, "destruct", vector<*type>())) {
// have to go up one because our parent is a statement // have to go up one because our parent is a statement
add_after_in(ast_statement_ptr(ast_defer_statement_ptr(ast_statement_ptr(make_method_call(backing.identifier, "destruct", vector<*ast_node>())))), add_after_in(ast_statement_ptr(ast_defer_statement_ptr(ast_statement_ptr(make_method_call(backing.identifier, "destruct", vector<*ast_node>())))),
parent_chain->top(), parent_chain->from_top(1)) parent_chain->top(), parent_chain->from_top(1))
@@ -133,6 +182,7 @@ fun obj_lower(name_ast_map: *map<string, pair<*tree<symbol>,*ast_node>>, ast_to_
} }
} }
} }
}
run_on_tree(empty_pass_first_half, construct_in_destruct_out, syntax_ast_pair.second) run_on_tree(empty_pass_first_half, construct_in_destruct_out, syntax_ast_pair.second)
}) })
} }

12
tests/test_adt.expected_results
View File

@@ -12,13 +12,11 @@ constructed object 100 : 100
copy constructed object 100 : 200 from 100 : 100 copy constructed object 100 : 200 from 100 : 100
destructed object 100 : 100 destructed object 100 : 100
copy constructed object 100 : 300 from 100 : 200 copy constructed object 100 : 300 from 100 : 200
destructed object 100 : 200
copy constructed object 100 : 400 from 100 : 300 copy constructed object 100 : 400 from 100 : 300
copy constructed object 100 : 500 from 100 : 400 copy constructed object 100 : 500 from 100 : 400
destructed object 100 : 400 destructed object 100 : 400
destructed object 100 : 300 destructed object 100 : 300
copy constructed object 100 : 600 from 100 : 500 copy constructed object 100 : 600 from 100 : 500
destructed object 100 : 500
done assignment to old variable done assignment to old variable
matched an_obj correctly 100 : 600 matched an_obj correctly 100 : 600
int assignment to old var int assignment to old var
@@ -31,7 +29,6 @@ constructed object 110 : 110
copy constructed object 110 : 210 from 110 : 110 copy constructed object 110 : 210 from 110 : 110
destructed object 110 : 110 destructed object 110 : 110
copy constructed object 110 : 310 from 110 : 210 copy constructed object 110 : 310 from 110 : 210
destructed object 110 : 210
copy constructed object 110 : 410 from 110 : 310 copy constructed object 110 : 410 from 110 : 310
copy constructed object 110 : 510 from 110 : 410 copy constructed object 110 : 510 from 110 : 410
destructed object 110 : 410 destructed object 110 : 410
@@ -41,7 +38,6 @@ constructed object 110 : 110
copy constructed object 110 : 210 from 110 : 110 copy constructed object 110 : 210 from 110 : 110
destructed object 110 : 110 destructed object 110 : 110
copy constructed object 110 : 310 from 110 : 210 copy constructed object 110 : 310 from 110 : 210
destructed object 110 : 210
copy constructed object 110 : 410 from 110 : 310 copy constructed object 110 : 410 from 110 : 310
copy constructed object 110 : 510 from 110 : 410 copy constructed object 110 : 510 from 110 : 410
destructed object 110 : 410 destructed object 110 : 410
@@ -49,7 +45,11 @@ destructed object 110 : 310
copy constructed object 110 : 610 from 110 : 510 copy constructed object 110 : 610 from 110 : 510
destructed object 110 : 610 destructed object 110 : 610
equality an_obj correctly equality an_obj correctly
destructed object 110 : 510
destructed object 110 : 510
done test copy_construct for non ref equality done test copy_construct for non ref equality
10 10
destructed object 110 : 510
destructed object 110 : 210
destructed object 110 : 510
destructed object 110 : 210
destructed object 100 : 500
destructed object 100 : 200

2
tests/test_destructor_copy_constructor.expected_results
View File

@@ -39,9 +39,9 @@ copy_construct outFunc : 1!
destroyed outFunc : 0! destroyed outFunc : 0!
destroyed inFunc : 1! destroyed inFunc : 1!
copy_construct outFunc : 2! copy_construct outFunc : 2!
destroyed outFunc : 1!
time for the end time for the end
destroyed outFunc : 2! destroyed outFunc : 2!
destroyed outFunc : 1!
destroyed inFunc : 0! destroyed inFunc : 0!
destroyed a2 : 0! destroyed a2 : 0!
destroyed a : 0! destroyed a : 0!

4
tests/test_util.expected_results
View File

@@ -24,10 +24,10 @@ destruct with 101
destruct with 1 destruct with 1
copy construct from 3 to 4 copy construct from 3 to 4
copy construct from 103 to 104 copy construct from 103 to 104
destruct with 3
destruct with 103
done done
destruct with 4 destruct with 4
destruct with 104 destruct with 104
destruct with 3
destruct with 103
destruct with 100 destruct with 100
destruct with 0 destruct with 0

6
tests/test_vectorTest.expected_results
View File

@@ -65,15 +65,15 @@ Destroyed: 101
Copied: 103 to 104 Copied: 103 to 104
Copied: 203 to 204 Copied: 203 to 204
Copied: 303 to 304 Copied: 303 to 304
Destroyed: 103
Destroyed: 203
Destroyed: 303
Destroyed: 204 Destroyed: 204
Copied: 304 to 305 Copied: 304 to 305
Destroyed: 304 Destroyed: 304
done done
Destroyed: 104 Destroyed: 104
Destroyed: 305 Destroyed: 305
Destroyed: 103
Destroyed: 203
Destroyed: 303
Destroyed: 300 Destroyed: 300
Destroyed: 200 Destroyed: 200
Destroyed: 100 Destroyed: 100