From d8d12f033831a6ed76049209d52450a7001a6879 Mon Sep 17 00:00:00 2001 From: A404M Date: Thu, 12 Jun 2025 18:03:30 +0330 Subject: removing lazy because macro can do the job --- code/lib/operator.felan | 4 +- code/main.felan | 29 +++++++- src/compiler/ast-tree.c | 6 -- src/compiler/ast-tree.h | 1 - src/compiler/lexer.c | 66 ++++++++++------- src/compiler/lexer.h | 1 - src/compiler/parser.c | 6 -- src/compiler/parser.h | 1 - src/runner/runner.c | 190 +++++++++++++++++++++++++++++++++++++----------- src/runner/runner.h | 5 +- 10 files changed, 215 insertions(+), 94 deletions(-) diff --git a/code/lib/operator.felan b/code/lib/operator.felan index 998a053..5536343 100644 --- a/code/lib/operator.felan +++ b/code/lib/operator.felan @@ -578,7 +578,7 @@ __logical_not__ :: (value:bool) -> bool { return value == false; }; -__logical_and__ :: (left:bool,lazy right:bool) -> bool { +__logical_and__ :: (left:bool,right:bool) macro -> bool { if left == false { return false; } else if right == false { @@ -588,7 +588,7 @@ __logical_and__ :: (left:bool,lazy right:bool) -> bool { } }; -__logical_or__ :: (left:bool,lazy right:bool) -> bool { +__logical_or__ :: (left:bool,right:bool) macro -> bool { if left == true { return true; } else if right == true { diff --git a/code/main.felan b/code/main.felan index 150dc6d..b13442c 100644 --- a/code/main.felan +++ b/code/main.felan @@ -1,12 +1,33 @@ -@import("basic.felan"); +// @import("basic.felan"); +/* t :: (comptime b:u8) -> void { print(b); - print(a); +}; +*/ + +__equal__ :: (a:u8,b:u8) -> bool { + return @equal(a,b); +}; + +h :: (a:u8,b:u8) macro -> void { + if a == 0u8 { + if b == 0u8 { + @putc('0'); + }else{ + @putc('1'); + } + }else{ + @putc('2'); + } +}; + +f :: (a:u8,c:u8) -> u8 { + @putc(c); + return a; }; main :: () -> void { - a := 2u8; - t(5u8); + h(f(1u8,'a'),f(0u8,'b')); }; diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index 8cea6f7..3dd2308 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -1784,7 +1784,6 @@ AstTreeVariables copyAstTreeVariables(AstTreeVariables variables, result.data[i]->name_begin = variables.data[i]->name_begin; result.data[i]->name_end = variables.data[i]->name_end; result.data[i]->isConst = variables.data[i]->isConst; - result.data[i]->isLazy = variables.data[i]->isLazy; result.data[i]->type = copyAstTreeBack(variables.data[i]->type, new_oldVariables, new_newVariables, new_variables_size, safetyCheck); @@ -2115,7 +2114,6 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) { variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = node->token == PARSER_TOKEN_CONSTANT; - variable->isLazy = node_metadata->isLazy; if (node_metadata->isComptime && !variable->isConst) { printError(node->str_begin, node->str_end, "Bad comptime %s", @@ -2678,7 +2676,6 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode) { argument->name_begin = arg_metadata->name->str_begin; argument->name_end = arg_metadata->name->str_end; argument->isConst = arg_metadata->isComptime; - argument->isLazy = arg_metadata->isLazy; if (!pushVariable(&function->arguments, argument)) { astTreeVariableDelete(argument); @@ -3329,7 +3326,6 @@ bool astTreeParseConstant(const ParserNode *parserNode, variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = true; - variable->isLazy = node_metadata->isLazy; if (!pushVariable(variables, variable)) { astTreeVariableDelete(variable); @@ -3381,7 +3377,6 @@ AstTree *astTreeParseVariable(const ParserNode *parserNode, variable->name_begin = node_metadata->name->str_begin; variable->name_end = node_metadata->name->str_end; variable->isConst = false; - variable->isLazy = node_metadata->isLazy; if (!pushVariable(variables, variable)) { astTreeVariableDelete(variable); @@ -3703,7 +3698,6 @@ AstTree *astTreeParseStruct(const ParserNode *parserNode) { variable->initValue = NULL; variable->isConst = false; } - variable->isLazy = node_variable->isLazy; variables.data[i] = variable; } diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h index 7ee62ff..7d4eb84 100644 --- a/src/compiler/ast-tree.h +++ b/src/compiler/ast-tree.h @@ -173,7 +173,6 @@ typedef struct AstTreeVariable { AstTree *value; AstTree *initValue; bool isConst; - bool isLazy; } AstTreeVariable; typedef struct AstTreeVariables { diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c index 869f62f..d6d4c55 100644 --- a/src/compiler/lexer.c +++ b/src/compiler/lexer.c @@ -137,7 +137,6 @@ const char *LEXER_TOKEN_STRINGS[] = { "LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS", "LEXER_TOKEN_SYMBOL_OPEN_BRACKET", "LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET", - "LEXER_TOKEN_KEYWORD_LAZY", "LEXER_TOKEN_KEYWORD_MACRO", "LEXER_TOKEN_NONE", @@ -192,40 +191,54 @@ static const size_t LEXER_SYMBOL_SIZE = sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS); static const char *LEXER_KEYWORD_STRINGS[] = { - "type", "anytype", "void", "i8", - "u8", "i16", "u16", "i32", - "u32", "i64", "u64", + "type", "anytype", "void", "i8", "u8", + "i16", "u16", "i32", "u32", "i64", + "u64", #ifdef FLOAT_16_SUPPORT "f16", #endif - "f32", "f64", "f128", "bool", - "return", "true", "false", "if", - "else", "while", "comptime", "null", - "struct", "undefined", "code", "lazy", - "namespace", "shape_shifter", "break", "continue", - "c_library", "c_function", "macro", + "f32", "f64", "f128", "bool", "return", + "true", "false", "if", "else", "while", + "comptime", "null", "struct", "undefined", "code", + "namespace", "shape_shifter", "break", "continue", "c_library", + "c_function", "macro", }; static const LexerToken LEXER_KEYWORD_TOKENS[] = { - LEXER_TOKEN_KEYWORD_TYPE, LEXER_TOKEN_KEYWORD_ANY_TYPE, - LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_I8, - LEXER_TOKEN_KEYWORD_U8, LEXER_TOKEN_KEYWORD_I16, - LEXER_TOKEN_KEYWORD_U16, LEXER_TOKEN_KEYWORD_I32, - LEXER_TOKEN_KEYWORD_U32, LEXER_TOKEN_KEYWORD_I64, + LEXER_TOKEN_KEYWORD_TYPE, + LEXER_TOKEN_KEYWORD_ANY_TYPE, + LEXER_TOKEN_KEYWORD_VOID, + LEXER_TOKEN_KEYWORD_I8, + LEXER_TOKEN_KEYWORD_U8, + LEXER_TOKEN_KEYWORD_I16, + LEXER_TOKEN_KEYWORD_U16, + LEXER_TOKEN_KEYWORD_I32, + LEXER_TOKEN_KEYWORD_U32, + LEXER_TOKEN_KEYWORD_I64, LEXER_TOKEN_KEYWORD_U64, #ifdef FLOAT_16_SUPPORT LEXER_TOKEN_KEYWORD_F16, #endif - LEXER_TOKEN_KEYWORD_F32, LEXER_TOKEN_KEYWORD_F64, - LEXER_TOKEN_KEYWORD_F128, LEXER_TOKEN_KEYWORD_BOOL, - LEXER_TOKEN_KEYWORD_RETURN, LEXER_TOKEN_KEYWORD_TRUE, - LEXER_TOKEN_KEYWORD_FALSE, LEXER_TOKEN_KEYWORD_IF, - LEXER_TOKEN_KEYWORD_ELSE, LEXER_TOKEN_KEYWORD_WHILE, - LEXER_TOKEN_KEYWORD_COMPTIME, LEXER_TOKEN_KEYWORD_NULL, - LEXER_TOKEN_KEYWORD_STRUCT, LEXER_TOKEN_KEYWORD_UNDEFINED, - LEXER_TOKEN_KEYWORD_CODE, LEXER_TOKEN_KEYWORD_LAZY, - LEXER_TOKEN_KEYWORD_NAMESPACE, LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER, - LEXER_TOKEN_KEYWORD_BREAK, LEXER_TOKEN_KEYWORD_CONTINUE, - LEXER_TOKEN_KEYWORD_C_LIBRARY, LEXER_TOKEN_KEYWORD_C_FUNCTION, + LEXER_TOKEN_KEYWORD_F32, + LEXER_TOKEN_KEYWORD_F64, + LEXER_TOKEN_KEYWORD_F128, + LEXER_TOKEN_KEYWORD_BOOL, + LEXER_TOKEN_KEYWORD_RETURN, + LEXER_TOKEN_KEYWORD_TRUE, + LEXER_TOKEN_KEYWORD_FALSE, + LEXER_TOKEN_KEYWORD_IF, + LEXER_TOKEN_KEYWORD_ELSE, + LEXER_TOKEN_KEYWORD_WHILE, + LEXER_TOKEN_KEYWORD_COMPTIME, + LEXER_TOKEN_KEYWORD_NULL, + LEXER_TOKEN_KEYWORD_STRUCT, + LEXER_TOKEN_KEYWORD_UNDEFINED, + LEXER_TOKEN_KEYWORD_CODE, + LEXER_TOKEN_KEYWORD_NAMESPACE, + LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER, + LEXER_TOKEN_KEYWORD_BREAK, + LEXER_TOKEN_KEYWORD_CONTINUE, + LEXER_TOKEN_KEYWORD_C_LIBRARY, + LEXER_TOKEN_KEYWORD_C_FUNCTION, LEXER_TOKEN_KEYWORD_MACRO, }; static const size_t LEXER_KEYWORD_SIZE = @@ -502,7 +515,6 @@ lexerPushClear(LexerNodeArray *array, size_t *array_size, char const *iter, case LEXER_TOKEN_KEYWORD_UNDEFINED: case LEXER_TOKEN_KEYWORD_CODE: case LEXER_TOKEN_KEYWORD_NAMESPACE: - case LEXER_TOKEN_KEYWORD_LAZY: case LEXER_TOKEN_KEYWORD_MACRO: case LEXER_TOKEN_NUMBER: case LEXER_TOKEN_CHAR: diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h index 568fabc..bf53b75 100644 --- a/src/compiler/lexer.h +++ b/src/compiler/lexer.h @@ -149,7 +149,6 @@ typedef enum LexerToken { LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS, LEXER_TOKEN_SYMBOL_OPEN_BRACKET, LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET, - LEXER_TOKEN_KEYWORD_LAZY, LEXER_TOKEN_KEYWORD_MACRO, LEXER_TOKEN_NONE, diff --git a/src/compiler/parser.c b/src/compiler/parser.c index ea54e52..a58b19c 100644 --- a/src/compiler/parser.c +++ b/src/compiler/parser.c @@ -353,7 +353,6 @@ void parserNodePrint(const ParserNode *node, int indent) { case PARSER_TOKEN_CONSTANT: case PARSER_TOKEN_VARIABLE: { const ParserNodeVariableMetadata *metadata = node->metadata; - printf("isLazy=%b,\n", metadata->isLazy); for (int i = 0; i < indent; ++i) printf(" "); printf("name=\n"); @@ -1177,7 +1176,6 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end, return parserComptime(node, end, parent); case LEXER_TOKEN_KEYWORD_STRUCT: return parserStruct(node, end, parent); - case LEXER_TOKEN_KEYWORD_LAZY: case LEXER_TOKEN_KEYWORD_ELSE: case LEXER_TOKEN_KEYWORD_MACRO: case LEXER_TOKEN_BUILTIN: @@ -2071,14 +2069,10 @@ ParserNode *parserVariable(LexerNode *node, LexerNode *begin, LexerNode *end, metadata->name = name; metadata->type = type; metadata->isComptime = false; - metadata->isLazy = false; LexerNode *flagNode = nameNode - 1; while (flagNode >= begin && flagNode->parserNode == NULL) { switch (flagNode->token) { - case LEXER_TOKEN_KEYWORD_LAZY: - metadata->isLazy = true; - break; case LEXER_TOKEN_KEYWORD_COMPTIME: metadata->isComptime = true; break; diff --git a/src/compiler/parser.h b/src/compiler/parser.h index 3db1d3d..9a7ac74 100644 --- a/src/compiler/parser.h +++ b/src/compiler/parser.h @@ -156,7 +156,6 @@ typedef struct ParserNodeVariableMetadata { ParserNode *name; ParserNode *type; ParserNode *value; - bool isLazy; bool isComptime; } ParserNodeVariableMetadata; diff --git a/src/runner/runner.c b/src/runner/runner.c index dcfda79..949d9fb 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -1364,17 +1364,19 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, AstTreeFunction *fun = function->metadata; for (size_t i = 0; i < args_size; ++i) { - AstTreeVariable *function_arg = fun->arguments.data[i]; AstTreeFunctionCallParam param = metadata->parameters.data[i]; - args[i] = - getForVariable(param.value, scope, shouldRet, false, isComptime, - breakCount, shouldContinue, function_arg->isLazy); - if (discontinue(*shouldRet, *breakCount)) { - astTreeDelete(function); - for (size_t j = 0; j < i; ++j) { - astTreeDelete(args[i]); + if (fun->isMacro) { + args[i] = copyAstTree(param.value); + } else { + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); + if (discontinue(*shouldRet, *breakCount)) { + astTreeDelete(function); + for (size_t j = 0; j < i; ++j) { + astTreeDelete(args[i]); + } + return args[i]; } - return args[i]; } } result = runAstTreeFunction(function, args, args_size, scope, isComptime); @@ -1383,9 +1385,8 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, for (size_t i = 0; i < args_size; ++i) { AstTreeFunctionCallParam param = metadata->parameters.data[i]; if (function->token != AST_TREE_TOKEN_BUILTIN_TYPE_OF) { - args[i] = - getForVariable(param.value, scope, shouldRet, false, isComptime, - breakCount, shouldContinue, false); + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { astTreeDelete(function); for (size_t j = 0; j < i; ++j) { @@ -1406,8 +1407,8 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } else if (function->token == AST_TREE_TOKEN_VALUE_C_FUNCTION) { for (size_t i = 0; i < args_size; ++i) { AstTreeFunctionCallParam param = metadata->parameters.data[i]; - args[i] = getForVariable(param.value, scope, shouldRet, false, - isComptime, breakCount, shouldContinue, false); + args[i] = runExpression(param.value, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { astTreeDelete(function); for (size_t j = 0; j < i; ++j) { @@ -1503,15 +1504,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } case AST_TREE_TOKEN_VARIABLE_DEFINE: { AstTreeVariable *variable = expr->metadata; - AstTree *value; - if (variable->isLazy) { - value = copyAstTree(variable->initValue); - } else { - value = runExpression(variable->initValue, scope, shouldRet, false, - isComptime, breakCount, shouldContinue); - if (discontinue(*shouldRet, *breakCount)) { - return value; - } + AstTree *value = runExpression(variable->initValue, scope, shouldRet, false, + isComptime, breakCount, shouldContinue); + if (discontinue(*shouldRet, *breakCount)) { + return value; } runnerVariableSetValue(variable, value, scope); return &AST_TREE_VOID_VALUE; @@ -1729,12 +1725,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, case AST_TREE_TOKEN_VARIABLE: { AstTreeVariable *variable = expr->metadata; - if (variable->isLazy) { - AstTree *value = runExpression(variable->value, scope, shouldRet, false, - isComptime, breakCount, shouldContinue); - runnerVariableSetValue(variable, value, scope); - } - if (variable->value->token == AST_TREE_TOKEN_RAW_VALUE) { if (isLeft) { return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, @@ -1756,7 +1746,12 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, if (variable->value == NULL) { UNREACHABLE; } - return copyAstTree(variable->value); + if (canBeRaw(variable->type)) { + return runExpression(variable->value, scope, shouldRet, isLeft, + isComptime, breakCount, shouldContinue); + } else { + return copyAstTree(variable->value); + } } } case AST_TREE_TOKEN_OPERATOR_ACCESS: { @@ -1887,17 +1882,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, UNREACHABLE; } -AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet, - bool isLeft, bool isComptime, u32 *breakCount, - bool *shouldContinue, bool isLazy) { - if (isLazy) { - return copyAstTree(expr); - } else { - return runExpression(expr, scope, shouldRet, isLeft, isComptime, breakCount, - shouldContinue); - } -} - bool discontinue(bool shouldRet, u32 breakCount) { return shouldRet || breakCount > 0; } @@ -2128,7 +2112,127 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: case AST_TREE_TOKEN_SCOPE: + case AST_TREE_TOKEN_TYPE_ANY_TYPE: + case AST_TREE_TOKEN_BUILTIN_SIZE_OF: + case AST_TREE_TOKEN_BUILTIN_C_LIBRARY: + case AST_TREE_TOKEN_BUILTIN_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_C_LIBRARY: + case AST_TREE_TOKEN_TYPE_C_FUNCTION: + case AST_TREE_TOKEN_TYPE_MACRO: + return NULL; case AST_TREE_TOKEN_NONE: + } + UNREACHABLE; +} + +bool canBeRaw(AstTree *type) { + switch (type->token) { + case AST_TREE_TOKEN_TYPE_ARRAY: + case AST_TREE_TOKEN_TYPE_TYPE: + case AST_TREE_TOKEN_TYPE_VOID: + case AST_TREE_TOKEN_TYPE_I8: + case AST_TREE_TOKEN_TYPE_U8: + case AST_TREE_TOKEN_TYPE_I16: + case AST_TREE_TOKEN_TYPE_U16: + case AST_TREE_TOKEN_TYPE_I32: + case AST_TREE_TOKEN_TYPE_U32: + case AST_TREE_TOKEN_TYPE_I64: + case AST_TREE_TOKEN_TYPE_U64: +#ifdef FLOAT_16_SUPPORT + case AST_TREE_TOKEN_TYPE_F16: +#endif + case AST_TREE_TOKEN_TYPE_F32: + case AST_TREE_TOKEN_TYPE_F64: + case AST_TREE_TOKEN_TYPE_F128: + case AST_TREE_TOKEN_TYPE_BOOL: + return true; + case AST_TREE_TOKEN_VALUE_VOID: + case AST_TREE_TOKEN_VALUE_NULL: + case AST_TREE_TOKEN_VALUE_UNDEFINED: + case AST_TREE_TOKEN_VALUE_BOOL: + case AST_TREE_TOKEN_VALUE_INT: + case AST_TREE_TOKEN_VALUE_FLOAT: + case AST_TREE_TOKEN_VALUE_OBJECT: + case AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED: + case AST_TREE_TOKEN_VALUE_C_LIBRARY: + case AST_TREE_TOKEN_VALUE_C_FUNCTION: + case AST_TREE_TOKEN_VALUE_SHAPE_SHIFTER: + case AST_TREE_TOKEN_VALUE_MACRO: + case AST_TREE_TOKEN_VALUE_NAMESPACE: + case AST_TREE_TOKEN_TYPE_FUNCTION: + case AST_TREE_TOKEN_TYPE_CODE: + case AST_TREE_TOKEN_TYPE_NAMESPACE: + case AST_TREE_TOKEN_TYPE_SHAPE_SHIFTER: + case AST_TREE_TOKEN_FUNCTION: + case AST_TREE_TOKEN_BUILTIN_CAST: + case AST_TREE_TOKEN_BUILTIN_TYPE_OF: + case AST_TREE_TOKEN_BUILTIN_IMPORT: + case AST_TREE_TOKEN_BUILTIN_IS_COMPTIME: + case AST_TREE_TOKEN_BUILTIN_STACK_ALLOC: + case AST_TREE_TOKEN_BUILTIN_HEAP_ALLOC: + case AST_TREE_TOKEN_BUILTIN_NEG: + case AST_TREE_TOKEN_BUILTIN_ADD: + case AST_TREE_TOKEN_BUILTIN_SUB: + case AST_TREE_TOKEN_BUILTIN_MUL: + case AST_TREE_TOKEN_BUILTIN_DIV: + case AST_TREE_TOKEN_BUILTIN_MOD: + case AST_TREE_TOKEN_BUILTIN_EQUAL: + case AST_TREE_TOKEN_BUILTIN_NOT_EQUAL: + case AST_TREE_TOKEN_BUILTIN_GREATER: + case AST_TREE_TOKEN_BUILTIN_SMALLER: + case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL: + case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL: + case AST_TREE_TOKEN_BUILTIN_PUTC: + case AST_TREE_TOKEN_BUILTIN_BITWISE_NOT: + case AST_TREE_TOKEN_BUILTIN_BITWISE_AND: + case AST_TREE_TOKEN_BUILTIN_BITWISE_XOR: + case AST_TREE_TOKEN_BUILTIN_BITWISE_OR: + case AST_TREE_TOKEN_BUILTIN_SHIFT_LEFT: + case AST_TREE_TOKEN_BUILTIN_SHIFT_RIGHT: + case AST_TREE_TOKEN_BUILTIN_INSERT: + case AST_TREE_TOKEN_KEYWORD_RETURN: + case AST_TREE_TOKEN_KEYWORD_BREAK: + case AST_TREE_TOKEN_KEYWORD_CONTINUE: + case AST_TREE_TOKEN_KEYWORD_IF: + case AST_TREE_TOKEN_KEYWORD_WHILE: + case AST_TREE_TOKEN_KEYWORD_COMPTIME: + case AST_TREE_TOKEN_KEYWORD_STRUCT: + case AST_TREE_TOKEN_FUNCTION_CALL: + case AST_TREE_TOKEN_VARIABLE: + case AST_TREE_TOKEN_VARIABLE_DEFINE: + case AST_TREE_TOKEN_RAW_VALUE: + case AST_TREE_TOKEN_SHAPE_SHIFTER_ELEMENT: + case AST_TREE_TOKEN_OPERATOR_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_PLUS: + case AST_TREE_TOKEN_OPERATOR_MINUS: + case AST_TREE_TOKEN_OPERATOR_SUM: + case AST_TREE_TOKEN_OPERATOR_SUB: + case AST_TREE_TOKEN_OPERATOR_MULTIPLY: + case AST_TREE_TOKEN_OPERATOR_DIVIDE: + case AST_TREE_TOKEN_OPERATOR_MODULO: + case AST_TREE_TOKEN_OPERATOR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_NOT_EQUAL: + case AST_TREE_TOKEN_OPERATOR_GREATER: + case AST_TREE_TOKEN_OPERATOR_SMALLER: + case AST_TREE_TOKEN_OPERATOR_GREATER_OR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_SMALLER_OR_EQUAL: + case AST_TREE_TOKEN_OPERATOR_POINTER: + case AST_TREE_TOKEN_OPERATOR_ADDRESS: + case AST_TREE_TOKEN_OPERATOR_DEREFERENCE: + case AST_TREE_TOKEN_OPERATOR_ACCESS: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_NOT: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_AND: + case AST_TREE_TOKEN_OPERATOR_LOGICAL_OR: + case AST_TREE_TOKEN_OPERATOR_BITWISE_NOT: + case AST_TREE_TOKEN_OPERATOR_BITWISE_AND: + case AST_TREE_TOKEN_OPERATOR_BITWISE_XOR: + case AST_TREE_TOKEN_OPERATOR_BITWISE_OR: + case AST_TREE_TOKEN_OPERATOR_SHIFT_LEFT: + case AST_TREE_TOKEN_OPERATOR_SHIFT_RIGHT: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ASSIGN: + case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS_ADDRESS: + case AST_TREE_TOKEN_SCOPE: case AST_TREE_TOKEN_TYPE_ANY_TYPE: case AST_TREE_TOKEN_BUILTIN_SIZE_OF: case AST_TREE_TOKEN_BUILTIN_C_LIBRARY: @@ -2136,8 +2240,10 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { case AST_TREE_TOKEN_TYPE_C_LIBRARY: case AST_TREE_TOKEN_TYPE_C_FUNCTION: case AST_TREE_TOKEN_TYPE_MACRO: + return false; + case AST_TREE_TOKEN_NONE: } - return NULL; + UNREACHABLE; } AstTree *fromRawValue(AstTree *value) { diff --git a/src/runner/runner.h b/src/runner/runner.h index 3175ece..815cb0a 100644 --- a/src/runner/runner.h +++ b/src/runner/runner.h @@ -31,13 +31,10 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, bool isLeft, bool isComptime, u32 *breakCount, bool *shouldContinue); -AstTree *getForVariable(AstTree *expr, AstTreeScope *scope, bool *shouldRet, - bool isLeft, bool isComptime, u32 *breakCount, - bool *shouldContinue, bool isLazy); - bool discontinue(bool shouldRet, u32 breakCount); AstTree *toRawValue(AstTree *value, AstTreeScope *scope); +bool canBeRaw(AstTree *type); AstTree *fromRawValue(AstTree *value); AstTree *castTo(AstTree *value, AstTree *to); -- cgit v1.2.3