From b06c329236efc05af1931c441f6aef2439e6843d Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Wed, 27 Jan 2016 18:56:44 -0500 Subject: [PATCH] Changed over to code_triple to set up for automatic object methods --- stdlib/c_generator.krak | 169 +++++++++++++++++++++++++++------------- 1 file changed, 114 insertions(+), 55 deletions(-) diff --git a/stdlib/c_generator.krak b/stdlib/c_generator.krak index 93ebec1..a948049 100644 --- a/stdlib/c_generator.krak +++ b/stdlib/c_generator.krak @@ -9,6 +9,67 @@ import symbol:* import ast_nodes:* import poset:* +fun code_triple(): code_triple return code_triple(string(), string(), string()); +fun code_triple(only: *char): code_triple return code_triple(string(), string(only), string()); +fun code_triple(only: string): code_triple return code_triple(string(), only, string()); +fun code_triple(first: string, second: string, third: string): code_triple { + var to_ret.construct(first, second, third): code_triple + return to_ret +} +obj code_triple (Object) { + var pre: string + var value: string + var post: string + fun construct(first: string, second: string, third: string): *code_triple { + pre.copy_construct(&first) + value.copy_construct(&second) + post.copy_construct(&third) + return this + } + fun copy_construct(old: *code_triple) { + pre.copy_construct(&old->pre) + value.copy_construct(&old->value) + post.copy_construct(&old->post) + } + fun operator=(other: code_triple) { + destruct() + copy_construct(&other) + } + fun destruct() { + pre.destruct() + value.destruct() + post.destruct() + } + fun operator==(other: code_triple): bool return pre == other.pre && value == other.value && post == other.value; + fun operator==(other: string): bool return (pre + value + post) == other; + fun operator==(other: *char): bool return (pre + value + post) == other; + fun operator!=(other: code_triple): bool return pre != other.pre || value != other.value || post != other.value; + fun operator!=(other: string): bool return (pre + value + post) != other; + fun operator!=(other: *char): bool return (pre + value + post) != other; + fun operator+(other: code_triple): code_triple { + return code_triple(pre+other.pre, value+other.value, other.post+post); + } + fun operator+(other: string): code_triple { + return code_triple(pre, value+other, post); + } + fun operator+(other: *char): code_triple { + return code_triple(pre, value + other, post); + } + fun operator+=(other: string) { + value += other + } + fun operator+=(other: *char) { + value += other + } + fun operator+=(other: code_triple) { + pre += other.pre + value += other.value + post += other.post + } + fun one_string():string { + return pre+value+post + } +} obj c_generator (Object) { fun construct(): *c_generator { @@ -45,7 +106,7 @@ obj c_generator (Object) { parameter_types = type_to_c(enclosing_object->type_def.self_type) + "*" parameters = type_to_c(enclosing_object->type_def.self_type) + "* this" } - var decorated_name = generate_function(child) + var decorated_name = generate_function(child).one_string() // also add in name decoration backing.parameters.for_each(fun(parameter: *ast_node) { if (parameter_types != "") { parameter_types += ", "; parameters += ", ";} @@ -58,7 +119,7 @@ obj c_generator (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>>(make_pair(false, 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) + function_definitions += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ") {\n" + generate_statement(backing.body_statement, enclosing_object, &defer_stack).one_string() // emit parameter destructors? function_definitions += "}\n" } @@ -76,7 +137,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(), null>>>()) + ";\n" + ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null(), null>>>()).one_string() + ";\n" ast_node::function(backing) { // make sure not a template // or a passthrough @@ -92,7 +153,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(), null>>>()) + ";\n";) + vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null(), null>>>()).one_string() + ";\n";) structs += "};\n" // generate the methods vert->type_def.methods.for_each(fun(method: *ast_node) generate_function_definition(method, vert);) @@ -100,73 +161,74 @@ obj c_generator (Object) { return make_pair(prequal+plain_typedefs+top_level_c_passthrough+variable_extern_declarations+structs+function_typedef_string_pre+function_typedef_string+function_prototypes+variable_declarations+function_definitions + "\n", linker_string) } - fun generate_if_comp(node: *ast_node): string { + fun generate_if_comp(node: *ast_node): code_triple { if (node->if_comp.wanted_generator == "__C__") return generate(node->if_comp.statement, null(), null>>>()) - return string("") + return code_triple() } 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, 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 { + fun generate_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple return generate(node->statement.child, enclosing_object, defer_stack) + ";\n"; + fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { // 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, null>>>()) + var to_ret = code_triple() + type_to_c(identifier->identifier.type) + " " + identifier->identifier.name + if (node->declaration_statement.expression) to_ret += code_triple(" = ") + generate(node->declaration_statement.expression, enclosing_object, null>>>()) return to_ret } - fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node): code_triple { 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, 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) + "}" + fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { + var if_str = code_triple("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, defer_stack) + "}" + if_str += code_triple(" 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, defer_stack: *stack>>): string { + fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { // stick another stack on defer_stack->push(make_pair(true, 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) + var to_ret = code_triple("while (") + generate(node->while_loop.condition, enclosing_object, null>>>()).one_string() + ") {\n" + generate(node->while_loop.statement, enclosing_object, defer_stack).one_string() 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, defer_stack: *stack>>): string { + fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { // stick another stack on defer_stack->push(make_pair(true, stack<*ast_node>())) // gotta take off last semicolon - 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) + var to_ret = code_triple("for (") + generate(node->for_loop.init, enclosing_object, null>>>()).one_string() + " " + generate(node->for_loop.condition, enclosing_object, null>>>()).one_string() + "; " + + generate(node->for_loop.update, enclosing_object, null>>>()).one_string().slice(0,-3) + + ") {\n" + generate(node->for_loop.body, enclosing_object, defer_stack).one_string() + to_ret += generate_from_defer_stack(defer_stack, 1, enclosing_object).one_string() defer_stack->pop() to_ret += "}\n" return to_ret } - fun generate_identifier(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_identifier(node: *ast_node, enclosing_object: *ast_node): code_triple { if (enclosing_object && get_ast_scope(enclosing_object)->contains_key(node->identifier.name)) - return string("(this->") + node->identifier.name + ")" - return node->identifier.name + return code_triple("(this->") + node->identifier.name + ")" + return code_triple(node->identifier.name) } - fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): string { - // generate all in stac + fun generate_return_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { + // generate all in stack by passing -1 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>>>()) + to_ret += code_triple("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 + fun generate_branching_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { + // -2 means generate up through loop var to_ret = generate_from_defer_stack(defer_stack, -2, enclosing_object) match(node->branching_statement.b_type) { branching_type::break_stmt() return to_ret + string("break") branching_type::continue_stmt() return to_ret + string("continue") } } - fun generate_from_defer_stack(defer_stack: *stack>>, num: int, enclosing_object: *ast_node): string { - var to_ret = string() + fun generate_from_defer_stack(defer_stack: *stack>>, num: int, enclosing_object: *ast_node): code_triple { + var to_ret = code_triple() if (num == -1) num = defer_stack->size() if (num == -2) { @@ -176,37 +238,34 @@ obj c_generator (Object) { break else num++ - print("HERE IS THE THING: "); println(num) } for (var i = 0; i < num; i++;) defer_stack->from_top(i).second.for_each(fun(node: *ast_node) to_ret += generate(node, enclosing_object, null>>>());) - /*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 { + fun generate_defer_statement(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { defer_stack->top().second.push(node->defer_statement.statement) - return string("/*defer*/") + return code_triple("/*defer wanna know what*/") } - fun generate_value(node: *ast_node): string return node->value.string_value; - fun generate_code_block(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): string { - var to_ret = string("{\n") + fun generate_value(node: *ast_node): code_triple return code_triple(node->value.string_value); + fun generate_code_block(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { + var to_ret = code_triple("{\n") // stick another stack on 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, defer_stack);) + node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object, defer_stack).one_string();) 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 - fun generate_function(node: *ast_node): string { - var str = node->function.name + fun generate_function(node: *ast_node): code_triple { + var str = code_triple(node->function.name) node->function.parameters.for_each(fun(param: *ast_node) str += string("_") + type_decoration(param->identifier.type);) return str - } - fun generate_function_call(node: *ast_node, enclosing_object: *ast_node): string { + fun generate_function_call(node: *ast_node, enclosing_object: *ast_node): code_triple { var func_name = string() - var call_string = string() + var call_string = code_triple() // handle the obj.method() style of method call var dot_style_method_call = is_function_call(node->function_call.func) && @@ -216,17 +275,17 @@ 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, null>>>()) + func_name = generate(node->function_call.func->function_call.parameters[1], enclosing_object, null>>>()).one_string() // don't add & if it was -> if (node->function_call.func->function_call.func->function.name == ".") - call_string += string("&") + call_string += "&" 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, null>>>()) + func_name = generate(node->function_call.func, enclosing_object, null>>>()).one_string() } // 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)) - call_string += string("this") + call_string += "this" var parameters = node->function_call.parameters @@ -234,13 +293,13 @@ 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, null>>>()) + func_name + generate(parameters[1], enclosing_object, null>>>()) + string(")") + return code_triple("(") + 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, null>>>()) + func_name + generate(parameters[1], null(), null>>>()) + string(")") + return code_triple("(") + 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, null>>>()) + ")" + func_name.slice(0,-2) + return code_triple("(") + generate(parameters[0], enclosing_object, null>>>()) + ")" + func_name.slice(0,-2) // regular parameter generation parameters.for_each(fun(param: *ast_node) { @@ -248,15 +307,15 @@ obj c_generator (Object) { call_string += ", " call_string += generate(param, enclosing_object, null>>>()) }) - return func_name + "(" + call_string + ")" + return code_triple() + func_name + "(" + call_string + ")" } // for now, anyway - fun generate(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): string { - if (!node) return string("/*NULL*/") + fun generate(node: *ast_node, enclosing_object: *ast_node, defer_stack: *stack>>): code_triple { + if (!node) return code_triple("/*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::simple_passthrough(backing) return code_triple() + generate_simple_passthrough(node) 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) @@ -272,7 +331,7 @@ obj c_generator (Object) { ast_node::value(backing) return generate_value(node) ast_node::identifier(backing) return generate_identifier(node, enclosing_object) } - return string("/* COULD NOT GENERATE */") + return code_triple("/* COULD NOT GENERATE */") } fun type_decoration(type: *type): string { var indirection = string()