fix bugs in float types

7 files changed, 496 insertions, 113 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 1b56220..8cb1fce 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -2447,7 +2447,8 @@ bool setTypesValueFloat(AstTree *tree, AstTreeSetTypesHelper helper) {
       printWarning(tree->str_begin, tree->str_end, "Value is overflowing");
     }
     tree->type = &AST_TREE_F32_TYPE;
-  } else if (helper.lookingType == &AST_TREE_F64_TYPE || helper.lookingType == NULL) {
+  } else if (helper.lookingType == &AST_TREE_F64_TYPE ||
+             helper.lookingType == NULL) {
     tree->token = AST_TREE_TOKEN_VALUE_FLOAT;
     AstTreeFloat value = *(AstTreeFloat *)tree->metadata;
     f64 newValue = value;
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 1c8ae5d..2b7a789 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -180,6 +180,7 @@ LexerNodeArray lexer(char *str) {
             goto RETURN_ERROR;
           }
         }
+        continue;
       } else {
         --iter;
         c = *iter;
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index a25f549..405c921 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -49,6 +49,11 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_SYMBOL_COMMA",
 
     "PARSER_TOKEN_OPERATOR_ASSIGN",
+    "PARSER_TOKEN_OPERATOR_SUM_ASSIGN",
+    "PARSER_TOKEN_OPERATOR_SUB_ASSIGN",
+    "PARSER_TOKEN_OPERATOR_MULTIPLY_ASSIGN",
+    "PARSER_TOKEN_OPERATOR_DIVIDE_ASSIGN",
+    "PARSER_TOKEN_OPERATOR_MODULO_ASSIGN",
     "PARSER_TOKEN_OPERATOR_PLUS",
     "PARSER_TOKEN_OPERATOR_MINUS",
     "PARSER_TOKEN_OPERATOR_SUM",
diff --git a/src/main.c b/src/main.c
index 3513ff3..71f6384 100644
--- a/src/main.c
+++ b/src/main.c
@@ -61,7 +61,7 @@ int main(int argc, char *argv[]) {
     return 1;
   }
 
-  const int ret = run(argv[1], false);
+  const int ret = run(argv[1], true);
   fileDelete();
   return ret;
 }
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 756d333..5362729 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -13,9 +13,9 @@
                                       ->metadata)
 
 #define doOperationFloat(op0, op1, operator, originalType, type)               \
-  (op0)->metadata =                                                            \
-      (void *)(u64)((type) * (originalType *)(op0)->metadata operator(type) *  \
-                    (originalType *)(op1)->metadata)
+  *((originalType *)(op0)->metadata) =                                         \
+      (originalType)((type) * (originalType *)(op0)->metadata operator(type) * \
+                     (originalType *)(op1)->metadata)
 
 #define doLogicalOperation(op0, op1, operator, originalType, _type)            \
   {                                                                            \
@@ -44,81 +44,6 @@
   *((originalType *)(op0)->metadata) = operator(                               \
       (type) * (originalType *)(op0)->metadata)
 
-#define doAllOperationsInt(op0, op1, operator, originalType, type)             \
-  switch (operator) {                                                          \
-  case AST_TREE_TOKEN_OPERATOR_SUM:                                            \
-    doOperation(op0, op1, +, originalType, type);                              \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SUB:                                            \
-    doOperation(op0, op1, -, originalType, type);                              \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_MULTIPLY:                                       \
-    doOperation(op0, op1, *, originalType, type);                              \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_DIVIDE:                                         \
-    doOperation(op0, op1, /, originalType, type);                              \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_MODULO:                                         \
-    doOperation(op0, op1, %, originalType, type);                              \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_EQUAL:                                          \
-    doLogicalOperation(op0, op1, ==, originalType, type);                      \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL:                                      \
-    doLogicalOperation(op0, op1, !=, originalType, type);                      \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_GREATER:                                        \
-    doLogicalOperation(op0, op1, >, originalType, type);                       \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:                               \
-    doLogicalOperation(op0, op1, >=, originalType, type);                      \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SMALLER:                                        \
-    doLogicalOperation(op0, op1, <, originalType, type);                       \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL:                               \
-    doLogicalOperation(op0, op1, <=, originalType, type);                      \
-    break;                                                                     \
-  default:                                                                     \
-    UNREACHABLE;                                                               \
-  }
-
-#define doAllOperationsFloat(op0, op1, operator, originalType, type)           \
-  switch (operator) {                                                          \
-  case AST_TREE_TOKEN_OPERATOR_SUM:                                            \
-    doOperationFloat(op0, op1, +, originalType, type);                         \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SUB:                                            \
-    doOperationFloat(op0, op1, -, originalType, type);                         \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_MULTIPLY:                                       \
-    doOperationFloat(op0, op1, *, originalType, type);                         \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_DIVIDE:                                         \
-    doOperationFloat(op0, op1, /, originalType, type);                         \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_EQUAL:                                          \
-    doLogicalOperationFloat(op0, op1, ==, originalType, type);                 \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL:                                      \
-    doLogicalOperationFloat(op0, op1, !=, originalType, type);                 \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_GREATER:                                        \
-    doLogicalOperationFloat(op0, op1, >, originalType, type);                  \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:                               \
-    doLogicalOperationFloat(op0, op1, >=, originalType, type);                 \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SMALLER:                                        \
-    doLogicalOperationFloat(op0, op1, <, originalType, type);                  \
-    break;                                                                     \
-  case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL:                               \
-    doLogicalOperationFloat(op0, op1, <=, originalType, type);                 \
-    break;                                                                     \
-  default:                                                                     \
-    UNREACHABLE;                                                               \
-  }
-
 void runnerVariablesDelete(RunnerVariables *variables) {
   for (size_t i = 0; i < variables->size; ++i) {
     if (variables->data[i]->value != NULL) {
@@ -438,7 +363,7 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     } else if (operand->type == &AST_TREE_F16_TYPE) {
       doLeftOperationFloat(operand, +, AstTreeFloat, f16);
     } else {
-      UNREACHABLE;
+      printError(expr->str_begin, expr->str_end, "Not supported");
     }
     return operand;
   }
@@ -469,62 +394,500 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     } else if (operand->type == &AST_TREE_F16_TYPE) {
       doLeftOperationFloat(operand, -, AstTreeFloat, f16);
     } else {
-      UNREACHABLE;
+      printError(expr->str_begin, expr->str_end, "Not supported");
     }
     return operand;
   }
