From bde04c7d905814330d60ed354e990177c530df6d Mon Sep 17 00:00:00 2001 From: A404M Date: Wed, 4 Jun 2025 02:16:41 +0330 Subject: fixing more bugs in access --- code/lib/string.felan | 2 +- code/main.felan | 25 +---------- src/compiler/ast-tree.c | 11 +---- src/runner/runner.c | 113 ++++++++++-------------------------------------- 4 files changed, 25 insertions(+), 126 deletions(-) diff --git a/code/lib/string.felan b/code/lib/string.felan index e2dacbb..c7047b3 100644 --- a/code/lib/string.felan +++ b/code/lib/string.felan @@ -2,7 +2,7 @@ @import("types.felan"); sub_string :: (str:string, begin:i64, end:i64) -> string { - result := ""; + result :[0]u8 = undefined; result.ptr = str.ptr + begin; result.length = @cast(end-begin,u64); return result; diff --git a/code/main.felan b/code/main.felan index 84e2949..ebb9cd5 100644 --- a/code/main.felan +++ b/code/main.felan @@ -24,30 +24,7 @@ t :: (comptime formatter : string) -> void { } }; -sub_string :: (str:string, begin:i64, end:i64) -> string { - result := ""; - result.ptr = str.ptr + begin; - result.length = @cast(end-begin,u64); - return result; -}; - main :: () -> void { - a := '2'; - // @insert("a = '3';a = '5';"); - // @putc(a); - println(a); - b := &a; - println(b.*); - println(a); - b.* = '5'; - println(b.*); - arr :[10]u8= undefined; - arr[0] = '6'; - @putc(arr[0]); - // t("hello {world}"); - // str := "abcdef"; - // print(@cast(9-3,u8)); - // print(sub_string(str,1,3)); - // @insert("print(123);"); + t("hello {world}"); }; diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c index b7212ad..b21532f 100644 --- a/src/compiler/ast-tree.c +++ b/src/compiler/ast-tree.c @@ -8495,16 +8495,7 @@ size_t getSizeOfType(AstTree *type) { return size; } case AST_TREE_TOKEN_TYPE_ARRAY: { - AstTreeBracket *metadata = type->metadata; - if (metadata->parameters.size == 1 && - (typeIsEqual(metadata->parameters.data[0]->type, &AST_TREE_I64_TYPE) || - typeIsEqual(metadata->parameters.data[0]->type, &AST_TREE_U64_TYPE))) { - const size_t itemSize = getSizeOfType(metadata->operand); - const size_t size = *(u64 *)metadata->parameters.data[0]->metadata; - return size * itemSize; - } else { - UNREACHABLE; - } + return sizeof(void *) + sizeof(u64); } case AST_TREE_TOKEN_OPERATOR_POINTER: return sizeof(void *); diff --git a/src/runner/runner.c b/src/runner/runner.c index dc81a70..2458cfe 100644 --- a/src/runner/runner.c +++ b/src/runner/runner.c @@ -48,43 +48,30 @@ switch (to->token) { \ case AST_TREE_TOKEN_TYPE_I8: \ doCast(value, i8, to); \ - break; \ case AST_TREE_TOKEN_TYPE_U8: \ doCast(value, u8, to); \ - break; \ case AST_TREE_TOKEN_TYPE_I16: \ doCast(value, i16, to); \ - break; \ case AST_TREE_TOKEN_TYPE_U16: \ doCast(value, u16, to); \ - break; \ case AST_TREE_TOKEN_TYPE_I32: \ doCast(value, i32, to); \ - break; \ case AST_TREE_TOKEN_TYPE_U32: \ doCast(value, u32, to); \ - break; \ case AST_TREE_TOKEN_TYPE_I64: \ doCast(value, i64, to); \ - break; \ case AST_TREE_TOKEN_TYPE_U64: \ doCast(value, u64, to); \ - break; \ case AST_TREE_TOKEN_TYPE_F16: \ doCast(value, f16, to); \ - break; \ case AST_TREE_TOKEN_TYPE_F32: \ doCast(value, f32, to); \ - break; \ case AST_TREE_TOKEN_TYPE_F64: \ doCast(value, f64, to); \ - break; \ case AST_TREE_TOKEN_TYPE_F128: \ doCast(value, f128, to); \ - break; \ case AST_TREE_TOKEN_TYPE_BOOL: \ doCast(value, bool, to); \ - break; \ default: \ UNREACHABLE; \ } \ @@ -1485,6 +1472,9 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, astTreeDelete(right); return l; } + printLog("%s %s", AST_TREE_TOKEN_STRINGS[l->token], + AST_TREE_TOKEN_STRINGS[metadata->left->token]); + UNREACHABLE; } UNREACHABLE; } @@ -1689,8 +1679,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, if (operand->token == AST_TREE_TOKEN_RAW_VALUE || operand->token == AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED) { if (operand->type->token != AST_TREE_TOKEN_OPERATOR_POINTER) { - printLog("%s %p", AST_TREE_TOKEN_STRINGS[operand->type->token], - operand); + printLog("%s", AST_TREE_TOKEN_STRINGS[operand->type->token]); UNREACHABLE; } AstTree *type = @@ -1725,10 +1714,19 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } if (variable->value->token == AST_TREE_TOKEN_RAW_VALUE) { - return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, - variable->value->metadata, - copyAstTree(variable->value->type), - variable->value->str_begin, variable->value->str_end); + if (isLeft) { + return newAstTree(AST_TREE_TOKEN_RAW_VALUE_NOT_OWNED, + variable->value->metadata, + copyAstTree(variable->value->type), + variable->value->str_begin, variable->value->str_end); + } else { + size_t size = getSizeOfType(variable->value->type); + void *value = a404m_malloc(size); + memcpy(value, variable->value->metadata, size); + return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value, + copyAstTree(variable->value->type), + variable->value->str_begin, variable->value->str_end); + } } if (isLeft) { return copyAstTree(expr); @@ -1741,82 +1739,13 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet, } case AST_TREE_TOKEN_OPERATOR_ACCESS: { AstTreeAccess *metadata = expr->metadata; - AstTree *tree = runExpression(metadata->object, scope, shouldRet, false, + AstTree *tree = runExpression(metadata->object, scope, shouldRet, true, isComptime, breakCount, shouldContinue); if (discontinue(*shouldRet, *breakCount)) { return tree; } if (tree->token == AST_TREE_TOKEN_VARIABLE) { UNREACHABLE; - /* - AstTreeVariable *variable = tree->metadata; - astTreeDelete(tree); - if (variable->type->token == AST_TREE_TOKEN_TYPE_ARRAY) { - AstTreeBracket *array_metadata = variable->type->metadata; - if (metadata->member.index != 0) { - UNREACHABLE; - } else if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) { - if (array_metadata->parameters.size == 0) { - UNREACHABLE; - } else { - AstTree *sizeTree = runExpression( - array_metadata->parameters.data[0], scope, shouldRet, false, - isComptime, breakCount, shouldContinue, false); - if (discontinue(*shouldRet, *breakCount)) { - return sizeTree; - } - if (sizeTree->token != AST_TREE_TOKEN_VALUE_INT) { - UNREACHABLE; - } else { - return sizeTree; - } - } - } else if (variable->value->token == AST_TREE_TOKEN_VALUE_OBJECT) { - AstTreeObject *object = variable->value->metadata; - AstTreeInt *res_metadata = a404m_malloc(sizeof(*res_metadata)); - *res_metadata = object->variables.size; - return newAstTree(AST_TREE_TOKEN_VALUE_INT, res_metadata, - &AST_TREE_U64_TYPE, NULL, NULL); - } - } else if (variable->type->token == AST_TREE_TOKEN_KEYWORD_STRUCT) { - if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) { - AstTreeStruct *struc = variable->type->metadata; - AstTreeObject *newMetadata = a404m_malloc(sizeof(*newMetadata)); - - newMetadata->variables = - copyAstTreeVariables(struc->variables, NULL, NULL, 0, false); - - for (size_t i = 0; i < newMetadata->variables.size; ++i) { - AstTreeVariable *member = newMetadata->variables.data[i]; - if (!member->isConst) { - runnerVariableSetValue(member, - newAstTree(AST_TREE_TOKEN_VALUE_UNDEFINED, - NULL, copyAstTree(member->type), - variable->value->str_begin, - variable->value->str_end), - scope); - } - } - - runnerVariableSetValue( - variable, - newAstTree(AST_TREE_TOKEN_VALUE_OBJECT, newMetadata, - copyAstTree(variable->type), - variable->value->str_begin, variable->value->str_end), - scope); - } - AstTreeObject *object = variable->value->metadata; - AstTreeVariable *var = object->variables.data[metadata->member.index]; - if (isLeft) { - return newAstTree(AST_TREE_TOKEN_VARIABLE, var, - copyAstTree(var->type), var->name_begin, - var->name_end); - } else { - return copyAstTree(var->value); - } - } - */ - UNREACHABLE; } else if (tree->token == AST_TREE_TOKEN_RAW_VALUE) { if (tree->type->token == AST_TREE_TOKEN_TYPE_ARRAY) { u64 *tree_value = tree->metadata; @@ -2027,9 +1956,11 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) { value->str_end); } case AST_TREE_TOKEN_VALUE_OBJECT: { - const size_t size = getSizeOfType(value->type); - AstTreeRawValue *rawValue = a404m_malloc(sizeof(void *) + sizeof(u64)); AstTreeObject *object = value->metadata; + AstTreeBracket *arrayTYpe = value->type->metadata; + const size_t itemSize = getSizeOfType(arrayTYpe->operand); + const size_t size = itemSize * object->items_size; + AstTreeRawValue *rawValue = a404m_malloc(sizeof(void *) + sizeof(u64)); if (value->type->token == AST_TREE_TOKEN_TYPE_ARRAY) { u8 *ptr = stackAlloc(size, scope); ((u64 *)rawValue)[0] = (u64)ptr; -- cgit v1.2.3