diff options
| -rw-r--r-- | src/compiler/ast-tree.c | 543 | ||||
| -rw-r--r-- | src/compiler/ast-tree.h | 24 | ||||
| -rw-r--r-- | src/compiler/lexer.c | 39 | ||||
| -rw-r--r-- | src/compiler/lexer.h | 3 | ||||
| -rw-r--r-- | src/compiler/parser.c | 38 | ||||
| -rw-r--r-- | src/compiler/parser.h | 5 | ||||
| -rw-r--r-- | src/runner/runner.c | 35 | ||||
| -rw-r--r-- | src/utils/log.h | 4 |
8 files changed, 360 insertions, 331 deletions
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index 2016bb8..17c2630 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -115,7 +115,10 @@ AstTree AST_TREE_VOID_VALUE = { const char *AST_TREE_TOKEN_STRINGS[] = { "AST_TREE_TOKEN_FUNCTION", - "AST_TREE_TOKEN_BUILTIN", + + "AST_TREE_TOKEN_BUILTIN_CAST", + "AST_TREE_TOKEN_BUILTIN_TYPE_OF", + "AST_TREE_TOKEN_BUILTIN_IMPORT", "AST_TREE_TOKEN_KEYWORD_PUTC", "AST_TREE_TOKEN_KEYWORD_RETURN", @@ -181,12 +184,6 @@ const char *AST_TREE_TOKEN_STRINGS[] = { "AST_TREE_TOKEN_NONE", }; -const char *AST_TREE_BUILTIN_TOKEN_STRINGS[] = { - "cast", - "typeOf", - "import", -}; - AstTreeRoots AST_TREE_ROOTS_ERROR = { .data = NULL, .size = -1ULL, @@ -623,11 +620,9 @@ void astTreeDestroy(AstTree tree) { free(metadata); } return; - case AST_TREE_TOKEN_BUILTIN: { - AstTreeBuiltin *metadata = tree.metadata; - free(metadata); - } - return; + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: case AST_TREE_TOKEN_TYPE_I8: @@ -896,6 +891,9 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], return tree; case AST_TREE_TOKEN_VALUE_NULL: case AST_TREE_TOKEN_VALUE_UNDEFINED: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: return newAstTree( tree->token, NULL, copyAstTreeBack(tree->type, oldVariables, newVariables, variables_size), @@ -1190,17 +1188,6 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[], copyAstTreeBack(tree->type, oldVariables, newVariables, variables_size), tree->str_begin, tree->str_end); } - case AST_TREE_TOKEN_BUILTIN: { - AstTreeBuiltin *metadata = tree->metadata; - AstTreeBuiltin *new_metadata = a404m_malloc(sizeof(*new_metadata)); - - *new_metadata = *metadata; - - return newAstTree( - tree->token, new_metadata, - copyAstTreeBack(tree->type, oldVariables, newVariables, variables_size), - tree->str_begin, tree->str_end); - } case AST_TREE_TOKEN_TYPE_ARRAY: case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: { AstTreeBracket *metadata = tree->metadata; @@ -1349,68 +1336,65 @@ AstTreeRoot *getAstTreeRoot(char *filePath, AstTreeRoots *roots if (tree->token == AST_TREE_TOKEN_FUNCTION_CALL) { AstTreeFunctionCall *tree_metadata = tree->metadata; AstTree *operand = tree_metadata->function; - if (operand->token == AST_TREE_TOKEN_BUILTIN) { - AstTreeBuiltin *operand_metadata = operand->metadata; - if (operand_metadata->token == AST_TREE_BUILTIN_TOKEN_IMPORT) { - AstTreeSetTypesHelper helper = { - .lookingType = NULL, - .dependencies.data = NULL, - .dependencies.size = 0, - .variables = root->variables, - }; - if (!setAllTypes(tree, helper, NULL, NULL)) { - goto RETURN_ERROR; - } - AstTree *parameter = tree_metadata->parameters[0].value; - if (!isConstByValue(parameter)) { - printError(parameter->str_begin, parameter->str_end, - "Is not constant"); - goto RETURN_ERROR; - } - parameter = getValue(parameter); - if (parameter == NULL) { - goto RETURN_ERROR; - } + if (operand->token == AST_TREE_TOKEN_BUILTIN_IMPORT) { + AstTreeSetTypesHelper helper = { + .lookingType = NULL, + .dependencies.data = NULL, + .dependencies.size = 0, + .variables = root->variables, + }; + if (!setAllTypes(tree, helper, NULL, NULL)) { + goto RETURN_ERROR; + } + AstTree *parameter = tree_metadata->parameters[0].value; + if (!isConstByValue(parameter)) { + printError(parameter->str_begin, parameter->str_end, + "Is not constant"); + goto RETURN_ERROR; + } + parameter = getValue(parameter); + if (parameter == NULL) { + goto RETURN_ERROR; + } - AstTreeBracket *type_metadata = a404m_malloc(sizeof(*type_metadata)); - type_metadata->operand = &AST_TREE_U8_TYPE; + AstTreeBracket *type_metadata = a404m_malloc(sizeof(*type_metadata)); + type_metadata->operand = &AST_TREE_U8_TYPE; - type_metadata->parameters.size = 0; - type_metadata->parameters.data = - a404m_malloc(0 * sizeof(*type_metadata->parameters.data)); + type_metadata->parameters.size = 0; + type_metadata->parameters.data = + a404m_malloc(0 * sizeof(*type_metadata->parameters.data)); - AstTree *type = newAstTree(AST_TREE_TOKEN_TYPE_ARRAY, type_metadata, - &AST_TREE_TYPE_TYPE, NULL, NULL); + AstTree *type = newAstTree(AST_TREE_TOKEN_TYPE_ARRAY, type_metadata, + &AST_TREE_TYPE_TYPE, NULL, NULL); - if (!typeIsEqual(type, parameter->type)) { - printError(parameter->str_begin, parameter->str_end, - "Type mismatch (must be a []u8 aka string)"); - goto RETURN_ERROR; - } + if (!typeIsEqual(type, parameter->type)) { + printError(parameter->str_begin, parameter->str_end, + "Type mismatch (must be a []u8 aka string)"); + goto RETURN_ERROR; + } - char *str = u8ArrayToCString(parameter); - astTreeDelete(parameter); + char *str = u8ArrayToCString(parameter); + astTreeDelete(parameter); - const size_t imports_size = - a404m_malloc_usable_size(root->imports) / sizeof(*root->imports); - if (imports_size == root->imports_size) { - root->imports = a404m_realloc( - root->imports, - (imports_size + imports_size / 2 + 1) * sizeof(*root->imports)); - } + const size_t imports_size = + a404m_malloc_usable_size(root->imports) / sizeof(*root->imports); + if (imports_size == root->imports_size) { + root->imports = a404m_realloc(root->imports, + (imports_size + imports_size / 2 + 1) * + sizeof(*root->imports)); + } - AstTreeRoot *import = getAstTreeRoot(joinToPathOf(filePath, str), - roots, lexingTime, parsingTime); - free(str); + AstTreeRoot *import = getAstTreeRoot(joinToPathOf(filePath, str), roots, + lexingTime, parsingTime); + free(str); - if (import == NULL) { - goto RETURN_ERROR; - } + if (import == NULL) { + goto RETURN_ERROR; + } - root->imports[root->imports_size++] = import; + root->imports[root->imports_size++] = import; - astTreeDelete(type); - } + astTreeDelete(type); } } } @@ -1506,12 +1490,9 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) { AstTreeFunctionCall *tree_metadata = tree->metadata; AstTree *operand = tree_metadata->function; - if (operand->token == AST_TREE_TOKEN_BUILTIN) { - AstTreeBuiltin *operand_metadata = operand->metadata; - if (operand_metadata->token == AST_TREE_BUILTIN_TOKEN_IMPORT) { - if (tree_metadata->parameters_size == 1) { - goto PUSH; - } + if (operand->token == AST_TREE_TOKEN_BUILTIN_IMPORT) { + if (tree_metadata->parameters_size == 1) { + goto PUSH; } } printError(tree->str_begin, tree->str_end, "Bad node"); @@ -1600,7 +1581,9 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) { case PARSER_TOKEN_OPERATOR_ADDRESS: case PARSER_TOKEN_OPERATOR_DEREFERENCE: case PARSER_TOKEN_KEYWORD_STRUCT: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_SYMBOL_BRACKET_LEFT: case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT: goto AFTER_SWITCH; @@ -1698,8 +1681,12 @@ AstTree *astTreeParse(const ParserNode *parserNode, AstTreeHelper *helper) { switch (parserNode->token) { case PARSER_TOKEN_FUNCTION_DEFINITION: return astTreeParseFunction(parserNode, helper); - case PARSER_TOKEN_BUILTIN: - return astTreeParseBuiltin(parserNode, helper); + case PARSER_TOKEN_BUILTIN_CAST: + return astTreeParseKeyword(parserNode, AST_TREE_TOKEN_BUILTIN_CAST); + case PARSER_TOKEN_BUILTIN_TYPE_OF: + return astTreeParseKeyword(parserNode, AST_TREE_TOKEN_BUILTIN_TYPE_OF); + case PARSER_TOKEN_BUILTIN_IMPORT: + return astTreeParseKeyword(parserNode, AST_TREE_TOKEN_BUILTIN_IMPORT); case PARSER_TOKEN_TYPE_TYPE: return &AST_TREE_TYPE_TYPE; case PARSER_TOKEN_TYPE_FUNCTION: @@ -2016,7 +2003,9 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode, case PARSER_TOKEN_OPERATOR_LOGICAL_NOT: case PARSER_TOKEN_OPERATOR_LOGICAL_AND: case PARSER_TOKEN_OPERATOR_LOGICAL_OR: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_SYMBOL_BRACKET_LEFT: case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT: printError(node->str_begin, node->str_end, "Unexpected %s", @@ -2608,7 +2597,9 @@ AstTree *astTreeParseCurlyBracket(const ParserNode *parserNode, case PARSER_TOKEN_OPERATOR_LOGICAL_NOT: case PARSER_TOKEN_OPERATOR_LOGICAL_AND: case PARSER_TOKEN_OPERATOR_LOGICAL_OR: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_SYMBOL_BRACKET_LEFT: case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT: printError(node->str_begin, node->str_end, "Unexpected %s", @@ -2759,27 +2750,6 @@ AstTree *astTreeParseAccessOperator(const ParserNode *parserNode, parserNode->str_end); } -AstTree *astTreeParseBuiltin(const ParserNode *parserNode, - AstTreeHelper *helper) { - (void)helper; - - AstTreeBuiltin *metadata = a404m_malloc(sizeof(*metadata)); - - metadata->token = searchInStringArray( - AST_TREE_BUILTIN_TOKEN_STRINGS, AST_TREE_BUILTIN_TOKEN__SIZE__, - parserNode->str_begin + 1, - parserNode->str_end - parserNode->str_begin - 1); - - if (metadata->token == AST_TREE_BUILTIN_TOKEN__SIZE__) { - printError(parserNode->str_begin, parserNode->str_end, "Builtin not found"); - free(metadata); - return NULL; - } - - return newAstTree(AST_TREE_TOKEN_BUILTIN, metadata, NULL, - parserNode->str_begin, parserNode->str_end); -} - AstTree *astTreeParseBracket(const ParserNode *parserNode, AstTreeHelper *helper, AstTreeToken token) { ParserNodeBracketMetadata *node_metadata = parserNode->metadata; @@ -2815,7 +2785,9 @@ bool isConst(AstTree *tree) { UNREACHABLE; } switch (tree->token) { - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_VOID: @@ -2930,7 +2902,9 @@ bool isConstByValue(AstTree *tree) { UNREACHABLE; } switch (tree->token) { - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_VOID: @@ -3164,7 +3138,9 @@ AstTree *makeTypeOf(AstTree *value) { return copyAstTree(metadata->operand); } - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_VALUE_OBJECT: case AST_TREE_TOKEN_VARIABLE_DEFINE: case AST_TREE_TOKEN_KEYWORD_PUTC: @@ -3201,7 +3177,9 @@ bool typeIsEqual(AstTree *type0, AstTree *type1) { bool typeIsEqualBack(const AstTree *type0, const AstTree *type1) { switch (type0->token) { - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_FUNCTION: case AST_TREE_TOKEN_KEYWORD_PUTC: case AST_TREE_TOKEN_KEYWORD_RETURN: @@ -3345,7 +3323,9 @@ AstTree *getValue(AstTree *tree) { return NULL; } switch (tree->token) { - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_TYPE_FUNCTION: case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: @@ -3449,7 +3429,9 @@ bool isIntType(AstTree *type) { case AST_TREE_TOKEN_TYPE_U64: return true; case AST_TREE_TOKEN_FUNCTION: - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_KEYWORD_PUTC: case AST_TREE_TOKEN_KEYWORD_RETURN: case AST_TREE_TOKEN_KEYWORD_IF: @@ -3460,9 +3442,9 @@ bool isIntType(AstTree *type) { case AST_TREE_TOKEN_TYPE_ARRAY: case AST_TREE_TOKEN_TYPE_TYPE: case AST_TREE_TOKEN_TYPE_VOID: - #ifdef FLOAT_16_SUPPORT +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: - #endif +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -3522,9 +3504,9 @@ bool isEqual(AstTree *left, AstTree *right) { case AST_TREE_TOKEN_TYPE_U32: case AST_TREE_TOKEN_TYPE_I64: case AST_TREE_TOKEN_TYPE_U64: - #ifdef FLOAT_16_SUPPORT +#ifdef FLOAT_16_SUPPORT case AST_TREE_TOKEN_TYPE_F16: - #endif +#endif case AST_TREE_TOKEN_TYPE_F32: case AST_TREE_TOKEN_TYPE_F64: case AST_TREE_TOKEN_TYPE_F128: @@ -3546,7 +3528,9 @@ bool isEqual(AstTree *left, AstTree *right) { return isEqualVariable(left_metadata, right_metadata); } case AST_TREE_TOKEN_FUNCTION: - case AST_TREE_TOKEN_BUILTIN: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: case AST_TREE_TOKEN_KEYWORD_PUTC: case AST_TREE_TOKEN_KEYWORD_RETURN: case AST_TREE_TOKEN_KEYWORD_IF: @@ -3778,8 +3762,12 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper, return setTypesStruct(tree, helper); case AST_TREE_TOKEN_OPERATOR_ACCESS: return setTypesOperatorAccess(tree, helper); - case AST_TREE_TOKEN_BUILTIN: - return setTypesBuiltin(tree, helper, functionCall); + case AST_TREE_TOKEN_BUILTIN_CAST: + return setTypesBuiltinCast(tree, helper, functionCall); + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + return setTypesBuiltinTypeOf(tree, helper, functionCall); + case AST_TREE_TOKEN_BUILTIN_IMPORT: + return setTypesBuiltinImport(tree, helper, functionCall); case AST_TREE_TOKEN_TYPE_ARRAY: return setTypesTypeArray(tree, helper); case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: @@ -4746,215 +4734,208 @@ bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper) { } } -bool setTypesBuiltin(AstTree *tree, AstTreeSetTypesHelper helper, - AstTreeFunctionCall *functionCall) { +bool setTypesBuiltinCast(AstTree *tree, AstTreeSetTypesHelper helper, + AstTreeFunctionCall *functionCall) { (void)helper; - AstTreeBuiltin *metadata = tree->metadata; - - switch (metadata->token) { - case AST_TREE_BUILTIN_TOKEN_CAST: { - if (functionCall->parameters_size == 2) { - AstTree *from = NULL; - AstTree *to = NULL; - - static char FROM_STR[] = "from"; - static const size_t FROM_STR_SIZE = - sizeof(FROM_STR) / sizeof(*FROM_STR) - sizeof(*FROM_STR); - static char TO_STR[] = "to"; - static const size_t TO_STR_SIZE = - sizeof(TO_STR) / sizeof(*TO_STR) - sizeof(*TO_STR); + if (functionCall->parameters_size == 2) { + AstTree *from = NULL; + AstTree *to = NULL; + + static char FROM_STR[] = "from"; + static const size_t FROM_STR_SIZE = + sizeof(FROM_STR) / sizeof(*FROM_STR) - sizeof(*FROM_STR); + static char TO_STR[] = "to"; + static const size_t TO_STR_SIZE = + sizeof(TO_STR) / sizeof(*TO_STR) - sizeof(*TO_STR); + + for (size_t i = 0; i < functionCall->parameters_size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters[i]; + const size_t param_name_size = param.nameEnd - param.nameBegin; - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; - const size_t param_name_size = param.nameEnd - param.nameBegin; - - if (param_name_size == 0) { - if (from == NULL) { - from = param.value; - } else if (to == NULL) { - to = param.value; - } else { - printError(param.value->str_begin, param.value->str_end, - "Bad paramter"); - return false; - } - } else if (param_name_size == FROM_STR_SIZE && - strnEquals(param.nameBegin, FROM_STR, FROM_STR_SIZE) && - from == NULL) { + if (param_name_size == 0) { + if (from == NULL) { from = param.value; - } else if (param_name_size == TO_STR_SIZE && - strnEquals(param.nameBegin, TO_STR, TO_STR_SIZE) && - to == NULL) { + } else if (to == NULL) { to = param.value; } else { printError(param.value->str_begin, param.value->str_end, "Bad paramter"); return false; } - } - - if (from == NULL || to == NULL) { + } else if (param_name_size == FROM_STR_SIZE && + strnEquals(param.nameBegin, FROM_STR, FROM_STR_SIZE) && + from == NULL) { + from = param.value; + } else if (param_name_size == TO_STR_SIZE && + strnEquals(param.nameBegin, TO_STR, TO_STR_SIZE) && + to == NULL) { + to = param.value; + } else { + printError(param.value->str_begin, param.value->str_end, + "Bad paramter"); return false; } + } - AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); - type_metadata->arguments_size = 2; - type_metadata->arguments = a404m_malloc( - type_metadata->arguments_size * sizeof(*type_metadata->arguments)); - - type_metadata->returnType = copyAstTree(to); - - type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ - .type = copyAstTree(from->type), - .name_begin = FROM_STR, - .name_end = FROM_STR + FROM_STR_SIZE, - .str_begin = NULL, - .str_end = NULL, - }; - - type_metadata->arguments[1] = (AstTreeTypeFunctionArgument){ - .type = copyAstTree(to->type), - .name_begin = TO_STR, - .name_end = TO_STR + TO_STR_SIZE, - .str_begin = NULL, - .str_end = NULL, - }; - - tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, - &AST_TREE_TYPE_TYPE, NULL, NULL); - return true; - } else { - printError(tree->str_begin, tree->str_end, - "Too many or too few arguments"); + if (from == NULL || to == NULL) { return false; } + + AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); + type_metadata->arguments_size = 2; + type_metadata->arguments = a404m_malloc(type_metadata->arguments_size * + sizeof(*type_metadata->arguments)); + + type_metadata->returnType = copyAstTree(to); + + type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ + .type = copyAstTree(from->type), + .name_begin = FROM_STR, + .name_end = FROM_STR + FROM_STR_SIZE, + .str_begin = NULL, + .str_end = NULL, + }; + + type_metadata->arguments[1] = (AstTreeTypeFunctionArgument){ + .type = copyAstTree(to->type), + .name_begin = TO_STR, + .name_end = TO_STR + TO_STR_SIZE, + .str_begin = NULL, + .str_end = NULL, + }; + + tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, + &AST_TREE_TYPE_TYPE, NULL, NULL); + return true; + } else { + printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - case AST_TREE_BUILTIN_TOKEN_TYPE_OF: { - if (functionCall->parameters_size == 1) { - AstTree *variable = NULL; + return false; +} - static char VARIABLE_STR[] = "variable"; - static const size_t VARIABLE_STR_SIZE = - sizeof(VARIABLE_STR) / sizeof(*VARIABLE_STR) - sizeof(*VARIABLE_STR); +bool setTypesBuiltinTypeOf(AstTree *tree, AstTreeSetTypesHelper helper, + AstTreeFunctionCall *functionCall) { + (void)helper; + if (functionCall->parameters_size == 1) { + AstTree *variable = NULL; - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; - const size_t param_name_size = param.nameEnd - param.nameBegin; - - if (param_name_size == 0) { - if (variable == NULL) { - variable = param.value; - } else { - printError(param.value->str_begin, param.value->str_end, - "Bad paramter"); - return false; - } - } else if (param_name_size == VARIABLE_STR_SIZE && - strnEquals(param.nameBegin, VARIABLE_STR, - VARIABLE_STR_SIZE) && - variable == NULL) { + static char VARIABLE_STR[] = "variable"; + static const size_t VARIABLE_STR_SIZE = + sizeof(VARIABLE_STR) / sizeof(*VARIABLE_STR) - sizeof(*VARIABLE_STR); + + for (size_t i = 0; i < functionCall->parameters_size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters[i]; + const size_t param_name_size = param.nameEnd - param.nameBegin; + + if (param_name_size == 0) { + if (variable == NULL) { variable = param.value; } else { printError(param.value->str_begin, param.value->str_end, "Bad paramter"); return false; } - } - - if (variable == NULL) { + } else if (param_name_size == VARIABLE_STR_SIZE && + strnEquals(param.nameBegin, VARIABLE_STR, VARIABLE_STR_SIZE) && + variable == NULL) { + variable = param.value; + } else { + printError(param.value->str_begin, param.value->str_end, + "Bad paramter"); return false; } + } - AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); - type_metadata->arguments_size = 1; - type_metadata->arguments = a404m_malloc( - type_metadata->arguments_size * sizeof(*type_metadata->arguments)); + if (variable == NULL) { + return false; + } - type_metadata->returnType = copyAstTree(&AST_TREE_TYPE_TYPE); + AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); + type_metadata->arguments_size = 1; + type_metadata->arguments = a404m_malloc(type_metadata->arguments_size * + sizeof(*type_metadata->arguments)); - type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ - .type = copyAstTree(variable->type), - .name_begin = VARIABLE_STR, - .name_end = VARIABLE_STR + VARIABLE_STR_SIZE, - .str_begin = NULL, - .str_end = NULL, - }; + type_metadata->returnType = copyAstTree(&AST_TREE_TYPE_TYPE); - tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, - &AST_TREE_TYPE_TYPE, NULL, NULL); - return true; - } else { - printError(tree->str_begin, tree->str_end, - "Too many or too few arguments"); - return false; - } + type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ + .type = copyAstTree(variable->type), + .name_begin = VARIABLE_STR, + .name_end = VARIABLE_STR + VARIABLE_STR_SIZE, + .str_begin = NULL, + .str_end = NULL, + }; + + tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, + &AST_TREE_TYPE_TYPE, NULL, NULL); + return true; + } else { + printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - case AST_TREE_BUILTIN_TOKEN_IMPORT: { - if (functionCall->parameters_size == 1) { - AstTree *file = NULL; + return false; +} - static char VARIABLE_STR[] = "variable"; - static const size_t VARIABLE_STR_SIZE = - sizeof(VARIABLE_STR) / sizeof(*VARIABLE_STR) - sizeof(*VARIABLE_STR); +bool setTypesBuiltinImport(AstTree *tree, AstTreeSetTypesHelper helper, + AstTreeFunctionCall *functionCall) { + (void)helper; + if (functionCall->parameters_size == 1) { + AstTree *file = NULL; - for (size_t i = 0; i < functionCall->parameters_size; ++i) { - AstTreeFunctionCallParam param = functionCall->parameters[i]; - const size_t param_name_size = param.nameEnd - param.nameBegin; - - if (param_name_size == 0) { - if (file == NULL) { - file = param.value; - } else { - printError(param.value->str_begin, param.value->str_end, - "Bad paramter"); - return false; - } - } else if (param_name_size == VARIABLE_STR_SIZE && - strnEquals(param.nameBegin, VARIABLE_STR, - VARIABLE_STR_SIZE) && - file == NULL) { + static char VARIABLE_STR[] = "variable"; + static const size_t VARIABLE_STR_SIZE = + sizeof(VARIABLE_STR) / sizeof(*VARIABLE_STR) - sizeof(*VARIABLE_STR); + + for (size_t i = 0; i < functionCall->parameters_size; ++i) { + AstTreeFunctionCallParam param = functionCall->parameters[i]; + const size_t param_name_size = param.nameEnd - param.nameBegin; + + if (param_name_size == 0) { + if (file == NULL) { file = param.value; } else { printError(param.value->str_begin, param.value->str_end, "Bad paramter"); return false; } - } - - if (file == NULL) { + } else if (param_name_size == VARIABLE_STR_SIZE && + strnEquals(param.nameBegin, VARIABLE_STR, VARIABLE_STR_SIZE) && + file == NULL) { + file = param.value; + } else { + printError(param.value->str_begin, param.value->str_end, + "Bad paramter"); return false; } + } + + if (file == NULL) { + return false; + } - AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); - type_metadata->arguments_size = 1; - type_metadata->arguments = a404m_malloc( - type_metadata->arguments_size * sizeof(*type_metadata->arguments)); + AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata)); + type_metadata->arguments_size = 1; + type_metadata->arguments = a404m_malloc(type_metadata->arguments_size * + sizeof(*type_metadata->arguments)); - type_metadata->returnType = copyAstTree(&AST_TREE_CODE_TYPE); + type_metadata->returnType = copyAstTree(&AST_TREE_CODE_TYPE); - type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ - .type = copyAstTree(file->type), - .name_begin = VARIABLE_STR, - .name_end = VARIABLE_STR + VARIABLE_STR_SIZE, - .str_begin = NULL, - .str_end = NULL, - }; + type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){ + .type = copyAstTree(file->type), + .name_begin = VARIABLE_STR, + .name_end = VARIABLE_STR + VARIABLE_STR_SIZE, + .str_begin = NULL, + .str_end = NULL, + }; - tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, - &AST_TREE_TYPE_TYPE, NULL, NULL); - return true; - } else { - printError(tree->str_begin, tree->str_end, - "Too many or too few arguments"); - return false; - } + tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata, + &AST_TREE_TYPE_TYPE, NULL, NULL); + return true; + } else { + printError(tree->str_begin, tree->str_end, "Too many or too few arguments"); return false; } - case AST_TREE_BUILTIN_TOKEN__SIZE__: - } - UNREACHABLE; + return false; } bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper) { diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h index 4eecd0a..aaf614e 100644 --- a/src/compiler/ast-tree.h +++ b/src/compiler/ast-tree.h @@ -5,7 +5,9 @@ typedef enum AstTreeToken { AST_TREE_TOKEN_FUNCTION, - AST_TREE_TOKEN_BUILTIN, + AST_TREE_TOKEN_BUILTIN_CAST, + AST_TREE_TOKEN_BUILTIN_TYPE_OF, + AST_TREE_TOKEN_BUILTIN_IMPORT, AST_TREE_TOKEN_KEYWORD_PUTC, AST_TREE_TOKEN_KEYWORD_RETURN, @@ -244,19 +246,6 @@ typedef struct AstTreeBracket { AstTrees parameters; } AstTreeBracket; -typedef enum AstTreeBuiltinToken { - AST_TREE_BUILTIN_TOKEN_CAST, - AST_TREE_BUILTIN_TOKEN_TYPE_OF, - AST_TREE_BUILTIN_TOKEN_IMPORT, - AST_TREE_BUILTIN_TOKEN__SIZE__, -} AstTreeBuiltinToken; - -extern const char *AST_TREE_BUILTIN_TOKEN_STRINGS[]; - -typedef struct AstTreeBuiltin { - AstTreeBuiltinToken token; -} AstTreeBuiltin; - #ifdef PRINT_COMPILE_TREE void astTreePrint(const AstTree *tree, int indent); void astTreeVariablePrint(const AstTreeVariable *variable, int indent); @@ -330,7 +319,6 @@ AstTree *astTreeParseParenthesis(const ParserNode *parserNode, AstTreeHelper *he AstTree *astTreeParseStruct(const ParserNode *parserNode, AstTreeHelper *helper); AstTree *astTreeParseAccessOperator(const ParserNode *parserNode, AstTreeHelper *helper, AstTreeToken token); -AstTree *astTreeParseBuiltin(const ParserNode *parserNode, AstTreeHelper *helper); AstTree *astTreeParseBracket(const ParserNode *parserNode, AstTreeHelper *helper, AstTreeToken token); @@ -388,7 +376,11 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper helper, bool setTypesComptime(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesStruct(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper); -bool setTypesBuiltin(AstTree *tree, AstTreeSetTypesHelper helper, +bool setTypesBuiltinCast(AstTree *tree, AstTreeSetTypesHelper helper, + AstTreeFunctionCall *functionCall); +bool setTypesBuiltinTypeOf(AstTree *tree, AstTreeSetTypesHelper helper, + AstTreeFunctionCall *functionCall); +bool setTypesBuiltinImport(AstTree *tree, AstTreeSetTypesHelper helper, AstTreeFunctionCall *functionCall); bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper); bool setTypesArrayAccess(AstTree *tree, AstTreeSetTypesHelper helper); diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index 6fe481c..ffc3976 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -169,6 +169,19 @@ static const LexerToken LEXER_KEYWORD_TOKENS[] = { static const size_t LEXER_KEYWORD_SIZE = sizeof(LEXER_KEYWORD_TOKENS) / sizeof(*LEXER_KEYWORD_TOKENS); +static const char *LEXER_BUILTIN_STRINGS[] = { + "@cast", + "@typeOf", + "@import", +}; +static const LexerToken LEXER_BUILTIN_TOKENS[] = { + LEXER_TOKEN_BUILTIN_CAST, + LEXER_TOKEN_BUILTIN_TYPE_OF, + LEXER_TOKEN_BUILTIN_IMPORT, +}; +static const size_t LEXER_BUILTIN_SIZE = + sizeof(LEXER_BUILTIN_TOKENS) / sizeof(*LEXER_BUILTIN_TOKENS); + const LexerNodeArray LEXER_NODE_ARRAY_ERROR = { .size = SIZE_MAX, }; @@ -305,9 +318,10 @@ RETURN_SUCCESS: return result; } -inline __attribute__((always_inline)) void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter, - char **node_str_begin, LexerToken *node_token, - LexerToken token) { +inline __attribute__((always_inline)) void +lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter, + char **node_str_begin, LexerToken *node_token, + LexerToken token) { switch (*node_token) { case LEXER_TOKEN_IDENTIFIER: { const size_t index = @@ -326,6 +340,17 @@ inline __attribute__((always_inline)) void lexerPushClear(LexerNodeArray *array, *node_token = LEXER_SYMBOL_TOKENS[index]; } } + goto PUSH; + case LEXER_TOKEN_BUILTIN: { + const size_t index = + searchInStringArray(LEXER_BUILTIN_STRINGS, LEXER_BUILTIN_SIZE, + *node_str_begin, iter - *node_str_begin); + if (index == LEXER_BUILTIN_SIZE) { + printError(*node_str_begin, iter, "Bad builtin"); + UNREACHABLE; + } + *node_token = LEXER_BUILTIN_TOKENS[index]; + } // goto PUSH; // fall through PUSH: @@ -395,7 +420,9 @@ inline __attribute__((always_inline)) void lexerPushClear(LexerNodeArray *array, case LEXER_TOKEN_SYMBOL_LOGICAL_NOT: case LEXER_TOKEN_SYMBOL_LOGICAL_AND: case LEXER_TOKEN_SYMBOL_LOGICAL_OR: - case LEXER_TOKEN_BUILTIN: + case LEXER_TOKEN_BUILTIN_CAST: + case LEXER_TOKEN_BUILTIN_TYPE_OF: + case LEXER_TOKEN_BUILTIN_IMPORT: case LEXER_TOKEN_SYMBOL_CLOSE_BRACKET: case LEXER_TOKEN_SYMBOL_OPEN_BRACKET: if (*array_size == array->size) { @@ -477,6 +504,4 @@ bool isSpace(char c) { } } -bool isString(char c) { - return c == '\'' || c == '\"'; -} +bool isString(char c) { return c == '\'' || c == '\"'; } diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h index 214d9f6..98da7b5 100644 --- a/src/compiler/lexer.h +++ b/src/compiler/lexer.h @@ -13,6 +13,9 @@ typedef enum LexerToken { LEXER_TOKEN_SYMBOL_CLOSE_BRACKET, LEXER_TOKEN_IDENTIFIER, LEXER_TOKEN_BUILTIN, + LEXER_TOKEN_BUILTIN_CAST, + LEXER_TOKEN_BUILTIN_TYPE_OF, + LEXER_TOKEN_BUILTIN_IMPORT, LEXER_TOKEN_KEYWORD_TYPE, LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_I8, diff --git a/src/compiler/parser.c b/src/compiler/parser.c index 19e0009..0f4a880 100644 --- a/src/compiler/parser.c +++ b/src/compiler/parser.c @@ -11,7 +11,10 @@ const char *PARSER_TOKEN_STRINGS[] = { "PARSER_TOKEN_ROOT", "PARSER_TOKEN_IDENTIFIER", - "PARSER_TOKEN_BUILTIN", + + "PARSER_TOKEN_BUILTIN_CAST", + "PARSER_TOKEN_BUILTIN_TYPE_OF", + "PARSER_TOKEN_BUILTIN_IMPORT", "PARSER_TOKEN_VALUE_INT", "PARSER_TOKEN_VALUE_FLOAT", @@ -220,7 +223,9 @@ void parserNodePrint(const ParserNode *node, int indent) { } goto RETURN_SUCCESS; case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_TYPE_TYPE: case PARSER_TOKEN_TYPE_VOID: case PARSER_TOKEN_TYPE_BOOL: @@ -504,7 +509,9 @@ void parserNodeDelete(ParserNode *node) { } goto RETURN_SUCCESS; case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_TYPE_TYPE: case PARSER_TOKEN_TYPE_VOID: case PARSER_TOKEN_TYPE_BOOL: @@ -783,8 +790,12 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, switch (node->token) { case LEXER_TOKEN_IDENTIFIER: return parserNoMetadata(node, parent, PARSER_TOKEN_IDENTIFIER); - case LEXER_TOKEN_BUILTIN: - return parserNoMetadata(node, parent, PARSER_TOKEN_BUILTIN); + case LEXER_TOKEN_BUILTIN_CAST: + return parserNoMetadata(node, parent, PARSER_TOKEN_BUILTIN_CAST); + case LEXER_TOKEN_BUILTIN_TYPE_OF: + return parserNoMetadata(node, parent, PARSER_TOKEN_BUILTIN_TYPE_OF); + case LEXER_TOKEN_BUILTIN_IMPORT: + return parserNoMetadata(node, parent, PARSER_TOKEN_BUILTIN_IMPORT); case LEXER_TOKEN_KEYWORD_TYPE: return parserNoMetadata(node, parent, PARSER_TOKEN_TYPE_TYPE); case LEXER_TOKEN_KEYWORD_VOID: @@ -957,6 +968,7 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, case LEXER_TOKEN_KEYWORD_STRUCT: return parserStruct(node, end, parent); case LEXER_TOKEN_KEYWORD_ELSE: + case LEXER_TOKEN_BUILTIN: case LEXER_TOKEN_SYMBOL: case LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS: case LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET: @@ -1516,7 +1528,9 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end, continue; case PARSER_TOKEN_ROOT: case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_VALUE_INT: case PARSER_TOKEN_VALUE_FLOAT: case PARSER_TOKEN_VALUE_BOOL: @@ -1977,7 +1991,9 @@ bool isAllArguments(const ParserNodeArray *nodes) { bool isExpression(ParserNode *node) { switch (node->token) { case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_CONSTANT: case PARSER_TOKEN_VARIABLE: case PARSER_TOKEN_SYMBOL_PARENTHESIS: @@ -2076,7 +2092,6 @@ bool isType(ParserNode *node) { case PARSER_TOKEN_TYPE_CODE: case PARSER_TOKEN_TYPE_BOOL: case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: case PARSER_TOKEN_SYMBOL_PARENTHESIS: case PARSER_TOKEN_SYMBOL_BRACKET_LEFT: case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT: @@ -2088,6 +2103,9 @@ bool isType(ParserNode *node) { case PARSER_TOKEN_KEYWORD_STRUCT: case PARSER_TOKEN_OPERATOR_ACCESS: return true; + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_OPERATOR_ADDRESS: case PARSER_TOKEN_KEYWORD_NULL: case PARSER_TOKEN_KEYWORD_UNDEFINED: @@ -2144,7 +2162,9 @@ bool isValue(ParserNode *node) { case PARSER_TOKEN_VALUE_CHAR: case PARSER_TOKEN_VALUE_STRING: case PARSER_TOKEN_IDENTIFIER: - case PARSER_TOKEN_BUILTIN: + case PARSER_TOKEN_BUILTIN_CAST: + case PARSER_TOKEN_BUILTIN_TYPE_OF: + case PARSER_TOKEN_BUILTIN_IMPORT: case PARSER_TOKEN_OPERATOR_ACCESS: case PARSER_TOKEN_OPERATOR_ASSIGN: case PARSER_TOKEN_OPERATOR_SUM_ASSIGN: diff --git a/src/compiler/parser.h b/src/compiler/parser.h index f7d1954..f0d8372 100644 --- a/src/compiler/parser.h +++ b/src/compiler/parser.h @@ -8,7 +8,10 @@ typedef enum ParserToken { PARSER_TOKEN_ROOT, PARSER_TOKEN_IDENTIFIER, - PARSER_TOKEN_BUILTIN, + + PARSER_TOKEN_BUILTIN_CAST, + PARSER_TOKEN_BUILTIN_TYPE_OF, + PARSER_TOKEN_BUILTIN_IMPORT, PARSER_TOKEN_VALUE_INT, PARSER_TOKEN_VALUE_FLOAT, diff --git a/src/runner/runner.c b/src/runner/runner.c index 3ab6bfc..8d3251d 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -27,6 +27,7 @@ void runnerVariableSetValue(AstTreeVariable *variable, AstTree *value) { if (variable->isConst) { + printLog("Can't assign to const"); UNREACHABLE; } runnerVariableSetValueWihtoutConstCheck(variable, value); @@ -119,8 +120,6 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTreeFunctionCallParam *arguments, AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, AstTreeFunctionCallParam *arguments, size_t arguments_size) { - AstTreeBuiltin *metadata = tree->metadata; - AstTrees args = { .data = a404m_malloc(arguments_size * sizeof(*args.data)), .size = arguments_size, @@ -134,13 +133,14 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, } if (shouldRet) { + printLog("Bad return"); UNREACHABLE; } AstTree *ret; - switch (metadata->token) { - case AST_TREE_BUILTIN_TOKEN_CAST: { + switch (tree->token) { + case AST_TREE_TOKEN_BUILTIN_CAST: { AstTree *from = args.data[0]; AstTree *to = args.data[1]; @@ -186,13 +186,13 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, *newValue = (i64)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE, NULL, NULL); - #ifdef FLOAT_16_SUPPORT +#ifdef FLOAT_16_SUPPORT } else if (typeIsEqual(to, &AST_TREE_F16_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f16)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue, &AST_TREE_F16_TYPE, NULL, NULL); - #endif +#endif } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f32)value; @@ -260,13 +260,13 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, *newValue = (i64)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE, NULL, NULL); - #ifdef FLOAT_16_SUPPORT +#ifdef FLOAT_16_SUPPORT } else if (typeIsEqual(to, &AST_TREE_F16_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f16)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue, &AST_TREE_F16_TYPE, NULL, NULL); - #endif +#endif } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f32)value; @@ -334,13 +334,13 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, *newValue = (i64)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE, NULL, NULL); - #ifdef FLOAT_16_SUPPORT +#ifdef FLOAT_16_SUPPORT } else if (typeIsEqual(to, &AST_TREE_F16_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f16)value; ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue, &AST_TREE_F16_TYPE, NULL, NULL); - #endif +#endif } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) { AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue)); *newValue = (f32)value; @@ -373,14 +373,15 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope, } goto RETURN; } - case AST_TREE_BUILTIN_TOKEN_TYPE_OF: { + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: { AstTree *variable = args.data[0]; ret = copyAstTree(variable->type); } goto RETURN; - case AST_TREE_BUILTIN_TOKEN_IMPORT: - case AST_TREE_BUILTIN_TOKEN__SIZE__: + case AST_TREE_TOKEN_BUILTIN_IMPORT: + default: } + printLog("Bad builtin"); UNREACHABLE; RETURN: @@ -410,7 +411,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, if (function->token == AST_TREE_TOKEN_FUNCTION) { result = runAstTreeFunction(function, metadata->parameters, metadata->parameters_size); - } else if (function->token == AST_TREE_TOKEN_BUILTIN) { + } else if (function->token == AST_TREE_TOKEN_BUILTIN_CAST || + function->token == AST_TREE_TOKEN_BUILTIN_TYPE_OF || + function->token == AST_TREE_TOKEN_BUILTIN_IMPORT) { result = runAstTreeBuiltin(function, scope, metadata->parameters, metadata->parameters_size); } else { @@ -1156,8 +1159,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, case AST_TREE_TOKEN_VALUE_FLOAT: case AST_TREE_TOKEN_VALUE_OBJECT: case AST_TREE_TOKEN_FUNCTION: - case AST_TREE_TOKEN_BUILTIN: case AST_TREE_TOKEN_TYPE_ARRAY: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: return copyAstTree(expr); case AST_TREE_TOKEN_OPERATOR_ADDRESS: { AstTreeSingleChild *metadata = expr->metadata; diff --git a/src/utils/log.h b/src/utils/log.h index d080c6a..f9fb7ed 100644 --- a/src/utils/log.h +++ b/src/utils/log.h @@ -8,9 +8,9 @@ #endif #ifdef __GNUC__ -#define UNREACHABLE_BACK (__builtin_unreachable()) +#define UNREACHABLE_BACK exit(1);__builtin_unreachable() #else -#define UNREACHABLE_BACK (exit(1)) +#define UNREACHABLE_BACK exit(1) #endif #define printLog(format,...) _printLogBack(format, __FILE_NAME__, __LINE__, ## __VA_ARGS__) |