fix some memory leak

7 files changed, 65 insertions, 20 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 1fd6dd1..8325b7f 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -41,16 +41,19 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_FUNCTION",
 
     "AST_TREE_TOKEN_KEYWORD_PRINT_U64",
+    "AST_TREE_TOKEN_KEYWORD_RETURN",
 
     "AST_TREE_TOKEN_TYPE_TYPE",
     "AST_TREE_TOKEN_TYPE_FUNCTION",
     "AST_TREE_TOKEN_TYPE_VOID",
     "AST_TREE_TOKEN_TYPE_U64",
+    "AST_TREE_TOKEN_TYPE_BOOL",
 
     "AST_TREE_TOKEN_FUNCTION_CALL",
     "AST_TREE_TOKEN_VARIABLE",
     "AST_TREE_TOKEN_VARIABLE_DEFINE",
     "AST_TREE_TOKEN_VALUE_U64",
+    "AST_TREE_TOKEN_VALUE_BOOL",
 
     "AST_TREE_TOKEN_OPERATOR_ASSIGN",
     "AST_TREE_TOKEN_OPERATOR_SUM",
@@ -219,6 +222,7 @@ void astTreeRootPrint(const AstTreeRoot *root) {
 }
 
 void astTreeDestroy(AstTree tree) {
+  astTreeDelete(tree.type);
   switch (tree.token) {
   case AST_TREE_TOKEN_FUNCTION: {
     AstTreeFunction *metadata = tree.metadata;
@@ -232,8 +236,8 @@ void astTreeDestroy(AstTree tree) {
       astTreeVariableDelete(metadata->arguments.data[i]);
     }
     astTreeDelete(metadata->returnType);
-    free(metadata->scope.variables.data);
     free(metadata->scope.expressions);
+    free(metadata->scope.variables.data);
     free(metadata->arguments.data);
     free(metadata);
   }
@@ -313,17 +317,16 @@ void astTreeVariableDelete(AstTreeVariable *variable) {
 
 void astTreeDelete(AstTree *tree) {
   if (tree != &AST_TREE_TYPE_TYPE && tree != &AST_TREE_VOID_TYPE &&
-      tree != &AST_TREE_U64_TYPE) {
-    return;
+      tree != &AST_TREE_U64_TYPE && tree != &AST_TREE_BOOL_TYPE &&
+      tree != &AST_TREE_VOID_VALUE) {
+    astTreeDestroy(*tree);
+    free(tree);
   }
-  astTreeDestroy(*tree);
-  free(tree);
 }
 
 void astTreeRootDelete(AstTreeRoot *root) {
   for (size_t i = 0; i < root->variables.size; ++i) {
-    astTreeVariableDestroy(*root->variables.data[i]);
-    free(root->variables.data[i]);
+    astTreeVariableDelete(root->variables.data[i]);
   }
   free(root->variables.data);
   free(root);
@@ -1163,7 +1166,6 @@ bool setAllTypes(AstTree *tree, AstTreeFunction *function) {
   case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_U64:
   case AST_TREE_TOKEN_VALUE_BOOL:
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
     return true;
   case AST_TREE_TOKEN_FUNCTION:
     return setTypesFunction(tree);
@@ -1181,6 +1183,8 @@ bool setAllTypes(AstTree *tree, AstTreeFunction *function) {
     return setTypesOperatorAssign(tree);
   case AST_TREE_TOKEN_OPERATOR_SUM:
     return setTypesOperatorSum(tree);
+  case AST_TREE_TOKEN_VARIABLE_DEFINE:
+    return setTypesVariableDefine(tree);
   case AST_TREE_TOKEN_NONE:
   }
   printLog("Bad token '%d'", tree->token);
@@ -1332,6 +1336,12 @@ bool setTypesOperatorSum(AstTree *tree) {
   }
 }
 
+bool setTypesVariableDefine(AstTree *tree) {
+  AstTreeVariable *metadata = tree->metadata;
+  tree->type = &AST_TREE_VOID_TYPE;
+  return setTypesAstVariable(metadata);
+}
+
 bool setTypesAstVariable(AstTreeVariable *variable) {
   if (variable->value != NULL && !setAllTypes(variable->value, NULL)) {
     return false;
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 9dd2a6a..83b77ef 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -171,6 +171,7 @@ bool setTypesFunctionCall(AstTree *tree);
 bool setTypesVariable(AstTree *tree);
 bool setTypesOperatorAssign(AstTree *tree);
 bool setTypesOperatorSum(AstTree *tree);
+bool setTypesVariableDefine(AstTree *tree);
 
 bool setTypesAstVariable(AstTreeVariable *variable);
 bool setTypesAstInfix(AstTreeInfix *infix);
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index d8ace78..7085ccb 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -346,6 +346,7 @@ void parserNodeDelete(ParserNode *node) {
     ParserNodeInfixMetadata *metadata = node->metadata;
     parserNodeDelete(metadata->left);
     parserNodeDelete(metadata->right);
+    free(metadata);
   }
     goto RETURN_SUCCESS;
 
diff --git a/src/main.c b/src/main.c
index 899e9bc..b206235 100644
--- a/src/main.c
+++ b/src/main.c
@@ -94,13 +94,15 @@ static int run(const char *filePath, bool print) {
   if (print)
     astTreeRootPrint(astTree);
 
+  int ret;
   if (runAstTree(astTree)) {
-    astTreeRootDelete(astTree);
-    return 0;
+    ret = 0;
   } else {
-    astTreeRootDelete(astTree);
-    return 1;
+    ret = 1;
   }
+  astTreeRootDelete(astTree);
+
+  return ret;
 
 RETURN_ERROR:
   free(code);
@@ -108,12 +110,14 @@ RETURN_ERROR:
 }
 
 int main(int argc, char *argv[]) {
+  fileInit();
   if (argc < 2) {
     // compileRun("test/main.felan", "build/out", false);
-    run("test/main.felan", false);
+    // run("test/main.felan", false);
     printLog("Too few args");
     return 1;
   }
 
-  return run(argv[1], false);
+  const int ret = run(argv[1], false);
+  fileDelete();
 }
diff --git a/src/utils/file.c b/src/utils/file.c
index f2244bf..89ccfa8 100644
--- a/src/utils/file.c
+++ b/src/utils/file.c
@@ -4,12 +4,32 @@
 #include "utils/memory.h"
 #include <stddef.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 size_t fileCodes_capacity = 0;
 char **fileCodes = NULL;
-const char **fileCodes_names = 0;
+char **fileCodes_names = NULL;
 size_t fileCodes_length = 0;
 
+void fileInit() {
+  fileCodes_capacity = 0;
+  fileCodes = a404m_malloc(fileCodes_capacity * sizeof(*fileCodes));
+  fileCodes_names = a404m_malloc(fileCodes_capacity * sizeof(*fileCodes_names));
+  fileCodes_length = 0;
+}
+
+void fileDelete() {
+  fileCodes_capacity = 0;
+  for (size_t i = 0; i < fileCodes_length; ++i) {
+    free(fileCodes[i]);
+    free(fileCodes_names[i]);
+  }
+  free(fileCodes);
+  free(fileCodes_names);
+  fileCodes_length = 0;
+}
+
 char *readWholeFile(const char *filePath) {
   FILE *file = fopen(filePath, "r");
 
@@ -36,7 +56,9 @@ char *readWholeFile(const char *filePath) {
         fileCodes_names, fileCodes_capacity * sizeof(*fileCodes_names));
   }
   fileCodes[fileCodes_length] = str;
-  fileCodes_names[fileCodes_length] = filePath;
+  fileCodes_names[fileCodes_length] =
+      a404m_malloc((strlen(filePath) + 1) * sizeof(**fileCodes_names));
+  strcpy(fileCodes_names[fileCodes_length], filePath);
   fileCodes_length += 1;
 
   return str;
diff --git a/src/utils/file.h b/src/utils/file.h
index 6f9753f..4a904e4 100644
--- a/src/utils/file.h
+++ b/src/utils/file.h
@@ -1,3 +1,13 @@
 #pragma once
 
+#include <stddef.h>
+
+extern size_t fileCodes_capacity;
+extern char **fileCodes;
+extern char **fileCodes_names;
+extern size_t fileCodes_length;
+
+void fileInit();
+void fileDelete();
+
 char *readWholeFile(const char *filePath);
diff --git a/src/utils/log.c b/src/utils/log.c
index e84f3b4..e1822c0 100644
--- a/src/utils/log.c
+++ b/src/utils/log.c
@@ -1,5 +1,6 @@
 #include "log.h"
 
+#include "utils/file.h"
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -16,10 +17,6 @@ void _printLogBack(const char *format, const char *file, int line, ...) {
   free(errorStr);
 }
 
-extern char **fileCodes;
-extern const char **fileCodes_names;
-extern size_t fileCodes_length;
-
 void _printErrorBack(const char *format, const char *file, int line,
                      char *begin, char *end, ...) {
   va_list args;