added fasm support

added compiler options
tried to compile to fasm first

2 files changed, 195 insertions, 69 deletions

diff --git a/src/compiler/tree_parser/tree_parser.c b/src/compiler/tree_parser/tree_parser.c
index f657f97..07bad0a 100644
--- a/src/compiler/tree_parser/tree_parser.c
+++ b/src/compiler/tree_parser/tree_parser.c
@@ -1,15 +1,9 @@
 #include "tree_parser.h"
 
-#include <compiler/error_helper/error_helper.h>
-#include <compiler/lexer/lexer.h>
-#include <compiler/parser/parser.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <utils/file.h>
-#include <utils/memory/memory.h>
-#include <utils/types.h>
 
 const char *TREE_TOKEN_STRINGS[] = {
     "TREE_TOKEN_NONE",
@@ -25,10 +19,27 @@ const char *TREE_TOKEN_STRINGS[] = {
     "TREE_TOKEN_FUNCTION",
 };
 
+static void _printParsedTreeVariable(const TreeDefineVariableMetadata *variable,
+                                     int indent) {
+  if (variable == NULL) {
+    for (int i = 0; i < indent; ++i) printf(" ");
+    printf("null\n");
+    return;
+  }
+  for (int i = 0; i < indent; ++i) printf(" ");
+  printf("{name='%.*s',type=%p,value=\n",
+         (int)(variable->nameEnd - variable->nameBegin), variable->nameBegin,
+         variable->type);
+  _printParsedTreeNode(variable->value, indent + 1);
+  for (int i = 0; i < indent; ++i) printf(" ");
+  printf("}\n");
+}
+
 void _printParsedTreeNode(const ParsedTree *parsedTree, int indent) {
+  for (int i = 0; i < indent; ++i) printf(" ");
   if (parsedTree == NULL) {
-    for (int i = 0; i < indent; ++i) printf(" ");
     printf("null\n");
+    return;
   }
   printf("{token=%s", TREE_TOKEN_STRINGS[parsedTree->token]);
   switch (parsedTree->token) {
@@ -36,19 +47,83 @@ void _printParsedTreeNode(const ParsedTree *parsedTree, int indent) {
       goto RETURN_SUCCESS;
     case TREE_TOKEN_ROOT:
     case TREE_TOKEN_GLOBAL_SCOPE:
-    case TREE_TOKEN_LOCAL_SCOPE:
-    case TREE_TOKEN_FUNCTION_CALL:
+    case TREE_TOKEN_LOCAL_SCOPE: {
+      const TreeScopeMetadata *metadata = parsedTree->metadata;
+      for (int i = 0; i < indent; ++i) printf(" ");
+      printf(",lines=\n");
+      for (size_t i = 0; i < metadata->lines_size; ++i) {
+        _printParsedTreeNode(metadata->lines[i], indent + 1);
+      }
+      for (int i = 0; i < indent; ++i) printf(" ");
+      printf(",variables=\n");
+      for (size_t i = 0; i < metadata->variables_size; ++i) {
+        _printParsedTreeVariable(metadata->variables[i], indent + 1);
+      }
+      goto RETURN_SUCCESS;
+    }
+    case TREE_TOKEN_FUNCTION_CALL: {
+      const TreeFunctionCallMetadata *metadata = parsedTree->metadata;
+      printf(",lines=\n");
+      for (size_t i = 0; i < metadata->values_size; ++i) {
+        _printParsedTreeNode(metadata->values[i], indent + 1);
+      }
+      goto RETURN_SUCCESS;
+    }
     case TREE_TOKEN_DEFINE_VARIABLE:
-    case TREE_TOKEN_IDENTIFIER:
-    case TREE_TOKEN_VALUE_STRING:
-    case TREE_TOKEN_STRUCT:
-    case TREE_TOKEN_DEFINE_CONSTANT:
-    case TREE_TOKEN_FUNCTION:
+    case TREE_TOKEN_DEFINE_CONSTANT: {
+      const TreeDefineVariableMetadata *metadata = parsedTree->metadata;
+      printf(",define=\n");
+      _printParsedTreeVariable(metadata, indent + 1);
+      goto RETURN_SUCCESS;
+    }
+    case TREE_TOKEN_IDENTIFIER: {
+      const TreeIdentifierMetadata *metadata = parsedTree->metadata;
+      printf(",variable=\n");
+      _printParsedTreeVariable(metadata->variable, indent + 1);
+      goto RETURN_SUCCESS;
+    }
+    case TREE_TOKEN_VALUE_STRING: {
+      const TreeStringValueMetadata *metadata = parsedTree->metadata;
+      printf(",str='%.*s'\n", (int)metadata->size, metadata->str);
+      goto RETURN_SUCCESS;
+    }
+    case TREE_TOKEN_STRUCT: {
+      const TreeStructMetadata *metadata = parsedTree->metadata;
+      printf(",metadata=%p\n", metadata);
+      goto RETURN_SUCCESS;
+    }
+    case TREE_TOKEN_FUNCTION: {
+      const TreeFunctionMetadata *metadata = parsedTree->metadata;
+      const TreeScopeMetadata *scope = metadata->scope;
+      printf(",scope=\n");
+      if (scope != NULL) {
+        for (int i = 0; i < indent; ++i) printf(" ");
+        printf(",lines=\n");
+        for (size_t i = 0; i < scope->lines_size; ++i) {
+          _printParsedTreeNode(scope->lines[i], indent + 1);
+        }
+        for (int i = 0; i < indent; ++i) printf(" ");
+        printf(",variables=\n");
+        for (size_t i = 0; i < scope->variables_size; ++i) {
+          _printParsedTreeVariable(scope->variables[i], indent + 1);
+        }
+      } else {
+        for (int i = 0; i < indent; ++i) printf(" ");
+        printf("null\n");
+      }
+      for (int i = 0; i < indent; ++i) printf(" ");
+      printf(",params=\n");
+      for (size_t i = 0; i < metadata->params_size; ++i) {
+        _printParsedTreeVariable(metadata->params[i], indent + 1);
+      }
+      goto RETURN_SUCCESS;
+    }
   }
   fprintf(stderr, "bad parsed tree token %d at %s:%d", parsedTree->token,
           __FILE_NAME__, __LINE__);
   exit(1);
 RETURN_SUCCESS:
+  for (int i = 0; i < indent; ++i) printf(" ");
   printf("}\n");
 };
 
@@ -143,6 +218,9 @@ ParsedTree *treeParser(SourceCode *code) {
 
   for (size_t i = 0; i < code->size; ++i) {
     ParsedNode *const nParsedNode = parser(code, i);
+    if (nParsedNode == NULL) {
+      goto RETURN_ERROR;
+    }
     ParserScopeMetadata *const nscope = nParsedNode->metadata;
     for (size_t j = 0; j < nscope->operands_size; ++j) {
       size_t scopeSize =
@@ -160,12 +238,52 @@ ParsedTree *treeParser(SourceCode *code) {
     nscope->operands_size = 0;
     deleteParsedNode(nParsedNode);
   }
-  if (parsedNode == NULL) {
-    return NULL;
+  ParsedTree *tree = _treeParser(parsedNode, code);
+  deleteParsedNode(parsedNode);
+  return tree;
+RETURN_ERROR:
+  deleteParsedNode(parsedNode);
+  return NULL;
+}
+
+ParsedTree *treeParserWithPrint(SourceCode *code) {
+  ParserScopeMetadata *scope = a404m_malloc(sizeof(*scope));
+  scope->operands_size = 0;
+  scope->operands = a404m_malloc(scope->operands_size * sizeof(ParsedNode *));
+  ParsedNode *const parsedNode =
+      newParsedNode(NULL, NULL, PARSED_TOKEN_ROOT, scope, NULL);
+
+  for (size_t i = 0; i < code->size; ++i) {
+    ParsedNode *const nParsedNode = parserWithPrint(code, i);
+    if (nParsedNode == NULL) {
+      fprintf(stderr, "Error in parser");
+      goto RETURN_ERROR;
+    }
+    printf("----parsed '%s'\n", code->codes[i]->filePath);
+    printParsedNode(parsedNode);
+    ParserScopeMetadata *const nscope = nParsedNode->metadata;
+    for (size_t j = 0; j < nscope->operands_size; ++j) {
+      size_t scopeSize =
+          a404m_malloc_usable_size(scope->operands) / sizeof(ParsedNode *);
+      if (scopeSize == scope->operands_size) {
+        scopeSize += scopeSize / 2 + 1;
+        scope->operands =
+            a404m_realloc(scope->operands, scopeSize * sizeof(ParsedNode *));
+      }
+      scope->operands[scope->operands_size] = nscope->operands[j];
+      scope->operands_size += 1;
+    }
+    free(nscope->operands);
+    nscope->operands = NULL;
+    nscope->operands_size = 0;
+    deleteParsedNode(nParsedNode);
   }
   ParsedTree *tree = _treeParser(parsedNode, code);
   deleteParsedNode(parsedNode);
   return tree;
+RETURN_ERROR:
+  deleteParsedNode(parsedNode);
+  return NULL;
 }
 
 ParsedTree *_treeParser(const ParsedNode *node, SourceCode *code) {
@@ -275,7 +393,7 @@ ParsedTree *treeParseLocalScope(const ParsedNode *node, SourceCode *code,
   const size_t newScopes_size = scopes_size + 1;
   TreeScopeMetadata *newScopes[newScopes_size];
 
-  memcpy(newScopes, scopes, scopes_size);
+  memcpy(newScopes, scopes, scopes_size * sizeof(TreeScopeMetadata *));
   newScopes[newScopes_size - 1] = metadata;
 
   for (size_t i = 0; i < operands_size; ++i) {
@@ -285,31 +403,18 @@ ParsedTree *treeParseLocalScope(const ParsedNode *node, SourceCode *code,
     if (parsedTree == NULL) {
       goto RETURN_ERROR;
     }
-    switch (parsedTree->token) {
-      case TREE_TOKEN_ROOT:
-        printError("It is not allowed here", code, operand->strBegin,
-                   operand->strEnd);
-        goto RETURN_ERROR;
-      case TREE_TOKEN_DEFINE_CONSTANT:
-      case TREE_TOKEN_DEFINE_VARIABLE: {
-        TreeDefineVariableMetadata *const variableDefine = parsedTree->metadata;
-        if (variableDefine == NULL) {
-          goto RETURN_ERROR;
-        }
-        pushVariableToScope(metadata, variableDefine);
-      }
-      /* fall through */
-      default:
-        pushLineToScope(metadata, parsedTree);
-        continue;
+    if (parsedTree->token != TREE_TOKEN_ROOT) {
+      pushLineToScope(metadata, parsedTree);
+    } else {
+      printError("'%s' Is not allowed here", code, operand->strBegin,
+                 operand->strEnd, PARSED_TOKEN_STRINGS[operand->token]);
+      goto RETURN_ERROR;
     }
-    printError("'%s' Is not allowed here", code, operand->strBegin,
-               operand->strEnd, PARSED_TOKEN_STRINGS[operand->token]);
-    goto RETURN_ERROR;
   }
 
-  metadata->variables =
-      a404m_realloc(metadata->variables, metadata->variables_size);
+  metadata->variables = a404m_realloc(
+      metadata->variables,
+      metadata->variables_size * sizeof(TreeDefineVariableMetadata *));
 
   return tree;
 
@@ -327,37 +432,37 @@ TreeDefineVariableMetadata *treeParseDefineVariable(ParsedTree *tree,
   TreeDefineVariableMetadata *define = a404m_malloc(sizeof(*define));
   define->tree = tree;
 
-  ParserVariableDefineMetadata *metadata = node->metadata;
+  const ParserVariableDefineMetadata *node_metadata = node->metadata;
 
-  if (metadata->value == NULL) {
+  if (node_metadata->value == NULL) {
     define->value = NULL;
-  } else if ((define->value = treeParseExpr(metadata->value, code, scopes,
+  } else if ((define->value = treeParseExpr(node_metadata->value, code, scopes,
                                             scopes_size)) == NULL) {
     goto RETURN_ERROR;
   }
 
-  if (metadata->name->token == PARSED_TOKEN_IDENTIFIER) {
-    define->nameBegin = metadata->name->strBegin;
-    define->nameEnd = metadata->name->strEnd;
+  if (node_metadata->name->token == PARSED_TOKEN_IDENTIFIER) {
+    define->nameBegin = node_metadata->name->strBegin;
+    define->nameEnd = node_metadata->name->strEnd;
   } else {
-    printError("Names should be an identifier", code, metadata->name->strBegin,
-               metadata->name->strEnd);
+    printError("Names should be an identifier", code,
+               node_metadata->name->strBegin, node_metadata->name->strEnd);
     goto RETURN_ERROR;
   }
 
-  if (metadata->type == NULL) {
+  if (node_metadata->type == NULL) {
     define->type = getTreeExpressionType(define->value);
-  } else if (metadata->type->token == PARSED_TOKEN_IDENTIFIER) {
+  } else if (node_metadata->type->token == PARSED_TOKEN_IDENTIFIER) {
     const TreeDefineVariableMetadata *variable =
-        getVariable(metadata->type->strBegin, metadata->type->strEnd, code,
-                    scopes, scopes_size);
+        getVariable(node_metadata->type->strBegin, node_metadata->type->strEnd,
+                    code, scopes, scopes_size);
     if (variable == NULL) {
       goto RETURN_ERROR;
     }
     define->type = getType(variable);
   } else {
     printError("Types should be an identifier (for now)", code,
-               metadata->type->strBegin, metadata->type->strEnd);
+               node_metadata->type->strBegin, node_metadata->type->strEnd);
     goto RETURN_ERROR;
   }
 
@@ -366,6 +471,8 @@ TreeDefineVariableMetadata *treeParseDefineVariable(ParsedTree *tree,
     goto RETURN_ERROR;
   }
 
+  pushVariableToScope(scopes[scopes_size - 1], define);
+
   return define;
 
 RETURN_ERROR:
@@ -536,14 +643,8 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code,
   ParsedTree *parsedTree =
       treeParseNode(node_metadata->type, code, scopes, scopes_size);
 
-  if (parsedTree == NULL) {
-    goto RETURN_ERROR;
-  }
-  metadata->returnType = getTreeExpressionType(parsedTree);
-  // TODO: this is not right
-  deleteParsedTree(parsedTree);
-
-  const ParserScopeMetadata *params = node_metadata->params->metadata;
+  const size_t newScopes_size = scopes_size + 1;
+  TreeScopeMetadata *newScopes[newScopes_size];
 
   metadata->params = a404m_malloc(0);
   metadata->params_size = 0;
@@ -555,10 +656,30 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code,
   metadata->scope->lines = a404m_malloc(0);
   metadata->scope->lines_size = 0;
 
+  memcpy(newScopes, scopes, scopes_size * sizeof(TreeScopeMetadata *));
+  newScopes[newScopes_size - 1] = metadata->scope;
+
+  if (parsedTree == NULL) {
+    goto RETURN_ERROR;
+  }
+  metadata->returnType = getTreeExpressionType(parsedTree);
+  // TODO: this is not right
+  deleteParsedTree(parsedTree);
+
+  const ParserScopeMetadata *params = node_metadata->params->metadata;
+
   for (size_t i = 0; i < params->operands_size; ++i) {
     const ParsedNode *operand = params->operands[i];
+    if (operand->token == PARSED_TOKEN_COMMA) {
+      operand = (ParserCommaMetadata *)operand->metadata;
+    }
+    if (operand->token != PARSED_TOKEN_DEFINE_VARIABLE) {
+      printError(
+          "Only variable definition is allowed in function parameter list",
+          code, operand->strBegin, operand->strEnd);
+    }
     TreeDefineVariableMetadata *define =
-        treeParseDefineVariable(tree, operand, code, scopes, scopes_size);
+        treeParseDefineVariable(tree, operand, code, newScopes, newScopes_size);
     if (define == NULL) {
       goto RETURN_ERROR;
     }
@@ -578,10 +699,15 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code,
                                           sizeof(TreeDefineVariableMetadata *));
 
   if (node_metadata->body != NULL) {
-    printError("Not implemented", code, node->strBegin, node->strEnd);
-
-    goto RETURN_ERROR;
-    return NULL;
+    const ParserScopeMetadata *body = node_metadata->body->metadata;
+    for (size_t i = 0; i < body->operands_size; ++i) {
+      ParsedTree *parsedTree =
+          treeParseNode(body->operands[i], code, newScopes, newScopes_size);
+      if (parsedTree == NULL) {
+        goto RETURN_ERROR;
+      }
+      pushLineToScope(metadata->scope, parsedTree);
+    }
   } else {
     free(metadata->scope->lines);
     metadata->scope->lines_size = 0;
@@ -589,7 +715,7 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code,
 
   return tree;
 RETURN_ERROR:
-
+  // TODO: doesn't delete all of them
   free(metadata);
   free(tree);
   return NULL;
@@ -598,12 +724,12 @@ RETURN_ERROR:
 ParsedTree *treeParseImport(const ParsedNode *node, SourceCode *code,
                             TreeScopeMetadata *[], size_t) {
   const ParserImportMetadata *node_metadata = node->metadata;
-  SizedString *path = nodeToString(node_metadata, code);
+  SizedString *const path = nodeToString(node_metadata, code);
   if (path == NULL) {
     return NULL;
   }
 
-  Code *fileCode = read_whole_file(path->str);
+  Code *const fileCode = read_whole_file(path->str);
   if (fileCode == NULL) {
     goto RETURN_ERROR;
   }
diff --git a/src/compiler/tree_parser/tree_parser.h b/src/compiler/tree_parser/tree_parser.h
index 8a9f7b5..b598348 100644
--- a/src/compiler/tree_parser/tree_parser.h
+++ b/src/compiler/tree_parser/tree_parser.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <compiler/parser/parser.h>
-#include <stdint.h>
 
 typedef enum TreeToken {
   TREE_TOKEN_NONE = 0,
@@ -71,6 +70,7 @@ extern void printParsedTreeNode(const ParsedTree *parsedTree);
 extern void deleteParsedTree(ParsedTree *parsedTree);
 
 extern ParsedTree *treeParser(SourceCode *code);
+extern ParsedTree *treeParserWithPrint(SourceCode *code);
 extern ParsedTree *_treeParser(const ParsedNode *node, SourceCode *code);
 
 extern ParsedTree *treeParseNode(const ParsedNode *node, SourceCode *code,