add functions to bytecode and continuing working on runtime objects

src/parser/declaration/declaration.c

@@ -3,6 +3,7 @@
 #include "../../memory.h"
 #include "../literals/literals.h"
 #include "../parser.h"
+#include "../function/function.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,7 +23,8 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
     darray_push(declarations, &_declaration);
     ParsedSingleDeclaration *declaration =
         darray_get(declarations, declarations->size - 1);
-    declaration->is_function = false;
+    bool isFunction = false;
+    DArray parameters;
     declaration->from = parse_null();
 
     if (token->type != TOKEN_IDENTIFIER) {
@@ -38,8 +40,8 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
       return parsedValue;
     token = darray_get(tokens, *index);
     if (token->type == TOKEN_LPAREN) {
-      declaration->is_function = true;
-      darray_init(&declaration->parameters, sizeof(char *));
+      isFunction = true;
+      darray_init(&parameters, sizeof(char *));
       (*index)++;
       error_if_finished(file, tokens, index);
       token = darray_get(tokens, *index);
@@ -63,7 +65,7 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
           }
           char *parameter_name =
               strcpy(checked_malloc(strlen(token->value) + 1), token->value);
-          darray_push(&declaration->parameters, &parameter_name);
+          darray_push(&parameters, &parameter_name);
           (*index)++;
           error_if_finished(file, tokens, index);
           skip_newlines_and_indents(tokens, index);
@@ -97,6 +99,9 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
                 token->column);
         exit(EXIT_FAILURE);
       }
+      if (isFunction) {
+        declaration->from = create_parsed_function(declaration->name, parameters, declaration->from);
+      }
       if ((*index) >= tokens->size)
         break;
       token = darray_get(tokens, *index);
@@ -127,8 +132,6 @@ void free_string(void *ptr) {
 void free_single_declaration(void *ptr) {
   ParsedSingleDeclaration *declaration = ptr;
   free(declaration->name);
-  if (declaration->is_function)
-    darray_free(&declaration->parameters, free_string);
   free_parsed(declaration->from);
   free(declaration->from);
 }

src/parser/declaration/declaration.h

@@ -5,8 +5,6 @@
 
 typedef struct {
   char * name;
-  bool is_function;
-  DArray parameters; // string[]
   ParsedValue * from;
 } ParsedSingleDeclaration;
 

src/parser/dictionary/dictionary.c

@@ -88,5 +88,5 @@ void free_parsed_dictionary(void *ptr) {
   ParsedValue *parsedValue = ptr;
   DArray *parsed_dictionary = parsedValue->data;
   darray_free(parsed_dictionary, free_dictionary_entry);
-  free(parsedValue->data);
+  free(parsed_dictionary);
 }

src/parser/function/function.c

@@ -0,0 +1,25 @@
+#include "function.h"
+#include "../../memory.h"
+#include <stdlib.h>
+#include <string.h>
+
+ParsedValue *create_parsed_function(char *name, DArray parameters,
+                                  ParsedValue *body) {
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  parsedValue->type=AST_FUNCTION;
+  ParsedFunction *parsedFunction = checked_malloc(sizeof(ParsedFunction));
+  parsedValue->data=parsedFunction;
+  parsedFunction->name=strcpy(checked_malloc(strlen(name) + 1), name);
+  parsedFunction->body = body;
+  parsedFunction->parameters=parameters;
+  return parsedValue;
+}
+
+void free_function(void *ptr) {
+  ParsedValue *parsedValue = ptr;
+  ParsedFunction *parsed = parsedValue->data;
+  free_parsed(parsed->body);
+  free(parsed->name);
+  darray_free(&parsed->parameters, NULL);
+  free(parsed);
+}

src/parser/function/function.h

@@ -0,0 +1,17 @@
+#ifndef FUNCTION_H
+#define FUNCTION_H
+#include "../../lexer/token.h" // for Token
+#include "../parser.h"
+
+typedef struct {
+  char * name;
+  DArray parameters;
+  ParsedValue *body;
+} ParsedFunction;
+
+ParsedValue *create_parsed_function(char *name, DArray parameters,
+                                  ParsedValue *body);
+
+void free_function(void *ptr);
+
+#endif // FUNCTION_H

src/parser/if/if.c

@@ -115,5 +115,5 @@ void free_parsed_if(void *ptr) {
   ParsedValue *parsedValue = ptr;
   DArray *parsed_if = parsedValue->data;
   darray_free(parsed_if, free_conditional);
-  free(parsedValue->data);
+  free(parsed_if);
 }

src/parser/list/list.c

@@ -45,5 +45,5 @@ void free_parsed_list(void *ptr) {
   ParsedValue *parsedValue = ptr;
   DArray *parsed_list = parsedValue->data;
   darray_free(parsed_list, free_parsed);
-  free(parsedValue->data);
+  free(parsed_list);
 }

src/parser/parser.c

@@ -8,6 +8,7 @@
 #include "declaration/declaration.h"
 #include "dictionary/dictionary.h"
 #include "dowrap/dowrap.h"
+#include "function/function.h"
 #include "if/if.h"
 #include "list/list.h"
 #include "literals/literals.h"
@@ -24,7 +25,7 @@
 const char *ValueTypeNames[] = {
     "string",  "assign",     "identifier",  "number",    "if statement",
     "access",  "call",       "declaration", "null",      "boolean",
-    "do wrap", "operations", "list",        "dictionary"};
+    "do wrap", "operations", "list",        "dictionary", "function"};
 
 void error_if_finished(char *file, DArray *tokens, size_t *index) {
   if ((*index) >= tokens->size) {
@@ -232,5 +233,7 @@ void free_parsed(void *ptr) {
   case AST_DICTIONARY:
     free_parsed_dictionary(parsed);
     break;
+  case AST_FUNCTION:
+    free_function(parsed);
   }
 }

src/parser/parser.h

@@ -39,7 +39,8 @@ typedef enum {
   AST_DOWRAP,
   AST_OPERATION,
   AST_LIST,
-  AST_DICTIONARY
+  AST_DICTIONARY,
+  AST_FUNCTION
 } ValueType;
 
 extern const char* ValueTypeNames[];