diff --git a/stdlib/c_generator.krak b/stdlib/c_generator.krak index 69df492..348c21c 100644 --- a/stdlib/c_generator.krak +++ b/stdlib/c_generator.krak @@ -1,6 +1,7 @@ import io:* import mem:* import map:* +import stack:* import string:* import util:* import tree:* @@ -54,7 +55,10 @@ obj c_generator (Object) { function_prototypes += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameter_types + ");\n" // add parameters to destructor thingy (for returns)? Or should that be a different pass? - function_definitions += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ") {\n" + generate_statement(backing.body_statement, enclosing_object) + // stack-stack thing // this could be a stack of strings too, maybe + // start out with one stack on the stack + var defer_stack = stack>(stack<*ast_node>()) + function_definitions += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ") {\n" + generate_statement(backing.body_statement, enclosing_object, &defer_stack) // emit parameter destructors? function_definitions += "}\n" } @@ -72,7 +76,7 @@ obj c_generator (Object) { top_level_c_passthrough += generate_simple_passthrough(backing.statement->statement.child) } ast_node::simple_passthrough(backing) top_level_c_passthrough += generate_simple_passthrough(child) - ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null()) + ";\n" + ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null(), null>>()) + ";\n" ast_node::function(backing) { // make sure not a template // or a passthrough @@ -88,7 +92,7 @@ obj c_generator (Object) { type_poset.get_sorted().for_each(fun(vert: *ast_node) { plain_typedefs += string("typedef struct ") + vert->type_def.name + "_dummy " + vert->type_def.name + ";\n" structs += string("struct ") + vert->type_def.name + "_dummy {\n" - vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null()) + ";\n";) + vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null(), null>>()) + ";\n";) structs += "};\n" // generate the methods vert->type_def.methods.for_each(fun(method: *ast_node) generate_function_definition(method, vert);) @@ -98,54 +102,89 @@ obj c_generator (Object) { } fun generate_if_comp(node: *ast_node): string { if (node->if_comp.wanted_generator == "__C__") - return generate(node->if_comp.statement, null()) + return generate(node->if_comp.statement, null(), null>>()) return string("") } fun generate_simple_passthrough(node: *ast_node): string { // deal with all the passthrough params return node->simple_passthrough.passthrough_str } - fun generate_statement(node: *ast_node, enclosing_object: *ast_node): string return generate(node->statement.child, enclosing_object) + ";\n"; - fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string return generate(node->statement.child, enclosing_object, defer_stack) + ";\n"; + fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + // add destruct to defer_stac var identifier = node->declaration_statement.identifier var to_ret = type_to_c(identifier->identifier.type) + " " + identifier->identifier.name - if (node->declaration_statement.expression) to_ret += string(" = ") + generate(node->declaration_statement.expression, enclosing_object) + if (node->declaration_statement.expression) to_ret += string(" = ") + generate(node->declaration_statement.expression, enclosing_object, null>>()) return to_ret } fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node): string { - return generate(node->assignment_statement.to, null()) + " = " + generate(node->assignment_statement.from, enclosing_object) + return generate(node->assignment_statement.to, null(), null>>()) + " = " + generate(node->assignment_statement.from, enclosing_object, null>>()) } - fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node): string { - var if_str = string("if (") + generate(node->if_statement.condition, enclosing_object) + ") {\n" + generate(node->if_statement.then_part, enclosing_object) + "}" + fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + var if_str = string("if (") + generate(node->if_statement.condition, enclosing_object, null>>()) + ") {\n" + generate(node->if_statement.then_part, enclosing_object, defer_stack) + "}" if (node->if_statement.else_part) - if_str += string(" else {\n") + generate(node->if_statement.else_part, enclosing_object) + "}" + if_str += string(" else {\n") + generate(node->if_statement.else_part, enclosing_object, defer_stack) + "}" return if_str + "\n" } - fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node): string { - return string("while (") + generate(node->while_loop.condition, enclosing_object) + ") {\n" + generate(node->while_loop.statement, enclosing_object) + "}\n" + fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + // stick another stack on + defer_stack->push(stack<*ast_node>()) + var to_ret = string("while (") + generate(node->while_loop.condition, enclosing_object, null>>()) + ") {\n" + generate(node->while_loop.statement, enclosing_object, defer_stack) + to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object) + defer_stack->pop() + to_ret += "}\n" + return to_ret } - fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + // stick another stack on + defer_stack->push(stack<*ast_node>()) // gotta take off last semicolon - return string("for (") + generate(node->for_loop.init, enclosing_object) + " " + generate(node->for_loop.condition, enclosing_object) + "; " + - generate(node->for_loop.update, enclosing_object).slice(0,-3) + ") {\n" + generate(node->for_loop.body, enclosing_object) + "}\n" + var to_ret = string("for (") + generate(node->for_loop.init, enclosing_object, null>>()) + " " + generate(node->for_loop.condition, enclosing_object, null>>()) + "; " + + generate(node->for_loop.update, enclosing_object, null>>()).slice(0,-3) + ") {\n" + generate(node->for_loop.body, enclosing_object, defer_stack) + to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object) + defer_stack->pop() + to_ret += "}\n" + return to_ret } fun generate_identifier(node: *ast_node, enclosing_object: *ast_node): string { if (enclosing_object && get_ast_scope(enclosing_object)->contains_key(node->identifier.name)) return string("(this->") + node->identifier.name + ")" return node->identifier.name } - fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node): string return string("return ") + generate(node->return_statement.return_value, enclosing_object); - fun generate_branching_statement(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + // generate all in stac + var to_ret = generate_from_defer_stack(defer_stack, -1, enclosing_object) + to_ret += string("return ") + generate(node->return_statement.return_value, enclosing_object, null>>()) + return to_ret + } + fun generate_branching_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + // should be up to loop + var to_ret = generate_from_defer_stack(defer_stack, 1, enclosing_object) match(node->branching_statement.b_type) { - branching_type::break_stmt() return string("break") - branching_type::continue_stmt() return string("continue") + branching_type::break_stmt() return to_ret + string("break") + branching_type::continue_stmt() return to_ret + string("continue") } } - fun generate_defer_statement(node: *ast_node, enclosing_object: *ast_node): string return string("/*defer ") + generate(node->defer_statement.statement, enclosing_object) + "*/"; + fun generate_from_defer_stack(defer_stack: *stack>, num: int, enclosing_object: *ast_node): string { + var to_ret = string() + if (num == -1) + num = defer_stack->size() + for (var i = 0; i < num; i++;) + defer_stack->from_top(i).for_each(fun(node: *ast_node) to_ret += generate(node, enclosing_object, null>>());) + return to_ret + } + fun generate_defer_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { + defer_stack->top().push(node->defer_statement.statement) + return string("/*defer*/") + } fun generate_value(node: *ast_node): string return node->value.string_value; - fun generate_code_block(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_code_block(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { var to_ret = string("{\n") - node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object);) + // stick another stack on + defer_stack->push(stack<*ast_node>()) + node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object, defer_stack);) + to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object) + defer_stack->pop() return to_ret + "}" } // this generates the function as a value, not the actual function @@ -167,13 +206,13 @@ obj c_generator (Object) { is_type_def(get_ast_scope(node->function_call.func->function_call.parameters[1])->get(string("~enclosing_scope"))[0]) if (dot_style_method_call) { - func_name = generate(node->function_call.func->function_call.parameters[1], enclosing_object) + func_name = generate(node->function_call.func->function_call.parameters[1], enclosing_object, null>>()) // don't add & if it was -> if (node->function_call.func->function_call.func->function.name == ".") call_string += string("&") - call_string += generate(node->function_call.func->function_call.parameters[0], enclosing_object) + call_string += generate(node->function_call.func->function_call.parameters[0], enclosing_object, null>>()) } else { // regular style function name - func_name = generate(node->function_call.func, enclosing_object) + func_name = generate(node->function_call.func, enclosing_object, null>>()) } // handle method call from inside method of same object if (!dot_style_method_call && enclosing_object && get_ast_scope(enclosing_object)->contains_key(func_name)) @@ -185,41 +224,41 @@ obj c_generator (Object) { || func_name == "&&" || func_name == "<" || func_name == ">" || func_name == "<=" || func_name == ">=" || func_name == "==" || func_name == "%" ) - return string("(") + generate(parameters[0], enclosing_object) + func_name + generate(parameters[1], enclosing_object) + string(")") + return string("(") + generate(parameters[0], enclosing_object, null>>()) + func_name + generate(parameters[1], enclosing_object, null>>()) + string(")") // don't propegate enclosing function down right of access if (func_name == "." || func_name == "->") - return string("(") + generate(parameters[0], enclosing_object) + func_name + generate(parameters[1], null()) + string(")") + return string("(") + generate(parameters[0], enclosing_object, null>>()) + func_name + generate(parameters[1], null(), null>>()) + string(")") // the post ones need to be post-ed specifically, and take the p off if (func_name == "++p" || func_name == "--p") - return string("(") + generate(parameters[0], enclosing_object) + ")" + func_name.slice(0,-2) + return string("(") + generate(parameters[0], enclosing_object, null>>()) + ")" + func_name.slice(0,-2) // regular parameter generation parameters.for_each(fun(param: *ast_node) { if (call_string != "") call_string += ", " - call_string += generate(param, enclosing_object) + call_string += generate(param, enclosing_object, null>>()) }) return func_name + "(" + call_string + ")" } // for now, anyway - fun generate(node: *ast_node, enclosing_object: *ast_node): string { + fun generate(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>): string { if (!node) return string("/*NULL*/") match (*node) { ast_node::if_comp(backing) return generate_if_comp(node) ast_node::simple_passthrough(backing) return generate_simple_passthrough(node) - ast_node::statement(backing) return generate_statement(node, enclosing_object) - ast_node::declaration_statement(backing) return generate_declaration_statement(node, enclosing_object) + ast_node::statement(backing) return generate_statement(node, enclosing_object, defer_stack) + ast_node::declaration_statement(backing) return generate_declaration_statement(node, enclosing_object, defer_stack) ast_node::assignment_statement(backing) return generate_assignment_statement(node, enclosing_object) - ast_node::if_statement(backing) return generate_if_statement(node, enclosing_object) - ast_node::while_loop(backing) return generate_while_loop(node, enclosing_object) - ast_node::for_loop(backing) return generate_for_loop(node, enclosing_object) + ast_node::if_statement(backing) return generate_if_statement(node, enclosing_object, defer_stack) + ast_node::while_loop(backing) return generate_while_loop(node, enclosing_object, defer_stack) + ast_node::for_loop(backing) return generate_for_loop(node, enclosing_object, defer_stack) ast_node::function(backing) return generate_function(node) ast_node::function_call(backing) return generate_function_call(node, enclosing_object) - ast_node::code_block(backing) return generate_code_block(node, enclosing_object) - ast_node::return_statement(backing) return generate_return_statement(node, enclosing_object) - ast_node::branching_statement(backing) return generate_branching_statement(node, enclosing_object) - ast_node::defer_statement(backing) return generate_defer_statement(node, enclosing_object) + ast_node::code_block(backing) return generate_code_block(node, enclosing_object, defer_stack) + ast_node::return_statement(backing) return generate_return_statement(node, enclosing_object, defer_stack) + ast_node::branching_statement(backing) return generate_branching_statement(node, enclosing_object, defer_stack) + ast_node::defer_statement(backing) return generate_defer_statement(node, enclosing_object, defer_stack) ast_node::value(backing) return generate_value(node) ast_node::identifier(backing) return generate_identifier(node, enclosing_object) } diff --git a/stdlib/stack.krak b/stdlib/stack.krak index 7ae6992..e53c47a 100644 --- a/stdlib/stack.krak +++ b/stdlib/stack.krak @@ -47,13 +47,22 @@ obj stack (Object, Serializable) { fun clear() { data.clear() } - fun top(): T { + fun top(): ref T { return data[data.size-1] } + fun from_top(num: int): ref T { + return data[(data.size-1)-num] + } fun size(): int { return data.size } fun empty():bool { return data.size == 0 } + fun for_each(func: fun(ref T):void) { + data.for_each(func) + } + fun for_each(func: fun(T):void) { + data.for_each(func) + } }