Added in assignment and variable usage

stdlib/ast_nodes.krak

@@ -1,5 +1,6 @@
 import tree:*
 import vector:*
+import vector_literals:*
 import set:*
 import stack:*
 import map:*
@@ -653,8 +654,8 @@ obj defer_statement (Object) {
         return true
     }
 }
-fun ast_assignment_statement_ptr(): *ast_node {
+fun ast_assignment_statement_ptr(to: *ast_node, from: *ast_node): *ast_node {
-    var to_ret.construct(): assignment_statement
+    var to_ret.construct(to, from): assignment_statement
     var ptr = new<ast_node>()
     ptr->copy_construct(&ast_node::assignment_statement(to_ret))
     return ptr
@@ -666,23 +667,25 @@ fun is_assignment_statement(node: *ast_node): bool {
     return false
 }
 obj assignment_statement (Object) {
-    var scope: map<string, vector<*ast_node>>
+    var to: *ast_node
-    fun construct(): *assignment_statement  {
+    var from: *ast_node
-        scope.construct()
+    fun construct(to_in: *ast_node, from_in: *ast_node): *assignment_statement  {
+        to = to_in
+        from = from_in
         return this
     }
     fun copy_construct(old: *assignment_statement) {
-        scope.copy_construct(&old->scope)
+        to = old->to
+        from = old->from
     }
     fun destruct() {
-        scope.destruct()
     }
     fun operator=(other: ref assignment_statement) {
         destruct()
         copy_construct(&other)
     }
     fun operator==(other: ref assignment_statement): bool {
-        return true
+        return to == other.to && from == other.from
     }
 }
 fun ast_declaration_statement_ptr(ident: *ast_node): *ast_node {
@@ -880,7 +883,7 @@ fun get_ast_children(node: *ast_node): vector<*ast_node> {
         ast_node::break_statement(backing) return vector<*ast_node>()
         ast_node::continue_statement(backing) return vector<*ast_node>()
         ast_node::defer_statement(backing) return vector<*ast_node>()
-        ast_node::assignment_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)
         ast_node::if_comp(backing) return vector<*ast_node>(backing.statement)
         ast_node::simple_passthrough(backing) return vector<*ast_node>()
@@ -934,7 +937,7 @@ fun get_ast_scope(node: *ast_node): *map<string,vector<*ast_node>> {
         ast_node::break_statement() return &node->break_statement.scope
         ast_node::continue_statement() return &node->continue_statement.scope
         ast_node::defer_statement() return &node->defer_statement.scope
-        ast_node::assignment_statement() return &node->assignment_statement.scope
+        ast_node::assignment_statement() return null<map<string,vector<*ast_node>>>()
         ast_node::declaration_statement() return null<map<string,vector<*ast_node>>>()
         ast_node::if_comp() return null<map<string,vector<*ast_node>>>()
         ast_node::simple_passthrough() return &node->simple_passthrough.scope

stdlib/ast_transformation.krak

@@ -186,6 +186,8 @@ obj ast_transformation (Object) {
             return transform_statement(node, scope)
         } else if (name == "declaration_statement") {
             return transform_declaration_statement(node, scope)
+        } else if (name == "assignment_statement") {
+            return transform_assignment_statement(node, scope)
         } else if (name == "return_statement") {
             return transform_return_statement(node, scope)
         } else if (name == "function_call") {
@@ -269,9 +271,16 @@ obj ast_transformation (Object) {
         return new_statement
     }
     fun transform_declaration_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
-        var declaration = ast_declaration_statement_ptr(ast_identifier_ptr(concat_symbol_tree(get_node("identifier", node)), transform_type(get_node("type", node), scope, map<string, *type>())))
+        var name = concat_symbol_tree(get_node("identifier", node))
+        var identifier = ast_identifier_ptr(name, transform_type(get_node("type", node), scope, map<string, *type>()))
+        var declaration = ast_declaration_statement_ptr(identifier)
+        add_to_scope(name, identifier, scope)
         return declaration
     }
+    fun transform_assignment_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
+        var assignment = ast_assignment_statement_ptr(transform(get_node("factor", node), scope), transform(get_node("boolean_expression", node), scope))
+        return assignment
+    }
     fun transform_return_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
         return ast_return_statement_ptr(transform(node->children[0], scope))
     }

stdlib/c_generator.krak

@@ -88,6 +88,12 @@ obj c_generator (Object) {
         var identifier = node->declaration_statement.identifier
         return type_to_c(identifier->identifier.type) + " " + identifier->identifier.name
     }
+    fun generate_assignment_statement(node: *ast_node): string {
+        return generate(node->assignment_statement.to) + " = " + generate(node->assignment_statement.from)
+    }
+    fun generate_identifier(node: *ast_node): string {
+        return node->identifier.name
+    }
     fun generate_return_statement(node: *ast_node): string return string("return ") + generate(node->return_statement.return_value);
     fun generate_value(node: *ast_node): string return node->value.string_value;
     fun generate_code_block(node: *ast_node): string {
@@ -120,11 +126,13 @@ obj c_generator (Object) {
             ast_node::simple_passthrough(backing) return generate_simple_passthrough(node)
             ast_node::statement(backing) return generate_statement(node)
             ast_node::declaration_statement(backing) return generate_declaration_statement(node)
+            ast_node::assignment_statement(backing) return generate_assignment_statement(node)
             ast_node::function(backing) return generate_function(node)
             ast_node::function_call(backing) return generate_function_call(node)
             ast_node::code_block(backing) return generate_code_block(node)
             ast_node::return_statement(backing) return generate_return_statement(node)
             ast_node::value(backing) return generate_value(node)
+            ast_node::identifier(backing) return generate_identifier(node)
         }
         return string("/* COULD NOT GENERATE */")
     }

tests/to_parse.krak

@@ -13,6 +13,8 @@ fun some_other_function(in: bool): float {
 }
 fun main(): int {
     var a_declaration:int
+    a_declaration = 78
+    simple_print(a_declaration)
     /*var another_declaration = 9*/
     simple_print("Hello World!\n")
     simple_print(1337)