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

Access to member variables from inside methods now work

Browse Source
This commit is contained in:
Nathan Braswell
2016-01-23 20:39:06 -05:00
parent 961feb6fa5
commit 23cad3ad1b
2 changed files with 48 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
stdlib/c_generator.krak
View File

@@ -54,7 +54,7 @@ obj c_generator (Object) {
function_prototypes += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameter_types + ");\n" 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? // 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) function_definitions += type_to_c(backing.type->return_type) + " " + decorated_name + "(" + parameters + ") {\n" + generate_statement(backing.body_statement, enclosing_object)
// emit parameter destructors? // emit parameter destructors?
function_definitions += "}\n" function_definitions += "}\n"
} }
@@ -72,7 +72,7 @@ obj c_generator (Object) {
top_level_c_passthrough += generate_simple_passthrough(backing.statement->statement.child) 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::simple_passthrough(backing) top_level_c_passthrough += generate_simple_passthrough(child)
ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child) + ";\n" ast_node::declaration_statement(backing) variable_declarations += generate_declaration_statement(child, null<ast_node>()) + ";\n"
ast_node::function(backing) { ast_node::function(backing) {
// make sure not a template // make sure not a template
// or a passthrough // or a passthrough
@@ -88,7 +88,7 @@ obj c_generator (Object) {
type_poset.get_sorted().for_each(fun(vert: *ast_node) { 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" plain_typedefs += string("typedef struct ") + vert->type_def.name + "_dummy " + vert->type_def.name + ";\n"
structs += string("struct ") + vert->type_def.name + "_dummy {\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) + ";\n";) vert->type_def.variables.for_each(fun(variable_declaration: *ast_node) structs += generate_declaration_statement(variable_declaration, null<ast_node>()) + ";\n";)
structs += "};\n" structs += "};\n"
// generate the methods // generate the methods
vert->type_def.methods.for_each(fun(method: *ast_node) generate_function_definition(method, vert);) vert->type_def.methods.for_each(fun(method: *ast_node) generate_function_definition(method, vert);)
@@ -98,45 +98,47 @@ obj c_generator (Object) {
} }
fun generate_if_comp(node: *ast_node): string { fun generate_if_comp(node: *ast_node): string {
if (node->if_comp.wanted_generator == "__C__") if (node->if_comp.wanted_generator == "__C__")
return generate(node->if_comp.statement) return generate(node->if_comp.statement, null<ast_node>())
return string("") return string("")
} }
fun generate_simple_passthrough(node: *ast_node): string { fun generate_simple_passthrough(node: *ast_node): string {
// deal with all the passthrough params // deal with all the passthrough params
return node->simple_passthrough.passthrough_str return node->simple_passthrough.passthrough_str
} }
fun generate_statement(node: *ast_node): string return generate(node->statement.child) + ";\n"; 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): string { fun generate_declaration_statement(node: *ast_node, enclosing_object: *ast_node): string {
var identifier = node->declaration_statement.identifier var identifier = node->declaration_statement.identifier
var to_ret = type_to_c(identifier->identifier.type) + " " + identifier->identifier.name 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) if (node->declaration_statement.expression) to_ret += string(" = ") + generate(node->declaration_statement.expression, enclosing_object)
return to_ret return to_ret
} }
fun generate_assignment_statement(node: *ast_node): string { fun generate_assignment_statement(node: *ast_node, enclosing_object: *ast_node): string {
return generate(node->assignment_statement.to) + " = " + generate(node->assignment_statement.from) return generate(node->assignment_statement.to, null<ast_node>()) + " = " + generate(node->assignment_statement.from, enclosing_object)
} }
fun generate_if_statement(node: *ast_node): string { fun generate_if_statement(node: *ast_node, enclosing_object: *ast_node): string {
var if_str = string("if (") + generate(node->if_statement.condition) + ") {\n" + generate(node->if_statement.then_part) + "}" var if_str = string("if (") + generate(node->if_statement.condition, enclosing_object) + ") {\n" + generate(node->if_statement.then_part, enclosing_object) + "}"
if (node->if_statement.else_part) if (node->if_statement.else_part)
if_str += string(" else {\n") + generate(node->if_statement.else_part) + "}" if_str += string(" else {\n") + generate(node->if_statement.else_part, enclosing_object) + "}"
return if_str + "\n" return if_str + "\n"
} }
fun generate_while_loop(node: *ast_node): string { fun generate_while_loop(node: *ast_node, enclosing_object: *ast_node): string {
return string("while (") + generate(node->while_loop.condition) + ") {\n" + generate(node->while_loop.statement) + "}\n" return string("while (") + generate(node->while_loop.condition, enclosing_object) + ") {\n" + generate(node->while_loop.statement, enclosing_object) + "}\n"
} }
fun generate_for_loop(node: *ast_node): string { fun generate_for_loop(node: *ast_node, enclosing_object: *ast_node): string {
// gotta take off last semicolon // gotta take off last semicolon
return string("for (") + generate(node->for_loop.init) + " " + generate(node->for_loop.condition) + "; " + return string("for (") + generate(node->for_loop.init, enclosing_object) + " " + generate(node->for_loop.condition, enclosing_object) + "; " +
generate(node->for_loop.update).slice(0,-3) + ") {\n" + generate(node->for_loop.body) + "}\n" generate(node->for_loop.update, enclosing_object).slice(0,-3) + ") {\n" + generate(node->for_loop.body, enclosing_object) + "}\n"
} }
fun generate_identifier(node: *ast_node): string { 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 return node->identifier.name
} }
fun generate_return_statement(node: *ast_node): string return string("return ") + generate(node->return_statement.return_value); 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_value(node: *ast_node): string return node->value.string_value; fun generate_value(node: *ast_node): string return node->value.string_value;
fun generate_code_block(node: *ast_node): string { fun generate_code_block(node: *ast_node, enclosing_object: *ast_node): string {
var to_ret = string("{\n") var to_ret = string("{\n")
node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child);) node->code_block.children.for_each(fun(child: *ast_node) to_ret += generate(child, enclosing_object);)
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
@@ -146,7 +148,7 @@ obj c_generator (Object) {
return str return str
} }
fun generate_function_call(node: *ast_node): string { fun generate_function_call(node: *ast_node, enclosing_object: *ast_node): string {
var func_name = string() var func_name = string()
var call_string = string() var call_string = string()
if (is_function_call(node->function_call.func) && if (is_function_call(node->function_call.func) &&
@@ -155,47 +157,50 @@ obj c_generator (Object) {
is_function(node->function_call.func->function_call.parameters[1]) && is_function(node->function_call.func->function_call.parameters[1]) &&
is_type_def(get_ast_scope(node->function_call.func->function_call.parameters[1])->get(string("~enclosing_scope"))[0]) is_type_def(get_ast_scope(node->function_call.func->function_call.parameters[1])->get(string("~enclosing_scope"))[0])
) { ) {
func_name = generate(node->function_call.func->function_call.parameters[1]) func_name = generate(node->function_call.func->function_call.parameters[1], enclosing_object)
call_string = string("&") + generate(node->function_call.func->function_call.parameters[0]) call_string = string("&") + generate(node->function_call.func->function_call.parameters[0], enclosing_object)
} else { } else {
func_name = generate(node->function_call.func) func_name = generate(node->function_call.func, enclosing_object)
} }
var parameters = node->function_call.parameters var parameters = node->function_call.parameters
if (func_name == "+" || func_name == "-" || func_name == "*" || func_name == "/" || func_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 == "=="
) )
return string("(") + generate(parameters[0]) + func_name + generate(parameters[1]) + string(")") return string("(") + generate(parameters[0], enclosing_object) + func_name + generate(parameters[1], enclosing_object) + 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<ast_node>()) + 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 string("(") + generate(parameters[0]) + ")" + func_name.slice(0,-2) return string("(") + generate(parameters[0], enclosing_object) + ")" + func_name.slice(0,-2)
parameters.for_each(fun(param: *ast_node) { parameters.for_each(fun(param: *ast_node) {
if (call_string != "") if (call_string != "")
call_string += ", " call_string += ", "
call_string += generate(param) call_string += generate(param, enclosing_object)
}) })
return func_name + "(" + call_string + ")" return func_name + "(" + call_string + ")"
} }
// for now, anyway // for now, anyway
fun generate(node: *ast_node): string { fun generate(node: *ast_node, enclosing_object: *ast_node): string {
if (!node) return string("/*NULL*/") if (!node) return string("/*NULL*/")
match (*node) { match (*node) {
ast_node::if_comp(backing) return generate_if_comp(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 generate_simple_passthrough(node)
ast_node::statement(backing) return generate_statement(node) ast_node::statement(backing) return generate_statement(node, enclosing_object)
ast_node::declaration_statement(backing) return generate_declaration_statement(node) ast_node::declaration_statement(backing) return generate_declaration_statement(node, enclosing_object)
ast_node::assignment_statement(backing) return generate_assignment_statement(node) ast_node::assignment_statement(backing) return generate_assignment_statement(node, enclosing_object)
ast_node::if_statement(backing) return generate_if_statement(node) ast_node::if_statement(backing) return generate_if_statement(node, enclosing_object)
ast_node::while_loop(backing) return generate_while_loop(node) ast_node::while_loop(backing) return generate_while_loop(node, enclosing_object)
ast_node::for_loop(backing) return generate_for_loop(node) ast_node::for_loop(backing) return generate_for_loop(node, enclosing_object)
ast_node::function(backing) return generate_function(node) ast_node::function(backing) return generate_function(node)
ast_node::function_call(backing) return generate_function_call(node) ast_node::function_call(backing) return generate_function_call(node, enclosing_object)
ast_node::code_block(backing) return generate_code_block(node) ast_node::code_block(backing) return generate_code_block(node, enclosing_object)
ast_node::return_statement(backing) return generate_return_statement(node) ast_node::return_statement(backing) return generate_return_statement(node, enclosing_object)
ast_node::value(backing) return generate_value(node) ast_node::value(backing) return generate_value(node)
ast_node::identifier(backing) return generate_identifier(node) ast_node::identifier(backing) return generate_identifier(node, enclosing_object)
} }
return string("/* COULD NOT GENERATE */") return string("/* COULD NOT GENERATE */")
} }

4
tests/to_parse.krak
View File

@@ -3,7 +3,7 @@ import to_import: simple_print, a, b
obj Something (ObjectTrait) { obj Something (ObjectTrait) {
var member: int var member: int
fun method(a: int):int { fun method(a: int):int {
return 5+a return 5+a+member
} }
} }
@@ -43,7 +43,9 @@ fun main(): int {
simple_print(an_obj.member) simple_print(an_obj.member)
simple_print("here is thing") simple_print("here is thing")
simple_print(123) simple_print(123)
simple_print("\n")
simple_print(an_obj.method(1)) simple_print(an_obj.method(1))
simple_print("\n")
return 0 return 0
} }