-  case AST_TREE_TOKEN_OPERATOR_SUM:
-  case AST_TREE_TOKEN_OPERATOR_SUB:
-  case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
-  case AST_TREE_TOKEN_OPERATOR_DIVIDE:
-  case AST_TREE_TOKEN_OPERATOR_MODULO:
-  case AST_TREE_TOKEN_OPERATOR_EQUAL:
-  case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL:
-  case AST_TREE_TOKEN_OPERATOR_GREATER:
-  case AST_TREE_TOKEN_OPERATOR_SMALLER:
-  case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
+  case AST_TREE_TOKEN_OPERATOR_SUM: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, +, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, +, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, +, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, +, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, +, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, +, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, +, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, +, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, +, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, +, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, +, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, +, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_SUB: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, -, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, -, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, -, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, -, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, -, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, -, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, -, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, -, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, -, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, -, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, -, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, -, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_MULTIPLY: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, *, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, *, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, *, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, *, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, *, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, *, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, *, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, *, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, *, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, *, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, *, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, *, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_DIVIDE: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, /, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, /, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, /, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, /, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, /, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, /, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, /, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, /, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, /, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, /, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, /, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, /, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_MODULO: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, %, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, %, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, %, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, %, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, %, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, %, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, %, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, %, AstTreeInt, i8);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_EQUAL: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, ==, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, ==, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, ==, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, ==, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, ==, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, !=, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, !=, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, !=, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, !=, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, !=, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_GREATER: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, >, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, >, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, >, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, >, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, >, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, >, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, >, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, >, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, >, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, >, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, >, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, >, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_SMALLER: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, <, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, <, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, <, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, <, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, <, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, <, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, <, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, <, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, <, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, <, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, <, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, <, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL: {
+    AstTreeInfix *metadata = expr->metadata;
+    AstTree *left = runExpression(&metadata->left, pages);
+    AstTree *right = runExpression(&metadata->right, pages);
+
+    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, u64);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doOperation(left, right, >=, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doOperationFloat(left, right, >=, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doOperationFloat(left, right, >=, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doOperationFloat(left, right, >=, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doOperationFloat(left, right, >=, AstTreeFloat, f16);
+    } else {
+      printError(expr->str_begin, expr->str_end, "Not supported");
+    }
+    astTreeDelete(right);
+    return left;
+  }
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: {
     AstTreeInfix *metadata = expr->metadata;
     AstTree *left = runExpression(&metadata->left, pages);
     AstTree *right = runExpression(&metadata->right, pages);
 
     if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, u64);
+      doOperation(left, right, <=, AstTreeInt, u64);
     } else if (left->type == &AST_TREE_I64_TYPE &&
                right->type == &AST_TREE_I64_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, i64);
+      doOperation(left, right, <=, AstTreeInt, i64);
     } else if (left->type == &AST_TREE_U32_TYPE &&
                right->type == &AST_TREE_U32_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, u32);
