From 302cc65d3e59937742c18475d63e22c482176fa7 Mon Sep 17 00:00:00 2001
From: A404M <ahmadmahmoudiprogrammer@gmail.com>
Date: Mon, 10 Feb 2025 00:17:29 +0330
Subject: add - * / %
---
src/compiler/ast-tree.c | 114 +++++++++++++++++++++++++++++++-----------------
src/compiler/ast-tree.h | 13 +++---
src/compiler/lexer.c | 17 +++++++-
src/compiler/lexer.h | 4 ++
src/compiler/parser.c | 94 ++++++++++++++++++++++++++++-----------
src/compiler/parser.h | 13 ++++--
6 files changed, 180 insertions(+), 75 deletions(-)
(limited to 'src/compiler')
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index ea5da0b..d7769bc 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -58,6 +58,10 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
"AST_TREE_TOKEN_OPERATOR_ASSIGN",
"AST_TREE_TOKEN_OPERATOR_SUM",
+ "AST_TREE_TOKEN_OPERATOR_SUB",
+ "AST_TREE_TOKEN_OPERATOR_MULTIPLY",
+ "AST_TREE_TOKEN_OPERATOR_DIVIDE",
+ "AST_TREE_TOKEN_OPERATOR_MODULO",
"AST_TREE_TOKEN_NONE",
};
@@ -184,6 +188,10 @@ void astTreePrint(const AstTree *tree, int indent) {
}
goto RETURN_SUCCESS;
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
case AST_TREE_TOKEN_OPERATOR_ASSIGN: {
AstTreeInfix *metadata = tree->metadata;
printf(",\n");
@@ -290,6 +298,10 @@ void astTreeDestroy(AstTree tree) {
}
return;
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
case AST_TREE_TOKEN_OPERATOR_ASSIGN: {
AstTreeInfix *metadata = tree.metadata;
astTreeDestroy(metadata->left);
@@ -374,7 +386,11 @@ AstTree *copyAstTree(AstTree *tree) {
tree->str_begin, tree->str_end);
}
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
- case AST_TREE_TOKEN_OPERATOR_SUM: {
+ case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO: {
AstTreeInfix *metadata = tree->metadata;
AstTreeInfix *new_metadata = a404m_malloc(sizeof(*new_metadata));
AstTree *left = copyAstTree(&metadata->left);
@@ -487,7 +503,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
for (size_t i = 0; i < nodes->size; ++i) {
ParserNode *eol = nodes->data[i];
if (eol->token != PARSER_TOKEN_SYMBOL_EOL) {
- printError(eol->str_begin, eol->str_end, "Unexpected %s",
+ printError(eol->str_begin, eol->str_end, "Did you forgot semicolon?",
PARSER_TOKEN_STRINGS[eol->token]);
goto RETURN_ERROR;
}
@@ -536,6 +552,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
case PARSER_TOKEN_VALUE_BOOL:
case PARSER_TOKEN_VALUE_U64:
case PARSER_TOKEN_FUNCTION_DEFINITION:
+ case PARSER_TOKEN_FUNCTION_CALL:
goto AFTER_SWITCH;
case PARSER_TOKEN_ROOT:
case PARSER_TOKEN_IDENTIFIER:
@@ -552,9 +569,12 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
case PARSER_TOKEN_SYMBOL_CURLY_BRACKET:
case PARSER_TOKEN_SYMBOL_PARENTHESIS:
case PARSER_TOKEN_SYMBOL_COMMA:
- case PARSER_TOKEN_FUNCTION_CALL:
case PARSER_TOKEN_OPERATOR_ASSIGN:
case PARSER_TOKEN_OPERATOR_SUM:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO:
printError(node->str_begin, node->str_end, "Should not be here");
goto RETURN_ERROR;
case PARSER_TOKEN_NONE:
@@ -675,9 +695,23 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables,
case PARSER_TOKEN_KEYWORD_RETURN:
return astTreeParseReturn(parserNode, variables, variables_size);
case PARSER_TOKEN_OPERATOR_ASSIGN:
- return astTreeParseAssign(parserNode, variables, variables_size);
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_ASSIGN);
case PARSER_TOKEN_OPERATOR_SUM:
- return astTreeParseSum(parserNode, variables, variables_size);
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_SUM);
+ case PARSER_TOKEN_OPERATOR_SUB:
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_SUB);
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_MULTIPLY);
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_DIVIDE);
+ case PARSER_TOKEN_OPERATOR_MODULO:
+ return astTreeParseBinaryOperator(parserNode, variables, variables_size,
+ AST_TREE_TOKEN_OPERATOR_MODULO);
case PARSER_TOKEN_VARIABLE:
return astTreeParseVariable(parserNode, variables, variables_size);
case PARSER_TOKEN_CONSTANT:
@@ -944,35 +978,9 @@ AstTree *astTreeParseReturn(ParserNode *parserNode,
parserNode->str_begin, parserNode->str_end);
}
-AstTree *astTreeParseAssign(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_ASSIGN, metadata, NULL,
- parserNode->str_begin, parserNode->str_end);
-}
-
-AstTree *astTreeParseSum(ParserNode *parserNode, AstTreeVariables **variables,
- size_t variables_size) {
+AstTree *astTreeParseBinaryOperator(ParserNode *parserNode,
+ AstTreeVariables **variables,
+ size_t variables_size, AstTreeToken token) {
ParserNodeInfixMetadata *node_metadata = parserNode->metadata;
AstTree *left = astTreeParse(node_metadata->left, variables, variables_size);
@@ -993,8 +1001,8 @@ AstTree *astTreeParseSum(ParserNode *parserNode, AstTreeVariables **variables,
free(left);
free(right);
- return newAstTree(AST_TREE_TOKEN_OPERATOR_SUM, metadata, NULL,
- parserNode->str_begin, parserNode->str_end);
+ return newAstTree(token, metadata, NULL, parserNode->str_begin,
+ parserNode->str_end);
}
bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables,
@@ -1115,6 +1123,10 @@ AstTreeFunction *getFunction(AstTree *value) {
case AST_TREE_TOKEN_VARIABLE_DEFINE:
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
return NULL;
case AST_TREE_TOKEN_NONE:
}
@@ -1139,6 +1151,10 @@ bool isConst(AstTree *value) {
case AST_TREE_TOKEN_VARIABLE_DEFINE:
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
return false;
case AST_TREE_TOKEN_VARIABLE: {
AstTreeVariable *metadata = value->metadata;
@@ -1190,7 +1206,11 @@ AstTree *makeTypeOf(AstTree *value) {
return copyAstTree(variable->type);
}
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
- case AST_TREE_TOKEN_OPERATOR_SUM: {
+ case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO: {
AstTreeInfix *metadata = value->metadata;
return copyAstTree(metadata->left.type);
}
@@ -1213,6 +1233,10 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
case AST_TREE_TOKEN_VARIABLE_DEFINE:
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
return false;
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_VOID:
@@ -1289,7 +1313,11 @@ bool setAllTypes(AstTree *tree, AstTreeFunction *function) {
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
return setTypesOperatorAssign(tree);
case AST_TREE_TOKEN_OPERATOR_SUM:
- return setTypesOperatorSum(tree);
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
+ return setTypesOperatorInfix(tree);
case AST_TREE_TOKEN_VARIABLE_DEFINE:
return setTypesVariableDefine(tree);
case AST_TREE_TOKEN_NONE:
@@ -1429,7 +1457,7 @@ bool setTypesOperatorAssign(AstTree *tree) {
}
}
-bool setTypesOperatorSum(AstTree *tree) {
+bool setTypesOperatorInfix(AstTree *tree) {
AstTreeInfix *infix = tree->metadata;
if (!setTypesAstInfix(infix)) {
return false;
@@ -1500,6 +1528,10 @@ bool astTreeClean(AstTree *tree) {
case AST_TREE_TOKEN_VARIABLE_DEFINE:
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
return true;
case AST_TREE_TOKEN_NONE:
}
@@ -1586,6 +1618,10 @@ size_t astTreeTypeSize(AstTree tree) {
case AST_TREE_TOKEN_VALUE_BOOL:
case AST_TREE_TOKEN_OPERATOR_ASSIGN:
case AST_TREE_TOKEN_OPERATOR_SUM:
+ case AST_TREE_TOKEN_OPERATOR_SUB:
+ case AST_TREE_TOKEN_OPERATOR_MULTIPLY:
+ case AST_TREE_TOKEN_OPERATOR_DIVIDE:
+ case AST_TREE_TOKEN_OPERATOR_MODULO:
case AST_TREE_TOKEN_NONE:
}
UNREACHABLE;
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index d67560f..9caef63 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -25,6 +25,10 @@ typedef enum AstTreeToken {
AST_TREE_TOKEN_OPERATOR_ASSIGN,
AST_TREE_TOKEN_OPERATOR_SUM,
+ AST_TREE_TOKEN_OPERATOR_SUB,
+ AST_TREE_TOKEN_OPERATOR_MULTIPLY,
+ AST_TREE_TOKEN_OPERATOR_DIVIDE,
+ AST_TREE_TOKEN_OPERATOR_MODULO,
AST_TREE_TOKEN_NONE,
} AstTreeToken;
@@ -146,12 +150,9 @@ AstTree *astTreeParseReturn(ParserNode *parserNode,
AstTreeVariables **variables,
size_t variables_size);
-AstTree *astTreeParseAssign(ParserNode *parserNode,
+AstTree *astTreeParseBinaryOperator(ParserNode *parserNode,
AstTreeVariables **variables,
- size_t variables_size);
-
-AstTree *astTreeParseSum(ParserNode *parserNode, AstTreeVariables **variables,
- size_t variables_size);
+ size_t variables_size,AstTreeToken token);
bool astTreeParseConstant(ParserNode *parserNode, AstTreeVariables **variables,
size_t variables_size);
@@ -174,7 +175,7 @@ bool setTypesTypeFunction(AstTree *tree);
bool setTypesFunctionCall(AstTree *tree);
bool setTypesVariable(AstTree *tree);
bool setTypesOperatorAssign(AstTree *tree);
-bool setTypesOperatorSum(AstTree *tree);
+bool setTypesOperatorInfix(AstTree *tree);
bool setTypesVariableDefine(AstTree *tree);
bool setTypesAstVariable(AstTreeVariable *variable);
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 52702ba..70cd1fb 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -33,12 +33,16 @@ const char *LEXER_TOKEN_STRINGS[] = {
"LEXER_TOKEN_SYMBOL_ASSIGN",
"LEXER_TOKEN_SYMBOL_COMMA",
"LEXER_TOKEN_SYMBOL_PLUS",
+ "LEXER_TOKEN_SYMBOL_MINUS",
+ "LEXER_TOKEN_SYMBOL_MULTIPLY",
+ "LEXER_TOKEN_SYMBOL_DIVIDE",
+ "LEXER_TOKEN_SYMBOL_MODULO",
"LEXER_TOKEN_NONE",
};
const char *LEXER_SYMBOL_STRINGS[] = {
- ";", "(", ")", "{", "}", "->", ":", "=", ",", "+",
+ ";", "(", ")", "{", "}", "->", ":", "=", ",", "+", "-", "*", "/", "%",
};
const LexerToken LEXER_SYMBOL_TOKENS[] = {
LEXER_TOKEN_SYMBOL_EOL,
@@ -51,6 +55,10 @@ const LexerToken LEXER_SYMBOL_TOKENS[] = {
LEXER_TOKEN_SYMBOL_ASSIGN,
LEXER_TOKEN_SYMBOL_COMMA,
LEXER_TOKEN_SYMBOL_PLUS,
+ LEXER_TOKEN_SYMBOL_MINUS,
+ LEXER_TOKEN_SYMBOL_MULTIPLY,
+ LEXER_TOKEN_SYMBOL_DIVIDE,
+ LEXER_TOKEN_SYMBOL_MODULO,
};
const size_t LEXER_SYMBOL_SIZE =
sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS);
@@ -119,6 +127,9 @@ LexerNodeArray lexer(char *str) {
goto RETURN_ERROR;
}
}
+ } else {
+ --iter;
+ c = *iter;
}
}
if (isSpace(c)) {
@@ -198,6 +209,10 @@ void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter,
case LEXER_TOKEN_SYMBOL_ASSIGN:
case LEXER_TOKEN_SYMBOL_COMMA:
case LEXER_TOKEN_SYMBOL_PLUS:
+ case LEXER_TOKEN_SYMBOL_MINUS:
+ case LEXER_TOKEN_SYMBOL_MULTIPLY:
+ case LEXER_TOKEN_SYMBOL_DIVIDE:
+ case LEXER_TOKEN_SYMBOL_MODULO:
if (*array_size == array->size) {
*array_size += 1 + *array_size / 2;
array->data =
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 6c0660f..6723cc9 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -27,6 +27,10 @@ typedef enum LexerToken {
LEXER_TOKEN_SYMBOL_ASSIGN,
LEXER_TOKEN_SYMBOL_COMMA,
LEXER_TOKEN_SYMBOL_PLUS,
+ LEXER_TOKEN_SYMBOL_MINUS,
+ LEXER_TOKEN_SYMBOL_MULTIPLY,
+ LEXER_TOKEN_SYMBOL_DIVIDE,
+ LEXER_TOKEN_SYMBOL_MODULO,
LEXER_TOKEN_NONE,
} LexerToken;
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index f61836e..4b736b7 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -36,6 +36,10 @@ const char *PARSER_TOKEN_STRINGS[] = {
"PARSER_TOKEN_OPERATOR_ASSIGN",
"PARSER_TOKEN_OPERATOR_SUM",
+ "PARSER_TOKEN_OPERATOR_SUB",
+ "PARSER_TOKEN_OPERATOR_MULTIPLY",
+ "PARSER_TOKEN_OPERATOR_DIVIDE",
+ "PARSER_TOKEN_OPERATOR_MODULO",
"PARSER_TOKEN_FUNCTION_DEFINITION",
@@ -67,7 +71,12 @@ static constexpr ParserOrder PARSER_ORDER[] = {
},
{
.ltr = true,
- ORDER_ARRAY(LEXER_TOKEN_SYMBOL_PLUS, ),
+ ORDER_ARRAY(LEXER_TOKEN_SYMBOL_MULTIPLY, LEXER_TOKEN_SYMBOL_DIVIDE,
+ LEXER_TOKEN_SYMBOL_MODULO, ),
+ },
+ {
+ .ltr = true,
+ ORDER_ARRAY(LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_SYMBOL_MINUS, ),
},
{
.ltr = true,
@@ -242,7 +251,11 @@ void parserNodePrint(const ParserNode *node, int indent) {
}
goto RETURN_SUCCESS;
case PARSER_TOKEN_OPERATOR_ASSIGN:
- case PARSER_TOKEN_OPERATOR_SUM: {
+ case PARSER_TOKEN_OPERATOR_SUM:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO: {
const ParserNodeInfixMetadata *metadata = node->metadata;
printf(",\n");
for (int i = 0; i < indent; ++i)
@@ -342,14 +355,17 @@ void parserNodeDelete(ParserNode *node) {
}
goto RETURN_SUCCESS;
case PARSER_TOKEN_OPERATOR_ASSIGN:
- case PARSER_TOKEN_OPERATOR_SUM: {
+ case PARSER_TOKEN_OPERATOR_SUM:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO: {
ParserNodeInfixMetadata *metadata = node->metadata;
parserNodeDelete(metadata->left);
parserNodeDelete(metadata->right);
free(metadata);
}
goto RETURN_SUCCESS;
-
case PARSER_TOKEN_NONE:
}
UNREACHABLE;
@@ -412,12 +428,13 @@ bool parserNodeArray(LexerNode *begin, LexerNode *end, ParserNode *parent) {
for (LexerNode *iter = begin; iter < end; ++iter) {
ParserNode *pNode = iter->parserNode;
- if (pNode->parent != parent) {
- continue;
- } else if (pNode == NULL) {
- printError(pNode->str_begin, pNode->str_end, "Bad child");
+ if (pNode == NULL) {
+ printError(iter->str_begin, iter->str_end, "Bad child");
goto RETURN_ERROR;
+ } else if (pNode->parent != parent) {
+ continue;
}
+
for (size_t i = 0; i < parsedNodes->size; ++i) {
if (parsedNodes->data[i] == pNode) {
goto CONTINUE;
@@ -484,13 +501,28 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
case LEXER_TOKEN_NUMBER:
return parserNumber(node, parent);
case LEXER_TOKEN_SYMBOL_ASSIGN:
- return parserAssign(node, begin, end, parent);
+ return parserBinaryOperator(node, begin, end, parent,
+ PARSER_TOKEN_OPERATOR_ASSIGN);
+ case LEXER_TOKEN_SYMBOL_MULTIPLY:
+ return parserBinaryOperator(node, begin, end, parent,
+ PARSER_TOKEN_OPERATOR_MULTIPLY);
+ case LEXER_TOKEN_SYMBOL_DIVIDE:
+ return parserBinaryOperator(node, begin, end, parent,
+ PARSER_TOKEN_OPERATOR_DIVIDE);
+ case LEXER_TOKEN_SYMBOL_MODULO:
+ return parserBinaryOperator(node, begin, end, parent,
+ PARSER_TOKEN_OPERATOR_MODULO);
case LEXER_TOKEN_SYMBOL_PLUS:
- return parserPlus(node, begin, end, parent);
+ 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:
case LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS:
case LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET:
case LEXER_TOKEN_NONE:
+ break;
}
UNREACHABLE;
}
@@ -915,7 +947,7 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end,
} else {
value = getUntilCommonParent(valueNode->parserNode, parent);
if (!isValue(value)) {
- printError(name->str_begin, name->str_end, "No value");
+ printError(name->str_begin, name->str_end, "Bad value");
return NULL;
}
value->parent = variableNode;
@@ -943,13 +975,14 @@ RETURN_ERROR:
return NULL;
}
-ParserNode *parserAssign(LexerNode *node, LexerNode *begin, LexerNode *end,
- ParserNode *parent) {
+ParserNode *parserBinaryOperator(LexerNode *node, LexerNode *begin,
+ LexerNode *end, ParserNode *parent,
+ ParserToken token) {
LexerNode *leftNode = node - 1;
LexerNode *rightNode = node + 1;
if (leftNode < begin || rightNode >= end) {
- printError(node->str_begin, node->str_end, "Bad assign");
+ printError(node->str_begin, node->str_end, "Bad binary operator");
return NULL;
}
@@ -957,7 +990,7 @@ ParserNode *parserAssign(LexerNode *node, LexerNode *begin, LexerNode *end,
ParserNode *right = getUntilCommonParent(rightNode->parserNode, parent);
if (left == NULL || right == NULL) {
- printError(node->str_begin, node->str_end, "Bad assign");
+ printError(node->str_begin, node->str_end, "Bad binary operator");
return NULL;
}
@@ -965,13 +998,13 @@ ParserNode *parserAssign(LexerNode *node, LexerNode *begin, LexerNode *end,
metadata->left = left;
metadata->right = right;
- return left->parent = right->parent = node->parserNode =
- newParserNode(PARSER_TOKEN_OPERATOR_ASSIGN, left->str_begin,
- right->str_end, metadata, parent);
+ return left->parent = right->parent = node->parserNode = newParserNode(
+ token, left->str_begin, right->str_end, metadata, parent);
}
-ParserNode *parserPlus(LexerNode *node, LexerNode *begin, LexerNode *end,
- ParserNode *parent) {
+ParserNode *parserBinaryOrLeftOperator(LexerNode *node, LexerNode *begin,
+ LexerNode *end, ParserNode *parent,
+ ParserToken token) {
LexerNode *leftNode = node - 1;
LexerNode *rightNode = node + 1;
@@ -992,9 +1025,8 @@ ParserNode *parserPlus(LexerNode *node, LexerNode *begin, LexerNode *end,
metadata->left = left;
metadata->right = right;
- return left->parent = right->parent = node->parserNode =
- newParserNode(PARSER_TOKEN_OPERATOR_SUM, left->str_begin,
- right->str_end, metadata, parent);
+ return left->parent = right->parent = node->parserNode = newParserNode(
+ token, left->str_begin, right->str_end, metadata, parent);
}
bool isAllArguments(const ParserNodeArray *nodes) {
@@ -1019,6 +1051,10 @@ bool isExpression(ParserNode *node) {
case PARSER_TOKEN_KEYWORD_RETURN:
case PARSER_TOKEN_OPERATOR_ASSIGN:
case PARSER_TOKEN_OPERATOR_SUM:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO:
case PARSER_TOKEN_VALUE_U64:
case PARSER_TOKEN_VALUE_BOOL:
return true;
@@ -1061,6 +1097,10 @@ bool isType(ParserNode *node) {
case PARSER_TOKEN_KEYWORD_RETURN:
case PARSER_TOKEN_OPERATOR_ASSIGN:
case PARSER_TOKEN_OPERATOR_SUM:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO:
return false;
case PARSER_TOKEN_NONE:
}
@@ -1076,12 +1116,16 @@ bool isValue(ParserNode *node) {
case PARSER_TOKEN_IDENTIFIER:
case PARSER_TOKEN_OPERATOR_ASSIGN:
case PARSER_TOKEN_OPERATOR_SUM:
- return true;
- case PARSER_TOKEN_TYPE_FUNCTION:
+ case PARSER_TOKEN_OPERATOR_SUB:
+ case PARSER_TOKEN_OPERATOR_MULTIPLY:
+ case PARSER_TOKEN_OPERATOR_DIVIDE:
+ case PARSER_TOKEN_OPERATOR_MODULO:
case PARSER_TOKEN_TYPE_TYPE:
case PARSER_TOKEN_TYPE_VOID:
case PARSER_TOKEN_TYPE_U64:
case PARSER_TOKEN_TYPE_BOOL:
+ return true;
+ case PARSER_TOKEN_TYPE_FUNCTION:
case PARSER_TOKEN_CONSTANT:
case PARSER_TOKEN_VARIABLE:
case PARSER_TOKEN_SYMBOL_PARENTHESIS:
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index 29a303c..0b92fe5 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -31,6 +31,10 @@ typedef enum ParserToken {
PARSER_TOKEN_OPERATOR_ASSIGN,
PARSER_TOKEN_OPERATOR_SUM,
+ PARSER_TOKEN_OPERATOR_SUB,
+ PARSER_TOKEN_OPERATOR_MULTIPLY,
+ PARSER_TOKEN_OPERATOR_DIVIDE,
+ PARSER_TOKEN_OPERATOR_MODULO,
PARSER_TOKEN_FUNCTION_DEFINITION,
@@ -130,10 +134,11 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end,
ParserNode *parent);
ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end,
ParserNode *parent);
-ParserNode *parserAssign(LexerNode *node, LexerNode *begin, LexerNode *end,
- ParserNode *parent);
-ParserNode *parserPlus(LexerNode *node, LexerNode *begin, LexerNode *end,
- ParserNode *parent);
+ParserNode *parserBinaryOperator(LexerNode *node, LexerNode *begin,
+ LexerNode *end, ParserNode *parent,
+ ParserToken token);
+ParserNode *parserBinaryOrLeftOperator(LexerNode *node, LexerNode *begin, LexerNode *end,
+ ParserNode *parent,ParserToken token);
bool isAllArguments(const ParserNodeArray *nodes);
--
cgit v1.2.3