From addd54dc31603dc204773d3108dba4e000cd7657 Mon Sep 17 00:00:00 2001 From: A404M Date: Tue, 8 Oct 2024 04:16:27 +0330 Subject: added fasm support added compiler options tried to compile to fasm first --- src/compiler/tree_parser/tree_parser.c | 262 ++++++++++++++++++++++++--------- 1 file changed, 194 insertions(+), 68 deletions(-) (limited to 'src/compiler/tree_parser/tree_parser.c') diff --git a/src/compiler/tree_parser/tree_parser.c b/src/compiler/tree_parser/tree_parser.c index f657f97..07bad0a 100644 --- a/src/compiler/tree_parser/tree_parser.c +++ b/src/compiler/tree_parser/tree_parser.c @@ -1,15 +1,9 @@ #include "tree_parser.h" -#include -#include -#include -#include #include #include #include #include -#include -#include const char *TREE_TOKEN_STRINGS[] = { "TREE_TOKEN_NONE", @@ -25,10 +19,27 @@ const char *TREE_TOKEN_STRINGS[] = { "TREE_TOKEN_FUNCTION", }; +static void _printParsedTreeVariable(const TreeDefineVariableMetadata *variable, + int indent) { + if (variable == NULL) { + for (int i = 0; i < indent; ++i) printf(" "); + printf("null\n"); + return; + } + for (int i = 0; i < indent; ++i) printf(" "); + printf("{name='%.*s',type=%p,value=\n", + (int)(variable->nameEnd - variable->nameBegin), variable->nameBegin, + variable->type); + _printParsedTreeNode(variable->value, indent + 1); + for (int i = 0; i < indent; ++i) printf(" "); + printf("}\n"); +} + void _printParsedTreeNode(const ParsedTree *parsedTree, int indent) { + for (int i = 0; i < indent; ++i) printf(" "); if (parsedTree == NULL) { - for (int i = 0; i < indent; ++i) printf(" "); printf("null\n"); + return; } printf("{token=%s", TREE_TOKEN_STRINGS[parsedTree->token]); switch (parsedTree->token) { @@ -36,19 +47,83 @@ void _printParsedTreeNode(const ParsedTree *parsedTree, int indent) { goto RETURN_SUCCESS; case TREE_TOKEN_ROOT: case TREE_TOKEN_GLOBAL_SCOPE: - case TREE_TOKEN_LOCAL_SCOPE: - case TREE_TOKEN_FUNCTION_CALL: + case TREE_TOKEN_LOCAL_SCOPE: { + const TreeScopeMetadata *metadata = parsedTree->metadata; + for (int i = 0; i < indent; ++i) printf(" "); + printf(",lines=\n"); + for (size_t i = 0; i < metadata->lines_size; ++i) { + _printParsedTreeNode(metadata->lines[i], indent + 1); + } + for (int i = 0; i < indent; ++i) printf(" "); + printf(",variables=\n"); + for (size_t i = 0; i < metadata->variables_size; ++i) { + _printParsedTreeVariable(metadata->variables[i], indent + 1); + } + goto RETURN_SUCCESS; + } + case TREE_TOKEN_FUNCTION_CALL: { + const TreeFunctionCallMetadata *metadata = parsedTree->metadata; + printf(",lines=\n"); + for (size_t i = 0; i < metadata->values_size; ++i) { + _printParsedTreeNode(metadata->values[i], indent + 1); + } + goto RETURN_SUCCESS; + } case TREE_TOKEN_DEFINE_VARIABLE: - case TREE_TOKEN_IDENTIFIER: - case TREE_TOKEN_VALUE_STRING: - case TREE_TOKEN_STRUCT: - case TREE_TOKEN_DEFINE_CONSTANT: - case TREE_TOKEN_FUNCTION: + case TREE_TOKEN_DEFINE_CONSTANT: { + const TreeDefineVariableMetadata *metadata = parsedTree->metadata; + printf(",define=\n"); + _printParsedTreeVariable(metadata, indent + 1); + goto RETURN_SUCCESS; + } + case TREE_TOKEN_IDENTIFIER: { + const TreeIdentifierMetadata *metadata = parsedTree->metadata; + printf(",variable=\n"); + _printParsedTreeVariable(metadata->variable, indent + 1); + goto RETURN_SUCCESS; + } + case TREE_TOKEN_VALUE_STRING: { + const TreeStringValueMetadata *metadata = parsedTree->metadata; + printf(",str='%.*s'\n", (int)metadata->size, metadata->str); + goto RETURN_SUCCESS; + } + case TREE_TOKEN_STRUCT: { + const TreeStructMetadata *metadata = parsedTree->metadata; + printf(",metadata=%p\n", metadata); + goto RETURN_SUCCESS; + } + case TREE_TOKEN_FUNCTION: { + const TreeFunctionMetadata *metadata = parsedTree->metadata; + const TreeScopeMetadata *scope = metadata->scope; + printf(",scope=\n"); + if (scope != NULL) { + for (int i = 0; i < indent; ++i) printf(" "); + printf(",lines=\n"); + for (size_t i = 0; i < scope->lines_size; ++i) { + _printParsedTreeNode(scope->lines[i], indent + 1); + } + for (int i = 0; i < indent; ++i) printf(" "); + printf(",variables=\n"); + for (size_t i = 0; i < scope->variables_size; ++i) { + _printParsedTreeVariable(scope->variables[i], indent + 1); + } + } else { + for (int i = 0; i < indent; ++i) printf(" "); + printf("null\n"); + } + for (int i = 0; i < indent; ++i) printf(" "); + printf(",params=\n"); + for (size_t i = 0; i < metadata->params_size; ++i) { + _printParsedTreeVariable(metadata->params[i], indent + 1); + } + goto RETURN_SUCCESS; + } } fprintf(stderr, "bad parsed tree token %d at %s:%d", parsedTree->token, __FILE_NAME__, __LINE__); exit(1); RETURN_SUCCESS: + for (int i = 0; i < indent; ++i) printf(" "); printf("}\n"); }; @@ -143,6 +218,9 @@ ParsedTree *treeParser(SourceCode *code) { for (size_t i = 0; i < code->size; ++i) { ParsedNode *const nParsedNode = parser(code, i); + if (nParsedNode == NULL) { + goto RETURN_ERROR; + } ParserScopeMetadata *const nscope = nParsedNode->metadata; for (size_t j = 0; j < nscope->operands_size; ++j) { size_t scopeSize = @@ -160,12 +238,52 @@ ParsedTree *treeParser(SourceCode *code) { nscope->operands_size = 0; deleteParsedNode(nParsedNode); } - if (parsedNode == NULL) { - return NULL; + ParsedTree *tree = _treeParser(parsedNode, code); + deleteParsedNode(parsedNode); + return tree; +RETURN_ERROR: + deleteParsedNode(parsedNode); + return NULL; +} + +ParsedTree *treeParserWithPrint(SourceCode *code) { + ParserScopeMetadata *scope = a404m_malloc(sizeof(*scope)); + scope->operands_size = 0; + scope->operands = a404m_malloc(scope->operands_size * sizeof(ParsedNode *)); + ParsedNode *const parsedNode = + newParsedNode(NULL, NULL, PARSED_TOKEN_ROOT, scope, NULL); + + for (size_t i = 0; i < code->size; ++i) { + ParsedNode *const nParsedNode = parserWithPrint(code, i); + if (nParsedNode == NULL) { + fprintf(stderr, "Error in parser"); + goto RETURN_ERROR; + } + printf("----parsed '%s'\n", code->codes[i]->filePath); + printParsedNode(parsedNode); + ParserScopeMetadata *const nscope = nParsedNode->metadata; + for (size_t j = 0; j < nscope->operands_size; ++j) { + size_t scopeSize = + a404m_malloc_usable_size(scope->operands) / sizeof(ParsedNode *); + if (scopeSize == scope->operands_size) { + scopeSize += scopeSize / 2 + 1; + scope->operands = + a404m_realloc(scope->operands, scopeSize * sizeof(ParsedNode *)); + } + scope->operands[scope->operands_size] = nscope->operands[j]; + scope->operands_size += 1; + } + free(nscope->operands); + nscope->operands = NULL; + nscope->operands_size = 0; + deleteParsedNode(nParsedNode); } ParsedTree *tree = _treeParser(parsedNode, code); deleteParsedNode(parsedNode); return tree; +RETURN_ERROR: + deleteParsedNode(parsedNode); + return NULL; } ParsedTree *_treeParser(const ParsedNode *node, SourceCode *code) { @@ -275,7 +393,7 @@ ParsedTree *treeParseLocalScope(const ParsedNode *node, SourceCode *code, const size_t newScopes_size = scopes_size + 1; TreeScopeMetadata *newScopes[newScopes_size]; - memcpy(newScopes, scopes, scopes_size); + memcpy(newScopes, scopes, scopes_size * sizeof(TreeScopeMetadata *)); newScopes[newScopes_size - 1] = metadata; for (size_t i = 0; i < operands_size; ++i) { @@ -285,31 +403,18 @@ ParsedTree *treeParseLocalScope(const ParsedNode *node, SourceCode *code, if (parsedTree == NULL) { goto RETURN_ERROR; } - switch (parsedTree->token) { - case TREE_TOKEN_ROOT: - printError("It is not allowed here", code, operand->strBegin, - operand->strEnd); - goto RETURN_ERROR; - case TREE_TOKEN_DEFINE_CONSTANT: - case TREE_TOKEN_DEFINE_VARIABLE: { - TreeDefineVariableMetadata *const variableDefine = parsedTree->metadata; - if (variableDefine == NULL) { - goto RETURN_ERROR; - } - pushVariableToScope(metadata, variableDefine); - } - /* fall through */ - default: - pushLineToScope(metadata, parsedTree); - continue; + if (parsedTree->token != TREE_TOKEN_ROOT) { + pushLineToScope(metadata, parsedTree); + } else { + printError("'%s' Is not allowed here", code, operand->strBegin, + operand->strEnd, PARSED_TOKEN_STRINGS[operand->token]); + goto RETURN_ERROR; } - printError("'%s' Is not allowed here", code, operand->strBegin, - operand->strEnd, PARSED_TOKEN_STRINGS[operand->token]); - goto RETURN_ERROR; } - metadata->variables = - a404m_realloc(metadata->variables, metadata->variables_size); + metadata->variables = a404m_realloc( + metadata->variables, + metadata->variables_size * sizeof(TreeDefineVariableMetadata *)); return tree; @@ -327,37 +432,37 @@ TreeDefineVariableMetadata *treeParseDefineVariable(ParsedTree *tree, TreeDefineVariableMetadata *define = a404m_malloc(sizeof(*define)); define->tree = tree; - ParserVariableDefineMetadata *metadata = node->metadata; + const ParserVariableDefineMetadata *node_metadata = node->metadata; - if (metadata->value == NULL) { + if (node_metadata->value == NULL) { define->value = NULL; - } else if ((define->value = treeParseExpr(metadata->value, code, scopes, + } else if ((define->value = treeParseExpr(node_metadata->value, code, scopes, scopes_size)) == NULL) { goto RETURN_ERROR; } - if (metadata->name->token == PARSED_TOKEN_IDENTIFIER) { - define->nameBegin = metadata->name->strBegin; - define->nameEnd = metadata->name->strEnd; + if (node_metadata->name->token == PARSED_TOKEN_IDENTIFIER) { + define->nameBegin = node_metadata->name->strBegin; + define->nameEnd = node_metadata->name->strEnd; } else { - printError("Names should be an identifier", code, metadata->name->strBegin, - metadata->name->strEnd); + printError("Names should be an identifier", code, + node_metadata->name->strBegin, node_metadata->name->strEnd); goto RETURN_ERROR; } - if (metadata->type == NULL) { + if (node_metadata->type == NULL) { define->type = getTreeExpressionType(define->value); - } else if (metadata->type->token == PARSED_TOKEN_IDENTIFIER) { + } else if (node_metadata->type->token == PARSED_TOKEN_IDENTIFIER) { const TreeDefineVariableMetadata *variable = - getVariable(metadata->type->strBegin, metadata->type->strEnd, code, - scopes, scopes_size); + getVariable(node_metadata->type->strBegin, node_metadata->type->strEnd, + code, scopes, scopes_size); if (variable == NULL) { goto RETURN_ERROR; } define->type = getType(variable); } else { printError("Types should be an identifier (for now)", code, - metadata->type->strBegin, metadata->type->strEnd); + node_metadata->type->strBegin, node_metadata->type->strEnd); goto RETURN_ERROR; } @@ -366,6 +471,8 @@ TreeDefineVariableMetadata *treeParseDefineVariable(ParsedTree *tree, goto RETURN_ERROR; } + pushVariableToScope(scopes[scopes_size - 1], define); + return define; RETURN_ERROR: @@ -536,14 +643,8 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code, ParsedTree *parsedTree = treeParseNode(node_metadata->type, code, scopes, scopes_size); - if (parsedTree == NULL) { - goto RETURN_ERROR; - } - metadata->returnType = getTreeExpressionType(parsedTree); - // TODO: this is not right - deleteParsedTree(parsedTree); - - const ParserScopeMetadata *params = node_metadata->params->metadata; + const size_t newScopes_size = scopes_size + 1; + TreeScopeMetadata *newScopes[newScopes_size]; metadata->params = a404m_malloc(0); metadata->params_size = 0; @@ -555,10 +656,30 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code, metadata->scope->lines = a404m_malloc(0); metadata->scope->lines_size = 0; + memcpy(newScopes, scopes, scopes_size * sizeof(TreeScopeMetadata *)); + newScopes[newScopes_size - 1] = metadata->scope; + + if (parsedTree == NULL) { + goto RETURN_ERROR; + } + metadata->returnType = getTreeExpressionType(parsedTree); + // TODO: this is not right + deleteParsedTree(parsedTree); + + const ParserScopeMetadata *params = node_metadata->params->metadata; + for (size_t i = 0; i < params->operands_size; ++i) { const ParsedNode *operand = params->operands[i]; + if (operand->token == PARSED_TOKEN_COMMA) { + operand = (ParserCommaMetadata *)operand->metadata; + } + if (operand->token != PARSED_TOKEN_DEFINE_VARIABLE) { + printError( + "Only variable definition is allowed in function parameter list", + code, operand->strBegin, operand->strEnd); + } TreeDefineVariableMetadata *define = - treeParseDefineVariable(tree, operand, code, scopes, scopes_size); + treeParseDefineVariable(tree, operand, code, newScopes, newScopes_size); if (define == NULL) { goto RETURN_ERROR; } @@ -578,10 +699,15 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code, sizeof(TreeDefineVariableMetadata *)); if (node_metadata->body != NULL) { - printError("Not implemented", code, node->strBegin, node->strEnd); - - goto RETURN_ERROR; - return NULL; + const ParserScopeMetadata *body = node_metadata->body->metadata; + for (size_t i = 0; i < body->operands_size; ++i) { + ParsedTree *parsedTree = + treeParseNode(body->operands[i], code, newScopes, newScopes_size); + if (parsedTree == NULL) { + goto RETURN_ERROR; + } + pushLineToScope(metadata->scope, parsedTree); + } } else { free(metadata->scope->lines); metadata->scope->lines_size = 0; @@ -589,7 +715,7 @@ ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code, return tree; RETURN_ERROR: - + // TODO: doesn't delete all of them free(metadata); free(tree); return NULL; @@ -598,12 +724,12 @@ RETURN_ERROR: ParsedTree *treeParseImport(const ParsedNode *node, SourceCode *code, TreeScopeMetadata *[], size_t) { const ParserImportMetadata *node_metadata = node->metadata; - SizedString *path = nodeToString(node_metadata, code); + SizedString *const path = nodeToString(node_metadata, code); if (path == NULL) { return NULL; } - Code *fileCode = read_whole_file(path->str); + Code *const fileCode = read_whole_file(path->str); if (fileCode == NULL) { goto RETURN_ERROR; } -- cgit v1.2.3