+      doOperation(left, right, <=, AstTreeInt, u32);
     } else if (left->type == &AST_TREE_I32_TYPE &&
                right->type == &AST_TREE_I32_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, i32);
+      doOperation(left, right, <=, AstTreeInt, i32);
     } else if (left->type == &AST_TREE_U16_TYPE &&
                right->type == &AST_TREE_U16_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, u16);
+      doOperation(left, right, <=, AstTreeInt, u16);
     } else if (left->type == &AST_TREE_I16_TYPE &&
                right->type == &AST_TREE_I16_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, i16);
+      doOperation(left, right, <=, AstTreeInt, i16);
     } else if (left->type == &AST_TREE_U8_TYPE &&
                right->type == &AST_TREE_U8_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, u8);
+      doOperation(left, right, <=, AstTreeInt, u8);
     } else if (left->type == &AST_TREE_I8_TYPE &&
                right->type == &AST_TREE_I8_TYPE) {
-      doAllOperationsInt(left, right, expr->token, AstTreeInt, i8);
+      doOperation(left, right, <=, AstTreeInt, i8);
     } else if (left->type == &AST_TREE_F128_TYPE &&
                right->type == &AST_TREE_F128_TYPE) {
-      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f128);
+      doOperationFloat(left, right, <=, AstTreeFloat, f128);
     } else if (left->type == &AST_TREE_F64_TYPE &&
                right->type == &AST_TREE_F64_TYPE) {
-      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f64);
+      doOperationFloat(left, right, <=, AstTreeFloat, f64);
     } else if (left->type == &AST_TREE_F32_TYPE &&
                right->type == &AST_TREE_F32_TYPE) {
-      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f32);
+      doOperationFloat(left, right, <=, AstTreeFloat, f32);
     } else if (left->type == &AST_TREE_F16_TYPE &&
                right->type == &AST_TREE_F16_TYPE) {
-      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f16);
+      doOperationFloat(left, right, <=, AstTreeFloat, f16);
     } else {
-      UNREACHABLE;
+      printError(expr->str_begin, expr->str_end, "Not supported");
     }
     astTreeDelete(right);
     return left;
@@ -552,7 +915,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     return copyAstTree(expr);
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *variable = expr->metadata;
-    return runExpression(runnerVariableGetValue(pages, variable), pages);
+    AstTree *value = runnerVariableGetValue(pages, variable);
+    return runExpression(value, pages);
   }
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_NONE:
diff --git a/src/utils/string.c b/src/utils/string.c
index ee8a354..17e27cd 100644
--- a/src/utils/string.c
+++ b/src/utils/string.c
@@ -3,6 +3,7 @@
 #include "utils/type.h"
 
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 
 size_t searchInStringArray(const char *array[], size_t array_size,
@@ -34,8 +35,8 @@ u64 decimalToU64(char *str_begin, char *str_end, bool *success) {
 }
 
 f128 numberToFloat(char *str_begin, char *str_end, bool *success) {
-  f64 left = 0;
-  f64 right = 0;
+  f128 left = 0;
+  f128 right = 0;
   bool isPastPoint = false;
 
   while (str_begin < str_end) {
@@ -46,12 +47,12 @@ f128 numberToFloat(char *str_begin, char *str_end, bool *success) {
       c = *str_begin++;
     }
     if (c >= '0' && c <= '9') {
-      if (isPastPoint) {
+      if (!isPastPoint) {
         left *= 10;
         left += c - '0';
       } else {
-        right /= 10;
         right += c - '0';
+        right /= 10;
       }
     } else if (c == '.' && !isPastPoint) {
       isPastPoint = true;
diff --git a/test/main.felan b/test/main.felan
index 5f19b06..fa275e4 100644
--- a/test/main.felan
+++ b/test/main.felan
@@ -1,7 +1,18 @@
 main :: () -> void {
   a := 2.3;
-  if a == 2.3
-    print_u64 1;
+  a /= 2.5;
+ print_u64 (if a == 1.15
+    1
   else
-    print_u64 2;
+    2);
+  // test(u64,i64);
 };
+
+/*
+test :: (from:type, to:type) -> void {
+  if from == to
+    print_u64 1234;
+  else
+    print_u64 4321;
+};
+*/