From d120d05eeef947f0e4845e490cd652493fe790f6 Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Sun, 1 Jan 2023 16:27:42 +0100 Subject: [PATCH] Move types to Core_Ctx --- core_ast.cpp | 20 ++++---- core_codegen_c_language.cpp | 4 +- core_compiler.cpp | 98 +++++++++++++++++++++++++++++-------- core_compiler.h | 65 +++++++++++++++++++++++- core_globals.cpp | 58 +--------------------- core_parsing.cpp | 2 +- core_typechecking.cpp | 62 +++++++++++------------ core_types.cpp | 13 +++-- 8 files changed, 191 insertions(+), 131 deletions(-) diff --git a/core_ast.cpp b/core_ast.cpp index a5b34f4..504050b 100644 --- a/core_ast.cpp +++ b/core_ast.cpp @@ -23,7 +23,7 @@ _ast_new(size_t size, Ast_Kind kind, Token *pos, Ast_Flag flags = 0){ CORE_Static Ast_Atom * ast_str(Token *pos, Intern_String string){ AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM); - result->type = untyped_string; + result->type = pctx->untyped_string; result->intern_val = string; return result; } @@ -39,14 +39,14 @@ CORE_Static Ast_Atom * ast_bool(Token *pos, B32 bool_val){ AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM); result->bool_val = bool_val; - result->type = untyped_bool; + result->type = pctx->untyped_bool; return result; } CORE_Static Ast_Atom * ast_float(Token *pos, F64 value){ AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM); - result->type = untyped_float; + result->type = pctx->untyped_float; result->f64_val = value; return result; } @@ -54,7 +54,7 @@ ast_float(Token *pos, F64 value){ CORE_Static Ast_Atom * ast_int(Token *pos, BigInt val){ AST_NEW(Atom, VALUE, pos, AST_EXPR | AST_ATOM); - result->type = untyped_int; + result->type = pctx->untyped_int; result->big_int_val = bigint_copy(pctx->perm, &val); return result; } @@ -256,7 +256,7 @@ ast_const(Token *pos, Intern_String name, Ast_Expr *expr){ CORE_Static Ast_Decl * ast_type(Token *pos, Intern_String name, Ast_Type *type){ AST_NEW(Decl, TYPE, pos, AST_DECL); - result->type = type_type; + result->type = pctx->type_type; result->type_val = type; result->name = name; return result; @@ -332,7 +332,7 @@ CORE_Static Value value_bool(B32 v){ Value value; value.bool_val = v; - value.type = untyped_bool; + value.type = pctx->untyped_bool; return value; } @@ -340,14 +340,14 @@ CORE_Static Value value_int(BigInt b){ Value value; value.big_int_val = b; - value.type = untyped_int; + value.type = pctx->untyped_int; return value; } CORE_Static Value value_int(S64 s64){ Value value; - value.type = untyped_int; + value.type = pctx->untyped_int; bigint_init_signed(&value.big_int_val, s64); return value; } @@ -356,7 +356,7 @@ CORE_Static Value value_float(F64 b){ Value value; value.f64_val = b; - value.type = untyped_float; + value.type = pctx->untyped_float; return value; } @@ -364,7 +364,7 @@ CORE_Static Value value_float(BigInt a){ Value value; value.f64_val = bigint_as_float(&a); - value.type = untyped_float; + value.type = pctx->untyped_float; return value; } diff --git a/core_codegen_c_language.cpp b/core_codegen_c_language.cpp index ff89cfc..b3fdd2e 100644 --- a/core_codegen_c_language.cpp +++ b/core_codegen_c_language.cpp @@ -213,7 +213,7 @@ gen_value(Token *pos, Value a){ gen("%s%Q", string, postfix); }break; case TYPE_POINTER:{ - if(a.type == type_pointer_to_char){ + if(a.type == pctx->type_pointer_to_char){ gen("\"%Q\"", a.intern_val); } else{ @@ -377,7 +377,7 @@ gen_expr(Ast_Expr *ast){ CASE(INDEX, Index){ gen("("); gen_expr(node->expr); - if(node->index_original_type == type_string || node->index_original_type == untyped_string){ + if(node->index_original_type == pctx->type_string || node->index_original_type == pctx->untyped_string){ gen(".str"); } else if(is_slice(node->index_original_type)){ diff --git a/core_compiler.cpp b/core_compiler.cpp index e470169..8fd5e6e 100644 --- a/core_compiler.cpp +++ b/core_compiler.cpp @@ -90,7 +90,63 @@ pctx->op_info_table[18] = {pctx->intern("~"_s), "NEG"_s, TK_Neg, 0, 1}; pctx->op_info_table[19] = {pctx->intern("!"_s), "NOT"_s, TK_Not, 0, 1}; /*END*/ - init_type(); + // Init types + pctx->type__void = {TYPE_VOID}; + pctx->type__string = {TYPE_STRING, sizeof(String), __alignof(String)}; + pctx->type__bool = {TYPE_BOOL, sizeof(bool), __alignof(bool)}; + pctx->type__type = {TYPE_TYPE, sizeof(S64), __alignof(S64)}; + + pctx->type__f32 = {TYPE_F32, sizeof(F32), __alignof(F32)}; + pctx->type__f64 = {TYPE_F64, sizeof(F64), __alignof(F64)}; + + pctx->type__s8 = {TYPE_S8, sizeof(S8), __alignof(S8)}; + pctx->type__s16 = {TYPE_S16, sizeof(S16), __alignof(S16)}; + pctx->type__s32 = {TYPE_S32, sizeof(S32), __alignof(S32)}; + pctx->type__s64 = {TYPE_S64, sizeof(S64), __alignof(S64)}; + + pctx->type__u8 = {TYPE_U8, sizeof(U8), __alignof(U8), true}; + pctx->type__u16 = {TYPE_U16, sizeof(U16), __alignof(U16), true}; + pctx->type__u32 = {TYPE_U32, sizeof(U32), __alignof(U32), true}; + pctx->type__u64 = {TYPE_U64, sizeof(U64), __alignof(U64), true}; + + pctx->type__untyped_bool = {TYPE_UNTYPED_BOOL, sizeof(bool), __alignof(bool)}; + pctx->type__untyped_int = {TYPE_UNTYPED_INT, sizeof(S64), __alignof(S64)}; + pctx->type__untyped_string = {TYPE_UNTYPED_STRING, sizeof(String), __alignof(String)}; + pctx->type__untyped_float = {TYPE_UNTYPED_FLOAT, sizeof(double), __alignof(double)}; + + pctx->type__char = {TYPE_CHAR, sizeof(char), __alignof(char)}; + pctx->type__int = {TYPE_INT, sizeof(int), __alignof(int)}; + + pctx->type_char = &pctx->type__char; + pctx->type_int = &pctx->type__int; + pctx->type_void = &pctx->type__void; + + //pctx->type_any; // Needs to be inited at runtime + + pctx->type_type = &pctx->type__type; + pctx->type_string = &pctx->type__string; + pctx->type_bool = &pctx->type__bool; + + pctx->type_f32 = &pctx->type__f32; + pctx->type_f64 = &pctx->type__f64; + + pctx->type_s8 = &pctx->type__s8 ; + pctx->type_s16 = &pctx->type__s16; + pctx->type_s32 = &pctx->type__s32; + pctx->type_s64 = &pctx->type__s64; + + pctx->type_u8 = &pctx->type__u8 ; + pctx->type_u16 = &pctx->type__u16; + pctx->type_u32 = &pctx->type__u32; + pctx->type_u64 = &pctx->type__u64; + + pctx->untyped_string = &pctx->type__untyped_string; + pctx->untyped_bool = &pctx->type__untyped_bool; + pctx->untyped_int = &pctx->type__untyped_int; + pctx->untyped_float = &pctx->type__untyped_float; + + pctx->type_pointer_to_char = type_pointer(pctx->type_char); + pctx->type_pointer_to_void = type_pointer(pctx->type_void); // Init paths ctx->exe_folder = os_get_exe_dir(ctx->perm); @@ -227,22 +283,22 @@ compile_file_to_string(Allocator *allocator, String filename) { { Ast_Module *module = add_module(0, pctx->intern("Language.core"_s)); { - insert_builtin_type_into_scope(module, "S64"_s, type_s64); - insert_builtin_type_into_scope(module, "S32"_s, type_s32); - insert_builtin_type_into_scope(module, "S16"_s, type_s16); - insert_builtin_type_into_scope(module, "S8"_s, type_s8); - insert_builtin_type_into_scope(module, "int"_s, type_int); - insert_builtin_type_into_scope(module, "char"_s, type_char); - insert_builtin_type_into_scope(module, "U64"_s, type_u64); - insert_builtin_type_into_scope(module, "U32"_s, type_u32); - insert_builtin_type_into_scope(module, "U16"_s, type_u16); - insert_builtin_type_into_scope(module, "U8"_s, type_u8); - insert_builtin_type_into_scope(module, "F64"_s, type_f64); - insert_builtin_type_into_scope(module, "F32"_s, type_f32); - insert_builtin_type_into_scope(module, "void"_s, type_void); - insert_builtin_type_into_scope(module, "Bool"_s, type_bool); - insert_builtin_type_into_scope(module, "String"_s, type_string); - insert_builtin_type_into_scope(module, "Type"_s, type_type); + insert_builtin_type_into_scope(module, "S64"_s, pctx->type_s64); + insert_builtin_type_into_scope(module, "S32"_s, pctx->type_s32); + insert_builtin_type_into_scope(module, "S16"_s, pctx->type_s16); + insert_builtin_type_into_scope(module, "S8"_s, pctx->type_s8); + insert_builtin_type_into_scope(module, "int"_s, pctx->type_int); + insert_builtin_type_into_scope(module, "char"_s, pctx->type_char); + insert_builtin_type_into_scope(module, "U64"_s, pctx->type_u64); + insert_builtin_type_into_scope(module, "U32"_s, pctx->type_u32); + insert_builtin_type_into_scope(module, "U16"_s, pctx->type_u16); + insert_builtin_type_into_scope(module, "U8"_s, pctx->type_u8); + insert_builtin_type_into_scope(module, "F64"_s, pctx->type_f64); + insert_builtin_type_into_scope(module, "F32"_s, pctx->type_f32); + insert_builtin_type_into_scope(module, "void"_s, pctx->type_void); + insert_builtin_type_into_scope(module, "Bool"_s, pctx->type_bool); + insert_builtin_type_into_scope(module, "String"_s, pctx->type_string); + insert_builtin_type_into_scope(module, "Type"_s, pctx->type_type); } { @@ -251,14 +307,14 @@ compile_file_to_string(Allocator *allocator, String filename) { decl->state = DECL_RESOLVED; Value v1 = {}; - v1.type = untyped_string; + v1.type = pctx->untyped_string; v1.intern_val = pctx->intern(OS_NAME); Ast_Decl *const_os1 = ast_const(&pctx->null_token, pctx->intern("OSName"_s), v1); const_os1->state = DECL_RESOLVED; insert_into_scope(scope, const_os1); Value v2 = {}; - v1.type = untyped_string; + v1.type = pctx->untyped_string; v1.intern_val = pctx->intern(OS_NAME_LOWER); Ast_Decl *const_os2 = ast_const(&pctx->null_token, pctx->intern("OSNameLower"_s), v2); const_os2->state = DECL_RESOLVED; @@ -276,8 +332,8 @@ compile_file_to_string(Allocator *allocator, String filename) { // so we mark where it ends pctx->base_language_ordered_decl_len = length(&pctx->ordered_decls); Ast_Decl *any_decl = search_for_single_decl(module, pctx->intern("Any"_s)); - assert(any_decl->type == type_type); - type_any = any_decl->type_val; + assert(any_decl->type == pctx->type_type); + pctx->type_any = any_decl->type_val; } Ast_Module *module = add_module(0, pctx->intern(filename), true); diff --git a/core_compiler.h b/core_compiler.h index e9a5c20..ab53532 100644 --- a/core_compiler.h +++ b/core_compiler.h @@ -8,6 +8,7 @@ with 2 allocators, and simplify stuff @! Cleanup big int allocator @! Replace iterator interface + @! Errors and logs should be placed on the compiler context @! Clean way to free all memory and reset the compiler @! Bring the Table<> @@ -135,10 +136,70 @@ size = 0 for i in meta.token_simple_expr: if i[1] != "SPECIAL": size += 1 -print(f" Ast_Operator_Info op_info_table[{size}];") +print(f"Ast_Operator_Info op_info_table[{size}];") */ - Ast_Operator_Info op_info_table[20]; +Ast_Operator_Info op_info_table[20]; /*END*/ + + Ast_Type type__void; + Ast_Type type__string; + Ast_Type type__bool; + Ast_Type type__type; + + Ast_Type type__f32; + Ast_Type type__f64; + + Ast_Type type__s8 ; + Ast_Type type__s16; + Ast_Type type__s32; + Ast_Type type__s64; + + Ast_Type type__u8 ; + Ast_Type type__u16; + Ast_Type type__u32; + Ast_Type type__u64; + + Ast_Type type__untyped_bool; + Ast_Type type__untyped_int; + Ast_Type type__untyped_string; + Ast_Type type__untyped_float; + + Ast_Type type__char; + Ast_Type type__int; + + Ast_Type *type_char = &type__char; + Ast_Type *type_int = &type__int; + Ast_Type *type_void = &type__void; + + Ast_Type *type_pointer_to_char; + Ast_Type *type_pointer_to_void; + Ast_Type *type_any; // Needs to be inited at runtime + + Ast_Type *type_type = &type__type; + Ast_Type *type_string = &type__string; + Ast_Type *type_bool = &type__bool; + + Ast_Type *type_f32 = &type__f32; + Ast_Type *type_f64 = &type__f64; + + Ast_Type *type_s8 = &type__s8 ; + Ast_Type *type_s16 = &type__s16; + Ast_Type *type_s32 = &type__s32; + Ast_Type *type_s64 = &type__s64; + + Ast_Type *type_u8 = &type__u8 ; + Ast_Type *type_u16 = &type__u16; + Ast_Type *type_u32 = &type__u32; + Ast_Type *type_u64 = &type__u64; + + Ast_Type *untyped_string = &type__untyped_string; + Ast_Type *untyped_bool = &type__untyped_bool; + Ast_Type *untyped_int = &type__untyped_int; + Ast_Type *untyped_float = &type__untyped_float; + + + + Intern_String intern(String string){ assert(string.len > 0); return intern_string(&interns, string); diff --git a/core_globals.cpp b/core_globals.cpp index 37ff9e9..fbd64ea 100644 --- a/core_globals.cpp +++ b/core_globals.cpp @@ -3,64 +3,8 @@ thread_local Core_Ctx *pctx; Allocator *bigint_allocator; global S64 bigint_allocation_count; -//----------------------------------------------------------------------------- -// Type globals -//----------------------------------------------------------------------------- const uintptr_t pointer_size = sizeof(uintptr_t); const uintptr_t pointer_align = __alignof(uintptr_t); -global Ast_Type type__void = {TYPE_VOID}; -global Ast_Type type__string = {TYPE_STRING, sizeof(String), __alignof(String)}; -global Ast_Type type__bool = {TYPE_BOOL, sizeof(bool), __alignof(bool)}; -global Ast_Type type__type = {TYPE_TYPE, sizeof(S64), __alignof(S64)}; - -global Ast_Type type__f32 = {TYPE_F32, sizeof(F32), __alignof(F32)}; -global Ast_Type type__f64 = {TYPE_F64, sizeof(F64), __alignof(F64)}; - -global Ast_Type type__s8 = {TYPE_S8, sizeof(S8), __alignof(S8)}; -global Ast_Type type__s16 = {TYPE_S16, sizeof(S16), __alignof(S16)}; -global Ast_Type type__s32 = {TYPE_S32, sizeof(S32), __alignof(S32)}; -global Ast_Type type__s64 = {TYPE_S64, sizeof(S64), __alignof(S64)}; - -global Ast_Type type__u8 = {TYPE_U8, sizeof(U8), __alignof(U8), true}; -global Ast_Type type__u16 = {TYPE_U16, sizeof(U16), __alignof(U16), true}; -global Ast_Type type__u32 = {TYPE_U32, sizeof(U32), __alignof(U32), true}; -global Ast_Type type__u64 = {TYPE_U64, sizeof(U64), __alignof(U64), true}; - -global Ast_Type type__untyped_bool = {TYPE_UNTYPED_BOOL, sizeof(bool), __alignof(bool)}; -global Ast_Type type__untyped_int = {TYPE_UNTYPED_INT, sizeof(S64), __alignof(S64)}; -global Ast_Type type__untyped_string = {TYPE_UNTYPED_STRING, sizeof(String), __alignof(String)}; -global Ast_Type type__untyped_float = {TYPE_UNTYPED_FLOAT, sizeof(double), __alignof(double)}; - -global Ast_Type type__char = {TYPE_CHAR, sizeof(char), __alignof(char)}; -global Ast_Type type__int = {TYPE_INT, sizeof(int), __alignof(int)}; -global Ast_Type *type_char = &type__char; -global Ast_Type *type_int = &type__int; -global Ast_Type *type_void = &type__void; - -global Ast_Type *type_pointer_to_char; // Needs to be inited at runtime -global Ast_Type *type_pointer_to_void; // Needs to be inited at runtime -global Ast_Type *type_any; // Needs to be inited at runtime - -global Ast_Type *type_type = &type__type; -global Ast_Type *type_string = &type__string; -global Ast_Type *type_bool = &type__bool; - -global Ast_Type *type_f32 = &type__f32; -global Ast_Type *type_f64 = &type__f64; - -global Ast_Type *type_s8 = &type__s8 ; -global Ast_Type *type_s16 = &type__s16; -global Ast_Type *type_s32 = &type__s32; -global Ast_Type *type_s64 = &type__s64; - -global Ast_Type *type_u8 = &type__u8 ; -global Ast_Type *type_u16 = &type__u16; -global Ast_Type *type_u32 = &type__u32; -global Ast_Type *type_u64 = &type__u64; - -global Ast_Type *untyped_string = &type__untyped_string; -global Ast_Type *untyped_bool = &type__untyped_bool; -global Ast_Type *untyped_int = &type__untyped_int; -global Ast_Type *untyped_float = &type__untyped_float; + diff --git a/core_parsing.cpp b/core_parsing.cpp index 85f10b8..8c6a392 100644 --- a/core_parsing.cpp +++ b/core_parsing.cpp @@ -973,7 +973,7 @@ parse_file(Ast_File *file){ set_flag(decl->flags, AST_GLOBAL); if(decl->kind == AST_STRUCT){ - decl->type = type_type; + decl->type = pctx->type_type; decl->type_val = type_incomplete(decl); decl->state = DECL_RESOLVED; } diff --git a/core_typechecking.cpp b/core_typechecking.cpp index d91e0cc..76f11fc 100644 --- a/core_typechecking.cpp +++ b/core_typechecking.cpp @@ -23,7 +23,7 @@ operand(Ast_Decl *decl){ static Operand operand_type(Ast_Type *type) { Operand result = {}; - result.type = type_type; + result.type = pctx->type_type; result.is_const = true; result.is_lvalue = false; result.type_val = type; @@ -33,7 +33,7 @@ operand_type(Ast_Type *type) { CORE_Static Operand operand_int(BigInt big_int){ Operand result = {}; - result.type = untyped_int; + result.type = pctx->untyped_int; result.big_int_val = bigint_copy(pctx->perm, &big_int); result.is_const = true; result.is_lvalue = false; @@ -43,7 +43,7 @@ operand_int(BigInt big_int){ CORE_Static Operand operand_str(Intern_String intern_val){ Operand result = {}; - result.type = type_string; + result.type = pctx->type_string; result.intern_val = intern_val; result.is_const = true; result.is_lvalue = false; @@ -89,10 +89,10 @@ operand_rvalue(Ast_Type *type){ CORE_Static Ast_Type * get_default_type_from_untyped(Ast_Type *type){ switch(type->kind){ - case TYPE_UNTYPED_INT: return type_s64; break; - case TYPE_UNTYPED_BOOL: return type_bool; break; - case TYPE_UNTYPED_STRING: return type_string; break; - case TYPE_UNTYPED_FLOAT: return type_f32; break; + case TYPE_UNTYPED_INT: return pctx->type_s64; break; + case TYPE_UNTYPED_BOOL: return pctx->type_bool; break; + case TYPE_UNTYPED_STRING: return pctx->type_string; break; + case TYPE_UNTYPED_FLOAT: return pctx->type_f32; break; default: invalid_codepath; } return 0; @@ -131,7 +131,7 @@ convert_untyped_to_typed(Token *pos, Value *a, Ast_Type *new_type){ if(is_any(new_type)) new_type = get_default_type_from_untyped(a->type); else if(is_int(a->type) && is_int(new_type)) - assert(a->type == untyped_int); + assert(a->type == pctx->untyped_int); else if(is_int(a->type) && is_enum(new_type)) ; else if(is_int(a->type) && is_float(new_type)) @@ -327,7 +327,7 @@ eval_unary(Token *pos, Token_Kind op, Operand *operand){ compiler_error(pos, "Unary [%s] cant be applied to value of type %Q", name(op), typestring(type)); if(op == TK_Not) - a->type = untyped_bool; + a->type = pctx->untyped_bool; if(op == TK_Increment || op == TK_Decrement || op == TK_PostIncrement || op == TK_PostDecrement) if(!operand->is_lvalue) @@ -681,7 +681,7 @@ resolve_typespec(Ast_Expr *ast, Resolve_Flag flags){ Operand resolved = resolve_expr(ast, flags | RESOLVE_TYPESPEC, 0, 0); if(is_flag_set(flags, RESOLVE_TYPESPEC_COMPLETE)) type_complete(resolved.type_val); - if(resolved.type != type_type) + if(resolved.type != pctx->type_type) compiler_error(ast->pos, "Expected [Type] got instead %Q", typestring(resolved.type)); return resolved.type_val; } @@ -780,7 +780,7 @@ resolve_stmt(Ast *ast, Ast_Type *ret){ CASE(RUNTIME_ASSERT, Builtin){ resolve_and_require_bool("Assert condition is not boolean", node->expr, AST_CAN_BE_NULL); - try_propagating_resolved_type_to_untyped_literals(node->expr, type_bool); + try_propagating_resolved_type_to_untyped_literals(node->expr, pctx->type_bool); BREAK(); } @@ -818,7 +818,7 @@ resolve_stmt(Ast *ast, Ast_Type *ret){ compiler_error(node->pos, "Invalid type of for loop condition %Q, required [Bool]", typestring(op.type)); } else{ - try_propagating_resolved_type_to_untyped_literals(node->cond, type_bool); + try_propagating_resolved_type_to_untyped_literals(node->cond, pctx->type_bool); } } @@ -832,7 +832,7 @@ resolve_stmt(Ast *ast, Ast_Type *ret){ For(node->ifs){ resolve_stmt(it->init, ret); resolve_and_require_bool("Conditional in a if condition", it->expr, AST_CAN_BE_NULL); - try_propagating_resolved_type_to_untyped_literals(it->expr, type_bool); + try_propagating_resolved_type_to_untyped_literals(it->expr, pctx->type_bool); For_Named(it->scope->stmts, jt) resolve_stmt(jt, ret); } @@ -1042,7 +1042,7 @@ resolve_compound_struct(Ast_Call *node, Ast_Type *type){ it->resolved_name = m.name; it->resolved_index = type->agg.members.get_index(&m); // @copy_paste - if(m.type == type_type) + if(m.type == pctx->type_type) item_type = m.type_val; else item_type = m.type; @@ -1067,7 +1067,7 @@ resolve_compound_struct(Ast_Call *node, Ast_Type *type){ m->visited = true; // @copy_paste - if(m->type == type_type && m->type_val){ + if(m->type == pctx->type_type && m->type_val){ item_type = m->type_val; } else item_type = m->type; @@ -1147,7 +1147,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str CASE(ARRAY, Array){ Operand type = resolve_expr(node->base, AST_CANT_BE_NULL, 0, 0); Operand expr = require_const_int(node->expr, AST_CAN_BE_NULL); - if(type.type != type_type) compiler_error(node->pos, "Prefix array operator is only allowed on types"); + if(type.type != pctx->type_type) compiler_error(node->pos, "Prefix array operator is only allowed on types"); type_complete(type.type_val); if(node->expr){ @@ -1184,8 +1184,8 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str node->index_original_type = left.type; node->resolved_type = left.type->arr.base; - if(left.type == type_pointer_to_char){ - node->resolved_type = type_char; + if(left.type == pctx->type_pointer_to_char){ + node->resolved_type = pctx->type_char; } else if(is_string(left.type)) { @@ -1199,16 +1199,16 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str left.type = compound_and_const_string_context; } else{ - left.type = type_string; + left.type = pctx->type_string; } } - node->resolved_type = type_u8; + node->resolved_type = pctx->type_u8; } // @todo: type_architecture? // we only try to convert the index cause array can't be const // right now - try_propagating_resolved_type_to_untyped_literals(node->index, type_s64); + try_propagating_resolved_type_to_untyped_literals(node->index, pctx->type_s64); try_propagating_resolved_type_to_untyped_literals(node->expr, left.type); if(!left.type) @@ -1217,7 +1217,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str compiler_error(node->expr->pos, "Internal compiler error: type of array is marked as untyped somehow"); if(is_string(left.type)){ - return operand_lvalue_set_flag_on_node(type_u8, node); + return operand_lvalue_set_flag_on_node(pctx->type_u8, node); } if(!is_array(left.type) && !is_pointer(left.type) && !is_slice(left.type)){ @@ -1259,7 +1259,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str else { // Make sure it's a type but also not a type id Ast_Type *type = left.type; - if(type == type_type && left.type_val){ + if(type == pctx->type_type && left.type_val){ if(is_enum(left.type_val) || is_struct(left.type_val)){ type = left.type_val; } @@ -1413,7 +1413,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Ast_Type *type = op.type; if(type){ - if(type != type_type) + if(type != pctx->type_type) compiler_error(node->pos, "Expected type [Type] got instead %Q", typestring(type)); type = op.type_val; } @@ -1446,7 +1446,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope); node->kind = AST_SIZE_OF; - Ast_Type *type = name.type == type_type ? name.type_val : name.type; + Ast_Type *type = name.type == pctx->type_type ? name.type_val : name.type; type_complete(type); if(type->size == 0){ @@ -1463,7 +1463,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope); node->kind = AST_TYPE_OF; - Ast_Type *type = name.type == type_type ? name.type_val : name.type; + Ast_Type *type = name.type == pctx->type_type ? name.type_val : name.type; Operand result = operand_type(type); rewrite_into_const(node, Ast_Builtin, result.value); @@ -1475,7 +1475,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope); node->kind = AST_ALIGN_OF; - Ast_Type *type = name.type == type_type ? name.type_val : name.type; + Ast_Type *type = name.type == pctx->type_type ? name.type_val : name.type; type_complete(type); if(type->size == 0){ compiler_error(node->pos, "Internal compiler error: calling SizeOf but the resulting size of type is obviously invalid suggesting that type was not completed properly"); @@ -1491,7 +1491,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Operand name = resolve_expr(expr, inherit_flag(flags, AST_CANT_BE_NULL), 0, field_access_scope); node->kind = AST_LENGTH_OF; - node->resolved_type = type_s64; + node->resolved_type = pctx->type_s64; if(is_array(name.type)){ Value value = value_int(name.type->arr.size); rewrite_into_const(node, Ast_Builtin, value); @@ -1503,7 +1503,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str return operand_const_rvalue(value); } else if(is_array(name.type) || is_slice(name.type) || is_string(name.type)){ - return operand_rvalue(type_s64); + return operand_rvalue(pctx->type_s64); } else compiler_error(node->pos, "Can't get length of type %Q", typestring(name.type)); } @@ -1666,7 +1666,7 @@ resolve_decl(Ast_Decl *ast){ } node->value = op.value; - if(op.value.type == type_type){ + if(op.value.type == pctx->type_type){ node->kind = AST_TYPE; if(is_flag_set(node->flags, AST_STRICT)){ node->type_val = type_copy(pctx->perm, node->type_val); @@ -1705,7 +1705,7 @@ resolve_decl(Ast_Decl *ast){ CASE(ENUM, Decl){ Ast_Type *type_of_enum = resolve_typespec(node->typespec, AST_CAN_BE_NULL); - node->type = type_type; + node->type = pctx->type_type; node->type_val = type_enum(node, type_of_enum); S64 value = 1; diff --git a/core_types.cpp b/core_types.cpp index 8952463..a1eabc3 100644 --- a/core_types.cpp +++ b/core_types.cpp @@ -27,7 +27,7 @@ get_name_of_type(Ast_Type *type){ //----------------------------------------------------------------------------- // Type constructors and utillities //----------------------------------------------------------------------------- -force_inline B32 is_any(Ast_Type *a){return a == type_any;} +force_inline B32 is_any(Ast_Type *a){return a == pctx->type_any;} force_inline B32 is_struct(Ast_Type *a){return a->kind == TYPE_STRUCT;} force_inline B32 is_lambda(Ast_Type *a){return a->kind == TYPE_LAMBDA;} force_inline B32 is_array(Ast_Type *a){return a->kind == TYPE_ARRAY;} @@ -36,8 +36,8 @@ force_inline B32 is_tuple(Ast_Type *a){return a->kind == TYPE_TUPLE;} force_inline B32 is_enum(Ast_Type *a){return a->kind == TYPE_ENUM;} force_inline B32 is_pointer(Ast_Type *a){return a->kind == TYPE_POINTER;} force_inline B32 is_void(Ast_Type *a){return a->kind == TYPE_VOID;} -force_inline B32 is_void_pointer(Ast_Type *a){return a == type_pointer_to_void;} -force_inline B32 is_string(Ast_Type *a){return a->kind == TYPE_STRING || a->kind == TYPE_UNTYPED_STRING || a == type_pointer_to_char;} +force_inline B32 is_void_pointer(Ast_Type *a){return a == pctx->type_pointer_to_void;} +force_inline B32 is_string(Ast_Type *a){return a->kind == TYPE_STRING || a->kind == TYPE_UNTYPED_STRING || a == pctx->type_pointer_to_char;} force_inline B32 is_untyped_int(Ast_Type *a){return a->kind == TYPE_UNTYPED_INT;} force_inline B32 is_typed_int(Ast_Type *a){return (a->kind >= TYPE_S64 && a->kind <= TYPE_U8);} force_inline B32 is_int(Ast_Type *a){return (a->kind >= TYPE_S64 && a->kind <= TYPE_U8) || a->kind == TYPE_UNTYPED_INT;} @@ -113,7 +113,7 @@ type_slice(Ast_Type *base, Ast *ast){ CORE_Static Ast_Type * type_try_tupling(Array types, Ast *ast){ - if(types.len == 0) return type_void; + if(types.len == 0) return pctx->type_void; if(types.len == 1) return types[0]; U64 hash = 13; @@ -204,7 +204,7 @@ type_lambda(Ast *ast, Array return_vals, Array args){ CORE_Static Ast_Type * type_enum(Ast_Decl *ast, Ast_Type *type){ if(!type){ - type = type_s64; + type = pctx->type_s64; } Ast_Type *result = type_new(pctx->perm, TYPE_ENUM, type->size, type->align); @@ -273,8 +273,7 @@ type_complete(Ast_Type *type){ CORE_Static void init_type(){ - type_pointer_to_char = type_pointer(type_char); - type_pointer_to_void = type_pointer(type_void); + } CORE_Static void