fixed an error in strings

fixed error in parenthesis
some code clean up

3 files changed, 81 insertions, 23 deletions

diff --git a/src/compiler/lexer/lexer.c b/src/compiler/lexer/lexer.c
index c216298..eee5ec3 100644
--- a/src/compiler/lexer/lexer.c
+++ b/src/compiler/lexer/lexer.c
@@ -174,6 +174,8 @@ Nodes lexer(char const *restrict str) {
         const char current = str[i];
         if (current == c) {
           break;
+        }else if(current == '\\'){
+          ++i;
         } else if (current == '\0') {
           fprintf(stderr, "expected %c to end\n", c);
           exit(1);
diff --git a/src/compiler/parser/parser.c b/src/compiler/parser/parser.c
index 7a486d9..2f5b89b 100644
--- a/src/compiler/parser/parser.c
+++ b/src/compiler/parser/parser.c
@@ -13,7 +13,7 @@ const char *PARSED_TOKEN_STRINGS[] = {
 
 static const ParseOrder PARSE_ORDER[] = {
     {
-        .ltr = false,
+        .ltr = true,
         .size = 2,
         .tokens =
             {
@@ -157,8 +157,8 @@ ParsedNode *parser(Nodes lexedNodes) {
   ParsedNode *root = a404m_malloc(sizeof(ParsedNode));
   root->token = PARSED_TOKEN_ROOT;
   root->parent = NULL;
-  root->metadata =
-      parserScope(lexedNodes.nodes, lexedNodes.nodes + lexedNodes.size, root);
+  root->metadata = parserScopeCode(lexedNodes.nodes,
+                                   lexedNodes.nodes + lexedNodes.size, root);
   if (root->metadata == NULL) {
     free(root);
     return NULL;
@@ -166,8 +166,8 @@ ParsedNode *parser(Nodes lexedNodes) {
   return root;
 }
 
-ScopeMetadata *parserScope(Node *nodesBegin, Node *nodesEnd,
-                           ParsedNode *parent) {
+ScopeMetadata *parserScope(Node *nodesBegin, Node *nodesEnd, ParsedNode *parent,
+                           bool (*isAllowed)(ParsedToken)) {
   if (nodesBegin >= nodesEnd) {
     return NULL;
   }
@@ -176,14 +176,14 @@ ScopeMetadata *parserScope(Node *nodesBegin, Node *nodesEnd,
   ParsedNode **nodes = a404m_malloc(nodes_size * sizeof(ParsedNode *));
   size_t nodes_inserted = 0;
 
-  for (size_t i = 0; i < PARSE_ORDER_SIZE; ++i) {
-    const ParseOrder order = PARSE_ORDER[i];
+  for (size_t order_index = 0; order_index < PARSE_ORDER_SIZE; ++order_index) {
+    const ParseOrder order = PARSE_ORDER[order_index];
 
     for (Node *node = order.ltr ? nodesBegin : (nodesEnd - 1);
          nodesBegin <= node && node < nodesEnd; order.ltr ? ++node : --node) {
-      for (size_t j = 0; j < order.size; ++j) {
-        const Token token = order.tokens[j];
-        if (node->token == token) {
+      for (size_t order_tokens_index = 0; order_tokens_index < order.size;
+           ++order_tokens_index) {
+        if (node->token == order.tokens[order_tokens_index]) {
           ParsedNode *parsedNode =
               parseNode(nodesBegin, nodesEnd, node, parent);
           if (parsedNode == NULL) {
@@ -210,23 +210,29 @@ ScopeMetadata *parserScope(Node *nodesBegin, Node *nodesEnd,
     }
   }
 
-  ScopeMetadata *metadata = a404m_malloc(sizeof(ScopeMetadata));
-  metadata->operands = a404m_malloc(nodes_inserted * sizeof(ParsedNode *));
-
+  ParsedNode **operands = a404m_malloc(nodes_inserted * sizeof(ParsedNode *));
   nodes_size = nodes_inserted;
   nodes_inserted = 0;
 
   for (size_t i = 0; i < nodes_size; ++i) {
     ParsedNode *currentNode = nodes[i];
     if (currentNode->parent == parent) {
-      metadata->operands[nodes_inserted] = currentNode;
+      if (!isAllowed(currentNode->token)) {
+        fprintf(
+            stderr,
+            "error in parsing token '%s' is not allowed at compiler line %d\n",
+            PARSED_TOKEN_STRINGS[currentNode->token], __LINE__);
+        goto RETURN_ERROR;
+      }
+      operands[nodes_inserted] = currentNode;
       ++nodes_inserted;
     }
   }
   free(nodes);
 
+  ScopeMetadata *metadata = a404m_malloc(sizeof(ScopeMetadata));
   metadata->operands =
-      a404m_realloc(metadata->operands, nodes_inserted * sizeof(ParsedNode *));
+      a404m_realloc(operands, nodes_inserted * sizeof(ParsedNode *));
   metadata->operands_size = nodes_inserted;
 
   return metadata;
@@ -236,6 +242,46 @@ RETURN_ERROR:
   return NULL;
 }
 
+static bool isAllowedCodeScope(ParsedToken token) {
+  switch (token) {
+    case PARSED_TOKEN_NONE:
+    case PARSED_TOKEN_ROOT:
+    case PARSED_TOKEN_PRINT:
+    case PARSED_TOKEN_PARENTHESIS:
+    case PARSED_TOKEN_VALUE_STRING:
+      return false;
+    case PARSED_TOKEN_EOL:
+      return true;
+  }
+  fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
+  exit(1);
+}
+
+static bool isAllowedParenthesisScope(ParsedToken token) {
+  switch (token) {
+    case PARSED_TOKEN_PARENTHESIS:
+    case PARSED_TOKEN_VALUE_STRING:
+      return true;
+    case PARSED_TOKEN_NONE:
+    case PARSED_TOKEN_ROOT:
+    case PARSED_TOKEN_PRINT:
+    case PARSED_TOKEN_EOL:
+      return false;
+  }
+  fprintf(stderr, "bad token '%d' at compiler line %d\n", token, __LINE__);
+  exit(1);
+}
+
+ScopeMetadata *parserScopeCode(Node *nodesBegin, Node *nodesEnd,
+                               ParsedNode *parent) {
+  return parserScope(nodesBegin, nodesEnd, parent, isAllowedCodeScope);
+}
+
+ScopeMetadata *parserScopeParenthesis(Node *nodesBegin, Node *nodesEnd,
+                                      ParsedNode *parent) {
+  return parserScope(nodesBegin, nodesEnd, parent, isAllowedParenthesisScope);
+}
+
 ParsedNode *parseNode(Node *nodesBegin, Node *nodesEnd, Node *node,
                       ParsedNode *parent) {
   switch (node->token) {
@@ -284,6 +330,7 @@ ParsedNode *parserPrint(Node *, Node *nodesEnd, Node *node,
 
 ParsedNode *parseParenthesis(Node *nodesBegin, Node *, Node *node,
                              ParsedNode *parent) {
+  ParsedNode *parsedNode = a404m_malloc(sizeof(*parsedNode));
   Node *opening = NULL;
   Node *closing = node;
   for (Node *iter = closing - 1; iter >= nodesBegin; --iter) {
@@ -295,26 +342,30 @@ ParsedNode *parseParenthesis(Node *nodesBegin, Node *, Node *node,
   if (opening == NULL) {
     fprintf(stderr, "error in parsing token '%s' at compiler line %d\n",
             TOKEN_STRINGS[node->token], __LINE__);
-    return NULL;
+    goto RETURN_ERROR;
   }
 
-  ParsedNode *parsedNode = closing->parsedNode = opening->parsedNode =
-      a404m_malloc(sizeof(*parsedNode));
   parsedNode->strBegin = opening->strBegin;
   parsedNode->strEnd = closing->strEnd;
   parsedNode->token = PARSED_TOKEN_PARENTHESIS;
   parsedNode->parent = parent;
-  parsedNode->metadata = parserScope(opening + 1, closing, parsedNode);
 
-  if (parsedNode->metadata == NULL) {
+  const ScopeMetadata *metadata = parsedNode->metadata =
+      parserScopeParenthesis(opening + 1, closing, parsedNode);
+
+  if (metadata == NULL) {
     fprintf(stderr, "error in parsing token '%s' at compiler line %d\n",
             TOKEN_STRINGS[node->token], __LINE__);
-    free(parsedNode);
-    return NULL;
+    goto RETURN_ERROR;
   }
 
+  closing->parsedNode = opening->parsedNode = parsedNode;
   opening->token = closing->token = TOKEN_PARSED;
   return parsedNode;
+
+RETURN_ERROR:
+  free(parsedNode);
+  return NULL;
 }
 
 ParsedNode *parseString(Node *node, ParsedNode *parent) {
diff --git a/src/compiler/parser/parser.h b/src/compiler/parser/parser.h
index efabc8c..4a39e17 100644
--- a/src/compiler/parser/parser.h
+++ b/src/compiler/parser/parser.h
@@ -46,7 +46,12 @@ extern void deleteParsedNode(ParsedNode *parsedNode);
 extern ParsedNode *parser(Nodes lexedNodes);
 
 extern ScopeMetadata *parserScope(Node *nodesBegin, Node *nodesEnd,
-                                  ParsedNode *parent);
+                                  ParsedNode *parent,
+                                  bool (*isAllowed)(ParsedToken));
+extern ScopeMetadata *parserScopeCode(Node *nodesBegin, Node *nodesEnd,
+                                      ParsedNode *parent);
+extern ScopeMetadata *parserScopeParenthesis(Node *nodesBegin, Node *nodesEnd,
+                                             ParsedNode *parent);
 
 extern ParsedNode *parseNode(Node *nodesBegin, Node *nodesEnd, Node *node,
                              ParsedNode *parent);