summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--code/main.felan12
-rw-r--r--src/compiler/ast-tree.c33
-rw-r--r--src/compiler/ast-tree.h1
-rw-r--r--src/compiler/parser.c21
-rw-r--r--src/main.c2
-rw-r--r--src/runner/runner.c243
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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;
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-29 21:50:44 +0000