1 files changed, 129 insertions, 57 deletions

diff --git a/src/parser.c b/src/parser.c
index 7a22f16..2817fa0 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -128,67 +128,94 @@ token_to_binary_operation_kind(token_t *token)
       return AST_BINOP_MULTIPLICATION;
     case TOKEN_SLASH:
       return AST_BINOP_DIVISION;
+    case TOKEN_EQUAL:
+      return AST_BINOP_EQUAL;
+    case TOKEN_NOT_EQUAL:
+      return AST_BINOP_NOT_EQUAL;
+    case TOKEN_AND:
+      return AST_BINOP_AND;
+    case TOKEN_OR:
+      return AST_BINOP_OR;
+    case TOKEN_GT:
+      return AST_BINOP_GT;
+    case TOKEN_GT_EQUAL:
+      return AST_BINOP_GT_EQUAL;
+    case TOKEN_LT:
+      return AST_BINOP_LT;
+    case TOKEN_LT_EQUAL:
+      return AST_BINOP_LT_EQUAL;
     default:
       assert(false && "token mapping not found.");
   }
 }
 
+ast_node_t *
+parser_parse_expression(parser_t *parser);
+
 static ast_node_t *
-parser_parse_factor(parser_t *parser)
+parser_parse_comparison(parser_t *parser);
+
+static ast_node_t *
+parser_parse_arithmetic1(parser_t *parser);
+
+static ast_node_t *
+parser_parse_arithmetic2(parser_t *parser);
+
+static ast_node_t *
+parser_parse_factor(parser_t *parser);
+
+/**
+ *
+ * <expression>  ::= <comparison>
+ * <comparison>  ::= <arithmetic1> (('>' | '>=' | '=' | ...) arithmetic1)*
+ * <arithmetic1> ::= <arithmetic2> (('+' | '-') arithmetic2)*
+ * <arithmetic2> ::= <factor> (('*' | '/') factor)*
+ * <factor>      ::= <integer> | '(' <expression> ')'
+ *
+ */
+ast_node_t *
+parser_parse_expression(parser_t *parser)
 {
-  token_t token;
-  lexer_next_token(parser->lexer, &token);
+  return parser_parse_comparison(parser);
+}
 
