From decaf9321cbf119d1efea0c4667f49b0ab2e8c96 Mon Sep 17 00:00:00 2001 From: A404M Date: Tue, 11 Feb 2025 00:00:35 +0330 Subject: add unary + - --- src/compiler/ast-tree.c | 58 ++++++++++++++++++++++++++++++++++++- src/compiler/ast-tree.h | 22 +++++++++----- src/compiler/lexer.c | 6 +++- src/compiler/lexer.h | 2 ++ src/compiler/parser.c | 76 +++++++++++++++++++++++++++++++++++-------------- src/compiler/parser.h | 10 +++++-- src/main.c | 2 +- src/runner/runner.c | 29 +++++++++++++++++++ src/utils/string.c | 1 - 9 files changed, 170 insertions(+), 36 deletions(-) (limited to 'src') diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index d7769bc..3fd1dd5 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -115,6 +115,8 @@ void astTreePrint(const AstTree *tree, int indent) { case AST_TREE_TOKEN_VALUE_VOID: case AST_TREE_TOKEN_VARIABLE_DEFINE: goto RETURN_SUCCESS; + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: { AstTreeSingleChild *metadata = tree->metadata; printf(",\n"); @@ -260,6 +262,8 @@ void astTreeDestroy(AstTree tree) { case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_VARIABLE_DEFINE: return; + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: { AstTreeSingleChild *metadata = tree.metadata; astTreeDelete(metadata); @@ -424,6 +428,8 @@ AstTree *copyAstTree(AstTree *tree) { return newAstTree(tree->token, new_metadata, copyAstTree(tree->type), tree->str_begin, tree->str_end); } + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: { AstTreeSingleChild *metadata = tree->metadata; AstTreeSingleChild *new_metadata = copyAstTree(metadata); @@ -461,7 +467,6 @@ AstTree *copyAstTree(AstTree *tree) { case AST_TREE_TOKEN_NONE: } printLog("Bad token %ld", tree->token); - *(int *)(NULL) = 2; UNREACHABLE; } @@ -570,6 +575,8 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) { case PARSER_TOKEN_SYMBOL_PARENTHESIS: case PARSER_TOKEN_SYMBOL_COMMA: case PARSER_TOKEN_OPERATOR_ASSIGN: + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_OPERATOR_SUM: case PARSER_TOKEN_OPERATOR_SUB: case PARSER_TOKEN_OPERATOR_MULTIPLY: @@ -712,6 +719,12 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables, case PARSER_TOKEN_OPERATOR_MODULO: return astTreeParseBinaryOperator(parserNode, variables, variables_size, AST_TREE_TOKEN_OPERATOR_MODULO); + case PARSER_TOKEN_OPERATOR_PLUS: + return astTreeParseUnaryOperator(parserNode, variables, variables_size, + AST_TREE_TOKEN_OPERATOR_PLUS); + case PARSER_TOKEN_OPERATOR_MINUS: + return astTreeParseUnaryOperator(parserNode, variables, variables_size, + AST_TREE_TOKEN_OPERATOR_MINUS); case PARSER_TOKEN_VARIABLE: return astTreeParseVariable(parserNode, variables, variables_size); case PARSER_TOKEN_CONSTANT: @@ -1005,6 +1018,21 @@ AstTree *astTreeParseBinaryOperator(ParserNode *parserNode, parserNode->str_end); } +AstTree *astTreeParseUnaryOperator(ParserNode *parserNode, + AstTreeVariables **variables, + size_t variables_size, AstTreeToken token) { + ParserNodeSingleChildMetadata *node_metadata = parserNode->metadata; + + AstTreeSingleChild *metadata = + astTreeParse(node_metadata, variables, variables_size); + if (metadata == NULL) { + return NULL; + } + + return newAstTree(token, metadata, NULL, parserNode->str_begin, + parserNode->str_end); +} + bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables, size_t variables_size) { ParserNodeVariableMetadata *node_metadata = parserNode->metadata; @@ -1122,6 +1150,8 @@ AstTreeFunction *getFunction(AstTree *value) { case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + 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: @@ -1150,6 +1180,8 @@ 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_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: @@ -1205,6 +1237,11 @@ AstTree *makeTypeOf(AstTree *value) { AstTreeVariable *variable = value->metadata; return copyAstTree(variable->type); } + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: { + AstTreeSingleChild *metadata = value->metadata; + return copyAstTree(metadata->type); + } case AST_TREE_TOKEN_OPERATOR_ASSIGN: case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_OPERATOR_SUB: @@ -1237,6 +1274,8 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) { case AST_TREE_TOKEN_OPERATOR_MULTIPLY: case AST_TREE_TOKEN_OPERATOR_DIVIDE: case AST_TREE_TOKEN_OPERATOR_MODULO: + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: return false; case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: @@ -1312,6 +1351,9 @@ bool setAllTypes(AstTree *tree, AstTreeFunction *function) { return setTypesVariable(tree); case AST_TREE_TOKEN_OPERATOR_ASSIGN: return setTypesOperatorAssign(tree); + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: + return setTypesOperatorUnary(tree); case AST_TREE_TOKEN_OPERATOR_SUM: case AST_TREE_TOKEN_OPERATOR_SUB: case AST_TREE_TOKEN_OPERATOR_MULTIPLY: @@ -1470,6 +1512,16 @@ bool setTypesOperatorInfix(AstTree *tree) { } } +bool setTypesOperatorUnary(AstTree *tree) { + AstTreeSingleChild *operand = tree->metadata; + if (!setAllTypes(operand, NULL)) { + return false; + } else { + tree->type = copyAstTree(operand->type); + return true; + } +} + bool setTypesVariableDefine(AstTree *tree) { AstTreeVariable *metadata = tree->metadata; tree->type = &AST_TREE_VOID_TYPE; @@ -1527,6 +1579,8 @@ bool astTreeClean(AstTree *tree) { case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + 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: @@ -1617,6 +1671,8 @@ size_t astTreeTypeSize(AstTree tree) { case AST_TREE_TOKEN_VALUE_U64: case AST_TREE_TOKEN_VALUE_BOOL: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + 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: diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h index 9caef63..00e8c75 100644 --- a/src/compiler/ast-tree.h +++ b/src/compiler/ast-tree.h @@ -24,6 +24,8 @@ typedef enum AstTreeToken { AST_TREE_TOKEN_VALUE_BOOL, AST_TREE_TOKEN_OPERATOR_ASSIGN, + AST_TREE_TOKEN_OPERATOR_PLUS, + AST_TREE_TOKEN_OPERATOR_MINUS, AST_TREE_TOKEN_OPERATOR_SUM, AST_TREE_TOKEN_OPERATOR_SUB, AST_TREE_TOKEN_OPERATOR_MULTIPLY, @@ -113,7 +115,8 @@ void astTreeVariableDelete(AstTreeVariable *variable); void astTreeDelete(AstTree *tree); void astTreeRootDelete(AstTreeRoot *root); -AstTree *newAstTree(AstTreeToken token, void *metadata, AstTree *type,char *str_begin,char *str_end); +AstTree *newAstTree(AstTreeToken token, void *metadata, AstTree *type, + char *str_begin, char *str_end); AstTree *copyAstTree(AstTree *tree); AstTreeVariables copyAstTreeVariables(AstTreeVariables variables); @@ -147,12 +150,16 @@ AstTree *astTreeParsePrintU64(ParserNode *parserNode, AstTreeVariables **variables, size_t variables_size); AstTree *astTreeParseReturn(ParserNode *parserNode, - AstTreeVariables **variables, - size_t variables_size); + AstTreeVariables **variables, + size_t variables_size); AstTree *astTreeParseBinaryOperator(ParserNode *parserNode, - AstTreeVariables **variables, - size_t variables_size,AstTreeToken token); + AstTreeVariables **variables, + size_t variables_size, AstTreeToken token); + +AstTree *astTreeParseUnaryOperator(ParserNode *parserNode, + AstTreeVariables **variables, + size_t variables_size, AstTreeToken token); bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables, size_t variables_size); @@ -167,15 +174,16 @@ AstTree *makeTypeOf(AstTree *value); bool typeIsEqual(const AstTree *type0, const AstTree *type1); bool setAllTypesRoot(AstTreeRoot *root); -bool setAllTypes(AstTree *tree,AstTreeFunction *function); +bool setAllTypes(AstTree *tree, AstTreeFunction *function); bool setTypesFunction(AstTree *tree); bool setTypesPrintU64(AstTree *tree); -bool setTypesReturn(AstTree *tree,AstTreeFunction *function); +bool setTypesReturn(AstTree *tree, AstTreeFunction *function); bool setTypesTypeFunction(AstTree *tree); bool setTypesFunctionCall(AstTree *tree); bool setTypesVariable(AstTree *tree); bool setTypesOperatorAssign(AstTree *tree); bool setTypesOperatorInfix(AstTree *tree); +bool setTypesOperatorUnary(AstTree *tree); bool setTypesVariableDefine(AstTree *tree); bool setTypesAstVariable(AstTreeVariable *variable); diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index e69afef..baedf24 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -4,8 +4,8 @@ #include "utils/memory.h" #include "utils/string.h" -#include #include +#include #include #include @@ -35,6 +35,8 @@ const char *LEXER_TOKEN_STRINGS[] = { "LEXER_TOKEN_SYMBOL_COMMA", "LEXER_TOKEN_SYMBOL_PLUS", "LEXER_TOKEN_SYMBOL_MINUS", + "LEXER_TOKEN_SYMBOL_SUM", + "LEXER_TOKEN_SYMBOL_SUB", "LEXER_TOKEN_SYMBOL_MULTIPLY", "LEXER_TOKEN_SYMBOL_DIVIDE", "LEXER_TOKEN_SYMBOL_MODULO", @@ -215,6 +217,8 @@ void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter, case LEXER_TOKEN_SYMBOL_COMMA: case LEXER_TOKEN_SYMBOL_PLUS: case LEXER_TOKEN_SYMBOL_MINUS: + case LEXER_TOKEN_SYMBOL_SUM: + case LEXER_TOKEN_SYMBOL_SUB: case LEXER_TOKEN_SYMBOL_MULTIPLY: case LEXER_TOKEN_SYMBOL_DIVIDE: case LEXER_TOKEN_SYMBOL_MODULO: diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h index 656084e..bc38270 100644 --- a/src/compiler/lexer.h +++ b/src/compiler/lexer.h @@ -28,6 +28,8 @@ typedef enum LexerToken { LEXER_TOKEN_SYMBOL_COMMA, LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_SYMBOL_MINUS, + LEXER_TOKEN_SYMBOL_SUM, + LEXER_TOKEN_SYMBOL_SUB, LEXER_TOKEN_SYMBOL_MULTIPLY, LEXER_TOKEN_SYMBOL_DIVIDE, LEXER_TOKEN_SYMBOL_MODULO, diff --git a/src/compiler/parser.c b/src/compiler/parser.c index 4b736b7..24b4984 100644 --- a/src/compiler/parser.c +++ b/src/compiler/parser.c @@ -35,6 +35,8 @@ const char *PARSER_TOKEN_STRINGS[] = { "PARSER_TOKEN_SYMBOL_COMMA", "PARSER_TOKEN_OPERATOR_ASSIGN", + "PARSER_TOKEN_OPERATOR_PLUS", + "PARSER_TOKEN_OPERATOR_MINUS", "PARSER_TOKEN_OPERATOR_SUM", "PARSER_TOKEN_OPERATOR_SUB", "PARSER_TOKEN_OPERATOR_MULTIPLY", @@ -69,6 +71,10 @@ static constexpr ParserOrder PARSER_ORDER[] = { .ltr = false, ORDER_ARRAY(LEXER_TOKEN_SYMBOL_FUNCTION_ARROW, ), }, + { + .ltr = true, + ORDER_ARRAY(LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_SYMBOL_MINUS, ), + }, { .ltr = true, ORDER_ARRAY(LEXER_TOKEN_SYMBOL_MULTIPLY, LEXER_TOKEN_SYMBOL_DIVIDE, @@ -76,7 +82,7 @@ static constexpr ParserOrder PARSER_ORDER[] = { }, { .ltr = true, - ORDER_ARRAY(LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_SYMBOL_MINUS, ), + ORDER_ARRAY(LEXER_TOKEN_SYMBOL_SUM, LEXER_TOKEN_SYMBOL_SUB, ), }, { .ltr = true, @@ -165,6 +171,8 @@ void parserNodePrint(const ParserNode *node, int indent) { printf(" "); } goto RETURN_SUCCESS; + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_KEYWORD_PRINT_U64: case PARSER_TOKEN_SYMBOL_COMMA: case PARSER_TOKEN_SYMBOL_EOL: { @@ -245,6 +253,8 @@ void parserNodePrint(const ParserNode *node, int indent) { parserNodePrint(metadata->params->data[i], indent + 1); printf(",\n"); } + for (int i = 0; i < indent; ++i) + printf(" "); printf("]\n"); for (int i = 0; i < indent; ++i) printf(" "); @@ -313,6 +323,8 @@ void parserNodeDelete(ParserNode *node) { free(metadata); } goto RETURN_SUCCESS; + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_KEYWORD_PRINT_U64: case PARSER_TOKEN_SYMBOL_COMMA: case PARSER_TOKEN_SYMBOL_EOL: { @@ -417,8 +429,9 @@ bool parserNodeArray(LexerNode *begin, LexerNode *end, ParserNode *parent) { for (size_t order_index = 0; order_index < orders.size; ++order_index) { const LexerToken order = orders.data[order_index]; if (iter->token == order) { - ParserNode *parserNode = parseNode(iter, begin, end, parent); - if (parserNode == NULL) { + bool conti = false; + ParserNode *parserNode = parseNode(iter, begin, end, parent, &conti); + if (parserNode == NULL && !conti) { goto RETURN_ERROR; } } @@ -467,7 +480,7 @@ RETURN_ERROR: } ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, - ParserNode *parent) { + ParserNode *parent, bool *conti) { switch (node->token) { case LEXER_TOKEN_IDENTIFIER: return parserIdentifier(node, parent); @@ -503,6 +516,12 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, case LEXER_TOKEN_SYMBOL_ASSIGN: return parserBinaryOperator(node, begin, end, parent, PARSER_TOKEN_OPERATOR_ASSIGN); + case LEXER_TOKEN_SYMBOL_SUM: + return parserBinaryOperator(node, begin, end, parent, + PARSER_TOKEN_OPERATOR_SUM); + case LEXER_TOKEN_SYMBOL_SUB: + return parserBinaryOperator(node, begin, end, parent, + PARSER_TOKEN_OPERATOR_SUB); case LEXER_TOKEN_SYMBOL_MULTIPLY: return parserBinaryOperator(node, begin, end, parent, PARSER_TOKEN_OPERATOR_MULTIPLY); @@ -512,12 +531,20 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, case LEXER_TOKEN_SYMBOL_MODULO: return parserBinaryOperator(node, begin, end, parent, PARSER_TOKEN_OPERATOR_MODULO); - case LEXER_TOKEN_SYMBOL_PLUS: - return parserBinaryOrLeftOperator(node, begin, end, parent, - PARSER_TOKEN_OPERATOR_SUM); - case LEXER_TOKEN_SYMBOL_MINUS: - return parserBinaryOrLeftOperator(node, begin, end, parent, - PARSER_TOKEN_OPERATOR_SUB); + case LEXER_TOKEN_SYMBOL_PLUS: { + ParserNode *result = parserBinaryOrLeftOperator(node, begin, end, parent, + PARSER_TOKEN_OPERATOR_PLUS, + LEXER_TOKEN_SYMBOL_SUM); + *conti = result == NULL; + return result; + } + case LEXER_TOKEN_SYMBOL_MINUS: { + ParserNode *result = parserBinaryOrLeftOperator(node, begin, end, parent, + PARSER_TOKEN_OPERATOR_MINUS, + LEXER_TOKEN_SYMBOL_SUB); + *conti = result == NULL; + return result; + } case LEXER_TOKEN_SYMBOL: case LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS: case LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET: @@ -1004,29 +1031,28 @@ ParserNode *parserBinaryOperator(LexerNode *node, LexerNode *begin, ParserNode *parserBinaryOrLeftOperator(LexerNode *node, LexerNode *begin, LexerNode *end, ParserNode *parent, - ParserToken token) { + ParserToken token, + LexerToken laterToken) { LexerNode *leftNode = node - 1; LexerNode *rightNode = node + 1; - if (leftNode < begin || rightNode >= end) { - printError(node->str_begin, node->str_end, "Bad plus"); + if ((leftNode >= begin && leftNode->parserNode != NULL) || rightNode >= end || + rightNode->parserNode == NULL) { + node->token = laterToken; return NULL; } - ParserNode *left = getUntilCommonParent(leftNode->parserNode, parent); ParserNode *right = getUntilCommonParent(rightNode->parserNode, parent); - if (left == NULL || right == NULL) { - printError(node->str_begin, node->str_end, "Bad plus"); + if (right == NULL) { + node->token = laterToken; return NULL; } - ParserNodeInfixMetadata *metadata = a404m_malloc(sizeof(*metadata)); - metadata->left = left; - metadata->right = right; - - return left->parent = right->parent = node->parserNode = newParserNode( - token, left->str_begin, right->str_end, metadata, parent); + printLog("here"); + return right->parent = node->parserNode = + newParserNode(token, node->str_begin, right->str_end, + (ParserNodeSingleChildMetadata *)right, parent); } bool isAllArguments(const ParserNodeArray *nodes) { @@ -1050,6 +1076,8 @@ bool isExpression(ParserNode *node) { case PARSER_TOKEN_KEYWORD_PRINT_U64: case PARSER_TOKEN_KEYWORD_RETURN: case PARSER_TOKEN_OPERATOR_ASSIGN: + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_OPERATOR_SUM: case PARSER_TOKEN_OPERATOR_SUB: case PARSER_TOKEN_OPERATOR_MULTIPLY: @@ -1096,6 +1124,8 @@ bool isType(ParserNode *node) { case PARSER_TOKEN_KEYWORD_PRINT_U64: case PARSER_TOKEN_KEYWORD_RETURN: case PARSER_TOKEN_OPERATOR_ASSIGN: + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_OPERATOR_SUM: case PARSER_TOKEN_OPERATOR_SUB: case PARSER_TOKEN_OPERATOR_MULTIPLY: @@ -1115,6 +1145,8 @@ bool isValue(ParserNode *node) { case PARSER_TOKEN_VALUE_BOOL: case PARSER_TOKEN_IDENTIFIER: case PARSER_TOKEN_OPERATOR_ASSIGN: + case PARSER_TOKEN_OPERATOR_PLUS: + case PARSER_TOKEN_OPERATOR_MINUS: case PARSER_TOKEN_OPERATOR_SUM: case PARSER_TOKEN_OPERATOR_SUB: case PARSER_TOKEN_OPERATOR_MULTIPLY: diff --git a/src/compiler/parser.h b/src/compiler/parser.h index 0b92fe5..2d57538 100644 --- a/src/compiler/parser.h +++ b/src/compiler/parser.h @@ -30,6 +30,8 @@ typedef enum ParserToken { PARSER_TOKEN_SYMBOL_COMMA, PARSER_TOKEN_OPERATOR_ASSIGN, + PARSER_TOKEN_OPERATOR_PLUS, + PARSER_TOKEN_OPERATOR_MINUS, PARSER_TOKEN_OPERATOR_SUM, PARSER_TOKEN_OPERATOR_SUB, PARSER_TOKEN_OPERATOR_MULTIPLY, @@ -111,7 +113,7 @@ ParserNode *newParserNode(ParserToken token, char *str_begin, char *str_end, void *metadata, ParserNode *parent); ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, - ParserNode *parent); + ParserNode *parent, bool *conti); ParserNode *getUntilCommonParent(ParserNode *node, ParserNode *parent); @@ -137,8 +139,10 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end, ParserNode *parserBinaryOperator(LexerNode *node, LexerNode *begin, LexerNode *end, ParserNode *parent, ParserToken token); -ParserNode *parserBinaryOrLeftOperator(LexerNode *node, LexerNode *begin, LexerNode *end, - ParserNode *parent,ParserToken token); +ParserNode *parserBinaryOrLeftOperator(LexerNode *node, LexerNode *begin, + LexerNode *end, ParserNode *parent, + ParserToken token, + LexerToken laterToken); bool isAllArguments(const ParserNodeArray *nodes); diff --git a/src/main.c b/src/main.c index 8a61324..4b7747b 100644 --- a/src/main.c +++ b/src/main.c @@ -111,7 +111,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 9c3e7e2..5235cac 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -204,6 +204,8 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTree **arguments, runnerVariableSetValue(&pages, variable, copyAstTree(variable->value)); } continue; + 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: @@ -295,6 +297,31 @@ AstTree *calcAstTreeValue(AstTree *tree, RunnerVariablePages *pages) { UNREACHABLE; } } + UNREACHABLE; + } + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: { + AstTreeSingleChild *metadata = tree->metadata; + if (typeIsEqual(metadata->type, &AST_TREE_U64_TYPE)) { + AstTree *operand = calcAstTreeValue(metadata, pages); + if (operand->token == AST_TREE_TOKEN_VALUE_U64) { + switch (tree->token) { + case AST_TREE_TOKEN_OPERATOR_PLUS: + operand->metadata = (void *)(+(AstTreeU64)operand->metadata); + break; + case AST_TREE_TOKEN_OPERATOR_MINUS: + operand->metadata = (void *)(-(AstTreeU64)operand->metadata); + break; + default: + UNREACHABLE; + } + return operand; + } else { + UNREACHABLE; + } + } else { + UNREACHABLE; + } } case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_KEYWORD_PRINT_U64: @@ -330,6 +357,8 @@ AstTree *deepCopyAstTree(AstTree *tree) { case AST_TREE_TOKEN_FUNCTION_CALL: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_OPERATOR_ASSIGN: + 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: diff --git a/src/utils/string.c b/src/utils/string.c index a5baab4..5f9b7de 100644 --- a/src/utils/string.c +++ b/src/utils/string.c @@ -1,6 +1,5 @@ #include "string.h" #include "memory.h" -#include "utils/log.h" #include #include -- cgit v1.2.3