summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/compiler/ast-tree.c543
-rw-r--r--src/compiler/ast-tree.h24
-rw-r--r--src/compiler/lexer.c39
-rw-r--r--src/compiler/lexer.h3
-rw-r--r--src/compiler/parser.c38
-rw-r--r--src/compiler/parser.h5
-rw-r--r--src/runner/runner.c35
-rw-r--r--src/utils/log.h4
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__)
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-29 09:13:25 +0000