some clean up

4 files changed, 155 insertions, 173 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 23da5de..4153d0d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -210,6 +210,10 @@ void astTreePrint(const AstTree *tree, int indent) {
   case AST_TREE_TOKEN_TYPE_U32:
   case AST_TREE_TOKEN_TYPE_I64:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F16:
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
   case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
@@ -241,6 +245,11 @@ void astTreePrint(const AstTree *tree, int indent) {
     printf(",value=%lu", metadata);
   }
     goto RETURN_SUCCESS;
+  case AST_TREE_TOKEN_VALUE_FLOAT: {
+    AstTreeFloat *metadata = (AstTreeFloat *)tree->metadata;
+    printf(",value=%Lf", *metadata);
+  }
+    goto RETURN_SUCCESS;
   case AST_TREE_TOKEN_VALUE_BOOL: {
     AstTreeBool metadata = (AstTreeBool)tree->metadata;
     printf(",value=%b", metadata);
@@ -811,6 +820,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     switch (node_metadata->value->token) {
     case PARSER_TOKEN_VALUE_BOOL:
     case PARSER_TOKEN_VALUE_INT:
+    case PARSER_TOKEN_VALUE_FLOAT:
     case PARSER_TOKEN_FUNCTION_DEFINITION:
     case PARSER_TOKEN_FUNCTION_CALL:
     case PARSER_TOKEN_IDENTIFIER:
@@ -842,6 +852,10 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     case PARSER_TOKEN_TYPE_U32:
     case PARSER_TOKEN_TYPE_I64:
     case PARSER_TOKEN_TYPE_U64:
+    case PARSER_TOKEN_TYPE_F16:
+    case PARSER_TOKEN_TYPE_F32:
+    case PARSER_TOKEN_TYPE_F64:
+    case PARSER_TOKEN_TYPE_F128:
     case PARSER_TOKEN_TYPE_BOOL:
       goto AFTER_SWITCH;
     case PARSER_TOKEN_ROOT:
@@ -1169,6 +1183,7 @@ AstTree *astTreeParseFunction(ParserNode *parserNode, AstTreeHelper *p_helper) {
     case PARSER_TOKEN_ROOT:
     case PARSER_TOKEN_IDENTIFIER:
     case PARSER_TOKEN_VALUE_INT:
+    case PARSER_TOKEN_VALUE_FLOAT:
     case PARSER_TOKEN_VALUE_BOOL:
     case PARSER_TOKEN_TYPE_TYPE:
     case PARSER_TOKEN_TYPE_FUNCTION:
@@ -1181,6 +1196,10 @@ AstTree *astTreeParseFunction(ParserNode *parserNode, AstTreeHelper *p_helper) {
     case PARSER_TOKEN_TYPE_U32:
     case PARSER_TOKEN_TYPE_I64:
     case PARSER_TOKEN_TYPE_U64:
+    case PARSER_TOKEN_TYPE_F16:
+    case PARSER_TOKEN_TYPE_F32:
+    case PARSER_TOKEN_TYPE_F64:
+    case PARSER_TOKEN_TYPE_F128:
     case PARSER_TOKEN_TYPE_BOOL:
     case PARSER_TOKEN_KEYWORD_PRINT_U64:
     case PARSER_TOKEN_KEYWORD_RETURN:
@@ -1601,10 +1620,12 @@ AstTree *astTreeParseCurlyBracket(ParserNode *parserNode,
       node = (ParserNodeSingleChildMetadata *)node->metadata;
       goto OK_NODE;
     case PARSER_TOKEN_KEYWORD_IF:
+    case PARSER_TOKEN_KEYWORD_WHILE:
       goto OK_NODE;
     case PARSER_TOKEN_ROOT:
     case PARSER_TOKEN_IDENTIFIER:
     case PARSER_TOKEN_VALUE_INT:
+    case PARSER_TOKEN_VALUE_FLOAT:
     case PARSER_TOKEN_VALUE_BOOL:
     case PARSER_TOKEN_TYPE_TYPE:
     case PARSER_TOKEN_TYPE_FUNCTION:
@@ -1617,6 +1638,10 @@ AstTree *astTreeParseCurlyBracket(ParserNode *parserNode,
     case PARSER_TOKEN_TYPE_U32:
     case PARSER_TOKEN_TYPE_I64:
     case PARSER_TOKEN_TYPE_U64:
+    case PARSER_TOKEN_TYPE_F16:
+    case PARSER_TOKEN_TYPE_F32:
+    case PARSER_TOKEN_TYPE_F64:
+    case PARSER_TOKEN_TYPE_F128:
     case PARSER_TOKEN_TYPE_BOOL:
     case PARSER_TOKEN_KEYWORD_PRINT_U64:
     case PARSER_TOKEN_KEYWORD_RETURN:
@@ -1725,6 +1750,10 @@ AstTreeFunction *getFunction(AstTree *value) {
   case AST_TREE_TOKEN_TYPE_U32:
   case AST_TREE_TOKEN_TYPE_I64:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F16:
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
   case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VALUE_INT:
@@ -1745,6 +1774,8 @@ AstTreeFunction *getFunction(AstTree *value) {
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL:
   case AST_TREE_TOKEN_SCOPE:
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
+  case AST_TREE_TOKEN_VALUE_FLOAT:
     return NULL;
   case AST_TREE_TOKEN_NONE:
   }
@@ -1764,9 +1795,14 @@ bool isConst(AstTree *tree, AstTreeHelper *helper) {
   case AST_TREE_TOKEN_TYPE_U32:
   case AST_TREE_TOKEN_TYPE_I64:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F16:
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
   case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VALUE_INT:
+  case AST_TREE_TOKEN_VALUE_FLOAT:
   case AST_TREE_TOKEN_VALUE_BOOL:
     return true;
   case AST_TREE_TOKEN_KEYWORD_IF: {
@@ -1787,6 +1823,7 @@ bool isConst(AstTree *tree, AstTreeHelper *helper) {
   case AST_TREE_TOKEN_FUNCTION: {
     return true;
   }
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
@@ -1828,6 +1865,10 @@ AstTree *makeTypeOf(AstTree *value) {
   case AST_TREE_TOKEN_TYPE_U32:
   case AST_TREE_TOKEN_TYPE_I64:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F16:
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
   case AST_TREE_TOKEN_TYPE_BOOL:
     return &AST_TREE_TYPE_TYPE;
   case AST_TREE_TOKEN_FUNCTION_CALL: {
@@ -1856,6 +1897,8 @@ AstTree *makeTypeOf(AstTree *value) {
     return &AST_TREE_VOID_TYPE;
   case AST_TREE_TOKEN_VALUE_INT:
     return &AST_TREE_U64_TYPE;
+  case AST_TREE_TOKEN_VALUE_FLOAT:
+    return &AST_TREE_F128_TYPE;
   case AST_TREE_TOKEN_VALUE_BOOL:
     return &AST_TREE_BOOL_TYPE;
   case AST_TREE_TOKEN_VARIABLE: {
@@ -1888,6 +1931,7 @@ AstTree *makeTypeOf(AstTree *value) {
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_IF:
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
   case AST_TREE_TOKEN_SCOPE:
   case AST_TREE_TOKEN_NONE:
   }
@@ -1900,6 +1944,7 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_IF:
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VALUE_INT:
   case AST_TREE_TOKEN_VALUE_FLOAT:
@@ -1958,7 +2003,6 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
     return type1->token == AST_TREE_TOKEN_VARIABLE &&
            type0->metadata == type1->metadata;
   case AST_TREE_TOKEN_NONE:
-    break;
   }
   UNREACHABLE;
 }
@@ -1989,18 +2033,8 @@ AstTree *getValue(AstTree *tree, AstTreeSetTypesHelper helper) {
   case AST_TREE_TOKEN_VALUE_INT:
   case AST_TREE_TOKEN_VALUE_FLOAT:
   case AST_TREE_TOKEN_VALUE_BOOL:
-    return copyAstTree(tree);
-  case AST_TREE_TOKEN_VARIABLE: {
-    AstTreeVariable *metadata = tree->metadata;
-    return getValue(metadata->value, helper);
-  }
-  case AST_TREE_TOKEN_FUNCTION_CALL: {
-    AstTree *value = runExpression(tree, helper.pages);
-    if (value == NULL) {
-      printError(tree->str_begin, tree->str_end, "Unknown error");
-    }
-    return value;
-  }
+  case AST_TREE_TOKEN_VARIABLE:
+  case AST_TREE_TOKEN_FUNCTION_CALL:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
   case AST_TREE_TOKEN_OPERATOR_MINUS:
@@ -2015,7 +2049,7 @@ AstTree *getValue(AstTree *tree, AstTreeSetTypesHelper helper) {
   case AST_TREE_TOKEN_OPERATOR_SMALLER:
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: {
-    AstTree *value = calcAstTreeValue(tree, helper.pages);
+    AstTree *value = runExpression(tree, helper.pages);
     if (value == NULL) {
       printError(tree->str_begin, tree->str_end, "Unknown error");
     }
@@ -2690,20 +2724,24 @@ bool setTypesAstInfix(AstTreeInfix *infix, AstTreeSetTypesHelper helper) {
 
 size_t astTreeTypeSize(AstTree tree) {
   switch (tree.token) {
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_TYPE_I8:
   case AST_TREE_TOKEN_TYPE_U8:
     return 1;
   case AST_TREE_TOKEN_TYPE_I16:
   case AST_TREE_TOKEN_TYPE_U16:
+  case AST_TREE_TOKEN_TYPE_F16:
     return 2;
   case AST_TREE_TOKEN_TYPE_I32:
   case AST_TREE_TOKEN_TYPE_U32:
+  case AST_TREE_TOKEN_TYPE_F32:
     return 4;
   case AST_TREE_TOKEN_TYPE_I64:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F64:
     return 8;
-  case AST_TREE_TOKEN_TYPE_BOOL:
-    return 1;
+  case AST_TREE_TOKEN_TYPE_F128:
+    return 16;
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
@@ -2715,6 +2753,7 @@ size_t astTreeTypeSize(AstTree tree) {
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_VALUE_VOID:
   case AST_TREE_TOKEN_VALUE_INT:
+  case AST_TREE_TOKEN_VALUE_FLOAT:
   case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_PLUS:
@@ -2731,6 +2770,7 @@ size_t astTreeTypeSize(AstTree tree) {
   case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL:
   case AST_TREE_TOKEN_KEYWORD_IF:
+  case AST_TREE_TOKEN_KEYWORD_WHILE:
   case AST_TREE_TOKEN_SCOPE:
   case AST_TREE_TOKEN_NONE:
   }
diff --git a/src/main.c b/src/main.c
index 8e8bf3f..58e92bf 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-static int compileRun(const char *filePath, const char *outFilePath,
+int compileRun(const char *filePath, const char *outFilePath,
                       bool print) {
   char *code = readWholeFile(filePath);
 
@@ -93,7 +93,7 @@ int runWithoutRead(char *code, bool shouldPrint) {
   return ret;
 }
 
-static int run(const char *filePath, bool shouldPrint) {
+int run(const char *filePath, bool shouldPrint) {
   char *code = readWholeFile(filePath);
 
   if (code == NULL) {
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 05883f1..a1a1f44 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -266,7 +266,7 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
 
   for (size_t i = 0; i < arguments_size; ++i) {
     AstTreeVariable *variable = function->arguments.data[i];
-    AstTree *value = calcAstTreeValue(arguments[i], &pages);
+    AstTree *value = runExpression(arguments[i], &pages);
     runnerVariablePush(pages.data[pages.size - 1], variable);
     runnerVariableSetValue(&pages, variable, value);
   }
@@ -301,24 +301,28 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   switch (expr->token) {
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64: {
     AstTreeSingleChild *metadata = expr->metadata;
-    AstTree *tree = calcAstTreeValue(metadata, pages);
+    AstTree *tree = runExpression(metadata, pages);
     printf("%lu", (AstTreeInt)tree->metadata);
     astTreeDelete(tree);
   }
     return NULL;
   case AST_TREE_TOKEN_FUNCTION_CALL: {
-    AstTree *ret = calcAstTreeValue(expr, pages);
-    if (ret != &AST_TREE_VOID_VALUE) {
-      astTreeDelete(ret);
+    AstTreeFunctionCall *metadata = expr->metadata;
+    if (metadata->function->token == AST_TREE_TOKEN_VARIABLE) {
+      AstTreeVariable *variable = metadata->function->metadata;
+      return runAstTreeFunction(runnerVariableGetValue(pages, variable),
+                                metadata->parameters, metadata->parameters_size,
+                                pages);
+    } else {
+      UNREACHABLE;
     }
-    return ret;
   }
   case AST_TREE_TOKEN_OPERATOR_ASSIGN: {
     AstTreeInfix *metadata = expr->metadata;
     if (metadata->left.token == AST_TREE_TOKEN_VARIABLE) {
       AstTreeVariable *left = metadata->left.metadata;
       runnerVariableSetValue(pages, left,
-                             calcAstTreeValue(&metadata->right, pages));
+                             runExpression(&metadata->right, pages));
     } else {
       UNREACHABLE;
     }
@@ -327,7 +331,7 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
   case AST_TREE_TOKEN_KEYWORD_RETURN: {
     AstTreeReturn *metadata = expr->metadata;
     if (metadata->value != NULL) {
-      return calcAstTreeValue(metadata->value, pages);
+      return runExpression(metadata->value, pages);
     } else {
       return &AST_TREE_VOID_VALUE;
     }
@@ -339,7 +343,7 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     return NULL;
   case AST_TREE_TOKEN_KEYWORD_IF: {
     AstTreeIf *metadata = expr->metadata;
-    AstTree *tree = calcAstTreeValue(metadata->condition, pages);
+    AstTree *tree = runExpression(metadata->condition, pages);
     AstTree *ret;
     if ((AstTreeBool)tree->metadata) {
       ret = runExpression(metadata->ifBody, pages);
@@ -353,7 +357,7 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     AstTreeWhile *metadata = expr->metadata;
     AstTree *ret = NULL;
     while (true) {
-      AstTree *tree = calcAstTreeValue(metadata->condition, pages);
+      AstTree *tree = runExpression(metadata->condition, pages);
       bool conti = (AstTreeBool)tree->metadata;
       astTreeDelete(tree);
       if (!conti) {
@@ -403,142 +407,8 @@ AstTree *runExpression(AstTree *expr, RunnerVariablePages *pages) {
     return ret;
   }
     return NULL;
-  case AST_TREE_TOKEN_OPERATOR_PLUS:
-  case AST_TREE_TOKEN_OPERATOR_MINUS:
-  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_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_FUNCTION:
-  case AST_TREE_TOKEN_TYPE_TYPE:
-  case AST_TREE_TOKEN_TYPE_FUNCTION:
-  case AST_TREE_TOKEN_TYPE_VOID:
-  case AST_TREE_TOKEN_TYPE_BOOL:
-  case AST_TREE_TOKEN_TYPE_I8:
-  case AST_TREE_TOKEN_TYPE_U8:
-  case AST_TREE_TOKEN_TYPE_I16:
-  case AST_TREE_TOKEN_TYPE_U16:
-  case AST_TREE_TOKEN_TYPE_I32:
-  case AST_TREE_TOKEN_TYPE_U32:
-  case AST_TREE_TOKEN_TYPE_I64:
-  case AST_TREE_TOKEN_TYPE_U64:
-  case AST_TREE_TOKEN_TYPE_F16:
-  case AST_TREE_TOKEN_TYPE_F32:
-  case AST_TREE_TOKEN_TYPE_F64:
-  case AST_TREE_TOKEN_TYPE_F128:
-  case AST_TREE_TOKEN_VARIABLE:
-  case AST_TREE_TOKEN_VALUE_VOID:
-  case AST_TREE_TOKEN_VALUE_INT:
-  case AST_TREE_TOKEN_VALUE_FLOAT:
-  case AST_TREE_TOKEN_VALUE_BOOL:
-  case AST_TREE_TOKEN_NONE:
-  }
-  UNREACHABLE;
-}
-
-AstTree *calcAstTreeValue(AstTree *tree, RunnerVariablePages *pages) {
-  switch (tree->token) {
-  case AST_TREE_TOKEN_TYPE_TYPE:
-  case AST_TREE_TOKEN_TYPE_FUNCTION:
-  case AST_TREE_TOKEN_TYPE_VOID:
-  case AST_TREE_TOKEN_TYPE_BOOL:
-  case AST_TREE_TOKEN_TYPE_I8:
-  case AST_TREE_TOKEN_TYPE_U8:
-  case AST_TREE_TOKEN_TYPE_I16:
-  case AST_TREE_TOKEN_TYPE_U16:
-  case AST_TREE_TOKEN_TYPE_I32:
-  case AST_TREE_TOKEN_TYPE_U32:
-  case AST_TREE_TOKEN_TYPE_I64:
-  case AST_TREE_TOKEN_TYPE_U64:
-  case AST_TREE_TOKEN_TYPE_F16:
-  case AST_TREE_TOKEN_TYPE_F32:
-  case AST_TREE_TOKEN_TYPE_F64:
-  case AST_TREE_TOKEN_TYPE_F128:
-  case AST_TREE_TOKEN_VALUE_VOID:
-  case AST_TREE_TOKEN_VALUE_INT:
-  case AST_TREE_TOKEN_VALUE_BOOL:
-  case AST_TREE_TOKEN_VALUE_FLOAT:
-    return copyAstTree(tree);
-  case AST_TREE_TOKEN_VARIABLE: {
-    AstTreeVariable *variable = tree->metadata;
-    return calcAstTreeValue(runnerVariableGetValue(pages, variable), pages);
-  }
-  case AST_TREE_TOKEN_FUNCTION_CALL: {
-    AstTreeFunctionCall *metadata = tree->metadata;
-    if (metadata->function->token == AST_TREE_TOKEN_VARIABLE) {
-      AstTreeVariable *variable = metadata->function->metadata;
-      return runAstTreeFunction(runnerVariableGetValue(pages, variable),
-                                metadata->parameters, metadata->parameters_size,
-                                pages);
-    } else {
-      UNREACHABLE;
-    }
-  }
-  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_SMALLER_OR_EQUAL: {
-    AstTreeInfix *metadata = tree->metadata;
-    AstTree *left = calcAstTreeValue(&metadata->left, pages);
-    AstTree *right = calcAstTreeValue(&metadata->right, pages);
-
-    if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, u64);
-    } else if (left->type == &AST_TREE_I64_TYPE &&
-               right->type == &AST_TREE_I64_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, i64);
-    } else if (left->type == &AST_TREE_U32_TYPE &&
-               right->type == &AST_TREE_U32_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, u32);
-    } else if (left->type == &AST_TREE_I32_TYPE &&
-               right->type == &AST_TREE_I32_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, i32);
-    } else if (left->type == &AST_TREE_U16_TYPE &&
-               right->type == &AST_TREE_U16_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, u16);
-    } else if (left->type == &AST_TREE_I16_TYPE &&
-               right->type == &AST_TREE_I16_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, i16);
-    } else if (left->type == &AST_TREE_U8_TYPE &&
-               right->type == &AST_TREE_U8_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, u8);
-    } else if (left->type == &AST_TREE_I8_TYPE &&
-               right->type == &AST_TREE_I8_TYPE) {
-      doAllOperationsInt(left, right, tree->token, AstTreeInt, i8);
-    } else if (left->type == &AST_TREE_F128_TYPE &&
-               right->type == &AST_TREE_F128_TYPE) {
-      doAllOperationsFloat(left, right, tree->token, AstTreeFloat, f128);
-    } else if (left->type == &AST_TREE_F64_TYPE &&
-               right->type == &AST_TREE_F64_TYPE) {
-      doAllOperationsFloat(left, right, tree->token, AstTreeFloat, f64);
-    } else if (left->type == &AST_TREE_F32_TYPE &&
-               right->type == &AST_TREE_F32_TYPE) {
-      doAllOperationsFloat(left, right, tree->token, AstTreeFloat, f32);
-    } else if (left->type == &AST_TREE_F16_TYPE &&
-               right->type == &AST_TREE_F16_TYPE) {
-      doAllOperationsFloat(left, right, tree->token, AstTreeFloat, f16);
-    } else {
-      UNREACHABLE;
-    }
-    astTreeDelete(right);
-    return left;
-  }
   case AST_TREE_TOKEN_OPERATOR_PLUS: {
-    AstTreeSingleChild *operand = calcAstTreeValue(tree->metadata, pages);
+    AstTreeSingleChild *operand = runExpression(expr->metadata, pages);
     if (operand->type == &AST_TREE_U64_TYPE) {
       doLeftOperation(operand, +, AstTreeInt, u64);
     } else if (operand->type == &AST_TREE_I64_TYPE) {
@@ -569,7 +439,7 @@ AstTree *calcAstTreeValue(AstTree *tree, RunnerVariablePages *pages) {
     return operand;
   }
   case AST_TREE_TOKEN_OPERATOR_MINUS: {
-    AstTreeSingleChild *operand = calcAstTreeValue(tree->metadata, pages);
+    AstTreeSingleChild *operand = runExpression(expr->metadata, pages);
     if (operand->type == &AST_TREE_U64_TYPE) {
       doLeftOperation(operand, -, AstTreeInt, u64);
     } else if (operand->type == &AST_TREE_I64_TYPE) {
@@ -599,13 +469,88 @@ AstTree *calcAstTreeValue(AstTree *tree, RunnerVariablePages *pages) {
     }
     return operand;
   }
-  case AST_TREE_TOKEN_KEYWORD_IF:
+  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_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);
+    } else if (left->type == &AST_TREE_I64_TYPE &&
+               right->type == &AST_TREE_I64_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, i64);
+    } else if (left->type == &AST_TREE_U32_TYPE &&
+               right->type == &AST_TREE_U32_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, u32);
+    } else if (left->type == &AST_TREE_I32_TYPE &&
+               right->type == &AST_TREE_I32_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, i32);
+    } else if (left->type == &AST_TREE_U16_TYPE &&
+               right->type == &AST_TREE_U16_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, u16);
+    } else if (left->type == &AST_TREE_I16_TYPE &&
+               right->type == &AST_TREE_I16_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, i16);
+    } else if (left->type == &AST_TREE_U8_TYPE &&
+               right->type == &AST_TREE_U8_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, u8);
+    } else if (left->type == &AST_TREE_I8_TYPE &&
+               right->type == &AST_TREE_I8_TYPE) {
+      doAllOperationsInt(left, right, expr->token, AstTreeInt, i8);
+    } else if (left->type == &AST_TREE_F128_TYPE &&
+               right->type == &AST_TREE_F128_TYPE) {
+      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f128);
+    } else if (left->type == &AST_TREE_F64_TYPE &&
+               right->type == &AST_TREE_F64_TYPE) {
+      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f64);
+    } else if (left->type == &AST_TREE_F32_TYPE &&
+               right->type == &AST_TREE_F32_TYPE) {
+      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f32);
+    } else if (left->type == &AST_TREE_F16_TYPE &&
+               right->type == &AST_TREE_F16_TYPE) {
+      doAllOperationsFloat(left, right, expr->token, AstTreeFloat, f16);
+    } else {
+      UNREACHABLE;
+    }
+    astTreeDelete(right);
+    return left;
+  }
+  case AST_TREE_TOKEN_TYPE_TYPE:
+  case AST_TREE_TOKEN_TYPE_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_VOID:
+  case AST_TREE_TOKEN_TYPE_BOOL:
+  case AST_TREE_TOKEN_TYPE_I8:
+  case AST_TREE_TOKEN_TYPE_U8:
+  case AST_TREE_TOKEN_TYPE_I16:
+  case AST_TREE_TOKEN_TYPE_U16:
+  case AST_TREE_TOKEN_TYPE_I32:
+  case AST_TREE_TOKEN_TYPE_U32:
+  case AST_TREE_TOKEN_TYPE_I64:
+  case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_F16:
+  case AST_TREE_TOKEN_TYPE_F32:
+  case AST_TREE_TOKEN_TYPE_F64:
+  case AST_TREE_TOKEN_TYPE_F128:
+  case AST_TREE_TOKEN_VALUE_VOID:
+  case AST_TREE_TOKEN_VALUE_INT:
+  case AST_TREE_TOKEN_VALUE_BOOL:
+  case AST_TREE_TOKEN_VALUE_FLOAT:
+    return copyAstTree(expr);
+  case AST_TREE_TOKEN_VARIABLE: {
+    AstTreeVariable *variable = expr->metadata;
+    return runExpression(runnerVariableGetValue(pages, variable), pages);
+  }
   case AST_TREE_TOKEN_FUNCTION:
-  case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
-  case AST_TREE_TOKEN_KEYWORD_RETURN:
-  case AST_TREE_TOKEN_VARIABLE_DEFINE:
-  case AST_TREE_TOKEN_OPERATOR_ASSIGN:
-  case AST_TREE_TOKEN_SCOPE:
   case AST_TREE_TOKEN_NONE:
   }
   UNREACHABLE;
diff --git a/src/runner/runner.h b/src/runner/runner.h
index 02fd01e..6fb0b36 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -33,6 +33,3 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments,
                             size_t arguments_size,RunnerVariablePages *pages);
 
 AstTree* runExpression(AstTree *expr,RunnerVariablePages *pages);
-
-AstTree *calcAstTreeValue(AstTree *tree,RunnerVariablePages *pages);
-AstTree *deepCopyAstTree(AstTree *tree);