add arguments

5 files changed, 60 insertions, 40 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 5d8056e..eab847d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -341,10 +341,11 @@ AstTree *copyAstTree(AstTree *tree) {
     AstTreeTypeFunction *metadata = tree->metadata;
     AstTreeTypeFunction *new_metadata = a404m_malloc(sizeof(*new_metadata));
     new_metadata->returnType = copyAstTree(metadata->returnType);
-    new_metadata->arguments = NULL;
-    new_metadata->arguments_size = 0;
-    if (metadata->arguments_size != 0) {
-      UNREACHABLE;
+    new_metadata->arguments_size = metadata->arguments_size;
+    new_metadata->arguments =
+        a404m_malloc(sizeof(*new_metadata) * new_metadata->arguments_size);
+    for (size_t i = 0; i < metadata->arguments_size; ++i) {
+      new_metadata->arguments[i] = copyAstTree(metadata->arguments[i]);
     }
     return newAstTree(tree->token, new_metadata, &AST_TREE_TYPE_TYPE);
   }
@@ -745,8 +746,8 @@ AstTree *astTreeParseFunctionCall(ParserNode *parserNode,
   metadata->parameters_size = node_metadata->params->size;
 
   for (size_t i = 0; i < metadata->parameters_size; ++i) {
-    printLog("Not impelemented yet");
-    exit(1);
+    metadata->parameters[i] =
+        astTreeParse(node_metadata->params->data[i], variables, variables_size);
   }
 
   return newAstTree(AST_TREE_TOKEN_FUNCTION_CALL, metadata, NULL);
@@ -1074,8 +1075,9 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
       return false;
     }
     for (size_t i = 0; i < type0_metadata->arguments_size; ++i) {
-      printLog("Not implemented yet");
-      exit(1);
+      if (!setAllTypes(type0_metadata->arguments[i], NULL)) {
+        return false;
+      }
     }
     return true;
   case AST_TREE_TOKEN_FUNCTION_CALL:
@@ -1139,8 +1141,10 @@ bool setTypesFunction(AstTree *tree) {
   AstTreeFunction *metadata = tree->metadata;
 
   for (size_t i = 0; i < metadata->arguments.size; ++i) {
-    printLog("Type mismatch");
-    return false;
+    AstTreeVariable *variable = metadata->arguments.data[i];
+    if (!setTypesAstVariable(variable)) {
+      return false;
+    }
   }
 
   if (!setAllTypes(metadata->returnType, NULL)) {
@@ -1215,8 +1219,9 @@ bool setTypesFunctionCall(AstTree *tree) {
   AstTreeFunctionCall *metadata = tree->metadata;
 
   for (size_t i = 0; i < metadata->parameters_size; ++i) {
-    printLog("Not yet supported");
-    return false;
+    if (!setAllTypes(metadata->parameters[i], NULL)) {
+      return false;
+    }
   }
 
   if (metadata->function->token != AST_TREE_TOKEN_VARIABLE) {
@@ -1278,7 +1283,7 @@ bool setTypesOperatorSum(AstTree *tree) {
 }
 
 bool setTypesAstVariable(AstTreeVariable *variable) {
-  if (!setAllTypes(variable->value, NULL)) {
+  if (variable->value != NULL && !setAllTypes(variable->value, NULL)) {
     return false;
   }
 
@@ -1288,7 +1293,8 @@ bool setTypesAstVariable(AstTreeVariable *variable) {
 
   if (variable->type == NULL) {
     return false;
-  } else if (!typeIsEqual(variable->value->type, variable->type)) {
+  } else if (variable->value != NULL &&
+             !typeIsEqual(variable->value->type, variable->type)) {
     printLog("Type mismatch");
     return false;
   }
@@ -1336,8 +1342,7 @@ bool astTreeCleanFunction(AstTree *tree) {
   AstTreeFunction *metadata = tree->metadata;
 
   for (size_t i = 0; i < metadata->arguments.size; ++i) {
-    printLog("Not supported");
-    return false;
+    // TODO: do it
   }
 
   if (!astTreeClean(metadata->returnType)) {
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index 6bc05e9..ced3b6a 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -628,11 +628,21 @@ ParserNode *parserComma(LexerNode *node, LexerNode *begin, ParserNode *parent) {
 
 ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,
                               ParserNode *parent) {
+  ParserNode *parserNode = a404m_malloc(sizeof(*parserNode));
+  parserNode->parent = parent;
+
   LexerNode *opening = NULL;
 
   for (LexerNode *iter = closing - 1; iter >= begin; --iter) {
-    if (iter->parserNode == NULL &&
-        iter->token == LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS) {
+
+    if (iter->parserNode != NULL) {
+      ParserNode *pNode = getUntilCommonParent(iter->parserNode, parent);
+      if (pNode == NULL) {
+        printLog("Bad node", pNode->str_begin, pNode->str_end);
+      } else {
+        pNode->parent = parserNode;
+      }
+    } else if (iter->token == LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS) {
       opening = iter;
       break;
     }
@@ -643,6 +653,8 @@ ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,
                closing->str_end);
     return NULL;
   }
+  opening->parserNode = parserNode;
+  closing->parserNode = parserNode;
 
   LexerNode *beforeNode = opening - 1;
   ParserNode *before;
@@ -650,15 +662,15 @@ ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,
       (before = getUntilCommonParent(beforeNode->parserNode, parent)) == NULL ||
       !isExpression(before)) {
     before = NULL;
+  } else {
+    before->parent = parserNode;
   }
 
   if (before == NULL) {
-    ParserNode *parserNode =
-        newParserNode(PARSER_TOKEN_SYMBOL_PARENTHESIS, opening->str_begin,
-                      closing->str_end, NULL, parent);
+    parserNode->token = PARSER_TOKEN_SYMBOL_PARENTHESIS;
+    parserNode->str_begin = opening->str_begin;
+    parserNode->str_end = closing->str_end;
 
-    opening->parserNode = parserNode;
-    closing->parserNode = parserNode;
     if (parserNodeArray(opening + 1, closing, parserNode)) {
       return parserNode;
     } else {
@@ -666,13 +678,10 @@ ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,
       return NULL;
     }
   } else {
-    ParserNode *parserNode =
-        newParserNode(PARSER_TOKEN_FUNCTION_CALL, before->str_begin,
-                      closing->str_end, NULL, parent);
+    parserNode->token = PARSER_TOKEN_FUNCTION_CALL;
+    parserNode->str_begin = before->str_begin;
+    parserNode->str_end = closing->str_end;
 
-    before->parent = parserNode;
-    opening->parserNode = parserNode;
-    closing->parserNode = parserNode;
     if (parserNodeArray(opening + 1, closing, parserNode)) {
       ParserNodeFunctionCall *metadata = malloc(sizeof(*metadata));
       metadata->function = before;
@@ -747,7 +756,8 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end,
     ParserNodeArray *bodyArray = body->metadata;
     for (size_t i = 0; i < bodyArray->size; ++i) {
       if (bodyArray->data[i]->token != PARSER_TOKEN_SYMBOL_EOL) {
-        printError("Maybe forgot a ; with %s", node->str_begin, node->str_end,
+        printError("Maybe forgot a ; with %s", bodyArray->data[i]->str_begin,
+                   bodyArray->data[i]->str_end,
                    PARSER_TOKEN_STRINGS[bodyArray->data[i]->token]);
         return NULL;
       }
@@ -801,7 +811,8 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end,
   ParserNode *name = getUntilCommonParent(nameNode->parserNode, parent);
 
   if (name == NULL) {
-    printError("Name should be identifier but got nothing", node->str_begin, node->str_end);
+    printError("Name should be identifier but got nothing", node->str_begin,
+               node->str_end);
     return NULL;
   } else if (name->token != PARSER_TOKEN_IDENTIFIER) {
     printError("Name should be identifier but got '%s'", name->str_begin,
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 23cbca0..50d87df 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -18,14 +18,18 @@ bool runAstTree(AstTreeRoot *root) {
 
       AstTree *main = variable->value;
       AstTreeFunction *mainFunction = main->metadata;
-      return runAstTreeFunction(mainFunction) == &AST_TREE_VOID_VALUE;
+      return runAstTreeFunction(mainFunction, NULL, 0) == &AST_TREE_VOID_VALUE;
     }
   }
   printLog("main function is not found");
   return false;
 }
 
-AstTree *runAstTreeFunction(AstTreeFunction *function) {
+AstTree *runAstTreeFunction(AstTreeFunction *function, AstTree **arguments,
+                            size_t arguments_size) {
+  for (size_t i = 0; i < arguments_size; ++i) {
+    function->arguments.data[i]->value = calcAstTreeValue(arguments[i]);
+  }
   for (size_t i = 0; i < function->scope.expressions_size; ++i) {
     AstTree expr = function->scope.expressions[i];
     switch (expr.token) {
@@ -96,11 +100,10 @@ AstTree *calcAstTreeValue(AstTree *tree) {
   }
   case AST_TREE_TOKEN_FUNCTION_CALL: {
     AstTreeFunctionCall *metadata = tree->metadata;
-    if (metadata->parameters_size != 0) {
-      UNREACHABLE;
-    } else if (metadata->function->token == AST_TREE_TOKEN_VARIABLE) {
+    if (metadata->function->token == AST_TREE_TOKEN_VARIABLE) {
       AstTreeVariable *variable = metadata->function->metadata;
-      return runAstTreeFunction(variable->value->metadata);
+      return runAstTreeFunction(variable->value->metadata, metadata->parameters,
+                                metadata->parameters_size);
     } else {
       UNREACHABLE;
     }
diff --git a/src/runner/runner.h b/src/runner/runner.h
index f143cbc..71c720b 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -5,7 +5,8 @@
 
 bool runAstTree(AstTreeRoot *root);
 
-AstTree *runAstTreeFunction(AstTreeFunction *function);
+AstTree *runAstTreeFunction(AstTreeFunction *function, AstTree **arguments,
+                            size_t arguments_size);
 
 AstTree *calcAstTreeValue(AstTree *tree);
 AstTree *deepCopyAstTree(AstTree *tree);
diff --git a/test/main.felan b/test/main.felan
index 4ca3372..0bd20fa 100644
--- a/test/main.felan
+++ b/test/main.felan
@@ -1,9 +1,9 @@
 main :: () -> void {
-  a : u64 = fun();
+  a : u64 = fun(2);
   print_u64 a + 5;
 };
 
 fun :: (b:u64)->u64 {
-  return 1;
+  return b+1;
 };