summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/compiler/ast-tree.c207
-rw-r--r--src/compiler/ast-tree.h17
-rw-r--r--src/compiler/lexer.c9
-rw-r--r--src/compiler/lexer.h1
-rw-r--r--src/compiler/parser.c9
-rw-r--r--src/compiler/parser.h1
-rw-r--r--src/runner/runner.c276
-rw-r--r--src/runner/runner.h3
8 files changed, 486 insertions, 37 deletions
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 7f30116..0d70822 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -4,6 +4,7 @@
#include "runner/runner.h"
#include "utils/log.h"
#include "utils/memory.h"
+#include "utils/string.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -108,6 +109,7 @@ AstTree AST_TREE_VOID_VALUE = {
const char *AST_TREE_TOKEN_STRINGS[] = {
"AST_TREE_TOKEN_FUNCTION",
+ "AST_TREE_TOKEN_BUILTIN",
"AST_TREE_TOKEN_KEYWORD_PUTC",
"AST_TREE_TOKEN_KEYWORD_RETURN",
@@ -170,6 +172,10 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
"AST_TREE_TOKEN_NONE",
};
+const char *AST_TREE_BUILTIN_TOKEN_STRINGS[] = {
+ "cast",
+};
+
void astTreePrint(const AstTree *tree, int indent) {
for (int i = 0; i < indent; ++i)
printf(" ");
@@ -212,6 +218,10 @@ void astTreePrint(const AstTree *tree, int indent) {
printf("]");
}
goto RETURN_SUCCESS;
+ case AST_TREE_TOKEN_BUILTIN: {
+ // empty for now
+ }
+ goto RETURN_SUCCESS;
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_VOID:
case AST_TREE_TOKEN_TYPE_I8:
@@ -558,6 +568,11 @@ void astTreeDestroy(AstTree tree) {
free(metadata);
}
return;
+ case AST_TREE_TOKEN_BUILTIN: {
+ AstTreeBuiltin *metadata = tree.metadata;
+ free(metadata);
+ }
+ return;
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_VOID:
case AST_TREE_TOKEN_TYPE_I8:
@@ -1092,6 +1107,17 @@ 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_NONE:
}
printLog("Bad token %d", tree->token);
@@ -1299,6 +1325,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
case PARSER_TOKEN_OPERATOR_ADDRESS:
case PARSER_TOKEN_OPERATOR_DEREFERENCE:
case PARSER_TOKEN_KEYWORD_STRUCT:
+ case PARSER_TOKEN_BUILTIN:
goto AFTER_SWITCH;
case PARSER_TOKEN_ROOT:
case PARSER_TOKEN_KEYWORD_PUTC:
@@ -1435,6 +1462,8 @@ AstTree *astTreeParse(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_TYPE_TYPE:
return &AST_TREE_TYPE_TYPE;
case PARSER_TOKEN_TYPE_FUNCTION:
@@ -1740,6 +1769,7 @@ AstTree *astTreeParseFunction(ParserNode *parserNode, AstTreeHelper *p_helper) {
case PARSER_TOKEN_OPERATOR_LOGICAL_NOT:
case PARSER_TOKEN_OPERATOR_LOGICAL_AND:
case PARSER_TOKEN_OPERATOR_LOGICAL_OR:
+ case PARSER_TOKEN_BUILTIN:
printError(node->str_begin, node->str_end, "Unexpected %s",
PARSER_TOKEN_STRINGS[node->token]);
goto RETURN_ERROR;
@@ -1872,10 +1902,6 @@ AstTree *astTreeParseFunctionCall(ParserNode *parserNode,
if (function == NULL) {
return NULL;
}
- if (function->token != AST_TREE_TOKEN_VARIABLE) {
- printError(function->str_begin, function->str_end, "Not yet supported");
- return NULL;
- }
AstTreeFunctionCall *metadata = a404m_malloc(sizeof(*metadata));
metadata->function = function;
@@ -2289,6 +2315,7 @@ AstTree *astTreeParseCurlyBracket(ParserNode *parserNode,
case PARSER_TOKEN_OPERATOR_LOGICAL_NOT:
case PARSER_TOKEN_OPERATOR_LOGICAL_AND:
case PARSER_TOKEN_OPERATOR_LOGICAL_OR:
+ case PARSER_TOKEN_BUILTIN:
printError(node->str_begin, node->str_end, "Unexpected %s",
PARSER_TOKEN_STRINGS[node->token]);
goto RETURN_ERROR;
@@ -2423,6 +2450,26 @@ AstTree *astTreeParseAccessOperator(ParserNode *parserNode,
parserNode->str_end);
}
+AstTree *astTreeParseBuiltin(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);
+}
+
bool isFunction(AstTree *value) {
return value->type->token == AST_TREE_TOKEN_TYPE_FUNCTION;
}
@@ -2432,6 +2479,7 @@ bool isConst(AstTree *tree) {
UNREACHABLE;
}
switch (tree->token) {
+ case AST_TREE_TOKEN_BUILTIN:
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_FUNCTION:
case AST_TREE_TOKEN_TYPE_VOID:
@@ -2534,6 +2582,7 @@ bool isConstByValue(AstTree *tree) {
UNREACHABLE;
}
switch (tree->token) {
+ case AST_TREE_TOKEN_BUILTIN:
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_FUNCTION:
case AST_TREE_TOKEN_TYPE_VOID:
@@ -2748,6 +2797,7 @@ AstTree *makeTypeOf(AstTree *value) {
}
UNREACHABLE;
}
+ case AST_TREE_TOKEN_BUILTIN:
case AST_TREE_TOKEN_VALUE_OBJECT:
case AST_TREE_TOKEN_VARIABLE_DEFINE:
case AST_TREE_TOKEN_KEYWORD_PUTC:
@@ -2784,6 +2834,7 @@ 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_FUNCTION:
case AST_TREE_TOKEN_KEYWORD_PUTC:
case AST_TREE_TOKEN_KEYWORD_RETURN:
@@ -2900,6 +2951,7 @@ AstTree *getValue(AstTree *tree) {
return NULL;
}
switch (tree->token) {
+ case AST_TREE_TOKEN_BUILTIN:
case AST_TREE_TOKEN_TYPE_FUNCTION:
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_VOID:
@@ -2986,6 +3038,7 @@ bool isCircularDependenciesBack(AstTreeHelper *helper,
AstTreeVariable *variable, AstTree *tree,
AstTreeVariables *checkedVariables) {
switch (tree->token) {
+ case AST_TREE_TOKEN_BUILTIN:
case AST_TREE_TOKEN_TYPE_TYPE:
case AST_TREE_TOKEN_TYPE_FUNCTION:
case AST_TREE_TOKEN_TYPE_VOID:
@@ -3153,7 +3206,7 @@ bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper) {
for (size_t i = 0; i < root->trees.size; ++i) {
AstTree *tree = root->trees.data[i];
- if (!setAllTypes(tree, setTypesHelper, NULL)) {
+ if (!setAllTypes(tree, setTypesHelper, NULL, NULL)) {
return false;
}
}
@@ -3169,7 +3222,7 @@ bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper) {
}
bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
- AstTreeFunction *function) {
+ AstTreeFunction *function, AstTreeFunctionCall *functionCall) {
if (tree->type != NULL) {
return true;
}
@@ -3262,8 +3315,9 @@ 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_NONE:
- break;
}
printError(tree->str_begin, tree->str_end, "Unknown token %d", tree->token);
UNREACHABLE;
@@ -3466,14 +3520,14 @@ bool setTypesFunction(AstTree *tree, AstTreeSetTypesHelper helper) {
}
}
- if (!setAllTypes(metadata->returnType, helper, NULL)) {
+ if (!setAllTypes(metadata->returnType, helper, NULL, NULL)) {
return false;
}
tree->type = makeTypeOf(tree);
for (size_t i = 0; i < metadata->scope.expressions_size; ++i) {
- if (!setAllTypes(metadata->scope.expressions[i], helper, metadata)) {
+ if (!setAllTypes(metadata->scope.expressions[i], helper, metadata, NULL)) {
return false;
}
}
@@ -3493,7 +3547,7 @@ bool setTypesPrintU64(AstTree *tree, AstTreeSetTypesHelper _helper) {
.lookingType = &AST_TREE_U8_TYPE,
.treeHelper = _helper.treeHelper,
};
- if (!setAllTypes(metadata, helper, NULL)) {
+ if (!setAllTypes(metadata, helper, NULL, NULL)) {
return false;
} else if (!typeIsEqual(metadata->type, &AST_TREE_U8_TYPE)) {
printError(tree->str_begin, tree->str_end, "Type mismatch");
@@ -3519,7 +3573,7 @@ bool setTypesReturn(AstTree *tree, AstTreeSetTypesHelper _helper,
if (helper.lookingType == NULL) {
return false;
}
- if (!setAllTypes(metadata->value, helper, NULL)) {
+ if (!setAllTypes(metadata->value, helper, NULL, NULL)) {
return false;
}
if (helper.lookingType != function->returnType) {
@@ -3539,7 +3593,7 @@ bool setTypesTypeFunction(AstTree *tree, AstTreeSetTypesHelper helper) {
for (size_t i = 0; i < metadata->arguments_size; ++i) {
AstTreeTypeFunctionArgument arg = metadata->arguments[i];
- if (!setAllTypes(arg.type, helper, NULL)) {
+ if (!setAllTypes(arg.type, helper, NULL, NULL)) {
return false;
} else if (!typeIsEqual(arg.type, &AST_TREE_TYPE_TYPE)) {
printError(arg.str_begin, arg.str_end, "Expected a type");
@@ -3547,7 +3601,7 @@ bool setTypesTypeFunction(AstTree *tree, AstTreeSetTypesHelper helper) {
}
}
- if (!setAllTypes(metadata->returnType, helper, NULL)) {
+ if (!setAllTypes(metadata->returnType, helper, NULL, NULL)) {
return false;
} else if (!typeIsEqual(metadata->returnType->type, &AST_TREE_TYPE_TYPE)) {
printError(tree->str_begin, tree->str_end, "Type mismatch");
@@ -3561,7 +3615,7 @@ bool setTypesTypeFunction(AstTree *tree, AstTreeSetTypesHelper helper) {
bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeFunctionCall *metadata = tree->metadata;
- if (!setAllTypes(metadata->function, helper, NULL)) {
+ if (!setAllTypes(metadata->function, helper, NULL, metadata)) {
return false;
} else if (!isFunction(metadata->function)) {
printError(metadata->function->str_begin, metadata->function->str_end,
@@ -3599,7 +3653,7 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper helper) {
.treeHelper = helper.treeHelper,
};
- if (!setAllTypes(param.value, newHelper, NULL)) {
+ if (!setAllTypes(param.value, newHelper, NULL, NULL)) {
return false;
}
goto END_OF_NAMED_FOR;
@@ -3624,7 +3678,7 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper helper) {
.treeHelper = helper.treeHelper,
};
- if (!setAllTypes(param.value, newHelper, NULL)) {
+ if (!setAllTypes(param.value, newHelper, NULL, NULL)) {
return false;
}
goto END_OF_UNNAMED_FOR;
@@ -3727,7 +3781,7 @@ bool setTypesOperatorInfixWithRetAndLooking(AstTree *tree, AstTree *lookingType,
bool setTypesOperatorUnary(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeSingleChild *operand = tree->metadata;
- if (!setAllTypes(operand, helper, NULL)) {
+ if (!setAllTypes(operand, helper, NULL, NULL)) {
return false;
} else {
tree->type = copyAstTree(operand->type);
@@ -3743,7 +3797,7 @@ bool setTypesOperatorUnaryWithRetAndLooking(AstTree *tree, AstTree *lookingType,
.treeHelper = _helper.treeHelper,
};
AstTreeSingleChild *operand = tree->metadata;
- if (!setAllTypes(operand, helper, NULL)) {
+ if (!setAllTypes(operand, helper, NULL, NULL)) {
return false;
} else {
tree->type = retType;
@@ -3753,7 +3807,7 @@ bool setTypesOperatorUnaryWithRetAndLooking(AstTree *tree, AstTree *lookingType,
bool setTypesOperatorPointer(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeSingleChild *metadata = tree->metadata;
- if (!setAllTypes(metadata, helper, NULL)) {
+ if (!setAllTypes(metadata, helper, NULL, NULL)) {
return false;
} else if (!typeIsEqual(metadata->type, &AST_TREE_TYPE_TYPE)) {
printError(tree->str_begin, tree->str_end, "Pointer type needs a type");
@@ -3766,7 +3820,7 @@ bool setTypesOperatorPointer(AstTree *tree, AstTreeSetTypesHelper helper) {
bool setTypesOperatorAddress(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeSingleChild *metadata = tree->metadata;
- if (!setAllTypes(metadata, helper, NULL)) {
+ if (!setAllTypes(metadata, helper, NULL, NULL)) {
return false;
}
@@ -3784,7 +3838,7 @@ bool setTypesOperatorAddress(AstTree *tree, AstTreeSetTypesHelper helper) {
bool setTypesOperatorDereference(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeSingleChild *metadata = tree->metadata;
- if (!setAllTypes(metadata, helper, NULL)) {
+ if (!setAllTypes(metadata, helper, NULL, NULL)) {
return false;
}
@@ -3812,7 +3866,7 @@ bool setTypesAstVariable(AstTreeVariable *variable,
};
if (variable->type != NULL) {
- if (!setAllTypes(variable->type, helper, NULL)) {
+ if (!setAllTypes(variable->type, helper, NULL, NULL)) {
return false;
}
@@ -3830,7 +3884,8 @@ bool setTypesAstVariable(AstTreeVariable *variable,
helper.lookingType = variable->type;
- if (variable->value != NULL && !setAllTypes(variable->value, helper, NULL)) {
+ if (variable->value != NULL &&
+ !setAllTypes(variable->value, helper, NULL, NULL)) {
return false;
}
@@ -3872,10 +3927,10 @@ bool setTypesIf(AstTree *tree, AstTreeSetTypesHelper helper,
AstTreeFunction *function) {
AstTreeIf *metadata = tree->metadata;
- if (!setAllTypes(metadata->condition, helper, function) ||
- !setAllTypes(metadata->ifBody, helper, function) ||
+ if (!setAllTypes(metadata->condition, helper, function, NULL) ||
+ !setAllTypes(metadata->ifBody, helper, function, NULL) ||
(metadata->elseBody != NULL &&
- !setAllTypes(metadata->elseBody, helper, function))) {
+ !setAllTypes(metadata->elseBody, helper, function, NULL))) {
return false;
}
@@ -3899,8 +3954,8 @@ bool setTypesWhile(AstTree *tree, AstTreeSetTypesHelper helper,
AstTreeFunction *function) {
AstTreeWhile *metadata = tree->metadata;
- if (!setAllTypes(metadata->condition, helper, function) ||
- !setAllTypes(metadata->body, helper, function)) {
+ if (!setAllTypes(metadata->condition, helper, function, NULL) ||
+ !setAllTypes(metadata->body, helper, function, NULL)) {
return false;
}
@@ -3919,7 +3974,7 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper helper,
AstTreeScope *metadata = tree->metadata;
for (size_t i = 0; i < metadata->expressions_size; ++i) {
- if (!setAllTypes(metadata->expressions[i], helper, function)) {
+ if (!setAllTypes(metadata->expressions[i], helper, function, NULL)) {
return false;
}
}
@@ -3943,7 +3998,7 @@ bool setTypesScope(AstTree *tree, AstTreeSetTypesHelper helper,
bool setTypesComptime(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeSingleChild *operand = tree->metadata;
- if (!setAllTypes(operand, helper, NULL)) {
+ if (!setAllTypes(operand, helper, NULL, NULL)) {
return false;
}
@@ -3976,7 +4031,7 @@ bool setTypesStruct(AstTree *tree, AstTreeSetTypesHelper helper) {
bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper) {
AstTreeAccess *metadata = tree->metadata;
- if (!setAllTypes(metadata->object, helper, NULL)) {
+ if (!setAllTypes(metadata->object, helper, NULL, NULL)) {
return false;
} else if (metadata->object->type->token != AST_TREE_TOKEN_KEYWORD_STRUCT) {
printError(metadata->object->str_begin, metadata->object->str_end,
@@ -4003,8 +4058,94 @@ bool setTypesOperatorAccess(AstTree *tree, AstTreeSetTypesHelper helper) {
return false;
}
+bool setTypesBuiltin(AstTree *tree, AstTreeSetTypesHelper helper,
+ AstTreeFunctionCall *functionCall) {
+ if (functionCall->parameters_size != 2) {
+ 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));
+
+ 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;
+
+ 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 &&
+ strncmp(param.nameBegin, FROM_STR, FROM_STR_SIZE) == 0 &&
+ from == NULL) {
+ from = param.value;
+ } else if (param_name_size == TO_STR_SIZE &&
+ strncmp(param.nameBegin, TO_STR, TO_STR_SIZE) == 0 &&
+ to == NULL) {
+ to = param.value;
+ } else {
+ printError(param.value->str_begin, param.value->str_end, "Bad paramter");
+ return false;
+ }
+ }
+
+ if (!setAllTypes(from,
+ (AstTreeSetTypesHelper){
+ .lookingType = NULL,
+ .treeHelper = helper.treeHelper,
+ },
+ NULL, NULL) ||
+ !setAllTypes(to,
+ (AstTreeSetTypesHelper){
+ .lookingType = NULL,
+ .treeHelper = helper.treeHelper,
+ },
+ NULL, NULL)) {
+ return false;
+ }
+
+ 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;
+}
+
bool setTypesAstInfix(AstTreeInfix *infix, AstTreeSetTypesHelper helper) {
- if (!setAllTypes(&infix->left, helper, NULL)) {
+ if (!setAllTypes(&infix->left, helper, NULL, NULL)) {
return false;
}
AstTreeSetTypesHelper newHelper = {
@@ -4012,5 +4153,5 @@ bool setTypesAstInfix(AstTreeInfix *infix, AstTreeSetTypesHelper helper) {
.treeHelper = helper.treeHelper,
};
- return setAllTypes(&infix->right, newHelper, NULL);
+ return setAllTypes(&infix->right, newHelper, NULL, NULL);
}
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 5170178..6d11e16 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -7,6 +7,7 @@
typedef enum AstTreeToken {
AST_TREE_TOKEN_FUNCTION,
+ AST_TREE_TOKEN_BUILTIN,
AST_TREE_TOKEN_KEYWORD_PUTC,
AST_TREE_TOKEN_KEYWORD_RETURN,
@@ -226,6 +227,17 @@ typedef struct AstTreeAccess {
} member;
} AstTreeAccess;
+typedef enum AstTreeBuiltinToken {
+ AST_TREE_BUILTIN_TOKEN_CAST,
+ AST_TREE_BUILTIN_TOKEN__SIZE__,
+} AstTreeBuiltinToken;
+
+extern const char *AST_TREE_BUILTIN_TOKEN_STRINGS[];
+
+typedef struct AstTreeBuiltin {
+ AstTreeBuiltinToken token;
+} AstTreeBuiltin;
+
void astTreePrint(const AstTree *tree, int indent);
void astTreeVariablePrint(const AstTreeVariable *variable, int indent);
void astTreeRootPrint(const AstTreeRoot *root);
@@ -285,6 +297,7 @@ AstTree *astTreeParseParenthesis(ParserNode *parserNode, AstTreeHelper *helper);
AstTree *astTreeParseStruct(ParserNode *parserNode, AstTreeHelper *helper);
AstTree *astTreeParseAccessOperator(ParserNode *parserNode,
AstTreeHelper *helper, AstTreeToken token);
+AstTree *astTreeParseBuiltin(ParserNode *parserNode, AstTreeHelper *helper);
bool isFunction(AstTree *value);
bool isConst(AstTree *tree);
@@ -305,7 +318,7 @@ bool isCircularDependenciesVariable(AstTreeHelper *helper,
bool setAllTypesRoot(AstTreeRoot *root, AstTreeHelper *helper);
bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
- AstTreeFunction *function);
+ AstTreeFunction *function, AstTreeFunctionCall *functionCall);
bool setTypesValueBool(AstTree *tree, AstTreeSetTypesHelper helper);
bool setTypesValueInt(AstTree *tree, AstTreeSetTypesHelper helper);
bool setTypesValueFloat(AstTree *tree, AstTreeSetTypesHelper helper);
@@ -343,6 +356,8 @@ 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,
+ AstTreeFunctionCall *functionCall);
bool setTypesAstVariable(AstTreeVariable *variable,
AstTreeSetTypesHelper helper);
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index d53560e..43502aa 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -13,6 +13,7 @@ const char *LEXER_TOKEN_STRINGS[] = {
"LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS",
"LEXER_TOKEN_IDENTIFIER",
+ "LEXER_TOKEN_BUILTIN",
"LEXER_TOKEN_KEYWORD_TYPE",
"LEXER_TOKEN_KEYWORD_VOID",
"LEXER_TOKEN_KEYWORD_I8",
@@ -257,8 +258,10 @@ LexerNodeArray lexer(char *str) {
}
}
} else if (isIdentifier(c) ||
- (node_token == LEXER_TOKEN_IDENTIFIER && isNumber(c))) {
+ (node_token == LEXER_TOKEN_IDENTIFIER && isNumber(c)) ||
+ (node_token == LEXER_TOKEN_BUILTIN && isNumber(c))) {
if (node_token != LEXER_TOKEN_IDENTIFIER &&
+ node_token != LEXER_TOKEN_BUILTIN &&
node_token != LEXER_TOKEN_NUMBER) {
lexerPushClear(&result, &result_size, iter, &node_str_begin,
&node_token, LEXER_TOKEN_IDENTIFIER);
@@ -274,6 +277,9 @@ LexerNodeArray lexer(char *str) {
lexerPushClear(&result, &result_size, iter, &node_str_begin,
&node_token, LEXER_TOKEN_SYMBOL);
}
+ } else if (c == '@') {
+ lexerPushClear(&result, &result_size, iter, &node_str_begin, &node_token,
+ LEXER_TOKEN_BUILTIN);
} else {
RETURN_ERROR:
free(result.data);
@@ -380,6 +386,7 @@ void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter,
case LEXER_TOKEN_SYMBOL_LOGICAL_NOT:
case LEXER_TOKEN_SYMBOL_LOGICAL_AND:
case LEXER_TOKEN_SYMBOL_LOGICAL_OR:
+ case LEXER_TOKEN_BUILTIN:
if (*array_size == array->size) {
*array_size += 1 + *array_size / 2;
array->data =
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index eff75c5..d7145e1 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -11,6 +11,7 @@ typedef enum LexerToken {
LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
LEXER_TOKEN_ORDER1 = LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
LEXER_TOKEN_IDENTIFIER,
+ LEXER_TOKEN_BUILTIN,
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 cd4a45b..ba8f20a 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -13,6 +13,7 @@ const char *PARSER_TOKEN_STRINGS[] = {
"PARSER_TOKEN_ROOT",
"PARSER_TOKEN_IDENTIFIER",
+ "PARSER_TOKEN_BUILTIN",
"PARSER_TOKEN_VALUE_INT",
"PARSER_TOKEN_VALUE_FLOAT",
@@ -192,6 +193,7 @@ void parserNodePrint(const ParserNode *node, int indent) {
}
goto RETURN_SUCCESS;
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
case PARSER_TOKEN_TYPE_TYPE:
case PARSER_TOKEN_TYPE_VOID:
case PARSER_TOKEN_TYPE_BOOL:
@@ -455,6 +457,7 @@ void parserNodeDelete(ParserNode *node) {
}
goto RETURN_SUCCESS;
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
case PARSER_TOKEN_TYPE_TYPE:
case PARSER_TOKEN_TYPE_VOID:
case PARSER_TOKEN_TYPE_BOOL:
@@ -693,6 +696,8 @@ 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_KEYWORD_TYPE:
return parserNoMetadata(node, parent, PARSER_TOKEN_TYPE_TYPE);
case LEXER_TOKEN_KEYWORD_VOID:
@@ -1286,6 +1291,7 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end,
continue;
case PARSER_TOKEN_ROOT:
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
case PARSER_TOKEN_VALUE_INT:
case PARSER_TOKEN_VALUE_FLOAT:
case PARSER_TOKEN_VALUE_BOOL:
@@ -1742,6 +1748,7 @@ bool isAllArguments(const ParserNodeArray *nodes) {
bool isExpression(ParserNode *node) {
switch (node->token) {
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
case PARSER_TOKEN_CONSTANT:
case PARSER_TOKEN_VARIABLE:
case PARSER_TOKEN_SYMBOL_PARENTHESIS:
@@ -1835,6 +1842,7 @@ bool isType(ParserNode *node) {
case PARSER_TOKEN_TYPE_F128:
case PARSER_TOKEN_TYPE_BOOL:
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
case PARSER_TOKEN_SYMBOL_PARENTHESIS:
case PARSER_TOKEN_FUNCTION_CALL:
case PARSER_TOKEN_KEYWORD_IF:
@@ -1898,6 +1906,7 @@ bool isValue(ParserNode *node) {
case PARSER_TOKEN_VALUE_BOOL:
case PARSER_TOKEN_VALUE_CHAR:
case PARSER_TOKEN_IDENTIFIER:
+ case PARSER_TOKEN_BUILTIN:
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 c3302f0..9464ca2 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -9,6 +9,7 @@ typedef enum ParserToken {
PARSER_TOKEN_ROOT,
PARSER_TOKEN_IDENTIFIER,
+ PARSER_TOKEN_BUILTIN,
PARSER_TOKEN_VALUE_INT,
PARSER_TOKEN_VALUE_FLOAT,
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 8746e7c..818f21a 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -94,6 +94,269 @@ AstTree *runAstTreeFunction(AstTree *tree, AstTreeFunctionCallParam *arguments,
return &AST_TREE_VOID_VALUE;
}
+AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeFunctionCallParam *arguments,
+ size_t arguments_size) {
+ AstTreeBuiltin *metadata = tree->metadata;
+
+ AstTrees args = {
+ .data = a404m_malloc(arguments_size * sizeof(*args.data)),
+ .size = arguments_size,
+ };
+
+ bool shouldRet = false;
+
+ for (size_t i = 0; i < arguments_size; ++i) {
+ AstTreeFunctionCallParam param = arguments[i];
+ args.data[i] = runExpression(param.value, &shouldRet, false);
+ }
+
+ if (shouldRet) {
+ UNREACHABLE;
+ }
+
+ AstTree *ret;
+
+ switch (metadata->token) {
+ case AST_TREE_BUILTIN_TOKEN_CAST: {
+ AstTree *from = args.data[0];
+ AstTree *to = args.data[1];
+
+ if (from->token == AST_TREE_TOKEN_VALUE_INT) {
+ AstTreeInt value = *(AstTreeInt *)from->metadata;
+ if (typeIsEqual(to, &AST_TREE_U8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U64_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE,
+ NULL, NULL);
+ } 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);
+ } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F32_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F64_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F64_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F128_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f128)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F128_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_BOOL_TYPE)) {
+ AstTreeBool *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (bool)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, newValue,
+ &AST_TREE_BOOL_TYPE, NULL, NULL);
+ } else {
+ printError(to->str_begin, to->str_end, "Bad type %s",
+ AST_TREE_TOKEN_STRINGS[to->token]);
+ UNREACHABLE;
+ }
+ } else if (from->token == AST_TREE_TOKEN_VALUE_FLOAT) {
+ AstTreeFloat value = *(AstTreeFloat *)from->metadata;
+ if (typeIsEqual(to, &AST_TREE_U8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U64_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE,
+ NULL, NULL);
+ } 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);
+ } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F32_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F64_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F64_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F128_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f128)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F128_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_BOOL_TYPE)) {
+ AstTreeBool *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (bool)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, newValue,
+ &AST_TREE_BOOL_TYPE, NULL, NULL);
+ } else {
+ printError(to->str_begin, to->str_end, "Bad type %s",
+ AST_TREE_TOKEN_STRINGS[to->token]);
+ UNREACHABLE;
+ }
+ } else if (from->token == AST_TREE_TOKEN_VALUE_BOOL) {
+ AstTreeBool value = *(AstTreeBool *)from->metadata;
+ if (typeIsEqual(to, &AST_TREE_U8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_U64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (u64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_U64_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I8_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i8)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I8_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I16_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i16)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I16_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I32_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I32_TYPE,
+ NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_I64_TYPE)) {
+ AstTreeInt *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (i64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_INT, newValue, &AST_TREE_I64_TYPE,
+ NULL, NULL);
+ } 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);
+ } else if (typeIsEqual(to, &AST_TREE_F32_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f32)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F32_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F64_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f64)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F64_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_F128_TYPE)) {
+ AstTreeFloat *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (f128)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_FLOAT, newValue,
+ &AST_TREE_F128_TYPE, NULL, NULL);
+ } else if (typeIsEqual(to, &AST_TREE_BOOL_TYPE)) {
+ AstTreeBool *newValue = a404m_malloc(sizeof(*newValue));
+ *newValue = (bool)value;
+ ret = newAstTree(AST_TREE_TOKEN_VALUE_BOOL, newValue,
+ &AST_TREE_BOOL_TYPE, NULL, NULL);
+ } else {
+ printError(to->str_begin, to->str_end, "Bad type %s",
+ AST_TREE_TOKEN_STRINGS[to->token]);
+ UNREACHABLE;
+ }
+ } else {
+ printError(to->str_begin, to->str_end, "Bad token %s",
+ AST_TREE_TOKEN_STRINGS[from->token]);
+ UNREACHABLE;
+ }
+ goto RETURN;
+ }
+ case AST_TREE_BUILTIN_TOKEN__SIZE__:
+ }
+ UNREACHABLE;
+
+RETURN:
+ for (size_t i = 0; i < args.size; ++i) {
+ astTreeDelete(args.data[i]);
+ }
+ free(args.data);
+
+ return ret;
+}
+
AstTree *runExpression(AstTree *expr, bool *shouldRet, bool isLeft) {
switch (expr->token) {
case AST_TREE_TOKEN_KEYWORD_PUTC: {
@@ -106,8 +369,16 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet, bool isLeft) {
case AST_TREE_TOKEN_FUNCTION_CALL: {
AstTreeFunctionCall *metadata = expr->metadata;
AstTree *function = runExpression(metadata->function, shouldRet, false);
- AstTree *result = runAstTreeFunction(function, metadata->parameters,
- metadata->parameters_size);
+ AstTree *result;
+ if (function->token == AST_TREE_TOKEN_FUNCTION) {
+ result = runAstTreeFunction(function, metadata->parameters,
+ metadata->parameters_size);
+ } else if (function->token == AST_TREE_TOKEN_BUILTIN) {
+ result = runAstTreeBuiltin(function, metadata->parameters,
+ metadata->parameters_size);
+ } else {
+ UNREACHABLE;
+ }
astTreeDelete(function);
return result;
}
@@ -843,6 +1114,7 @@ AstTree *runExpression(AstTree *expr, bool *shouldRet, bool isLeft) {
case AST_TREE_TOKEN_VALUE_FLOAT:
case AST_TREE_TOKEN_VALUE_OBJECT:
case AST_TREE_TOKEN_FUNCTION:
+ case AST_TREE_TOKEN_BUILTIN:
return copyAstTree(expr);
case AST_TREE_TOKEN_OPERATOR_ADDRESS: {
AstTreeSingleChild *metadata = expr->metadata;
diff --git a/src/runner/runner.h b/src/runner/runner.h
index 2ff2ec2..6ed9956 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -11,4 +11,7 @@ bool runAstTree(AstTreeRoot *root);
AstTree *runAstTreeFunction(AstTree *tree, AstTreeFunctionCallParam *arguments,
size_t arguments_size);
+AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeFunctionCallParam *arguments,
+ size_t arguments_size);
+
AstTree *runExpression(AstTree *expr, bool *shouldRet,bool isLeft);
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-29 21:16:57 +0000