From 6bd439f35c1184f04488ee4f0db21632e1301b51 Mon Sep 17 00:00:00 2001 From: A404M Date: Fri, 7 Feb 2025 21:14:11 +0330 Subject: add plus trying to add return --- src/compiler/ast-tree.c | 337 +++++++++++++++++++++++++----------------------- 1 file changed, 175 insertions(+), 162 deletions(-) (limited to 'src/compiler/ast-tree.c') diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index 7bb9f8f..7f955ff 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -6,9 +6,28 @@ #include #include -const AstTree AST_TREE_U64_TYPE = { +AstTree AST_TREE_TYPE_TYPE = { + .token = AST_TREE_TOKEN_TYPE_TYPE, + .metadata = NULL, + .type = &AST_TREE_TYPE_TYPE, +}; + +AstTree AST_TREE_VOID_TYPE = { + .token = AST_TREE_TOKEN_TYPE_VOID, + .metadata = NULL, + .type = &AST_TREE_TYPE_TYPE, +}; + +AstTree AST_TREE_U64_TYPE = { .token = AST_TREE_TOKEN_TYPE_U64, .metadata = NULL, + .type = &AST_TREE_TYPE_TYPE, +}; + +AstTree AST_TREE_VOID_VALUE = { + .token = AST_TREE_TOKEN_NONE, + .metadata = NULL, + .type = &AST_TREE_VOID_TYPE, }; const char *AST_TREE_TOKEN_STRINGS[] = { @@ -27,6 +46,7 @@ const char *AST_TREE_TOKEN_STRINGS[] = { "AST_TREE_TOKEN_VALUE_U64", "AST_TREE_TOKEN_OPERATOR_ASSIGN", + "AST_TREE_TOKEN_OPERATOR_SUM", "AST_TREE_TOKEN_NONE", }; @@ -134,6 +154,7 @@ void astTreePrint(const AstTree *tree, int indent) { metadata->name_begin); } goto RETURN_SUCCESS; + case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_OPERATOR_ASSIGN: { AstTreeInfix *metadata = tree->metadata; printf(",\n"); @@ -146,16 +167,6 @@ void astTreePrint(const AstTree *tree, int indent) { printf(" "); printf("right=\n"); astTreePrint(&metadata->right, indent + 1); - printf(",\n"); - for (int i = 0; i < indent; ++i) - printf(" "); - printf("leftType=\n"); - astTreePrint(&metadata->leftType, indent + 1); - printf(",\n"); - for (int i = 0; i < indent; ++i) - printf(" "); - printf("rightType=\n"); - astTreePrint(&metadata->rightType, indent + 1); printf("\n"); for (int i = 0; i < indent; ++i) printf(" "); @@ -184,6 +195,15 @@ void astTreeRootPrint(const AstTreeRoot *root) { } void astTreeDestroy(AstTree tree) { + if (tree.type != &AST_TREE_TYPE_TYPE && tree.type != &AST_TREE_VOID_TYPE && + tree.type != &AST_TREE_U64_TYPE) { + if (tree.type == NULL) { + printLog("token = %s %p %p", AST_TREE_TOKEN_STRINGS[tree.token], + tree.metadata, tree.type); + return; + } + astTreeDelete(tree.type); + } switch (tree.token) { case AST_TREE_TOKEN_FUNCTION: { AstTreeFunction *metadata = tree.metadata; @@ -238,12 +258,11 @@ void astTreeDestroy(AstTree tree) { // AstTreeIdentifier *metadata = tree.metadata; // not needed } return; + case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_OPERATOR_ASSIGN: { AstTreeInfix *metadata = tree.metadata; astTreeDestroy(metadata->left); astTreeDestroy(metadata->right); - astTreeDestroy(metadata->leftType); - astTreeDestroy(metadata->rightType); free(metadata); } return; @@ -281,28 +300,40 @@ void astTreeRootDelete(AstTreeRoot *root) { free(root); } -AstTree *newAstTree(AstTreeToken token, void *metadata) { +AstTree *newAstTree(AstTreeToken token, void *metadata, AstTree *type) { AstTree *result = a404m_malloc(sizeof(*result)); result->token = token; result->metadata = metadata; - result->typeChecked = false; + result->type = type; return result; } AstTree *copyAstTree(AstTree *tree) { switch (tree->token) { case AST_TREE_TOKEN_TYPE_TYPE: + return &AST_TREE_TYPE_TYPE; case AST_TREE_TOKEN_TYPE_VOID: + return &AST_TREE_VOID_TYPE; case AST_TREE_TOKEN_TYPE_U64: - return newAstTree(tree->token, NULL); + return &AST_TREE_U64_TYPE; case AST_TREE_TOKEN_VALUE_U64: - return newAstTree(tree->token, (void *)(AstTreeU64)tree->metadata); + return newAstTree(tree->token, (void *)(AstTreeU64)tree->metadata, + &AST_TREE_U64_TYPE); case AST_TREE_TOKEN_VARIABLE: - return newAstTree(tree->token, tree->metadata); + return newAstTree(tree->token, tree->metadata, copyAstTree(tree->type)); + case AST_TREE_TOKEN_TYPE_FUNCTION: { + AstTreeTypeFunction *metadata = tree->metadata; + AstTreeTypeFunction *new_metadata = a404m_malloc(sizeof(*new_metadata)); + new_metadata->returnType = copyAstTree(metadata->returnType); + if (metadata->arguments_size != 0) { + UNREACHABLE; + } + return newAstTree(tree->token, new_metadata, copyAstTree(tree->type)); + } case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: - case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_NONE: @@ -387,6 +418,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) { case PARSER_TOKEN_SYMBOL_COMMA: case PARSER_TOKEN_FUNCTION_CALL: case PARSER_TOKEN_OPERATOR_ASSIGN: + case PARSER_TOKEN_OPERATOR_SUM: case PARSER_TOKEN_NONE: printLog("Should not be here"); goto RETURN_ERROR; @@ -408,11 +440,6 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) { if (type == NULL) { goto RETURN_ERROR; } - - if (!hasTypeOf(value, type)) { - printLog("Type mismatch"); - goto RETURN_ERROR; - } } else { type = NULL; } @@ -483,13 +510,13 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables, case PARSER_TOKEN_FUNCTION_DEFINITION: return astTreeParseFunction(parserNode, variables, variables_size); case PARSER_TOKEN_TYPE_TYPE: - return newAstTree(AST_TREE_TOKEN_TYPE_TYPE, NULL); + return &AST_TREE_TYPE_TYPE; case PARSER_TOKEN_TYPE_FUNCTION: return astTreeParseTypeFunction(parserNode, variables, variables_size); case PARSER_TOKEN_TYPE_VOID: - return newAstTree(AST_TREE_TOKEN_TYPE_VOID, NULL); + return &AST_TREE_VOID_TYPE; case PARSER_TOKEN_TYPE_U64: - return newAstTree(AST_TREE_TOKEN_TYPE_U64, NULL); + return &AST_TREE_U64_TYPE; case PARSER_TOKEN_FUNCTION_CALL: return astTreeParseFunctionCall(parserNode, variables, variables_size); case PARSER_TOKEN_IDENTIFIER: @@ -497,11 +524,14 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables, case PARSER_TOKEN_VALUE_U64: return newAstTree( AST_TREE_TOKEN_VALUE_U64, - (void *)(AstTreeU64)(ParserNodeU64Metadata)parserNode->metadata); + (void *)(AstTreeU64)(ParserNodeU64Metadata)parserNode->metadata, + &AST_TREE_U64_TYPE); case PARSER_TOKEN_KEYWORD_PRINT_U64: return astTreeParsePrintU64(parserNode, variables, variables_size); case PARSER_TOKEN_OPERATOR_ASSIGN: return astTreeParseAssign(parserNode, variables, variables_size); + case PARSER_TOKEN_OPERATOR_SUM: + return astTreeParseSum(parserNode, variables, variables_size); case PARSER_TOKEN_VARIABLE: case PARSER_TOKEN_CONSTANT: case PARSER_TOKEN_SYMBOL_EOL: @@ -611,7 +641,7 @@ AstTree *astTreeParseFunction(ParserNode *parserNode, function->scope = scope; - AstTree *result = newAstTree(AST_TREE_TOKEN_FUNCTION, function); + AstTree *result = newAstTree(AST_TREE_TOKEN_FUNCTION, function, NULL); return result; @@ -663,7 +693,8 @@ AstTree *astTreeParseTypeFunction(ParserNode *parserNode, goto RETURN_ERROR; } - return newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, typeFunction); + return newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, typeFunction, + &AST_TREE_TYPE_TYPE); RETURN_ERROR: return NULL; @@ -693,15 +724,9 @@ AstTree *astTreeParseFunctionCall(ParserNode *parserNode, for (size_t i = 0; i < metadata->parameters_size; ++i) { printLog("Not impelemented yet"); exit(1); - if ((metadata->parameters[i] = astTreeParse(node_metadata->params->data[i], - variables, variables_size)) == - NULL || - hasTypeOf(metadata->parameters[i], function->metadata)) { - goto RETURN_ERROR; - } } - return newAstTree(AST_TREE_TOKEN_FUNCTION_CALL, metadata); + return newAstTree(AST_TREE_TOKEN_FUNCTION_CALL, metadata, NULL); RETURN_ERROR: for (size_t i = 0; i < metadata->parameters_size; ++i) { astTreeDelete(metadata->parameters[i]); @@ -719,7 +744,7 @@ AstTree *astTreeParseIdentifier(ParserNode *parserNode, printLog("Variable not found"); return NULL; } - return newAstTree(AST_TREE_TOKEN_VARIABLE, var); + return newAstTree(AST_TREE_TOKEN_VARIABLE, var, NULL); } AstTree *astTreeParsePrintU64(ParserNode *parserNode, @@ -733,7 +758,7 @@ AstTree *astTreeParsePrintU64(ParserNode *parserNode, } return newAstTree(AST_TREE_TOKEN_KEYWORD_PRINT_U64, - (AstTreeSingleChild *)operand); + (AstTreeSingleChild *)operand, NULL); } AstTree *astTreeParseAssign(ParserNode *parserNode, @@ -759,7 +784,32 @@ AstTree *astTreeParseAssign(ParserNode *parserNode, free(left); free(right); - return newAstTree(AST_TREE_TOKEN_OPERATOR_ASSIGN, metadata); + return newAstTree(AST_TREE_TOKEN_OPERATOR_ASSIGN, metadata, NULL); +} + +AstTree *astTreeParseSum(ParserNode *parserNode, AstTreeVariables **variables, + size_t variables_size) { + ParserNodeInfixMetadata *node_metadata = parserNode->metadata; + + AstTree *left = astTreeParse(node_metadata->left, variables, variables_size); + if (left == NULL) { + return NULL; + } + AstTree *right = + astTreeParse(node_metadata->right, variables, variables_size); + if (right == NULL) { + return NULL; + } + + AstTreeInfix *metadata = a404m_malloc(sizeof(*metadata)); + + metadata->left = *left; + metadata->right = *right; + + free(left); + free(right); + + return newAstTree(AST_TREE_TOKEN_OPERATOR_SUM, metadata, NULL); } bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables, @@ -844,84 +894,11 @@ AstTree *astTreeParseVariable(ParserNode *parserNode, goto RETURN_ERROR; } - return newAstTree(AST_TREE_TOKEN_VARIABLE_DEFINE, variable); + return newAstTree(AST_TREE_TOKEN_VARIABLE_DEFINE, variable, NULL); RETURN_ERROR: return NULL; } -bool hasTypeOf(AstTree *value, const AstTree *type) { - if (value->token == AST_TREE_TOKEN_VARIABLE) { - AstTreeVariable *variable = value->metadata; - return typeIsEqual(variable->type, type); - } - - switch (type->token) { - case AST_TREE_TOKEN_TYPE_TYPE: - switch (value->token) { - case AST_TREE_TOKEN_TYPE_TYPE: - case AST_TREE_TOKEN_TYPE_FUNCTION: - case AST_TREE_TOKEN_TYPE_VOID: - case AST_TREE_TOKEN_TYPE_U64: - return true; - case AST_TREE_TOKEN_FUNCTION: - case AST_TREE_TOKEN_KEYWORD_PRINT_U64: - case AST_TREE_TOKEN_FUNCTION_CALL: - case AST_TREE_TOKEN_VARIABLE: - case AST_TREE_TOKEN_VALUE_U64: - case AST_TREE_TOKEN_VARIABLE_DEFINE: - case AST_TREE_TOKEN_OPERATOR_ASSIGN: - return false; - case AST_TREE_TOKEN_NONE: - } - goto ERROR; - case AST_TREE_TOKEN_TYPE_FUNCTION: - AstTreeTypeFunction *typeMetadata = type->metadata; - switch (value->token) { - case AST_TREE_TOKEN_FUNCTION: { - AstTreeFunction *valueMetadata = value->metadata; - if (typeMetadata->arguments_size != valueMetadata->arguments.size) { - return false; - } - for (size_t i = 0; i < typeMetadata->arguments_size; ++i) { - if (!typeIsEqual(typeMetadata->arguments[i], - valueMetadata->arguments.data[i]->type)) { - return false; - } - } - return typeIsEqual(typeMetadata->returnType, valueMetadata->returnType); - } - case AST_TREE_TOKEN_KEYWORD_PRINT_U64: - case AST_TREE_TOKEN_VALUE_U64: - case AST_TREE_TOKEN_TYPE_TYPE: - case AST_TREE_TOKEN_TYPE_FUNCTION: - case AST_TREE_TOKEN_TYPE_VOID: - case AST_TREE_TOKEN_TYPE_U64: - case AST_TREE_TOKEN_FUNCTION_CALL: - case AST_TREE_TOKEN_VARIABLE: - case AST_TREE_TOKEN_VARIABLE_DEFINE: - case AST_TREE_TOKEN_OPERATOR_ASSIGN: - return false; - case AST_TREE_TOKEN_NONE: - } - goto ERROR; - case AST_TREE_TOKEN_TYPE_U64: - return value->token == AST_TREE_TOKEN_VALUE_U64; - case AST_TREE_TOKEN_FUNCTION: - case AST_TREE_TOKEN_TYPE_VOID: - case AST_TREE_TOKEN_FUNCTION_CALL: - case AST_TREE_TOKEN_VARIABLE: - case AST_TREE_TOKEN_KEYWORD_PRINT_U64: - case AST_TREE_TOKEN_VALUE_U64: - case AST_TREE_TOKEN_VARIABLE_DEFINE: - case AST_TREE_TOKEN_OPERATOR_ASSIGN: - return false; - case AST_TREE_TOKEN_NONE: - } -ERROR: - printLog("Bad token '%d'", type->token); - exit(1); -} - AstTreeFunction *getFunction(AstTree *value) { switch (value->token) { case AST_TREE_TOKEN_FUNCTION: @@ -933,7 +910,7 @@ AstTreeFunction *getFunction(AstTree *value) { } case AST_TREE_TOKEN_VARIABLE: { AstTreeVariable *metadata = value->metadata; - if (metadata->type->token == AST_TREE_TOKEN_TYPE_FUNCTION) { + if (metadata->value->token == AST_TREE_TOKEN_FUNCTION) { return metadata->value->metadata; } else { return NULL; @@ -947,6 +924,7 @@ AstTreeFunction *getFunction(AstTree *value) { case AST_TREE_TOKEN_VALUE_U64: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: return NULL; case AST_TREE_TOKEN_NONE: } @@ -967,6 +945,7 @@ bool isConst(AstTree *value) { case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: return false; case AST_TREE_TOKEN_VARIABLE: { AstTreeVariable *metadata = value->metadata; @@ -984,7 +963,7 @@ AstTree *makeTypeOf(AstTree *value) { case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_VOID: case AST_TREE_TOKEN_TYPE_U64: - return newAstTree(AST_TREE_TOKEN_TYPE_TYPE, NULL); + return &AST_TREE_TYPE_TYPE; case AST_TREE_TOKEN_FUNCTION_CALL: { AstTreeFunctionCall *metadata = value->metadata; AstTreeFunction *function = metadata->function->metadata; @@ -1004,17 +983,28 @@ AstTree *makeTypeOf(AstTree *value) { copyAstTree(function->arguments.data[i]->type); } - return newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata); + return newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, + &AST_TREE_TYPE_TYPE); } case AST_TREE_TOKEN_VALUE_U64: - return newAstTree(AST_TREE_TOKEN_TYPE_U64, NULL); + return &AST_TREE_U64_TYPE; case AST_TREE_TOKEN_VARIABLE: { AstTreeVariable *variable = value->metadata; return copyAstTree(variable->type); } + case AST_TREE_TOKEN_OPERATOR_ASSIGN: { + AstTreeInfix *metadata = value->metadata; + return makeTypeOf(&metadata->left); + } + case AST_TREE_TOKEN_OPERATOR_SUM: { + AstTreeInfix *metadata = value->metadata; + + // TODO: find a better way + + return makeTypeOf(&metadata->left); + } case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: - case AST_TREE_TOKEN_OPERATOR_ASSIGN: case AST_TREE_TOKEN_NONE: } printLog("Bad token '%d'", value->token); @@ -1028,6 +1018,7 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) { case AST_TREE_TOKEN_VALUE_U64: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: return false; case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: @@ -1037,8 +1028,20 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) { if (type1->token != AST_TREE_TOKEN_TYPE_FUNCTION) { return false; } - printLog("Not implemented yet"); - exit(1); + AstTreeTypeFunction *type0_metadata = type0->metadata; + AstTreeTypeFunction *type1_metadata = type1->metadata; + if (!typeIsEqual(type0_metadata->returnType->type, + type1_metadata->returnType->type)) { + return false; + } + if (type0_metadata->arguments_size != type1_metadata->arguments_size) { + return false; + } + for (size_t i = 0; i < type0_metadata->arguments_size; ++i) { + printLog("Not implemented yet"); + exit(1); + } + return true; case AST_TREE_TOKEN_FUNCTION_CALL: printLog("Not implemented yet"); exit(1); @@ -1064,10 +1067,9 @@ bool setAllTypesRoot(AstTreeRoot *root) { } bool setAllTypes(AstTree *tree) { - if (tree->typeChecked == true) { + if (tree->type != NULL) { return true; } - tree->typeChecked = true; switch (tree->token) { case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: @@ -1087,6 +1089,8 @@ bool setAllTypes(AstTree *tree) { return setTypesVariable(tree); case AST_TREE_TOKEN_OPERATOR_ASSIGN: return setTypesOperatorAssign(tree); + case AST_TREE_TOKEN_OPERATOR_SUM: + return setTypesOperatorSum(tree); case AST_TREE_TOKEN_NONE: } printLog("Bad token '%d'", tree->token); @@ -1106,8 +1110,8 @@ bool setTypesFunction(AstTree *tree) { } for (size_t i = 0; i < metadata->scope.expressions_size; ++i) { - AstTree expression = metadata->scope.expressions[i]; - if (!setAllTypes(&expression)) { + AstTree *expression = &metadata->scope.expressions[i]; + if (!setAllTypes(expression)) { return false; } } @@ -1118,18 +1122,19 @@ bool setTypesFunction(AstTree *tree) { } } - return true; + tree->type = makeTypeOf(tree); + return tree->type != NULL; } bool setTypesPrintU64(AstTree *tree) { AstTreeSingleChild *metadata = tree->metadata; if (!setAllTypes(metadata)) { return false; - } - if (!hasTypeOf(metadata, &AST_TREE_U64_TYPE)) { + } else if (!typeIsEqual(metadata->type, &AST_TREE_U64_TYPE)) { printLog("Type mismatch"); return false; } else { + tree->type = &AST_TREE_VOID_TYPE; return true; } } @@ -1142,7 +1147,15 @@ bool setTypesTypeFunction(AstTree *tree) { return false; } - return setAllTypes(metadata->returnType); + if (!setAllTypes(metadata->returnType)) { + return false; + } else if (!typeIsEqual(metadata->returnType->type, &AST_TREE_TYPE_TYPE)) { + printLog("Type mismatch"); + return false; + } + + tree->type = &AST_TREE_TYPE_TYPE; + return true; } bool setTypesFunctionCall(AstTree *tree) { @@ -1156,10 +1169,7 @@ bool setTypesFunctionCall(AstTree *tree) { if (metadata->function->token != AST_TREE_TOKEN_VARIABLE) { printLog("Not yet supported"); return false; - } - - if (!setAllTypes(metadata->function)) { - printLog("Type mismatch"); + } else if (!setAllTypes(metadata->function)) { return false; } @@ -1168,64 +1178,65 @@ bool setTypesFunctionCall(AstTree *tree) { function->arguments.size != metadata->parameters_size) { printLog("Arguments doesn't match %ld != %ld", function->arguments.size, metadata->parameters_size); - return false; + return NULL; } + tree->type = copyAstTree(function->returnType); return true; } bool setTypesVariable(AstTree *tree) { AstTreeVariable *metadata = tree->metadata; - return setTypesAstVariable(metadata); + if (setTypesAstVariable(metadata)) { + tree->type = copyAstTree(metadata->type); + return true; + } else { + return false; + } } bool setTypesOperatorAssign(AstTree *tree) { AstTreeInfix *infix = tree->metadata; if (!setTypesAstInfix(infix)) { - return true; - } else if (!typeIsEqual(&infix->leftType, &infix->rightType)) { + return false; + } else if (!typeIsEqual(infix->left.type, infix->right.type)) { printLog("Type mismatch"); return false; } else { + tree->type = copyAstTree(infix->left.type); return true; } } -bool setTypesAstVariable(AstTreeVariable *variable) { - if (!setAllTypes(variable->value)) { +bool setTypesOperatorSum(AstTree *tree) { + AstTreeInfix *infix = tree->metadata; + if (!setTypesAstInfix(infix)) { return false; - } - - if (variable->type == NULL) { - if ((variable->type = makeTypeOf(variable->value)) == NULL) { - return false; - } - } - - if (!hasTypeOf(variable->value, variable->type)) { + } else if (!typeIsEqual(infix->left.type, infix->right.type)) { printLog("Type mismatch"); return false; } else { + tree->type = copyAstTree(infix->left.type); return true; } } -bool setTypesAstInfix(AstTreeInfix *infix) { - if (!setAllTypes(&infix->left) || !setAllTypes(&infix->right)) { +bool setTypesAstVariable(AstTreeVariable *variable) { + if (!setAllTypes(variable->value)) { + return false; + } else if (variable->type == NULL && + (variable->type = makeTypeOf(variable->value)) == NULL) { + return false; + } else if (!typeIsEqual(variable->value->type, variable->type)) { printLog("Type mismatch"); return false; + } else { + return true; } +} - AstTree *lType = makeTypeOf(&infix->left); - AstTree *rType = makeTypeOf(&infix->right); - - infix->leftType = *lType; - infix->rightType = *rType; - - free(lType); - free(rType); - - return true; +bool setTypesAstInfix(AstTreeInfix *infix) { + return setAllTypes(&infix->left) && setAllTypes(&infix->right); } bool astTreeCleanRoot(AstTreeRoot *root) { @@ -1251,6 +1262,7 @@ bool astTreeClean(AstTree *tree) { case AST_TREE_TOKEN_VALUE_U64: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: return true; case AST_TREE_TOKEN_NONE: } @@ -1271,8 +1283,8 @@ bool astTreeCleanFunction(AstTree *tree) { } for (size_t i = 0; i < metadata->scope.expressions_size; ++i) { - AstTree expression = metadata->scope.expressions[i]; - if (!astTreeClean(&expression)) { + AstTree *expression = &metadata->scope.expressions[i]; + if (!astTreeClean(expression)) { return false; } } @@ -1331,6 +1343,7 @@ size_t astTreeTypeSize(AstTree tree) { case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_VALUE_U64: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_NONE: } UNREACHABLE; -- cgit v1.2.3