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

continue and break statements

Browse Source
This commit is contained in:
Nathan Braswell
2016-01-24 17:31:41 -05:00
parent 9f714dc9ec
commit 83a76c36de
5 changed files with 53 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
stdlib/ast_nodes.krak
View File

@@ -26,8 +26,7 @@ adt ast_node {
while_loop: while_loop,
for_loop: for_loop,
return_statement: return_statement,
break_statement: break_statement,
continue_statement: continue_statement,
branching_statement: branching_statement,
defer_statement: defer_statement,
assignment_statement: assignment_statement,
declaration_statement: declaration_statement,
@@ -597,67 +596,39 @@ obj return_statement (Object) {
return return_value == other.return_value
}
}
fun ast_break_statement_ptr(): *ast_node {
var to_ret.construct(): break_statement
adt branching_type {
break_stmt,
continue_stmt
}
fun ast_branching_statement_ptr(b_type: branching_type): *ast_node {
var to_ret.construct(b_type): branching_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::break_statement(to_ret))
ptr->copy_construct(&ast_node::branching_statement(to_ret))
return ptr
}
fun is_break_statement(node: *ast_node): bool {
fun is_branching_statement(node: *ast_node): bool {
match(*node) {
ast_node::break_statement(backing) return true
ast_node::branching_statement(backing) return true
}
return false
}
obj break_statement (Object) {
var scope: map<string, vector<*ast_node>>
fun construct(): *break_statement {
scope.construct()
obj branching_statement (Object) {
var b_type: branching_type
fun construct(b_type_in: branching_type): *branching_statement {
b_type.copy_construct(&b_type_in)
return this
}
fun copy_construct(old: *break_statement) {
scope.copy_construct(&old->scope)
fun copy_construct(old: *branching_statement) {
b_type.copy_construct(&old->b_type)
}
fun destruct() {
scope.destruct()
b_type.destruct()
}
fun operator=(other: ref break_statement) {
fun operator=(other: ref branching_statement) {
destruct()
copy_construct(&other)
}
fun operator==(other: ref break_statement): bool {
return true
}
}
fun ast_continue_statement_ptr(): *ast_node {
var to_ret.construct(): continue_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::continue_statement(to_ret))
return ptr
}
fun is_continue_statement(node: *ast_node): bool {
match(*node) {
ast_node::continue_statement(backing) return true
}
return false
}
obj continue_statement (Object) {
var scope: map<string, vector<*ast_node>>
fun construct(): *continue_statement {
scope.construct()
return this
}
fun copy_construct(old: *continue_statement) {
scope.copy_construct(&old->scope)
}
fun destruct() {
scope.destruct()
}
fun operator=(other: ref continue_statement) {
destruct()
copy_construct(&other)
}
fun operator==(other: ref continue_statement): bool {
fun operator==(other: ref branching_statement): bool {
return true
}
}
@@ -922,8 +893,7 @@ fun get_ast_children(node: *ast_node): vector<*ast_node> {
ast_node::while_loop(backing) return vector(backing.condition, backing.statement)
ast_node::for_loop(backing) return vector(backing.init, backing.condition, backing.update, backing.body)
ast_node::return_statement(backing) return vector(backing.return_value)
ast_node::break_statement(backing) return vector<*ast_node>()
ast_node::continue_statement(backing) return vector<*ast_node>()
ast_node::branching_statement(backing) return vector<*ast_node>()
ast_node::defer_statement(backing) return vector<*ast_node>()
ast_node::assignment_statement(backing) return vector(backing.to, backing.from)
ast_node::declaration_statement(backing) return vector(backing.identifier, backing.expression)
@@ -949,8 +919,7 @@ fun get_ast_name(node: *ast_node): string {
ast_node::while_loop(backing) return string("while_loop")
ast_node::for_loop(backing) return string("for_loop")
ast_node::return_statement(backing) return string("return_statement")
ast_node::break_statement(backing) return string("break_statement")
ast_node::continue_statement(backing) return string("continue_statement")
ast_node::branching_statement(backing) return string("branching_statement")
ast_node::defer_statement(backing) return string("defer_statement")
ast_node::assignment_statement(backing) return string("assignment_statement")
ast_node::declaration_statement(backing) return string("declaration_statement")
@@ -976,8 +945,7 @@ fun get_ast_scope(node: *ast_node): *map<string,vector<*ast_node>> {
ast_node::while_loop() return &node->while_loop.scope
ast_node::for_loop() return &node->for_loop.scope
ast_node::return_statement() return &node->return_statement.scope
ast_node::break_statement() return &node->break_statement.scope
ast_node::continue_statement() return &node->continue_statement.scope
ast_node::branching_statement() return null<map<string,vector<*ast_node>>>()
ast_node::defer_statement() return &node->defer_statement.scope
ast_node::assignment_statement() return null<map<string,vector<*ast_node>>>()
ast_node::declaration_statement() return null<map<string,vector<*ast_node>>>()

7
stdlib/ast_transformation.krak
View File

@@ -227,6 +227,8 @@ obj ast_transformation (Object) {
return transform_for_loop(node, scope)
} else if (name == "return_statement") {
return transform_return_statement(node, scope)
} else if (name == "continue_statement" || name == "break_statement") {
return transform_branching_statement(node, scope)
} else if (name == "function_call") {
return transform_function_call(node, scope)
} else if (name == "boolean_expression" || name == "and_boolean_expression"
@@ -363,6 +365,11 @@ obj ast_transformation (Object) {
fun transform_return_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
return ast_return_statement_ptr(transform(node->children[0], scope))
}
fun transform_branching_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
if (node->data.name == "break_statement")
return ast_branching_statement_ptr(branching_type::break_stmt())
return ast_branching_statement_ptr(branching_type::continue_stmt())
}
fun transform_function_call(node: *tree<symbol>, scope: *ast_node): *ast_node {
// don't bother with a full transform for parameters with their own function, just get the boolean expression and transform it
var parameters = get_nodes("parameter", node).map(fun(child: *tree<symbol>): *ast_node return transform(get_node("boolean_expression", child), scope);)

9
stdlib/c_generator.krak
View File

@@ -135,6 +135,12 @@ obj c_generator (Object) {
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 {
match(node->branching_statement.b_type) {
branching_type::break_stmt() return string("break")
branching_type::continue_stmt() return string("continue")
}
}
fun generate_value(node: *ast_node): string return node->value.string_value;
fun generate_code_block(node: *ast_node, enclosing_object: *ast_node): string {
var to_ret = string("{\n")
@@ -176,7 +182,7 @@ obj c_generator (Object) {
var parameters = node->function_call.parameters
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 == "%"
)
return string("(") + generate(parameters[0], enclosing_object) + func_name + generate(parameters[1], enclosing_object) + string(")")
// don't propegate enclosing function down right of access
@@ -211,6 +217,7 @@ obj c_generator (Object) {
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::value(backing) return generate_value(node)
ast_node::identifier(backing) return generate_identifier(node, enclosing_object)
}