-  switch (token.kind) {
-    case TOKEN_NUMBER:
-      return parser_literal_integer_node(&token);
-    case TOKEN_TRUE:
-      return parser_literal_bool_node(&token);
-    case TOKEN_FALSE:
-      return parser_literal_bool_node(&token);
-    case TOKEN_OPAREN: {
-      ast_node_t *expression = parser_parse_expression(parser);
+static ast_node_t *
+parser_parse_comparison(parser_t *parser)
+{
+  ast_node_t *node = parser_parse_arithmetic1(parser);
 
-      if (expression == NULL) {
-        return NULL;
-      }
+  if (node == NULL) {
+    return NULL;
+  }
 
-      if (!drop_expected_token(parser, TOKEN_CPAREN)) {
-        ast_node_destroy(expression);
-        return NULL;
-      }
+  token_t token;
+  lexer_peek_next_token(parser->lexer, &token);
 
-      return expression;
-    }
-    case TOKEN_NAME: {
-      // TODO: Check node kind, today accepts only variables
-      ast_node_t *var_node = scope_get(parser->scope, token.value);
+  while (token.kind == TOKEN_GT || token.kind == TOKEN_LT || token.kind == TOKEN_GT_EQUAL ||
+         token.kind == TOKEN_LT_EQUAL || token.kind == TOKEN_EQUAL || token.kind == TOKEN_NOT_EQUAL ||
+         token.kind == TOKEN_AND || token.kind == TOKEN_OR) {
+    lexer_drop_next_token(parser->lexer);
 
-      if (var_node == NULL) {
-        parser_error_t error;
-        error.token = token;
-        sprintf(error.message, "identifier '" SVFMT "' not defined", SVARG(&token.value));
-        parser->errors[parser->errors_len++] = error;
-        return NULL;
-      }
+    ast_node_t *left = node;
+    ast_node_t *right = parser_parse_arithmetic1(parser);
 
-      return ast_node_new_variable(&var_node->data.variable_declaration.identifier,
-                                   var_node->data.variable_declaration.type);
-    }
-    default: {
-      parser_error_t error;
-      error.token = token;
-      sprintf(error.message, "unexpected '%s (" SVFMT ")' token", token_kind_to_str(token.kind), SVARG(&token.value));
-      parser->errors[parser->errors_len++] = error;
+    if (right == NULL) {
+      ast_node_destroy(node);
       return NULL;
     }
+
+    node = ast_node_new_binary_operation(token_to_binary_operation_kind(&token), left, right, TYPE_BOOL);
+
+    lexer_peek_next_token(parser->lexer, &token);
   }
+
+  return node;
 }
 
 static ast_node_t *
-parser_parse_term(parser_t *parser)
+parser_parse_arithmetic1(parser_t *parser)
 {
-  ast_node_t *node = parser_parse_factor(parser);
+  ast_node_t *node = parser_parse_arithmetic2(parser);
 
   if (node == NULL) {
     return NULL;
@@ -197,14 +224,14 @@ parser_parse_term(parser_t *parser)
   token_t token;
   lexer_peek_next_token(parser->lexer, &token);
 
-  while (token.kind == TOKEN_STAR || token.kind == TOKEN_SLASH) {
+  while (token.kind == TOKEN_PLUS || token.kind == TOKEN_MINUS) {
     lexer_drop_next_token(parser->lexer);
 
     ast_node_t *left = node;
-    ast_node_t *right = parser_parse_factor(parser);
+    ast_node_t *right = parser_parse_arithmetic2(parser);
 
     if (right == NULL) {
-      ast_node_destroy(node);
+      ast_node_destroy(left);
       return NULL;
     }
 
@@ -216,17 +243,10 @@ parser_parse_term(parser_t *parser)
   return node;
 }
 
-/**
- *
- * <expression> ::= <term> (('+' | '-') term)*
- * <term>       ::= <factor> (('*' | '/') factor)*
- * <factor>     ::= <integer> | '(' <expression> ')'
- *
- */
-ast_node_t *
-parser_parse_expression(parser_t *parser)
+static ast_node_t *
+parser_parse_arithmetic2(parser_t *parser)
 {
-  ast_node_t *node = parser_parse_term(parser);
+  ast_node_t *node = parser_parse_factor(parser);
 
   if (node == NULL) {
     return NULL;
@@ -235,14 +255,14 @@ parser_parse_expression(parser_t *parser)
   token_t token;
   lexer_peek_next_token(parser->lexer, &token);
 
-  while (token.kind == TOKEN_PLUS || token.kind == TOKEN_MINUS) {
+  while (token.kind == TOKEN_STAR || token.kind == TOKEN_SLASH) {
     lexer_drop_next_token(parser->lexer);
 
     ast_node_t *left = node;
-    ast_node_t *right = parser_parse_term(parser);
+    ast_node_t *right = parser_parse_factor(parser);
 
     if (right == NULL) {
-      ast_node_destroy(left);
+      ast_node_destroy(node);
       return NULL;
     }
 
@@ -255,6 +275,58 @@ parser_parse_expression(parser_t *parser)
 }
 
 static ast_node_t *
+parser_parse_factor(parser_t *parser)
+{
+  token_t token;
+  lexer_next_token(parser->lexer, &token);
+
+  switch (token.kind) {
+    case TOKEN_NUMBER:
+      return parser_literal_integer_node(&token);
+    case TOKEN_TRUE:
+      return parser_literal_bool_node(&token);
+    case TOKEN_FALSE:
+      return parser_literal_bool_node(&token);
+    case TOKEN_OPAREN: {
+      ast_node_t *expression = parser_parse_expression(parser);
+
+      if (expression == NULL) {
+        return NULL;
+      }
+
+      if (!drop_expected_token(parser, TOKEN_CPAREN)) {
+        ast_node_destroy(expression);
+        return NULL;
+      }
+
+      return expression;
+    }
+    case TOKEN_NAME: {
+      // TODO: Check node kind, today accepts only variables
+      ast_node_t *var_node = scope_get(parser->scope, token.value);
+
+      if (var_node == NULL) {
+        parser_error_t error;
+        error.token = token;
+        sprintf(error.message, "identifier '" SVFMT "' not defined", SVARG(&token.value));
+        parser->errors[parser->errors_len++] = error;
+        return NULL;
+      }
+
+      return ast_node_new_variable(&var_node->data.variable_declaration.identifier,
+                                   var_node->data.variable_declaration.type);
+    }
+    default: {
+      parser_error_t error;
+      error.token = token;
+      sprintf(error.message, "unexpected '%s (" SVFMT ")' token", token_kind_to_str(token.kind), SVARG(&token.value));
+      parser->errors[parser->errors_len++] = error;
+      return NULL;
+    }
+  }
+}
+
+static ast_node_t *
 parser_parse_return_stmt(parser_t *parser, type_t result_type)
 {
   token_t token;