fixed multiple variable definition bug

tried to implement import

2 files changed, 85 insertions, 53 deletions

diff --git a/src/compiler/parser/parser.c b/src/compiler/parser/parser.c
index 61a0cf9..2ffde16 100644
--- a/src/compiler/parser/parser.c
+++ b/src/compiler/parser/parser.c
@@ -22,6 +22,7 @@ const char *PARSED_TOKEN_STRINGS[] = {
     "PARSED_TOKEN_FUNCTION",
     "PARSED_TOKEN_FUNCTION_PARAMS",
     "PARSED_TOKEN_CODE_BODY",
+    "PARSED_TOKEN_IMPORT",
 };
 
 static const ParseOrder PARSE_ORDER[] = {
@@ -45,18 +46,12 @@ static const ParseOrder PARSE_ORDER[] = {
     },
     {
         .ltr = true,
-        .size = 1,
+        .size = 3,
         .tokens =
             {
                 TOKEN_OPERATOR_FUNCTION,
-            },
-    },
-    {
-        .ltr = true,
-        .size = 1,
-        .tokens =
-            {
                 TOKEN_KEYWORD_STRUCT,
+                TOKEN_KEYWORD_IMPORT,
             },
     },
     {
@@ -70,18 +65,11 @@ static const ParseOrder PARSE_ORDER[] = {
             },
     },
     {
-        .ltr = false,
-        .size = 1,
-        .tokens =
-            {
-                TOKEN_OPERATOR_COMMA,
-            },
-    },
-    {
         .ltr = true,
-        .size = 1,
+        .size = 2,
         .tokens =
             {
+                TOKEN_OPERATOR_COMMA,
                 TOKEN_OPERATOR_EOL,
             },
     },
@@ -187,6 +175,12 @@ void _printParsedNode(const ParsedNode *parsedNode, int indent) {
       _printParsedNode(metadata->body, indent + 1);
       goto END_SUCCESS;
     }
+    case PARSED_TOKEN_IMPORT: {
+      const ParserImportMetadata *metadata = parsedNode->metadata;
+      printf(",import=\n");
+      _printParsedNode(metadata, indent + 1);
+      goto END_SUCCESS;
+    }
     case PARSED_TOKEN_NONE:
   }
   fprintf(stderr, "bad parsed token %d at compiler line %d\n",
@@ -269,6 +263,11 @@ void deleteParsedNode(ParsedNode *parsedNode) {
       free(metadata);
       goto FREE;
     }
+    case PARSED_TOKEN_IMPORT: {
+      ParserImportMetadata *metadata = parsedNode->metadata;
+      deleteParsedNode(metadata);
+      goto FREE;
+    }
   }
   fprintf(stderr, "bad parsed token %d at compiler line %d\n",
           parsedNode->token, __LINE__);
@@ -277,8 +276,8 @@ FREE:
   free(parsedNode);
 }
 
