From 285c054d3774f4661058edce5b34e06a51604378 Mon Sep 17 00:00:00 2001
From: augustin64 <me.git@augustin64.fr>
Date: Fri, 24 Nov 2023 11:15:17 +0100
Subject: [PATCH] Fix comp parse order

---
 src/parser.cpp | 104 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 65 insertions(+), 39 deletions(-)

diff --git a/src/parser.cpp b/src/parser.cpp
index 77733d7..3e26f58 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -331,51 +331,77 @@ ParseReturn parse_expr(vector<Token> tokens) {
 }
 
 ParseReturn parse_comp(vector<Token> tokens) {
-    ParseReturn ret = parse_sum(tokens);
     if (tokens.size() == 0)
-        return ret;
+        throw ParseException();
 
+    // At least 1 Sum
+    ParseReturn ret = parse_sum(tokens);
     tokens = ret.tokens;
-    NodeType type;
-    switch (tokens.back().type) {
-        case TokenType::Equal:
-            type = NodeType::Eq;
-            break;
-        case TokenType::NotEqual:
-            type = NodeType::Neq;
-            break;
-        case TokenType::Lt:
-            type = NodeType::Lt;
-            break;
-        case TokenType::Gt:
-            type = NodeType::Gt;
-            break;
-        case TokenType::Leq:
-            type = NodeType::Leq;
-            break;
-        case TokenType::Geq:
-            type = NodeType::Geq;
-            break;
-        case TokenType::Land:
-            type = NodeType::Land;
-            break;
-        case TokenType::Lor:
-            type = NodeType::Lor;
-            break;
-        default:
-            return ret;
+
+    Node node = ret.node;
+
+    //* We construct a tree
+    while (tokens.size() != 0) {
+        NodeType type;
+
+        switch (tokens.back().type) {
+            case TokenType::DoubleEqual:
+                type = NodeType::Eq;
+                break;
+            case TokenType::NotEqual:
+                type = NodeType::Neq;
+                break;
+            case TokenType::Lt:
+                type = NodeType::Lt;
+                break;
+            case TokenType::Gt:
+                type = NodeType::Gt;
+                break;
+            case TokenType::Leq:
+                type = NodeType::Leq;
+                break;
+            case TokenType::Geq:
+                type = NodeType::Geq;
+                break;
+            case TokenType::Land:
+                type = NodeType::Land;
+                break;
+            case TokenType::Lor:
+                type = NodeType::Lor;
+                break;
+            default:
+                return {
+                    .node=node,
+                    .tokens=tokens
+                };
+        }
+
+        Token last_token;
+        try {
+            last_token = tokens.back();
+            tokens.pop_back();
+
+            ParseReturn ret = parse_sum(tokens);
+            tokens = ret.tokens;
+
+            InnerNode new_node = {
+                .type=type,
+                .children={node, ret.node},
+                .pos=last_token.pos
+            };
+            node = new_node;
+        } catch (const ParseException& pex) {
+            tokens.emplace_back(last_token);
+            return {
+                .node=node,
+                .tokens=tokens
+            };
+        }
     }
-    tokens.pop_back();
-    ParseReturn ret_comp = parse_comp(tokens);
-    
-    InnerNode node = {
-        .type=type,
-        .children={ ret.node, ret_comp.node },
-        .pos=get_node_pos(ret_comp.node)
-    };
+
     return {
         .node=node,
-        .tokens=ret_comp.tokens
+        .tokens=tokens
     };
 }