From 2316751587cf3998112f4e076b5b33080ce66124 Mon Sep 17 00:00:00 2001 From: A404M Date: Sat, 29 Mar 2025 20:05:54 +0330 Subject: fix bug in conditions --- code/main.felan | 12 +-- src/compiler/ast-tree.c | 33 +++++-- src/compiler/ast-tree.h | 1 + src/compiler/parser.c | 21 +++-- src/main.c | 2 +- src/runner/runner.c | 243 ++++++++++++++++++++++-------------------------- 6 files changed, 155 insertions(+), 157 deletions(-) diff --git a/code/main.felan b/code/main.felan index 07500ac..e91185a 100644 --- a/code/main.felan +++ b/code/main.felan @@ -7,12 +7,8 @@ double :: f64; main :: () -> void { a : int = 2; -}; - -foo :: (a:u64)->void{ - a = 4; -}; - -bar :: (a:*u64)->void{ - a.* = 5; + if a == 2 + print_u64 1; + else + print_u64 0; }; diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index 3963e77..2f9c27c 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -260,8 +260,8 @@ void astTreePrint(const AstTree *tree, int indent) { } goto RETURN_SUCCESS; case AST_TREE_TOKEN_VALUE_BOOL: { - AstTreeBool metadata = (AstTreeBool)tree->metadata; - printf(",value=%b", metadata); + AstTreeBool *metadata = tree->metadata; + printf(",value=%b", *metadata); } goto RETURN_SUCCESS; case AST_TREE_TOKEN_TYPE_FUNCTION: { @@ -457,9 +457,13 @@ void astTreeDestroy(AstTree tree) { case AST_TREE_TOKEN_TYPE_BOOL: case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_VOID: - case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_VARIABLE_DEFINE: return; + case AST_TREE_TOKEN_VALUE_BOOL: { + AstTreeBool *metadata = tree.metadata; + free(metadata); + return; + } case AST_TREE_TOKEN_VALUE_INT: { AstTreeInt *metadata = tree.metadata; free(metadata); @@ -642,9 +646,13 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], tree->token, NULL, copyAstTreeBack(tree->type, oldVariables, newVariables, variables_size), tree->str_begin, tree->str_end); - case AST_TREE_TOKEN_VALUE_BOOL: - return newAstTree(tree->token, tree->metadata, tree->type, tree->str_begin, + case AST_TREE_TOKEN_VALUE_BOOL: { + AstTreeBool *metadata = tree->metadata; + AstTreeBool *newMetadata = a404m_malloc(sizeof(*newMetadata)); + *newMetadata = *metadata; + return newAstTree(tree->token, newMetadata, tree->type, tree->str_begin, tree->str_end); + } case AST_TREE_TOKEN_VALUE_INT: { AstTreeInt *metadata = tree->metadata; AstTreeInt *newMetadata = a404m_malloc(sizeof(*newMetadata)); @@ -1219,10 +1227,8 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeHelper *helper) { return astTreeParseValue(parserNode, AST_TREE_TOKEN_VALUE_FLOAT, sizeof(AstTreeFloat)); case PARSER_TOKEN_VALUE_BOOL: - return newAstTree( - AST_TREE_TOKEN_VALUE_BOOL, - (void *)(AstTreeBool)(ParserNodeBoolMetadata)parserNode->metadata, - &AST_TREE_BOOL_TYPE, parserNode->str_begin, parserNode->str_end); + return astTreeParseValue(parserNode, AST_TREE_TOKEN_VALUE_BOOL, + sizeof(AstTreeBool)); case PARSER_TOKEN_KEYWORD_NULL: return astTreeParseKeyword(parserNode, AST_TREE_TOKEN_VALUE_NULL); case PARSER_TOKEN_KEYWORD_PRINT_U64: @@ -2626,8 +2632,9 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: case AST_TREE_TOKEN_VALUE_VOID: - case AST_TREE_TOKEN_VALUE_BOOL: return true; + case AST_TREE_TOKEN_VALUE_BOOL: + return setTypesValueBool(tree, helper); case AST_TREE_TOKEN_VALUE_INT: return setTypesValueInt(tree, helper); case AST_TREE_TOKEN_VALUE_FLOAT: @@ -2687,6 +2694,12 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, UNREACHABLE; } +bool setTypesValueBool(AstTree *tree, AstTreeSetTypesHelper helper) { + (void)helper; + tree->type = &AST_TREE_BOOL_TYPE; + return true; +} + bool setTypesValueInt(AstTree *tree, AstTreeSetTypesHelper helper) { if (helper.lookingType == NULL || typeIsEqual(helper.lookingType, &AST_TREE_I64_TYPE)) { diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h index a553a1d..d6c2523 100644 --- a/src/compiler/ast-tree.h +++ b/src/compiler/ast-tree.h @@ -252,6 +252,7 @@ bool isCircularDependenciesVariable(AstTreeHelper *helper, bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper); bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunction *function); +bool setTypesValueBool(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesValueInt(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesValueFloat(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesValueNull(AstTree *tree, AstTreeSetTypesHelper helper); diff --git a/src/compiler/parser.c b/src/compiler/parser.c index db189ed..69209ab 100644 --- a/src/compiler/parser.c +++ b/src/compiler/parser.c @@ -218,8 +218,8 @@ void parserNodePrint(const ParserNode *node, int indent) { } goto RETURN_SUCCESS; case PARSER_TOKEN_VALUE_BOOL: { - ParserNodeIntMetadata metadata = (ParserNodeIntMetadata)node->metadata; - printf(",value=%b", (ParserNodeBoolMetadata)metadata); + ParserNodeBoolMetadata *metadata = node->metadata; + printf(",value=%b", *metadata); } goto RETURN_SUCCESS; case PARSER_TOKEN_CONSTANT: @@ -455,9 +455,14 @@ void parserNodeDelete(ParserNode *node) { case PARSER_TOKEN_TYPE_F32: case PARSER_TOKEN_TYPE_F64: case PARSER_TOKEN_TYPE_F128: - case PARSER_TOKEN_VALUE_BOOL: case PARSER_TOKEN_KEYWORD_NULL: goto RETURN_SUCCESS; + case PARSER_TOKEN_VALUE_BOOL: { + ParserNodeBoolMetadata *metadata = node->metadata; + free(metadata); + } + goto RETURN_SUCCESS; + case PARSER_TOKEN_VALUE_INT: { ParserNodeIntMetadata *metadata = node->metadata; free(metadata); @@ -979,11 +984,11 @@ ParserNode *parserNumber(LexerNode *node, ParserNode *parent) { } ParserNode *parserBoolValue(LexerNode *node, ParserNode *parent) { - return node->parserNode = newParserNode( - PARSER_TOKEN_VALUE_BOOL, node->str_begin, node->str_end, - (void *)(ParserNodeBoolMetadata)(node->token == - LEXER_TOKEN_KEYWORD_TRUE), - parent); + ParserNodeBoolMetadata *metadata = a404m_malloc(sizeof(*metadata)); + *metadata = node->token == LEXER_TOKEN_KEYWORD_TRUE; + return node->parserNode = + newParserNode(PARSER_TOKEN_VALUE_BOOL, node->str_begin, + node->str_end, metadata, parent); } ParserNode *parserEol(LexerNode *node, LexerNode *begin, ParserNode *parent) { 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 bc15a90..9e82a6c 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -1,45 +1,28 @@ #include "runner.h" #include "compiler/ast-tree.h" #include "utils/log.h" +#include "utils/memory.h" #include #include #include #define doOperation(op0, op1, operator, originalType, type) \ - (op0)->metadata = (void *)(u64)((type)(originalType)(op0) \ - ->metadata \ - operator(type)(originalType)(op1) \ - ->metadata) - -#define doOperationFloat(op0, op1, operator, originalType, type) \ *((originalType *)(op0)->metadata) = \ - (originalType)((type) * (originalType *)(op0)->metadata operator(type) * \ - (originalType *)(op1)->metadata) + (originalType)(((type) * (originalType *)(op0)->metadata) operator( \ + (type) * (originalType *)(op1)->metadata)) #define doLogicalOperation(op0, op1, operator, originalType, _type) \ { \ - bool res = (bool)(((_type)(originalType)(op0)->metadata) operator( \ - (_type)(originalType)(op1)->metadata)); \ - astTreeDestroy(*(op0)); \ - (op0)->metadata = (void *)(bool)res; \ - (op0)->type = &AST_TREE_BOOL_TYPE; \ - (op0)->token = AST_TREE_TOKEN_VALUE_BOOL; \ - } - -#define doLogicalOperationFloat(op0, op1, operator, originalType, _type) \ - { \ - bool res = (bool)(((_type) * ((originalType *)(op0)->metadata)) operator( \ - (_type) * ((originalType *)(op1)->metadata))); \ + bool *res = a404m_malloc(sizeof(*res)); \ + *res = ((_type) * ((originalType *)(op0)->metadata)) operator( \ + (_type) * ((originalType *)(op1)->metadata)); \ astTreeDestroy(*(op0)); \ - (op0)->metadata = (void *)(bool)res; \ + (op0)->metadata = res; \ (op0)->type = &AST_TREE_BOOL_TYPE; \ (op0)->token = AST_TREE_TOKEN_VALUE_BOOL; \ } #define doLeftOperation(op0, operator, originalType, type) \ - (op0)->metadata = (void *)(u64)(operator(type)(originalType)(op0)->metadata) - -#define doLeftOperationFloat(op0, operator, originalType, type) \ *((originalType *)(op0)->metadata) = operator( \ (type) * (originalType *)(op0)->metadata) @@ -215,7 +198,7 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTreeIf *metadata = expr->metadata; AstTree *condition = runExpression(metadata->condition, shouldRet); AstTree *ret; - if ((AstTreeBool)condition->metadata) { + if (*(AstTreeBool *)condition->metadata) { ret = runExpression(metadata->ifBody, shouldRet); } else if (metadata->elseBody != NULL) { ret = runExpression(metadata->elseBody, shouldRet); @@ -230,7 +213,7 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *ret = NULL; while (!*shouldRet) { AstTree *tree = runExpression(metadata->condition, shouldRet); - bool conti = (AstTreeBool)tree->metadata; + bool conti = *(AstTreeBool *)tree->metadata; astTreeDelete(tree); if (!conti) { break; @@ -272,13 +255,13 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { } else if (operand->type == &AST_TREE_I8_TYPE) { doLeftOperation(operand, +, AstTreeInt, i8); } else if (operand->type == &AST_TREE_F128_TYPE) { - doLeftOperationFloat(operand, +, AstTreeFloat, f128); + doLeftOperation(operand, +, AstTreeFloat, f128); } else if (operand->type == &AST_TREE_F64_TYPE) { - doLeftOperationFloat(operand, +, AstTreeFloat, f64); + doLeftOperation(operand, +, AstTreeFloat, f64); } else if (operand->type == &AST_TREE_F32_TYPE) { - doLeftOperationFloat(operand, +, AstTreeFloat, f32); + doLeftOperation(operand, +, AstTreeFloat, f32); } else if (operand->type == &AST_TREE_F16_TYPE) { - doLeftOperationFloat(operand, +, AstTreeFloat, f16); + doLeftOperation(operand, +, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -304,13 +287,13 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { } else if (operand->type == &AST_TREE_I8_TYPE) { doLeftOperation(operand, -, AstTreeInt, i8); } else if (operand->type == &AST_TREE_F128_TYPE) { - doLeftOperationFloat(operand, -, AstTreeFloat, f128); + doLeftOperation(operand, -, AstTreeFloat, f128); } else if (operand->type == &AST_TREE_F64_TYPE) { - doLeftOperationFloat(operand, -, AstTreeFloat, f64); + doLeftOperation(operand, -, AstTreeFloat, f64); } else if (operand->type == &AST_TREE_F32_TYPE) { - doLeftOperationFloat(operand, -, AstTreeFloat, f32); + doLeftOperation(operand, -, AstTreeFloat, f32); } else if (operand->type == &AST_TREE_F16_TYPE) { - doLeftOperationFloat(operand, -, AstTreeFloat, f16); + doLeftOperation(operand, -, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -347,16 +330,16 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { doOperation(left, right, +, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, +, AstTreeFloat, f128); + doOperation(left, right, +, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, +, AstTreeFloat, f64); + doOperation(left, right, +, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, +, AstTreeFloat, f32); + doOperation(left, right, +, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, +, AstTreeFloat, f16); + doOperation(left, right, +, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -394,16 +377,16 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { doOperation(left, right, -, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, -, AstTreeFloat, f128); + doOperation(left, right, -, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, -, AstTreeFloat, f64); + doOperation(left, right, -, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, -, AstTreeFloat, f32); + doOperation(left, right, -, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, -, AstTreeFloat, f16); + doOperation(left, right, -, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -441,16 +424,16 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { doOperation(left, right, *, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, *, AstTreeFloat, f128); + doOperation(left, right, *, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, *, AstTreeFloat, f64); + doOperation(left, right, *, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, *, AstTreeFloat, f32); + doOperation(left, right, *, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, *, AstTreeFloat, f16); + doOperation(left, right, *, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -488,16 +471,16 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { doOperation(left, right, /, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, /, AstTreeFloat, f128); + doOperation(left, right, /, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, /, AstTreeFloat, f64); + doOperation(left, right, /, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, /, AstTreeFloat, f32); + doOperation(left, right, /, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, /, AstTreeFloat, f16); + doOperation(left, right, /, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -546,46 +529,46 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, ==, AstTreeInt, u64); + doLogicalOperation(left, right, ==, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, ==, AstTreeInt, i64); + doLogicalOperation(left, right, ==, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, ==, AstTreeInt, u32); + doLogicalOperation(left, right, ==, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, ==, AstTreeInt, i32); + doLogicalOperation(left, right, ==, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, ==, AstTreeInt, u16); + doLogicalOperation(left, right, ==, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, ==, AstTreeInt, i16); + doLogicalOperation(left, right, ==, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, ==, AstTreeInt, u8); + doLogicalOperation(left, right, ==, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, ==, AstTreeInt, i8); + doLogicalOperation(left, right, ==, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, ==, AstTreeFloat, f128); + doLogicalOperation(left, right, ==, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, ==, AstTreeFloat, f64); + doLogicalOperation(left, right, ==, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, ==, AstTreeFloat, f32); + doLogicalOperation(left, right, ==, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, ==, AstTreeFloat, f16); + doLogicalOperation(left, right, ==, AstTreeFloat, f16); } else if (left->type == &AST_TREE_TYPE_TYPE) { - bool res = typeIsEqual(left, right); + bool *res = a404m_malloc(sizeof(*res)); + *res = typeIsEqual(left, right); astTreeDelete(left); - left = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, (void *)(AstTreeBool)res, - &AST_TREE_BOOL_TYPE, NULL, NULL); - left->token = AST_TREE_TOKEN_VALUE_BOOL; + left = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, res, &AST_TREE_BOOL_TYPE, + NULL, NULL); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -599,46 +582,46 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, !=, AstTreeInt, u64); + doLogicalOperation(left, right, !=, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, !=, AstTreeInt, i64); + doLogicalOperation(left, right, !=, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, !=, AstTreeInt, u32); + doLogicalOperation(left, right, !=, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, !=, AstTreeInt, i32); + doLogicalOperation(left, right, !=, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, !=, AstTreeInt, u16); + doLogicalOperation(left, right, !=, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, !=, AstTreeInt, i16); + doLogicalOperation(left, right, !=, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, !=, AstTreeInt, u8); + doLogicalOperation(left, right, !=, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, !=, AstTreeInt, i8); + doLogicalOperation(left, right, !=, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, !=, AstTreeFloat, f128); + doLogicalOperation(left, right, !=, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, !=, AstTreeFloat, f64); + doLogicalOperation(left, right, !=, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, !=, AstTreeFloat, f32); + doLogicalOperation(left, right, !=, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, !=, AstTreeFloat, f16); + doLogicalOperation(left, right, !=, AstTreeFloat, f16); } else if (left->type == &AST_TREE_TYPE_TYPE) { - bool res = !typeIsEqual(left, right); + bool *res = a404m_malloc(sizeof(*res)); + *res = !typeIsEqual(left, right); astTreeDelete(left); - left = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, (void *)(AstTreeBool)res, - &AST_TREE_BOOL_TYPE, NULL, NULL); - left->token = AST_TREE_TOKEN_VALUE_BOOL; + left = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, res, &AST_TREE_BOOL_TYPE, + NULL, NULL); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -652,40 +635,40 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, >, AstTreeInt, u64); + doLogicalOperation(left, right, >, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, >, AstTreeInt, i64); + doLogicalOperation(left, right, >, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, >, AstTreeInt, u32); + doLogicalOperation(left, right, >, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, >, AstTreeInt, i32); + doLogicalOperation(left, right, >, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, >, AstTreeInt, u16); + doLogicalOperation(left, right, >, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, >, AstTreeInt, i16); + doLogicalOperation(left, right, >, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, >, AstTreeInt, u8); + doLogicalOperation(left, right, >, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, >, AstTreeInt, i8); + doLogicalOperation(left, right, >, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, >, AstTreeFloat, f128); + doLogicalOperation(left, right, >, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, >, AstTreeFloat, f64); + doLogicalOperation(left, right, >, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, >, AstTreeFloat, f32); + doLogicalOperation(left, right, >, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, >, AstTreeFloat, f16); + doLogicalOperation(left, right, >, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -699,40 +682,40 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, <, AstTreeInt, u64); + doLogicalOperation(left, right, <, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, <, AstTreeInt, i64); + doLogicalOperation(left, right, <, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, <, AstTreeInt, u32); + doLogicalOperation(left, right, <, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, <, AstTreeInt, i32); + doLogicalOperation(left, right, <, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, <, AstTreeInt, u16); + doLogicalOperation(left, right, <, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, <, AstTreeInt, i16); + doLogicalOperation(left, right, <, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, <, AstTreeInt, u8); + doLogicalOperation(left, right, <, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, <, AstTreeInt, i8); + doLogicalOperation(left, right, <, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, <, AstTreeFloat, f128); + doLogicalOperation(left, right, <, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, <, AstTreeFloat, f64); + doLogicalOperation(left, right, <, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, <, AstTreeFloat, f32); + doLogicalOperation(left, right, <, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, <, AstTreeFloat, f16); + doLogicalOperation(left, right, <, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -746,40 +729,40 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, >=, AstTreeInt, u64); + doLogicalOperation(left, right, >=, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, >=, AstTreeInt, i64); + doLogicalOperation(left, right, >=, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, >=, AstTreeInt, u32); + doLogicalOperation(left, right, >=, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, >=, AstTreeInt, i32); + doLogicalOperation(left, right, >=, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, >=, AstTreeInt, u16); + doLogicalOperation(left, right, >=, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, >=, AstTreeInt, i16); + doLogicalOperation(left, right, >=, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, >=, AstTreeInt, u8); + doLogicalOperation(left, right, >=, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, >=, AstTreeInt, i8); + doLogicalOperation(left, right, >=, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, >=, AstTreeFloat, f128); + doLogicalOperation(left, right, >=, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, >=, AstTreeFloat, f64); + doLogicalOperation(left, right, >=, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, >=, AstTreeFloat, f32); + doLogicalOperation(left, right, >=, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, >=, AstTreeFloat, f16); + doLogicalOperation(left, right, >=, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; @@ -793,40 +776,40 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet) { AstTree *right = runExpression(&metadata->right, shouldRet); if (left->type == &AST_TREE_U64_TYPE && right->type == &AST_TREE_U64_TYPE) { - doOperation(left, right, <=, AstTreeInt, u64); + doLogicalOperation(left, right, <=, AstTreeInt, u64); } else if (left->type == &AST_TREE_I64_TYPE && right->type == &AST_TREE_I64_TYPE) { - doOperation(left, right, <=, AstTreeInt, i64); + doLogicalOperation(left, right, <=, AstTreeInt, i64); } else if (left->type == &AST_TREE_U32_TYPE && right->type == &AST_TREE_U32_TYPE) { - doOperation(left, right, <=, AstTreeInt, u32); + doLogicalOperation(left, right, <=, AstTreeInt, u32); } else if (left->type == &AST_TREE_I32_TYPE && right->type == &AST_TREE_I32_TYPE) { - doOperation(left, right, <=, AstTreeInt, i32); + doLogicalOperation(left, right, <=, AstTreeInt, i32); } else if (left->type == &AST_TREE_U16_TYPE && right->type == &AST_TREE_U16_TYPE) { - doOperation(left, right, <=, AstTreeInt, u16); + doLogicalOperation(left, right, <=, AstTreeInt, u16); } else if (left->type == &AST_TREE_I16_TYPE && right->type == &AST_TREE_I16_TYPE) { - doOperation(left, right, <=, AstTreeInt, i16); + doLogicalOperation(left, right, <=, AstTreeInt, i16); } else if (left->type == &AST_TREE_U8_TYPE && right->type == &AST_TREE_U8_TYPE) { - doOperation(left, right, <=, AstTreeInt, u8); + doLogicalOperation(left, right, <=, AstTreeInt, u8); } else if (left->type == &AST_TREE_I8_TYPE && right->type == &AST_TREE_I8_TYPE) { - doOperation(left, right, <=, AstTreeInt, i8); + doLogicalOperation(left, right, <=, AstTreeInt, i8); } else if (left->type == &AST_TREE_F128_TYPE && right->type == &AST_TREE_F128_TYPE) { - doOperationFloat(left, right, <=, AstTreeFloat, f128); + doLogicalOperation(left, right, <=, AstTreeFloat, f128); } else if (left->type == &AST_TREE_F64_TYPE && right->type == &AST_TREE_F64_TYPE) { - doOperationFloat(left, right, <=, AstTreeFloat, f64); + doLogicalOperation(left, right, <=, AstTreeFloat, f64); } else if (left->type == &AST_TREE_F32_TYPE && right->type == &AST_TREE_F32_TYPE) { - doOperationFloat(left, right, <=, AstTreeFloat, f32); + doLogicalOperation(left, right, <=, AstTreeFloat, f32); } else if (left->type == &AST_TREE_F16_TYPE && right->type == &AST_TREE_F16_TYPE) { - doOperationFloat(left, right, <=, AstTreeFloat, f16); + doLogicalOperation(left, right, <=, AstTreeFloat, f16); } else { printError(expr->str_begin, expr->str_end, "Not supported"); UNREACHABLE; -- cgit v1.2.3