-ParsedNode *parser(SourceCode code) {
-  Nodes nodes = lexer(code);
+ParsedNode *parser(SourceCode *code, size_t sourceIndex) {
+  Nodes nodes = lexer(code,sourceIndex);
   if (nodes.size == ERROR_SIZE) {
     return NULL;
   }
@@ -288,7 +287,7 @@ ParsedNode *parser(SourceCode code) {
   return root;
 }
 
-ParsedNode *_parser(Nodes lexedNodes, SourceCode code) {
+ParsedNode *_parser(Nodes lexedNodes, SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
   root->token = PARSED_TOKEN_ROOT;
   root->parent = NULL;
@@ -303,7 +302,7 @@ ParsedNode *_parser(Nodes lexedNodes, SourceCode code) {
 
 ParserScopeMetadata *parserScope(
     Node *nodesBegin, Node *nodesEnd, ParsedNode *parent,
-    bool (*isAllowed)(ParsedToken token, bool isLast), SourceCode code) {
+    bool (*isAllowed)(ParsedToken token, bool isLast), SourceCode *code) {
   size_t nodes_size = 0;
   ParsedNode **nodes = a404m_malloc(nodes_size * sizeof(ParsedNode *));
   size_t nodes_inserted = 0;
@@ -385,6 +384,7 @@ static bool isAllowedCodeScope(ParsedToken token, bool) {
     case PARSED_TOKEN_STRUCT:
     case PARSED_TOKEN_FUNCTION:
     case PARSED_TOKEN_FUNCTION_PARAMS:
+    case PARSED_TOKEN_IMPORT:
       return false;
     case PARSED_TOKEN_EOL:
     case PARSED_TOKEN_CODE_BODY:
@@ -411,6 +411,7 @@ static bool isAllowedParenthesisScope(ParsedToken token, bool) {
     case PARSED_TOKEN_FUNCTION:
     case PARSED_TOKEN_CODE_BODY:
     case PARSED_TOKEN_FUNCTION_PARAMS:
+    case PARSED_TOKEN_IMPORT:
       return false;
   }
   fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
@@ -435,6 +436,7 @@ static bool isAllowedFunctionCallScope(ParsedToken token, bool isLast) {
     case PARSED_TOKEN_FUNCTION:
     case PARSED_TOKEN_FUNCTION_PARAMS:
     case PARSED_TOKEN_CODE_BODY:
+    case PARSED_TOKEN_IMPORT:
       return false;
   }
   fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
@@ -459,6 +461,7 @@ static bool isAllowedFunctionParamScope(ParsedToken token, bool isLast) {
     case PARSED_TOKEN_FUNCTION:
     case PARSED_TOKEN_FUNCTION_PARAMS:
     case PARSED_TOKEN_CODE_BODY:
+    case PARSED_TOKEN_IMPORT:
       return false;
   }
   fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
@@ -481,6 +484,7 @@ static bool isAllowedStructScope(ParsedToken token, bool) {
     case PARSED_TOKEN_DEFINE_CONSTANT:
     case PARSED_TOKEN_FUNCTION_PARAMS:
     case PARSED_TOKEN_CODE_BODY:
+    case PARSED_TOKEN_IMPORT:
       return false;
   }
   fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
@@ -488,38 +492,38 @@ static bool isAllowedStructScope(ParsedToken token, bool) {
 }
 
 ParserScopeMetadata *parserScopeCode(Node *nodesBegin, Node *nodesEnd,
-                                     ParsedNode *parent, SourceCode code) {
+                                     ParsedNode *parent, SourceCode *code) {
   return parserScope(nodesBegin, nodesEnd, parent, isAllowedCodeScope, code);
 }
 
 ParserScopeMetadata *parserScopeParenthesis(Node *nodesBegin, Node *nodesEnd,
                                             ParsedNode *parent,
-                                            SourceCode code) {
+                                            SourceCode *code) {
   return parserScope(nodesBegin, nodesEnd, parent, isAllowedParenthesisScope,
                      code);
 }
 
 ParserScopeMetadata *parserScopeFunctionCall(Node *nodesBegin, Node *nodesEnd,
                                              ParsedNode *parent,
-                                             SourceCode code) {
+                                             SourceCode *code) {
   return parserScope(nodesBegin, nodesEnd, parent, isAllowedFunctionCallScope,
                      code);
 }
 
 ParserScopeMetadata *parserScopeFunctionParam(Node *nodesBegin, Node *nodesEnd,
                                               ParsedNode *parent,
-                                              SourceCode code) {
+                                              SourceCode *code) {
   return parserScope(nodesBegin, nodesEnd, parent, isAllowedFunctionParamScope,
                      code);
 }
 
 ParserScopeMetadata *parserScopeStruct(Node *nodesBegin, Node *nodesEnd,
-                                       ParsedNode *parent, SourceCode code) {
+                                       ParsedNode *parent, SourceCode *code) {
   return parserScope(nodesBegin, nodesEnd, parent, isAllowedStructScope, code);
 }
 
 ParsedNode *parseNode(Node *nodesBegin, Node *nodesEnd, Node *node,
-                      ParsedNode *parent, SourceCode code) {
+                      ParsedNode *parent, SourceCode *code) {
   switch (node->token) {
     case TOKEN_OPERATOR_PARENTHESES_CLOSE:
       return parseParenthesis(nodesBegin, nodesEnd, node, parent, code);
@@ -559,7 +563,7 @@ ParsedNode *parseNode(Node *nodesBegin, Node *nodesEnd, Node *node,
 }
 
 ParsedNode *parseParenthesis(Node *nodesBegin, Node *nodesEnd, Node *closing,
-                             ParsedNode *parent, SourceCode code) {
+                             ParsedNode *parent, SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
   Node *opening = NULL;
   for (Node *iter = closing - 1; iter >= nodesBegin; --iter) {
@@ -635,7 +639,7 @@ RETURN_ERROR:
 }
 
 ParsedNode *parseCurly(Node *nodesBegin, Node *closing, ParsedNode *parent,
-                       SourceCode code) {
+                       SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
 
   Node *opening = NULL;
@@ -685,7 +689,7 @@ ParsedNode *parseIdentifier(Node *node, ParsedNode *parent) {
 }
 
 ParsedNode *parseEOL(Node *nodesBegin, Node *node, ParsedNode *parent,
-                     SourceCode code) {
+                     SourceCode *code) {
   Node *before = node - 1;
   if (before < nodesBegin) {
   RETURN_EMPTY:
@@ -719,7 +723,7 @@ ParsedNode *parseEOL(Node *nodesBegin, Node *node, ParsedNode *parent,
 }
 
 ParsedNode *parseVariable(Node *nodesBegin, Node *nodesEnd, Node *node,
-                          ParsedNode *parent, SourceCode code) {
+                          ParsedNode *parent, SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
   ParserVariableDefineMetadata *metadata = root->metadata =
       a404m_malloc(sizeof(*metadata));
@@ -832,7 +836,7 @@ RETURN_ERROR:
 }
 
 ParsedNode *parseComma(Node *nodesBegin, Node *, Node *node, ParsedNode *parent,
-                       SourceCode code) {
+                       SourceCode *code) {
   Node *before = node - 1;
   if (before < nodesBegin || before->token != TOKEN_PARSED) {
   UNEXPECTED:
@@ -861,7 +865,7 @@ ParsedNode *parseComma(Node *nodesBegin, Node *, Node *node, ParsedNode *parent,
 }
 
 ParsedNode *parseStruct(Node *nodesEnd, Node *node, ParsedNode *parent,
-                        SourceCode code) {
+                        SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
   ParserStructMetadata *metadata = root->metadata =
       a404m_malloc(sizeof(*metadata));
@@ -904,7 +908,7 @@ RETURN_ERROR:
 }
 
 ParsedNode *parseFunction(Node *nodesBegin, Node *nodesEnd, Node *node,
-                          ParsedNode *parent, SourceCode code) {
+                          ParsedNode *parent, SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
   ParserFunctionMetadata *metadata = root->metadata =
       a404m_malloc(sizeof(*metadata));
@@ -965,10 +969,36 @@ RETURN_ERROR:
 }
 
 ParsedNode *parseImport(Node *nodesEnd, Node *node, ParsedNode *parent,
-                        SourceCode code) {
+                        SourceCode *code) {
   ParsedNode *root = a404m_malloc(sizeof(*root));
+  root->parent = parent;
+  root->token = PARSED_TOKEN_IMPORT;
+  ParserImportMetadata *metadata;
+
+  Node const *package = node + 1;
 
-  // TODO: do it
+  if (package == nodesEnd) {
+  NO_PATH:
+    printError("Import needs a path", code, node->strBegin, node->strEnd);
+    goto RETURN_ERROR;
+  } else if (package->token != TOKEN_PARSED) {
+  BAD_PATH:
+    printError("Import path should be an string", code, package->strBegin,
+               package->strEnd);
+    goto RETURN_ERROR;
+  } else if ((metadata = getUntilCommonFather(package->parsedNode, parent)) ==
+             NULL) {
+    goto NO_PATH;
+  } else if (metadata->token != PARSED_TOKEN_VALUE_STRING) {
+    goto BAD_PATH;
+  }
+  metadata->parent = root;
+  root->metadata = metadata;
+
+  node->token = TOKEN_PARSED;
+  node->parsedNode = root;
+  root->strBegin = node->strBegin;
+  root->strEnd = package->strEnd;
 
   return root;
 
diff --git a/src/compiler/parser/parser.h b/src/compiler/parser/parser.h
index 24c6c5d..234264b 100644
--- a/src/compiler/parser/parser.h
+++ b/src/compiler/parser/parser.h
@@ -17,6 +17,7 @@ typedef enum ParsedToken {
   PARSED_TOKEN_FUNCTION,
   PARSED_TOKEN_FUNCTION_PARAMS,
   PARSED_TOKEN_CODE_BODY,
+  PARSED_TOKEN_IMPORT,
 } ParsedToken;
 
 extern const char *PARSED_TOKEN_STRINGS[];
@@ -61,6 +62,7 @@ typedef struct ParserFunctionMetadata {
   ParsedNode *type;
   ParsedNode *body;
 } ParserFunctionMetadata;
+typedef ParsedNode ParserImportMetadata;
 
 extern ParsedNode *newParsedNode(char const *strBegin, char const *strEnd,
                                  ParsedToken token, void *metadata,
@@ -71,50 +73,50 @@ extern ParsedNode *getUntilCommonFather(ParsedNode *parsedNode,
                                         ParsedNode *parent);
 extern void deleteParsedNode(ParsedNode *parsedNode);
 
-extern ParsedNode *parser(SourceCode code);
-extern ParsedNode *_parser(Nodes lexedNodes, SourceCode code);
+extern ParsedNode *parser(SourceCode *code,size_t sourceIndex);
+extern ParsedNode *_parser(Nodes lexedNodes, SourceCode *code);
 
 extern ParserScopeMetadata *parserScope(
     Node *nodesBegin, Node *nodesEnd, ParsedNode *parent,
-    bool (*isAllowed)(ParsedToken token, bool isLast), SourceCode code);
+    bool (*isAllowed)(ParsedToken token, bool isLast), SourceCode *code);
 extern ParserScopeMetadata *parserScopeCode(Node *nodesBegin, Node *nodesEnd,
                                             ParsedNode *parent,
-                                            SourceCode code);
+                                            SourceCode *code);
 extern ParserScopeMetadata *parserScopeParenthesis(Node *nodesBegin,
                                                    Node *nodesEnd,
                                                    ParsedNode *parent,
-                                                   SourceCode code);
+                                                   SourceCode *code);
 extern ParserScopeMetadata *parserScopeFunctionCall(Node *nodesBegin,
                                                     Node *nodesEnd,
                                                     ParsedNode *parent,
-                                                    SourceCode code);
+                                                    SourceCode *code);
 extern ParserScopeMetadata *parserScopeFunctionParam(Node *nodesBegin,
                                                      Node *nodesEnd,
                                                      ParsedNode *parent,
-                                                     SourceCode code);
+                                                     SourceCode *code);
 extern ParserScopeMetadata *parserScopeStruct(Node *nodesBegin, Node *nodesEnd,
                                               ParsedNode *parent,
-                                              SourceCode code);
+                                              SourceCode *code);
 
 extern ParsedNode *parseNode(Node *nodesBegin, Node *nodesEnd, Node *node,
-                             ParsedNode *parent, SourceCode code);
+                             ParsedNode *parent, SourceCode *code);
 
 extern ParsedNode *parseParenthesis(Node *nodesBegin, Node *nodesEnd,
                                     Node *node, ParsedNode *parent,
-                                    SourceCode code);
+                                    SourceCode *code);
 extern ParsedNode *parseCurly(Node *nodesBegin, Node *node, ParsedNode *parent,
-                              SourceCode code);
+                              SourceCode *code);
 extern ParsedNode *parseString(Node *node, ParsedNode *parent);
 extern ParsedNode *parseIdentifier(Node *node, ParsedNode *parent);
 extern ParsedNode *parseEOL(Node *nodesBegin, Node *node, ParsedNode *parent,
-                            SourceCode code);
+                            SourceCode *code);
 extern ParsedNode *parseVariable(Node *nodesBegin, Node *nodesEnd, Node *node,
-                                 ParsedNode *parent, SourceCode code);
+                                 ParsedNode *parent, SourceCode *code);
 extern ParsedNode *parseComma(Node *nodesBegin, Node *nodesEnd, Node *node,
-                              ParsedNode *parent, SourceCode code);
+                              ParsedNode *parent, SourceCode *code);
 extern ParsedNode *parseStruct(Node *nodesEnd, Node *node, ParsedNode *parent,
-                               SourceCode code);
+                               SourceCode *code);
 extern ParsedNode *parseFunction(Node *nodesBegin, Node *nodesEnd, Node *node,
-                                 ParsedNode *parent, SourceCode code);
+                                 ParsedNode *parent, SourceCode *code);
 extern ParsedNode *parseImport(Node *nodesEnd, Node *node, ParsedNode *parent,
-                               SourceCode code);
+                               SourceCode *code);