diff --git a/src/array.cpp b/src/array.cpp index bb9e789db..a46ccc47f 100644 --- a/src/array.cpp +++ b/src/array.cpp @@ -1,98 +1,7 @@ #define ARRAY_GROW_FORMULA(x) (2*(x) + 8) GB_STATIC_ASSERT(ARRAY_GROW_FORMULA(0) > 0); -#define Array(Type_) struct { \ - gbAllocator allocator; \ - Type_ * e; \ - isize count; \ - isize capacity; \ -} - -typedef Array(void) ArrayVoid; - -#define array_init_reserve(x_, allocator_, init_capacity_) do { \ - void **e = cast(void **)&((x_)->e); \ - GB_ASSERT((x_) != NULL); \ - (x_)->allocator = (allocator_); \ - (x_)->count = 0; \ - (x_)->capacity = (init_capacity_); \ - *e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \ -} while (0) - -#define array_init_count(x_, allocator_, init_count_) do { \ - void **e = cast(void **)&((x_)->e); \ - GB_ASSERT((x_) != NULL); \ - (x_)->allocator = (allocator_); \ - (x_)->count = (init_count_); \ - (x_)->capacity = (init_count_); \ - *e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \ -} while (0) - -#define array_init(x_, allocator_) do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0) -#define array_free(x_) do { gb_free((x_)->allocator, (x_)->e); } while (0) -#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0) - -#define array_grow(x_, min_capacity_) do { \ - isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \ - if (new_capacity < (min_capacity_)) { \ - new_capacity = (min_capacity_); \ - } \ - array_set_capacity(x_, new_capacity); \ -} while (0) - -#define array_add(x_, item_) do { \ - if ((x_)->capacity < (x_)->count+1) { \ - array_grow(x_, 0); \ - } \ - (x_)->e[(x_)->count++] = item_; \ -} while (0) - -#define array_pop(x_) do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0) -#define array_clear(x_) do { (x_)->count = 0; } while (0) - -#define array_resize(x_, new_count_) do { \ - if ((x_)->capacity < (new_count_)) { \ - array_grow((x_), (new_count_)); \ - } \ - (x_)->count = (new_count_); \ -} while (0) - -#define array_reserve(x_, new_capacity_) do { \ - if ((x_)->capacity < (new_capacity_)) { \ - array_set_capacity((x_), (new_capacity_)); \ - } \ -} while (0) - - - - -void array__set_capacity(void *ptr, isize capacity, isize element_size) { - ArrayVoid *x = cast(ArrayVoid *)ptr; - GB_ASSERT(ptr != NULL); - - GB_ASSERT(element_size > 0); - - if (capacity == x->capacity) { - return; - } - - if (capacity < x->count) { - if (x->capacity < capacity) { - isize new_capacity = ARRAY_GROW_FORMULA(x->capacity); - if (new_capacity < capacity) { - new_capacity = capacity; - } - array__set_capacity(ptr, new_capacity, element_size); - } - x->count = capacity; - } - - x->e = gb_resize(x->allocator, x->e, element_size*x->capacity, element_size*capacity); - x->capacity = capacity; -} - - -#if 0 +#if 1 template struct Array { gbAllocator allocator; @@ -224,6 +133,97 @@ void array_set_capacity(Array *array, isize capacity) { array->capacity = capacity; } - - #endif + +#if 0 +#define Array(Type_) struct { \ + gbAllocator allocator; \ + Type_ * e; \ + isize count; \ + isize capacity; \ +} + +typedef Array(void) ArrayVoid; + +#define array_init_reserve(x_, allocator_, init_capacity_) do { \ + void **e = cast(void **)&((x_)->e); \ + GB_ASSERT((x_) != NULL); \ + (x_)->allocator = (allocator_); \ + (x_)->count = 0; \ + (x_)->capacity = (init_capacity_); \ + *e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_capacity_)); \ +} while (0) + +#define array_init_count(x_, allocator_, init_count_) do { \ + void **e = cast(void **)&((x_)->e); \ + GB_ASSERT((x_) != NULL); \ + (x_)->allocator = (allocator_); \ + (x_)->count = (init_count_); \ + (x_)->capacity = (init_count_); \ + *e = gb_alloc((allocator_), gb_size_of(*(x_)->e)*(init_count_)); \ +} while (0) + +#define array_init(x_, allocator_) do { array_init_reserve(x_, allocator_, ARRAY_GROW_FORMULA(0)); } while (0) +#define array_free(x_) do { gb_free((x_)->allocator, (x_)->e); } while (0) +#define array_set_capacity(x_, capacity_) do { array__set_capacity((x_), (capacity_), gb_size_of(*(x_)->e)); } while (0) + +#define array_grow(x_, min_capacity_) do { \ + isize new_capacity = ARRAY_GROW_FORMULA((x_)->capacity); \ + if (new_capacity < (min_capacity_)) { \ + new_capacity = (min_capacity_); \ + } \ + array_set_capacity(x_, new_capacity); \ +} while (0) + +#define array_add(x_, item_) do { \ + if ((x_)->capacity < (x_)->count+1) { \ + array_grow(x_, 0); \ + } \ + (x_)->e[(x_)->count++] = item_; \ +} while (0) + +#define array_pop(x_) do { GB_ASSERT((x_)->count > 0); (x_)->count--; } while (0) +#define array_clear(x_) do { (x_)->count = 0; } while (0) + +#define array_resize(x_, new_count_) do { \ + if ((x_)->capacity < (new_count_)) { \ + array_grow((x_), (new_count_)); \ + } \ + (x_)->count = (new_count_); \ +} while (0) + +#define array_reserve(x_, new_capacity_) do { \ + if ((x_)->capacity < (new_capacity_)) { \ + array_set_capacity((x_), (new_capacity_)); \ + } \ +} while (0) + + + + +void array__set_capacity(void *ptr, isize capacity, isize element_size) { + ArrayVoid *x = cast(ArrayVoid *)ptr; + GB_ASSERT(ptr != NULL); + + GB_ASSERT(element_size > 0); + + if (capacity == x->capacity) { + return; + } + + if (capacity < x->count) { + if (x->capacity < capacity) { + isize new_capacity = ARRAY_GROW_FORMULA(x->capacity); + if (new_capacity < capacity) { + new_capacity = capacity; + } + array__set_capacity(ptr, new_capacity, element_size); + } + x->count = capacity; + } + + x->e = gb_resize(x->allocator, x->e, element_size*x->capacity, element_size*capacity); + x->capacity = capacity; +} +#endif + diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 1229c466c..dac763010 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -35,7 +35,7 @@ String const NIX_SEPARATOR_STRING = {cast(u8 *)"/", 1}; #if defined(GB_SYSTEM_WINDOWS) String odin_root_dir(void) { String path = global_module_path; - Array(wchar_t) path_buf; + Array path_buf; isize len, i; gbTempArenaMemory tmp; wchar_t *text; @@ -48,7 +48,7 @@ String odin_root_dir(void) { len = 0; for (;;) { - len = GetModuleFileNameW(NULL, &path_buf.e[0], path_buf.count); + len = GetModuleFileNameW(NULL, &path_buf[0], path_buf.count); if (len == 0) { return make_string(NULL, 0); } @@ -102,7 +102,7 @@ String odin_root_dir(void) { len = 0; for (;;) { int sz = path_buf.count; - int res = _NSGetExecutablePath(&path_buf.e[0], &sz); + int res = _NSGetExecutablePath(&path_buf[0], &sz); if(res == 0) { len = sz; break; @@ -114,7 +114,7 @@ String odin_root_dir(void) { tmp = gb_temp_arena_memory_begin(&string_buffer_arena); text = gb_alloc_array(string_buffer_allocator, u8, len + 1); - gb_memmove(text, &path_buf.e[0], len); + gb_memmove(text, &path_buf[0], len); path = make_string(text, len); for (i = path.len-1; i >= 0; i--) { @@ -158,7 +158,7 @@ String odin_root_dir(void) { // of this compiler, it should be _good enough_. // That said, there's no solid 100% method on Linux to get the program's // path without checking this link. Sorry. - len = readlink("/proc/self/exe", &path_buf.e[0], path_buf.count); + len = readlink("/proc/self/exe", &path_buf[0], path_buf.count); if(len == 0) { return make_string(NULL, 0); } @@ -171,7 +171,7 @@ String odin_root_dir(void) { tmp = gb_temp_arena_memory_begin(&string_buffer_arena); text = gb_alloc_array(string_buffer_allocator, u8, len + 1); - gb_memmove(text, &path_buf.e[0], len); + gb_memmove(text, &path_buf[0], len); path = make_string(text, len); for (i = path.len-1; i >= 0; i--) { diff --git a/src/check_decl.cpp b/src/check_decl.cpp index f8c74c0be..1e7e23398 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -67,20 +67,20 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArra // NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be // an extra allocation - ArrayOperand operands = {}; - array_init_reserve(&operands, c->tmp_allocator, 2*lhs_count); + Array operands = {}; + array_init(&operands, c->tmp_allocator, 2*lhs_count); check_unpack_arguments(c, lhs_count, &operands, inits, true); isize rhs_count = operands.count; for_array(i, operands) { - if (operands.e[i].mode == Addressing_Invalid) { + if (operands[i].mode == Addressing_Invalid) { rhs_count--; } } isize max = gb_min(lhs_count, rhs_count); for (isize i = 0; i < max; i++) { - check_init_variable(c, lhs[i], &operands.e[i], context_name); + check_init_variable(c, lhs[i], &operands[i], context_name); } if (rhs_count > 0 && lhs_count != rhs_count) { error(lhs[0]->token, "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); @@ -432,7 +432,7 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count } AstNodeArray inits; - array_init_reserve(&inits, c->allocator, 1); + array_init(&inits, c->allocator, 1); array_add(&inits, init_expr); check_init_variables(c, entities, entity_count, inits, str_lit("variable declaration")); } @@ -514,7 +514,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node)); GB_ASSERT(found != NULL); for_array(i, (*found)->elements.entries) { - Entity *f = (*found)->elements.entries.e[i].value; + Entity *f = (*found)->elements.entries[i].value; if (f->kind == Entity_Variable) { Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); uvar->Variable.is_immutable = is_immutable; @@ -555,7 +555,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod if (decl->parent != NULL) { // NOTE(bill): Add the dependencies from the procedure literal (lambda) for_array(i, decl->deps.entries) { - HashKey key = decl->deps.entries.e[i].key; + HashKey key = decl->deps.entries[i].key; Entity *e = cast(Entity *)key.ptr; map_bool_set(&decl->parent->deps, key, true); } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 86d0541af..55670f7e5 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -53,7 +53,7 @@ void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) { check_collect_entities(c, nodes, false); for_array(i, s->elements.entries) { - Entity *e = s->elements.entries.e[i].value; + Entity *e = s->elements.entries[i].value; switch (e->kind) { case Entity_Constant: case Entity_TypeName: @@ -70,7 +70,7 @@ void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) { } for_array(i, s->elements.entries) { - Entity *e = s->elements.entries.e[i].value; + Entity *e = s->elements.entries[i].value; if (e->kind != Entity_Procedure) { continue; } @@ -401,7 +401,7 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls, isize field_index = 0; for_array(decl_index, decls) { - AstNode *decl = decls.e[decl_index]; + AstNode *decl = decls[decl_index]; if (decl->kind != AstNode_Field) { continue; } @@ -412,13 +412,13 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls, if (is_using) { if (f->names.count > 1) { - error_node(f->names.e[0], "Cannot apply `using` to more than one of the same type"); + error_node(f->names[0], "Cannot apply `using` to more than one of the same type"); is_using = false; } } for_array(name_index, f->names) { - AstNode *name = f->names.e[name_index]; + AstNode *name = f->names[name_index]; if (!ast_node_expect(name, AstNode_Ident)) { continue; } @@ -454,15 +454,15 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls, Type *t = base_type(type_deref(type)); if (!is_type_struct(t) && !is_type_raw_union(t) && !is_type_bit_field(t) && f->names.count >= 1 && - f->names.e[0]->kind == AstNode_Ident) { - Token name_token = f->names.e[0]->Ident; + f->names[0]->kind == AstNode_Ident) { + Token name_token = f->names[0]->Ident; if (is_type_indexable(t)) { bool ok = true; for_array(emi, entity_map.entries) { - Entity *e = entity_map.entries.e[emi].value; + Entity *e = entity_map.entries[emi].value; if (e->kind == Entity_Variable && e->flags & EntityFlag_Using) { if (is_type_indexable(e->type)) { - if (e->identifier != f->names.e[0]) { + if (e->identifier != f->names[0]) { ok = false; using_index_expr = e; break; @@ -545,7 +545,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) { isize field_count = 0; for_array(field_index, st->fields) { - AstNode *field = st->fields.e[field_index]; + AstNode *field = st->fields[field_index]; switch (field->kind) { case_ast_node(f, Field, field); field_count += f->names.count; @@ -641,7 +641,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { isize variant_count = ut->variants.count+1; isize field_count = 0; for_array(i, ut->fields) { - AstNode *field = ut->fields.e[i]; + AstNode *field = ut->fields[i]; if (field->kind == AstNode_Field) { ast_node(f, Field, field); field_count += f->names.count; @@ -680,7 +680,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { } for_array(i, ut->variants) { - AstNode *variant = ut->variants.e[i]; + AstNode *variant = ut->variants[i]; if (variant->kind != AstNode_UnionField) { continue; } @@ -694,12 +694,12 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { // NOTE(bill): Copy the contents for the common fields for now AstNodeArray list = {}; array_init_count(&list, c->allocator, ut->fields.count+fl->list.count); - gb_memmove_array(list.e, ut->fields.e, ut->fields.count); - gb_memmove_array(list.e+ut->fields.count, fl->list.e, fl->list.count); + gb_memmove_array(list.data, ut->fields.data, ut->fields.count); + gb_memmove_array(list.data+ut->fields.count, fl->list.data, fl->list.count); isize list_count = 0; for_array(j, list) { - ast_node(f, Field, list.e[j]); + ast_node(f, Field, list[j]); list_count += f->names.count; } @@ -760,7 +760,7 @@ void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) { isize field_count = 0; for_array(field_index, ut->fields) { - AstNode *field = ut->fields.e[field_index]; + AstNode *field = ut->fields[field_index]; switch (field->kind) { case_ast_node(f, Field, field); field_count += f->names.count; @@ -817,7 +817,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod ExactValue max_value = exact_value_i64(0); for_array(i, et->fields) { - AstNode *field = et->fields.e[i]; + AstNode *field = et->fields[i]; AstNode *ident = NULL; AstNode *init = NULL; if (field->kind == AstNode_FieldValue) { @@ -932,7 +932,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As u32 curr_offset = 0; for_array(i, bft->fields) { - AstNode *field = bft->fields.e[i]; + AstNode *field = bft->fields[i]; GB_ASSERT(field->kind == AstNode_FieldValue); AstNode *ident = field->FieldValue.field; AstNode *value = field->FieldValue.value; @@ -1041,7 +1041,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari isize variable_count = 0; for_array(i, params) { - AstNode *field = params.e[i]; + AstNode *field = params[i]; if (ast_node_expect(field, AstNode_Field)) { ast_node(f, Field, field); variable_count += gb_max(f->names.count, 1); @@ -1052,10 +1052,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari Entity **variables = gb_alloc_array(c->allocator, Entity *, variable_count); isize variable_index = 0; for_array(i, params) { - if (params.e[i]->kind != AstNode_Field) { + if (params[i]->kind != AstNode_Field) { continue; } - ast_node(p, Field, params.e[i]); + ast_node(p, Field, params[i]); AstNode *type_expr = p->type; if (type_expr) { if (type_expr->kind == AstNode_Ellipsis) { @@ -1063,20 +1063,20 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (i+1 == params.count) { is_variadic = true; } else { - error_node(params.e[i], "Invalid AST: Invalid variadic parameter"); + error_node(params[i], "Invalid AST: Invalid variadic parameter"); } } Type *type = check_type(c, type_expr); if (p->flags&FieldFlag_no_alias) { if (!is_type_pointer(type)) { - error_node(params.e[i], "`no_alias` can only be applied to fields of pointer type"); + error_node(params[i], "`no_alias` can only be applied to fields of pointer type"); p->flags &= ~FieldFlag_no_alias; // Remove the flag } } for_array(j, p->names) { - AstNode *name = p->names.e[j]; + AstNode *name = p->names[j]; if (ast_node_expect(name, AstNode_Ident)) { Entity *param = make_entity_param(c->allocator, scope, name->Ident, type, (p->flags&FieldFlag_using) != 0, (p->flags&FieldFlag_immutable) != 0); @@ -1127,7 +1127,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { isize variable_count = 0; for_array(i, results) { - AstNode *field = results.e[i]; + AstNode *field = results[i]; if (ast_node_expect(field, AstNode_Field)) { ast_node(f, Field, field); variable_count += gb_max(f->names.count, 1); @@ -1137,7 +1137,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { Entity **variables = gb_alloc_array(c->allocator, Entity *, variable_count); isize variable_index = 0; for_array(i, results) { - ast_node(field, Field, results.e[i]); + ast_node(field, Field, results[i]); Type *type = check_type(c, field->type); if (field->names.count == 0) { Token token = ast_node_token(field->type); @@ -1149,7 +1149,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { Token token = ast_node_token(field->type); token.string = str_lit(""); - AstNode *name = field->names.e[j]; + AstNode *name = field->names[j]; if (name->kind != AstNode_Ident) { error_node(name, "Expected an identifer for as the field name"); } else { @@ -3551,7 +3551,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // NOTE(bill): The first arg may be a Type, this will be checked case by case break; default: - check_multi_expr(c, operand, ce->args.e[0]); + check_multi_expr(c, operand, ce->args[0]); } switch (id) { @@ -3609,10 +3609,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_new: { // new :: proc(Type) -> ^Type Operand op = {}; - check_expr_or_type(c, &op, ce->args.e[0]); + check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `new`"); + error_node(ce->args[0], "Expected a type for `new`"); return false; } operand->mode = Addressing_Value; @@ -3623,16 +3623,16 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // new_slice :: proc(Type, len: int) -> []Type // new_slice :: proc(Type, len, cap: int) -> []Type Operand op = {}; - check_expr_or_type(c, &op, ce->args.e[0]); + check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `new_slice`"); + error_node(ce->args[0], "Expected a type for `new_slice`"); return false; } isize arg_count = ce->args.count; if (arg_count < 2 || 3 < arg_count) { - error_node(ce->args.e[0], "`new_slice` expects 2 or 3 arguments, found %td", arg_count); + error_node(ce->args[0], "`new_slice` expects 2 or 3 arguments, found %td", arg_count); // NOTE(bill): Return the correct type to reduce errors } else { // If any are constant @@ -3640,7 +3640,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id isize size_count = 0; for (isize i = 1; i < arg_count; i++) { i64 val = 0; - bool ok = check_index_value(c, ce->args.e[i], -1, &val); + bool ok = check_index_value(c, ce->args[i], -1, &val); if (ok && val >= 0) { GB_ASSERT(size_count < gb_count_of(sizes)); sizes[size_count++] = val; @@ -3648,7 +3648,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (size_count == 2 && sizes[0] > sizes[1]) { - error_node(ce->args.e[1], "`new_slice` count and capacity are swapped"); + error_node(ce->args[1], "`new_slice` count and capacity are swapped"); // No need quit } } @@ -3661,10 +3661,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // make :: proc(Type, len: int) -> Type // make :: proc(Type, len, cap: int) -> Type Operand op = {}; - check_expr_or_type(c, &op, ce->args.e[0]); + check_expr_or_type(c, &op, ce->args[0]); Type *type = op.type; if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `make`"); + error_node(ce->args[0], "Expected a type for `make`"); return false; } @@ -3688,7 +3688,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id isize arg_count = ce->args.count; if (arg_count < min_args || max_args < arg_count) { - error_node(ce->args.e[0], "`make` expects %td or %d argument, found %td", min_args, max_args, arg_count); + error_node(ce->args[0], "`make` expects %td or %d argument, found %td", min_args, max_args, arg_count); return false; } @@ -3697,7 +3697,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id isize size_count = 0; for (isize i = 1; i < arg_count; i++) { i64 val = 0; - bool ok = check_index_value(c, false, ce->args.e[i], -1, &val); + bool ok = check_index_value(c, false, ce->args[i], -1, &val); if (ok && val >= 0) { GB_ASSERT(size_count < gb_count_of(sizes)); sizes[size_count++] = val; @@ -3705,7 +3705,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (size_count == 2 && sizes[0] > sizes[1]) { - error_node(ce->args.e[1], "`make` count and capacity are swapped"); + error_node(ce->args[1], "`make` count and capacity are swapped"); // No need quit } @@ -3755,7 +3755,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - AstNode *capacity = ce->args.e[1]; + AstNode *capacity = ce->args[1]; Operand op = {}; check_expr(c, &op, capacity); if (op.mode == Addressing_Invalid) { @@ -3846,7 +3846,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Type *key = base_type(type)->Map.key; Operand x = {Addressing_Invalid}; - AstNode *key_node = ce->args.e[1]; + AstNode *key_node = ce->args[1]; Operand op = {}; check_expr(c, &op, key_node); if (op.mode == Addressing_Invalid) { @@ -3868,9 +3868,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_size_of: { // size_of :: proc(Type) -> untyped int - Type *type = check_type(c, ce->args.e[0]); + Type *type = check_type(c, ce->args[0]); if (type == NULL || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `size_of`"); + error_node(ce->args[0], "Expected a type for `size_of`"); return false; } @@ -3894,9 +3894,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_align_of: { // align_of :: proc(Type) -> untyped int - Type *type = check_type(c, ce->args.e[0]); + Type *type = check_type(c, ce->args[0]); if (type == NULL || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `align_of`"); + error_node(ce->args[0], "Expected a type for `align_of`"); return false; } operand->mode = Addressing_Constant; @@ -3919,14 +3919,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_offset_of: { // offset_of :: proc(Type, field) -> untyped int Operand op = {}; - Type *bt = check_type(c, ce->args.e[0]); + Type *bt = check_type(c, ce->args[0]); Type *type = base_type(bt); if (type == NULL || type == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `offset_of`"); + error_node(ce->args[0], "Expected a type for `offset_of`"); return false; } - AstNode *field_arg = unparen_expr(ce->args.e[1]); + AstNode *field_arg = unparen_expr(ce->args[1]); if (field_arg == NULL || field_arg->kind != AstNode_Ident) { error_node(field_arg, "Expected an identifier for field argument"); @@ -3942,14 +3942,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id Selection sel = lookup_field(c->allocator, type, arg->string, operand->mode == Addressing_Type); if (sel.entity == NULL) { gbString type_str = type_to_string(bt); - error_node(ce->args.e[0], + error_node(ce->args[0], "`%s` has no field named `%.*s`", type_str, LIT(arg->string)); gb_string_free(type_str); return false; } if (sel.indirect) { gbString type_str = type_to_string(bt); - error_node(ce->args.e[0], + error_node(ce->args[0], "Field `%.*s` is embedded via a pointer in `%s`", LIT(arg->string), type_str); gb_string_free(type_str); return false; @@ -3962,7 +3962,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_offset_of_val: { // offset_of_val :: proc(val: expression) -> untyped int - AstNode *arg = unparen_expr(ce->args.e[0]); + AstNode *arg = unparen_expr(ce->args[0]); if (arg->kind != AstNode_SelectorExpr) { gbString str = expr_to_string(arg); error_node(arg, "`%s` is not a selector expression", str); @@ -3997,7 +3997,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (sel.indirect) { gbString type_str = type_to_string(type); - error_node(ce->args.e[0], + error_node(ce->args[0], "Field `%.*s` is embedded via a pointer in `%s`", LIT(i->string), type_str); gb_string_free(type_str); return false; @@ -4031,7 +4031,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // NOTE(bill): The type information may not be setup yet init_preload(c); - AstNode *expr = ce->args.e[0]; + AstNode *expr = ce->args[0]; Type *type = check_type(c, expr); if (type == NULL || type == t_invalid) { error_node(expr, "Invalid argument to `type_info`"); @@ -4052,7 +4052,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // NOTE(bill): The type information may not be setup yet init_preload(c); - AstNode *expr = ce->args.e[0]; + AstNode *expr = ce->args[0]; check_assignment(c, operand, NULL, str_lit("argument of `type_info_of_val`")); if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin) return false; @@ -4066,13 +4066,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // compile_assert :: proc(cond: bool) -> bool if (!is_type_boolean(operand->type) && operand->mode != Addressing_Constant) { - gbString str = expr_to_string(ce->args.e[0]); + gbString str = expr_to_string(ce->args[0]); error_node(call, "`%s` is not a constant boolean", str); gb_string_free(str); return false; } if (!operand->value.value_bool) { - gbString str = expr_to_string(ce->args.e[0]); + gbString str = expr_to_string(ce->args[0]); error_node(call, "Compile time assertion: `%s`", str); gb_string_free(str); } @@ -4085,7 +4085,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // assert :: proc(cond: bool) -> bool if (!is_type_boolean(operand->type)) { - gbString str = expr_to_string(ce->args.e[0]); + gbString str = expr_to_string(ce->args[0]); error_node(call, "`%s` is not a boolean", str); gb_string_free(str); return false; @@ -4099,7 +4099,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id // panic :: proc(msg: string) if (!is_type_string(operand->type)) { - gbString str = expr_to_string(ce->args.e[0]); + gbString str = expr_to_string(ce->args[0]); error_node(call, "`%s` is not a string", str); gb_string_free(str); return false; @@ -4117,7 +4117,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id dest_type = d->Slice.elem; } Operand op = {}; - check_expr(c, &op, ce->args.e[1]); + check_expr(c, &op, ce->args[1]); if (op.mode == Addressing_Invalid) { return false; } @@ -4132,8 +4132,8 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (!are_types_identical(dest_type, src_type)) { - gbString d_arg = expr_to_string(ce->args.e[0]); - gbString s_arg = expr_to_string(ce->args.e[1]); + gbString d_arg = expr_to_string(ce->args[0]); + gbString s_arg = expr_to_string(ce->args[1]); gbString d_str = type_to_string(dest_type); gbString s_str = type_to_string(src_type); error_node(call, @@ -4169,7 +4169,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id if (i == 0) { continue; } - AstNode *arg = ce->args.e[i]; + AstNode *arg = ce->args[i]; Operand op = {}; check_expr(c, &op, arg); if (op.mode == Addressing_Invalid) { @@ -4213,7 +4213,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id operand->type = t_invalid; operand->mode = Addressing_Invalid; - check_expr(c, &y, ce->args.e[1]); + check_expr(c, &y, ce->args[1]); if (y.mode == Addressing_Invalid) { return false; } @@ -4348,7 +4348,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id isize arg_count = ce->args.count; if (arg_count < 2 || 3 < arg_count) { - error_node(ce->args.e[0], "`slice_ptr` expects 2 or 3 arguments, found %td", arg_count); + error_node(ce->args[0], "`slice_ptr` expects 2 or 3 arguments, found %td", arg_count); // NOTE(bill): Return the correct type to reduce errors } else { // If any are constant @@ -4356,7 +4356,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id isize size_count = 0; for (isize i = 1; i < arg_count; i++) { i64 val = 0; - bool ok = check_index_value(c, false, ce->args.e[i], -1, &val); + bool ok = check_index_value(c, false, ce->args[i], -1, &val); if (ok && val >= 0) { GB_ASSERT(size_count < gb_count_of(sizes)); sizes[size_count++] = val; @@ -4364,7 +4364,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id } if (size_count == 2 && sizes[0] > sizes[1]) { - error_node(ce->args.e[1], "`slice_ptr` count and capacity are swapped"); + error_node(ce->args[1], "`slice_ptr` count and capacity are swapped"); // No need quit } } @@ -4396,7 +4396,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - AstNode *other_arg = ce->args.e[1]; + AstNode *other_arg = ce->args[1]; Operand a = *operand; Operand b = {}; check_expr(c, &b, other_arg); @@ -4464,7 +4464,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - AstNode *other_arg = ce->args.e[1]; + AstNode *other_arg = ce->args[1]; Operand a = *operand; Operand b = {}; check_expr(c, &b, other_arg); @@ -4566,8 +4566,8 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return false; } - AstNode *min_arg = ce->args.e[1]; - AstNode *max_arg = ce->args.e[2]; + AstNode *min_arg = ce->args[1]; + AstNode *max_arg = ce->args[2]; Operand x = *operand; Operand y = {}; Operand z = {}; @@ -4646,13 +4646,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id case BuiltinProc_transmute: { Operand op = {}; - check_expr_or_type(c, &op, ce->args.e[0]); + check_expr_or_type(c, &op, ce->args[0]); Type *t = op.type; if ((op.mode != Addressing_Type && t == NULL) || t == t_invalid) { - error_node(ce->args.e[0], "Expected a type for `transmute`"); + error_node(ce->args[0], "Expected a type for `transmute`"); return false; } - AstNode *expr = ce->args.e[1]; + AstNode *expr = ce->args[1]; Operand *o = operand; check_expr(c, o, expr); if (o->mode == Addressing_Invalid) { @@ -4834,13 +4834,11 @@ int valid_proc_and_score_cmp(void const *a, void const *b) { return sj < si ? -1 : sj > si; } -typedef Array(Operand) ArrayOperand; - -bool check_unpack_arguments(Checker *c, isize lhs_count, ArrayOperand *operands, AstNodeArray rhs, bool allow_ok) { +bool check_unpack_arguments(Checker *c, isize lhs_count, Array *operands, AstNodeArray rhs, bool allow_ok) { bool optional_ok = false; for_array(i, rhs) { Operand o = {}; - check_multi_expr(c, &o, rhs.e[i]); + check_multi_expr(c, &o, rhs[i]); if (o.type == NULL || o.type->kind != Type_Tuple) { if (allow_ok && lhs_count == 2 && rhs.count == 1 && @@ -4877,8 +4875,8 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod ast_node(ce, CallExpr, call); - ArrayOperand operands; - array_init_reserve(&operands, heap_allocator(), 2*ce->args.count); + Array operands; + array_init(&operands, heap_allocator(), 2*ce->args.count); check_unpack_arguments(c, -1, &operands, ce->args, false); if (operand->mode == Addressing_Overload) { @@ -4905,7 +4903,7 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod Type *proc_type = base_type(p->type); if (proc_type != NULL && is_type_proc(proc_type)) { i64 score = 0; - CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_NoErrors, &score); + CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_NoErrors, &score); if (err == CallArgumentError_None) { valids[valid_count].index = i; valids[valid_count].score = score; @@ -4950,14 +4948,14 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod add_entity_use(c, expr, e); proc_type = e->type; i64 score = 0; - CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_ShowErrors, &score); + CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_ShowErrors, &score); } gb_free(heap_allocator(), valids); gb_free(heap_allocator(), procs); } else { i64 score = 0; - CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_ShowErrors, &score); + CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_ShowErrors, &score); array_free(&operands); } return proc_type; @@ -4994,7 +4992,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { if (operand->mode == Addressing_Invalid) { for_array(i, ce->args) { - check_expr_base(c, operand, ce->args.e[i], NULL); + check_expr_base(c, operand, ce->args[i], NULL); } operand->mode = Addressing_Invalid; operand->expr = call; @@ -5010,7 +5008,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { case 0: error_node(call, "Missing argument in convertion to `%s`", str); break; default: error_node(call, "Too many arguments in convertion to `%s`", str); break; case 1: - check_expr(c, operand, ce->args.e[0]); + check_expr(c, operand, ce->args[0]); if (operand->mode != Addressing_Invalid) { check_cast(c, operand, t); } @@ -5388,11 +5386,11 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } { // Checker values isize field_count = t->Record.field_count; - if (cl->elems.e[0]->kind == AstNode_FieldValue) { + if (cl->elems[0]->kind == AstNode_FieldValue) { bool *fields_visited = gb_alloc_array(c->allocator, bool, field_count); for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { error_node(elem, "Mixture of `field = value` and value elements in a structure literal is not allowed"); continue; @@ -5423,15 +5421,15 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t continue; } - Entity *field = t->Record.fields[sel.index.e[0]]; + Entity *field = t->Record.fields[sel.index[0]]; add_entity_use(c, fv->field, field); - if (fields_visited[sel.index.e[0]]) { + if (fields_visited[sel.index[0]]) { error_node(elem, "Duplicate field `%.*s` in structure literal", LIT(name)); continue; } - fields_visited[sel.index.e[0]] = true; + fields_visited[sel.index[0]] = true; check_expr(c, o, fv->value); if (is_type_any(field->type) || is_type_union(field->type) || is_type_raw_union(field->type)) { @@ -5455,7 +5453,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } for_array(index, cl->elems) { - AstNode *elem = cl->elems.e[index]; + AstNode *elem = cl->elems[index]; if (elem->kind == AstNode_FieldValue) { error_node(elem, "Mixture of `field = value` and value elements in a structure literal is not allowed"); continue; @@ -5533,8 +5531,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } for (; index < elem_count; index++) { - GB_ASSERT(cl->elems.e != NULL); - AstNode *e = cl->elems.e[index]; + GB_ASSERT(cl->elems.data != NULL); + AstNode *e = cl->elems[index]; if (e == NULL) { error_node(node, "Invalid literal element"); continue; @@ -5563,7 +5561,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t if (t->kind == Type_Vector) { if (t->Vector.count > 1 && gb_is_between(index, 2, t->Vector.count-1)) { - error_node(cl->elems.e[0], "Expected either 1 (broadcast) or %td elements in vector literal, got %td", t->Vector.count, index); + error_node(cl->elems[0], "Expected either 1 (broadcast) or %td elements in vector literal, got %td", t->Vector.count, index); } } @@ -5585,11 +5583,11 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t { // Checker values Type *field_types[2] = {t_rawptr, t_type_info_ptr}; isize field_count = 2; - if (cl->elems.e[0]->kind == AstNode_FieldValue) { + if (cl->elems[0]->kind == AstNode_FieldValue) { bool fields_visited[2] = {}; for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { error_node(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed"); continue; @@ -5609,7 +5607,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t continue; } - isize index = sel.index.e[0]; + isize index = sel.index[0]; if (fields_visited[index]) { error_node(elem, "Duplicate field `%.*s` in `any` literal", LIT(name)); @@ -5626,7 +5624,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t } } else { for_array(index, cl->elems) { - AstNode *elem = cl->elems.e[index]; + AstNode *elem = cl->elems[index]; if (elem->kind == AstNode_FieldValue) { error_node(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed"); continue; @@ -5658,7 +5656,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t is_constant = false; { // Checker values for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (elem->kind != AstNode_FieldValue) { error_node(elem, "Only `field = value` elements are allowed in a map literal"); continue; @@ -6146,7 +6144,7 @@ gbString write_record_fields_to_string(gbString str, AstNodeArray params) { if (i > 0) { str = gb_string_appendc(str, ", "); } - str = write_expr_to_string(str, params.e[i]); + str = write_expr_to_string(str, params[i]); } return str; } @@ -6200,7 +6198,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { if (i > 0) { str = gb_string_appendc(str, ", "); } - str = write_expr_to_string(str, cl->elems.e[i]); + str = write_expr_to_string(str, cl->elems[i]); } str = gb_string_appendc(str, "}"); case_end; @@ -6321,7 +6319,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { } for_array(i, f->names) { - AstNode *name = f->names.e[i]; + AstNode *name = f->names[i]; if (i > 0) { str = gb_string_appendc(str, ", "); } @@ -6341,7 +6339,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { if (i > 0) { str = gb_string_appendc(str, ", "); } - str = write_expr_to_string(str, f->list.e[i]); + str = write_expr_to_string(str, f->list[i]); } case_end; @@ -6357,7 +6355,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { str = gb_string_appendc(str, "("); for_array(i, ce->args) { - AstNode *arg = ce->args.e[i]; + AstNode *arg = ce->args[i]; if (i > 0) { str = gb_string_appendc(str, ", "); } @@ -6406,7 +6404,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) { if (i > 0) { str = gb_string_appendc(str, ", "); } - str = write_expr_to_string(str, et->fields.e[i]); + str = write_expr_to_string(str, et->fields[i]); } str = gb_string_appendc(str, "}"); case_end; diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 187dab3b7..9a0f6afa5 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -12,13 +12,13 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { isize max = stmts.count; for (isize i = stmts.count-1; i >= 0; i--) { - if (stmts.e[i]->kind != AstNode_EmptyStmt) { + if (stmts[i]->kind != AstNode_EmptyStmt) { break; } max--; } for (isize i = 0; i < max; i++) { - AstNode *n = stmts.e[i]; + AstNode *n = stmts[i]; if (n->kind == AstNode_EmptyStmt) { continue; } @@ -43,7 +43,7 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { bool check_is_terminating_list(AstNodeArray stmts) { // Iterate backwards for (isize n = stmts.count-1; n >= 0; n--) { - AstNode *stmt = stmts.e[n]; + AstNode *stmt = stmts[n]; if (stmt->kind != AstNode_EmptyStmt) { return check_is_terminating(stmt); } @@ -54,7 +54,7 @@ bool check_is_terminating_list(AstNodeArray stmts) { bool check_has_break_list(AstNodeArray stmts, bool implicit) { for_array(i, stmts) { - AstNode *stmt = stmts.e[i]; + AstNode *stmt = stmts[i]; if (check_has_break(stmt, implicit)) { return true; } @@ -137,7 +137,7 @@ bool check_is_terminating(AstNode *node) { case_ast_node(ms, MatchStmt, node); bool has_default = false; for_array(i, ms->body->BlockStmt.stmts) { - AstNode *clause = ms->body->BlockStmt.stmts.e[i]; + AstNode *clause = ms->body->BlockStmt.stmts[i]; ast_node(cc, CaseClause, clause); if (cc->list.count == 0) { has_default = true; @@ -153,7 +153,7 @@ bool check_is_terminating(AstNode *node) { case_ast_node(ms, TypeMatchStmt, node); bool has_default = false; for_array(i, ms->body->BlockStmt.stmts) { - AstNode *clause = ms->body->BlockStmt.stmts.e[i]; + AstNode *clause = ms->body->BlockStmt.stmts[i]; ast_node(cc, CaseClause, clause); if (cc->list.count == 0) { has_default = true; @@ -448,7 +448,7 @@ void check_label(Checker *c, AstNode *label) { bool ok = true; for_array(i, c->context.decl->labels) { - BlockLabel bl = c->context.decl->labels.e[i]; + BlockLabel bl = c->context.decl->labels[i]; if (bl.name == name) { error_node(label, "Duplicate label with the name `%.*s`", LIT(name)); ok = false; @@ -513,7 +513,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo case Entity_ImportName: { Scope *scope = e->ImportName.scope; for_array(i, scope->elements.entries) { - Entity *decl = scope->elements.entries.e[i].value; + Entity *decl = scope->elements.entries[i].value; Entity *found = scope_insert_entity(c->context.scope, decl); if (found != NULL) { gbString expr_str = expr_to_string(expr); @@ -539,7 +539,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo GB_ASSERT(found_ != NULL); Scope *found = *found_; for_array(i, found->elements.entries) { - Entity *f = found->elements.entries.e[i].value; + Entity *f = found->elements.entries[i].value; if (f->kind == Entity_Variable) { Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); // if (is_selector) { @@ -693,23 +693,23 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { // NOTE(bill): If there is a bad syntax error, rhs > lhs which would mean there would need to be // an extra allocation - ArrayOperand operands = {}; - array_init_reserve(&operands, c->tmp_allocator, 2 * lhs_count); + Array operands = {}; + array_init(&operands, c->tmp_allocator, 2 * lhs_count); check_unpack_arguments(c, lhs_count, &operands, as->rhs, true); isize rhs_count = operands.count; for_array(i, operands) { - if (operands.e[i].mode == Addressing_Invalid) { + if (operands[i].mode == Addressing_Invalid) { rhs_count--; } } isize max = gb_min(lhs_count, rhs_count); for (isize i = 0; i < max; i++) { - check_assignment_variable(c, &operands.e[i], as->lhs.e[i]); + check_assignment_variable(c, &operands[i], as->lhs[i]); } if (lhs_count != rhs_count) { - error_node(as->lhs.e[0], "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); + error_node(as->lhs[0], "Assignment count mismatch `%td` = `%td`", lhs_count, rhs_count); } gb_temp_arena_memory_end(tmp); @@ -732,15 +732,15 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { be->op = op; be->op.kind = cast(TokenKind)(cast(i32)be->op.kind - (Token_AddEq - Token_Add)); // NOTE(bill): Only use the first one will be used - be->left = as->lhs.e[0]; - be->right = as->rhs.e[0]; + be->left = as->lhs[0]; + be->right = as->rhs[0]; check_binary_expr(c, &operand, &binary_expr); if (operand.mode == Addressing_Invalid) { return; } // NOTE(bill): Only use the first one will be used - check_assignment_variable(c, &operand, as->lhs.e[0]); + check_assignment_variable(c, &operand, as->lhs[0]); } break; } case_end; @@ -794,7 +794,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } - Type *proc_type = c->proc_stack.e[c->proc_stack.count-1]; + Type *proc_type = c->proc_stack[c->proc_stack.count-1]; isize result_count = 0; if (proc_type->Proc.results) { result_count = proc_type->Proc.results->Tuple.variable_count; @@ -816,13 +816,13 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_init_variables(c, variables, result_count, rs->results, str_lit("return statement")); // if (pos.line == 10) { - // AstNode *x = rs->results.e[0]; + // AstNode *x = rs->results[0]; // gb_printf_err("%s\n", expr_to_string(x)); // gb_printf_err("%s\n", type_to_string(type_of_expr(&c->info, x))); // } } } else if (rs->results.count > 0) { - error_node(rs->results.e[0], "No return values expected"); + error_node(rs->results[0], "No return values expected"); } case_end; @@ -1106,7 +1106,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { AstNode *first_default = NULL; ast_node(bs, BlockStmt, ms->body); for_array(i, bs->stmts) { - AstNode *stmt = bs->stmts.e[i]; + AstNode *stmt = bs->stmts[i]; AstNode *default_stmt = NULL; if (stmt->kind == AstNode_CaseClause) { ast_node(cc, CaseClause, stmt); @@ -1134,7 +1134,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { map_type_and_token_init(&seen, heap_allocator()); for_array(i, bs->stmts) { - AstNode *stmt = bs->stmts.e[i]; + AstNode *stmt = bs->stmts[i]; if (stmt->kind != AstNode_CaseClause) { // NOTE(bill): error handled by above multiple default checker continue; @@ -1142,7 +1142,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { ast_node(cc, CaseClause, stmt); for_array(j, cc->list) { - AstNode *expr = unparen_expr(cc->list.e[j]); + AstNode *expr = unparen_expr(cc->list[j]); if (is_ast_node_a_range(expr)) { ast_node(ie, BinaryExpr, expr); @@ -1297,8 +1297,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { syntax_error(as_token, "Expected 1 expression after `in`"); break; } - AstNode *lhs = as->lhs.e[0]; - AstNode *rhs = as->rhs.e[0]; + AstNode *lhs = as->lhs[0]; + AstNode *rhs = as->rhs[0]; check_expr(c, &x, rhs); check_assignment(c, &x, NULL, str_lit("type match expression")); @@ -1316,7 +1316,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { AstNode *first_default = NULL; ast_node(bs, BlockStmt, ms->body); for_array(i, bs->stmts) { - AstNode *stmt = bs->stmts.e[i]; + AstNode *stmt = bs->stmts[i]; AstNode *default_stmt = NULL; if (stmt->kind == AstNode_CaseClause) { ast_node(cc, CaseClause, stmt); @@ -1350,7 +1350,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { map_bool_init(&seen, heap_allocator()); for_array(i, bs->stmts) { - AstNode *stmt = bs->stmts.e[i]; + AstNode *stmt = bs->stmts[i]; if (stmt->kind != AstNode_CaseClause) { // NOTE(bill): error handled by above multiple default checker continue; @@ -1362,7 +1362,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Type *case_type = NULL; for_array(type_index, cc->list) { - AstNode *type_expr = cc->list.e[type_index]; + AstNode *type_expr = cc->list[type_index]; if (type_expr != NULL) { // Otherwise it's a default expression Operand y = {}; check_expr_or_type(c, &y, type_expr); @@ -1502,7 +1502,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { return; } for_array(i, us->list) { - AstNode *expr = unparen_expr(us->list.e[0]); + AstNode *expr = unparen_expr(us->list[0]); Entity *e = NULL; bool is_selector = false; @@ -1555,7 +1555,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; Entity *entity = NULL; if (name->kind != AstNode_Ident) { error_node(name, "A variable declaration must be an identifier"); @@ -1638,7 +1638,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Scope **found = map_scope_get(&c->info.scopes, hash_pointer(t->Record.node)); GB_ASSERT(found != NULL); for_array(i, (*found)->elements.entries) { - Entity *f = (*found)->elements.entries.e[i].value; + Entity *f = (*found)->elements.entries[i].value; if (f->kind == Entity_Variable) { Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); uvar->Variable.is_immutable = is_immutable; diff --git a/src/checker.cpp b/src/checker.cpp index 4922dd548..6a9011df1 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -197,7 +197,7 @@ struct DeclInfo { AstNode * proc_lit; // AstNode_ProcLit MapBool deps; // Key: Entity * - Array(BlockLabel) labels; + Array labels; }; // ProcedureInfo stores the information needed for checking a procedure @@ -240,8 +240,8 @@ typedef struct Scope { MapEntity elements; // Key: String MapBool implicit; // Key: Entity * - Array(Scope *) shared; - Array(Scope *) imported; + Array shared; + Array imported; bool is_proc; bool is_global; bool is_file; @@ -286,10 +286,10 @@ typedef struct DelayedDecl { } DelayedDecl; typedef struct CheckerFileNode { - i32 id; - Array_i32 wheres; - Array_i32 whats; - i32 score; // Higher the score, the better + i32 id; + Array wheres; + Array whats; + i32 score; // Higher the score, the better } CheckerFileNode; typedef struct CheckerContext { @@ -324,10 +324,10 @@ typedef struct Checker { AstFile * curr_ast_file; Scope * global_scope; - Array(ProcedureInfo) procs; // NOTE(bill): Procedures to check - Array(DelayedDecl) delayed_imports; - Array(DelayedDecl) delayed_foreign_libraries; - Array(CheckerFileNode) file_nodes; + Array procs; // NOTE(bill): Procedures to check + Array delayed_imports; + Array delayed_foreign_libraries; + Array file_nodes; gbArena arena; gbArena tmp_arena; @@ -336,7 +336,7 @@ typedef struct Checker { CheckerContext context; - Array(Type *) proc_stack; + Array proc_stack; bool done_preload; } Checker; @@ -347,8 +347,6 @@ typedef struct DelayedEntity { DeclInfo * decl; } DelayedEntity; -typedef Array(DelayedEntity) DelayedEntities; - @@ -406,7 +404,7 @@ Scope *make_scope(Scope *parent, gbAllocator allocator) { void destroy_scope(Scope *scope) { for_array(i, scope->elements.entries) { - Entity *e =scope->elements.entries.e[i].value; + Entity *e =scope->elements.entries[i].value; if (e->kind == Entity_Variable) { if (!(e->flags & EntityFlag_Used)) { #if 0 @@ -462,7 +460,7 @@ Entity *current_scope_lookup_entity(Scope *s, String name) { return *found; } for_array(i, s->shared) { - Scope *shared = s->shared.e[i]; + Scope *shared = s->shared[i]; Entity **found = map_entity_get(&shared->elements, key); if (found) { Entity *e = *found; @@ -512,7 +510,7 @@ void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entit } else { // Check shared scopes - i.e. other files @ global scope for_array(i, s->shared) { - Scope *shared = s->shared.e[i]; + Scope *shared = s->shared[i]; Entity **found = map_entity_get(&shared->elements, key); if (found) { Entity *e = *found; @@ -753,7 +751,7 @@ void init_checker(Checker *c, Parser *parser, BuildContext *bc) { array_init(&c->file_nodes, a); for_array(i, parser->files) { - AstFile *file = &parser->files.e[i]; + AstFile *file = &parser->files[i]; CheckerFileNode node = {}; node.id = file->id; array_init(&node.whats, a); @@ -765,7 +763,7 @@ void init_checker(Checker *c, Parser *parser, BuildContext *bc) { isize item_size = gb_max3(gb_size_of(Entity), gb_size_of(Type), gb_size_of(Scope)); isize total_token_count = 0; for_array(i, c->parser->files) { - AstFile *f = &c->parser->files.e[i]; + AstFile *f = &c->parser->files[i]; total_token_count += f->tokens.count; } isize arena_size = 2 * item_size * total_token_count; @@ -961,7 +959,7 @@ void add_type_info_type(Checker *c, Type *t) { isize ti_index = -1; for_array(i, c->info.type_info_map.entries) { - MapIsizeEntry *e = &c->info.type_info_map.entries.e[i]; + MapIsizeEntry *e = &c->info.type_info_map.entries[i]; Type *prev_type = cast(Type *)e->key.ptr; if (are_types_identical(t, prev_type)) { // Duplicate entry @@ -1107,7 +1105,7 @@ void pop_procedure(Checker *c) { Type *const curr_procedure_type(Checker *c) { isize count = c->proc_stack.count; if (count > 0) { - return c->proc_stack.e[count-1]; + return c->proc_stack[count-1]; } return NULL; } @@ -1143,7 +1141,7 @@ void add_dependency_to_map(MapEntity *map, CheckerInfo *info, Entity *node) { DeclInfo *decl = *found; for_array(i, decl->deps.entries) { - Entity *e = cast(Entity *)decl->deps.entries.e[i].key.ptr; + Entity *e = cast(Entity *)decl->deps.entries[i].key.ptr; add_dependency_to_map(map, info, e); } } @@ -1153,7 +1151,7 @@ MapEntity generate_minimum_dependency_map(CheckerInfo *info, Entity *start) { map_entity_init(&map, heap_allocator()); for_array(i, info->definitions.entries) { - Entity *e = info->definitions.entries.e[i].value; + Entity *e = info->definitions.entries[i].value; if (e->scope->is_global) { // NOTE(bill): Require runtime stuff add_dependency_to_map(&map, info, e); @@ -1401,21 +1399,21 @@ bool check_arity_match(Checker *c, AstNodeValueDecl *d) { if (rhs == 0) { if (d->type == NULL) { - error_node(d->names.e[0], "Missing type or initial expression"); + error_node(d->names[0], "Missing type or initial expression"); return false; } } else if (lhs < rhs) { if (lhs < d->values.count) { - AstNode *n = d->values.e[lhs]; + AstNode *n = d->values[lhs]; gbString str = expr_to_string(n); error_node(n, "Extra initial expression `%s`", str); gb_string_free(str); } else { - error_node(d->names.e[0], "Extra initial expression"); + error_node(d->names[0], "Extra initial expression"); } return false; } else if (lhs > rhs && rhs != 1) { - AstNode *n = d->names.e[rhs]; + AstNode *n = d->names[rhs]; gbString str = expr_to_string(n); error_node(n, "Missing expression for `%s`", str); gb_string_free(str); @@ -1466,7 +1464,7 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) } for_array(decl_index, nodes) { - AstNode *decl = nodes.e[decl_index]; + AstNode *decl = nodes[decl_index]; if (!is_ast_node_decl(decl) && !is_ast_node_when_stmt(decl)) { continue; } @@ -1498,7 +1496,7 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) di = make_declaration_info(heap_allocator(), c->context.scope, c->context.decl); di->entities = entities; di->type_expr = vd->type; - di->init_expr = vd->values.e[0]; + di->init_expr = vd->values[0]; if (vd->flags & VarDeclFlag_thread_local) { @@ -1508,10 +1506,10 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; AstNode *value = NULL; if (i < vd->values.count) { - value = vd->values.e[i]; + value = vd->values[i]; } if (name->kind != AstNode_Ident) { error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); @@ -1545,7 +1543,7 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) check_arity_match(c, vd); } else { for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; if (name->kind != AstNode_Ident) { error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); continue; @@ -1553,7 +1551,7 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) AstNode *init = NULL; if (i < vd->values.count) { - init = vd->values.e[i]; + init = vd->values[i]; } DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); @@ -1648,7 +1646,7 @@ void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) // NOTE(bill): `when` stmts need to be handled after the other as the condition may refer to something // declared after this stmt in source for_array(i, nodes) { - AstNode *node = nodes.e[i]; + AstNode *node = nodes[i]; switch (node->kind) { case_ast_node(ws, WhenStmt, node); check_collect_entities_from_when_stmt(c, ws, is_file_scope); @@ -1663,7 +1661,7 @@ void check_all_global_entities(Checker *c) { Scope *prev_file = {}; for_array(i, c->info.entities.entries) { - MapDeclInfoEntry *entry = &c->info.entities.entries.e[i]; + MapDeclInfoEntry *entry = &c->info.entities.entries[i]; Entity *e = cast(Entity *)cast(uintptr)entry->key.key; DeclInfo *d = entry->value; @@ -1701,7 +1699,7 @@ void check_all_global_entities(Checker *c) { } for_array(i, c->info.entities.entries) { - MapDeclInfoEntry *entry = &c->info.entities.entries.e[i]; + MapDeclInfoEntry *entry = &c->info.entities.entries[i]; Entity *e = cast(Entity *)cast(uintptr)entry->key.key; if (e->kind != Entity_Procedure) { continue; @@ -1779,8 +1777,8 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { Array_i32 shared_global_file_ids = {}; array_init_reserve(&shared_global_file_ids, heap_allocator(), c->file_nodes.count); for_array(i, c->file_nodes) { - CheckerFileNode *node = &c->file_nodes.e[i]; - AstFile *f = &c->parser->files.e[node->id]; + CheckerFileNode *node = &c->file_nodes[i]; + AstFile *f = &c->parser->files[node->id]; GB_ASSERT(f->id == node->id); if (f->scope->is_global) { array_add(&shared_global_file_ids, f->id); @@ -1788,11 +1786,11 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { } for_array(i, c->file_nodes) { - CheckerFileNode *node = &c->file_nodes.e[i]; - AstFile *f = &c->parser->files.e[node->id]; + CheckerFileNode *node = &c->file_nodes[i]; + AstFile *f = &c->parser->files[node->id]; if (!f->scope->is_global) { for_array(j, shared_global_file_ids) { - array_add(&node->whats, shared_global_file_ids.e[j]); + array_add(&node->whats, shared_global_file_ids[j]); } } } @@ -1801,8 +1799,8 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { } for_array(i, c->delayed_imports) { - Scope *parent_scope = c->delayed_imports.e[i].parent; - AstNode *decl = c->delayed_imports.e[i].decl; + Scope *parent_scope = c->delayed_imports[i].parent; + AstNode *decl = c->delayed_imports[i].decl; ast_node(id, ImportDecl, decl); Token token = id->relpath; @@ -1816,7 +1814,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { Scope **found = map_scope_get(file_scopes, key); if (found == NULL) { for_array(scope_index, file_scopes->entries) { - Scope *scope = file_scopes->entries.e[scope_index].value; + Scope *scope = file_scopes->entries[scope_index].value; gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath)); } gb_printf_err("%.*s(%td:%td)\n", LIT(token.pos.file), token.pos.line, token.pos.column); @@ -1832,10 +1830,10 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { i32 child_id = scope->file->id; // TODO(bill): Very slow - CheckerFileNode *parent_node = &c->file_nodes.e[parent_id]; + CheckerFileNode *parent_node = &c->file_nodes[parent_id]; bool add_child = true; for_array(j, parent_node->whats) { - if (parent_node->whats.e[j] == child_id) { + if (parent_node->whats[j] == child_id) { add_child = false; break; } @@ -1844,10 +1842,10 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { array_add(&parent_node->whats, child_id); } - CheckerFileNode *child_node = &c->file_nodes.e[child_id]; + CheckerFileNode *child_node = &c->file_nodes[child_id]; bool add_parent = true; for_array(j, parent_node->wheres) { - if (parent_node->wheres.e[j] == parent_id) { + if (parent_node->wheres[j] == parent_id) { add_parent = false; break; } @@ -1858,24 +1856,24 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { } for_array(i, c->file_nodes) { - CheckerFileNode *node = &c->file_nodes.e[i]; - AstFile *f = &c->parser->files.e[node->id]; + CheckerFileNode *node = &c->file_nodes[i]; + AstFile *f = &c->parser->files[node->id]; gb_printf_err("File %d %.*s", node->id, LIT(f->tokenizer.fullpath)); gb_printf_err("\n wheres:"); for_array(j, node->wheres) { - gb_printf_err(" %d", node->wheres.e[j]); + gb_printf_err(" %d", node->wheres[j]); } gb_printf_err("\n whats:"); for_array(j, node->whats) { - gb_printf_err(" %d", node->whats.e[j]); + gb_printf_err(" %d", node->whats[j]); } gb_printf_err("\n"); } #endif for_array(i, c->delayed_imports) { - Scope *parent_scope = c->delayed_imports.e[i].parent; - AstNode *decl = c->delayed_imports.e[i].decl; + Scope *parent_scope = c->delayed_imports[i].parent; + AstNode *decl = c->delayed_imports[i].decl; ast_node(id, ImportDecl, decl); Token token = id->relpath; @@ -1889,7 +1887,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { Scope **found = map_scope_get(file_scopes, key); if (found == NULL) { for_array(scope_index, file_scopes->entries) { - Scope *scope = file_scopes->entries.e[scope_index].value; + Scope *scope = file_scopes->entries[scope_index].value; gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath)); } gb_printf_err("%.*s(%td:%td)\n", LIT(token.pos.file), token.pos.line, token.pos.column); @@ -1917,7 +1915,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { bool previously_added = false; for_array(import_index, parent_scope->imported) { - Scope *prev = parent_scope->imported.e[import_index]; + Scope *prev = parent_scope->imported[import_index]; if (prev == scope) { previously_added = true; break; @@ -1935,7 +1933,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { if (id->import_name.string == ".") { // NOTE(bill): Add imported entities to this file's scope for_array(elem_index, scope->elements.entries) { - Entity *e = scope->elements.entries.e[elem_index].value; + Entity *e = scope->elements.entries[elem_index].value; if (e->scope == parent_scope) { continue; } @@ -1974,8 +1972,8 @@ void check_import_entities(Checker *c, MapScope *file_scopes) { } for_array(i, c->delayed_foreign_libraries) { - Scope *parent_scope = c->delayed_foreign_libraries.e[i].parent; - AstNode *decl = c->delayed_foreign_libraries.e[i].decl; + Scope *parent_scope = c->delayed_foreign_libraries[i].parent; + AstNode *decl = c->delayed_foreign_libraries[i].decl; ast_node(fl, ForeignLibrary, decl); String file_str = fl->filepath.string; @@ -2029,7 +2027,7 @@ void check_parsed_files(Checker *c) { // Map full filepaths to Scopes for_array(i, c->parser->files) { - AstFile *f = &c->parser->files.e[i]; + AstFile *f = &c->parser->files[i]; Scope *scope = NULL; scope = make_scope(c->global_scope, c->allocator); scope->is_global = f->is_global_scope; @@ -2056,7 +2054,7 @@ void check_parsed_files(Checker *c) { // Collect Entities for_array(i, c->parser->files) { - AstFile *f = &c->parser->files.e[i]; + AstFile *f = &c->parser->files[i]; CheckerContext prev_context = c->context; add_curr_ast_file(c, f); check_collect_entities(c, f->decls, true); @@ -2071,7 +2069,7 @@ void check_parsed_files(Checker *c) { // Check procedure bodies // NOTE(bill): Nested procedures bodies will be added to this "queue" for_array(i, c->procs) { - ProcedureInfo *pi = &c->procs.e[i]; + ProcedureInfo *pi = &c->procs[i]; CheckerContext prev_context = c->context; add_curr_ast_file(c, pi->file); @@ -2094,7 +2092,7 @@ void check_parsed_files(Checker *c) { // Add untyped expression values for_array(i, c->info.untyped.entries) { - MapExprInfoEntry *entry = &c->info.untyped.entries.e[i]; + MapExprInfoEntry *entry = &c->info.untyped.entries[i]; HashKey key = entry->key; AstNode *expr = cast(AstNode *)cast(uintptr)key.key; ExprInfo *info = &entry->value; @@ -2132,7 +2130,7 @@ void check_parsed_files(Checker *c) { // NOTE(bill): Check for illegal cyclic type declarations for_array(i, c->info.definitions.entries) { - Entity *e = c->info.definitions.entries.e[i].value; + Entity *e = c->info.definitions.entries[i].value; if (e->kind == Entity_TypeName) { if (e->type != NULL) { // i64 size = type_size_of(c->sizes, c->allocator, e->type); @@ -2148,13 +2146,13 @@ void check_parsed_files(Checker *c) { if (!build_context.is_dll) { for_array(i, file_scopes.entries) { - Scope *s = file_scopes.entries.e[i].value; + Scope *s = file_scopes.entries[i].value; if (s->is_init) { Entity *e = current_scope_lookup_entity(s, str_lit("main")); if (e == NULL) { Token token = {}; if (s->file->tokens.count > 0) { - token = s->file->tokens.e[0]; + token = s->file->tokens[0]; } else { token.pos.file = s->file->tokenizer.fullpath; token.pos.line = 1; diff --git a/src/common.cpp b/src/common.cpp index 1155429d1..0aa37a001 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -242,10 +242,6 @@ f64 gb_sqrt(f64 x) { // //////////////////////////////////////////////////////////////// -typedef Array(i32) Array_i32; -typedef Array(isize) Array_isize; - - #define MAP_TYPE String #define MAP_PROC map_string_ #define MAP_NAME MapString diff --git a/src/ir.cpp b/src/ir.cpp index bab4027ef..c9afb05ba 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -3,7 +3,7 @@ typedef struct irBlock irBlock; typedef struct irValue irValue; typedef struct irDebugInfo irDebugInfo; -typedef Array(irValue *) irValueArray; +typedef Array irValueArray; #define MAP_TYPE irValue * #define MAP_PROC map_ir_value_ @@ -41,16 +41,16 @@ typedef struct irModule { Entity * entry_point_entity; - Array(irProcedure *) procs; // NOTE(bill): All procedures with bodies + Array procs; // NOTE(bill): All procedures with bodies irValueArray procs_to_generate; // NOTE(bill): Procedures to generate - Array(String) foreign_library_paths; // Only the ones that were used + Array foreign_library_paths; // Only the ones that were used } irModule; // NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory) typedef struct irDomNode { irBlock * idom; // Parent (Immediate Dominator) - Array(irBlock *) children; + Array children; i32 pre, post; // Ordering in tree } irDomNode; @@ -68,8 +68,8 @@ typedef struct irBlock { irValueArray instrs; irValueArray locals; - Array(irBlock *) preds; - Array(irBlock *) succs; + Array preds; + Array succs; } irBlock; typedef struct irTargetList irTargetList; @@ -111,7 +111,7 @@ typedef struct irBranchBlocks { struct irProcedure { irProcedure * parent; - Array(irProcedure *) children; + Array children; Entity * entity; irModule * module; @@ -123,8 +123,8 @@ struct irProcedure { irValue * return_ptr; irValueArray params; - Array(irDefer) defer_stmts; - Array(irBlock *) blocks; + Array defer_stmts; + Array blocks; i32 scope_index; irBlock * decl_block; irBlock * entry_block; @@ -132,7 +132,7 @@ struct irProcedure { irTargetList * target_list; irValueArray referrers; - Array(irBranchBlocks) branch_blocks; + Array branch_blocks; i32 local_count; i32 instr_count; @@ -516,7 +516,7 @@ struct irDebugInfo { TokenPos pos; } Proc; struct { - Array(irDebugInfo *) procs; + Array procs; } AllProcs; @@ -528,7 +528,7 @@ struct irDebugInfo { } BasicType; struct { irDebugInfo * return_type; - Array(irDebugInfo *) param_types; + Array param_types; } ProcType; struct { irDebugInfo * base_type; @@ -542,7 +542,7 @@ struct irDebugInfo { TokenPos pos; i32 size; i32 align; - Array(irDebugInfo *) elements; + Array elements; } CompositeType; struct { String name; @@ -662,7 +662,7 @@ irInstr *ir_get_last_instr(irBlock *block) { if (block != NULL) { isize len = block->instrs.count; if (len > 0) { - irValue *v = block->instrs.e[len-1]; + irValue *v = block->instrs[len-1]; GB_ASSERT(v->kind == irValue_Instr); return &v->Instr; } @@ -1125,7 +1125,7 @@ irValue *ir_value_procedure(gbAllocator a, irModule *m, Entity *entity, Type *ty Type *t = base_type(type); GB_ASSERT(is_type_proc(t)); - array_init_reserve(&v->Proc.params, heap_allocator(), t->Proc.param_count); + array_init(&v->Proc.params, heap_allocator(), t->Proc.param_count); return v; } @@ -1177,7 +1177,7 @@ irBlock *ir_new_block(irProcedure *proc, AstNode *node, char *label) { void ir_add_block_to_proc(irProcedure *proc, irBlock *b) { for_array(i, proc->blocks) { - if (proc->blocks.e[i] == b) { + if (proc->blocks[i] == b) { return; } } @@ -1535,7 +1535,7 @@ void ir_emit_defer_stmts(irProcedure *proc, irDeferExitKind kind, irBlock *block isize count = proc->defer_stmts.count; isize i = count; while (i --> 0) { - irDefer d = proc->defer_stmts.e[i]; + irDefer d = proc->defer_stmts[i]; if (kind == irDeferExit_Default) { if (proc->scope_index == d.scope_index && d.scope_index > 1) { @@ -2446,7 +2446,7 @@ irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) { Type *type = type_deref(ir_type(e)); for_array(i, sel.index) { - i32 index = cast(i32)sel.index.e[i]; + i32 index = cast(i32)sel.index[i]; if (is_type_pointer(type)) { type = type_deref(type); e = ir_emit_load(proc, e); @@ -2516,7 +2516,7 @@ irValue *ir_emit_deep_field_ev(irProcedure *proc, irValue *e, Selection sel) { Type *type = ir_type(e); for_array(i, sel.index) { - i32 index = cast(i32)sel.index.e[i]; + i32 index = cast(i32)sel.index[i]; if (is_type_pointer(type)) { type = type_deref(type); e = ir_emit_load(proc, e); @@ -3294,7 +3294,7 @@ isize ir_type_info_index(CheckerInfo *info, Type *type) { // NOTE(bill): Do manual search // TODO(bill): This is O(n) and can be very slow for_array(i, info->type_info_map.entries){ - MapIsizeEntry *e = &info->type_info_map.entries.e[i]; + MapIsizeEntry *e = &info->type_info_map.entries[i]; Type *prev_type = cast(Type *)e->key.ptr; if (are_types_identical(prev_type, type)) { entry_index = e->value; @@ -3388,7 +3388,7 @@ irValue *ir_emit_logical_binary_expr(irProcedure *proc, AstNode *expr) { } irValueArray edges = {}; - array_init_reserve(&edges, proc->module->allocator, done->preds.count+1); + array_init(&edges, proc->module->allocator, done->preds.count+1); for_array(i, done->preds) { array_add(&edges, short_circuit); } @@ -3514,7 +3514,7 @@ irBranchBlocks ir_lookup_branch_blocks(irProcedure *proc, AstNode *ident) { Entity *e = *found; GB_ASSERT(e->kind == Entity_Label); for_array(i, proc->branch_blocks) { - irBranchBlocks *b = &proc->branch_blocks.e[i]; + irBranchBlocks *b = &proc->branch_blocks[i]; if (b->label == e->Label.node) { return *b; } @@ -3537,7 +3537,7 @@ void ir_push_target_list(irProcedure *proc, AstNode *label, irBlock *break_, irB GB_ASSERT(label->kind == AstNode_Label); for_array(i, proc->branch_blocks) { - irBranchBlocks *b = &proc->branch_blocks.e[i]; + irBranchBlocks *b = &proc->branch_blocks[i]; GB_ASSERT(b->label != NULL && label != NULL); GB_ASSERT(b->label->kind == AstNode_Label); if (b->label == label) { @@ -3713,7 +3713,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_emit_comment(proc, str_lit("TernaryExpr")); irValueArray edges = {}; - array_init_reserve(&edges, proc->module->allocator, 2); + array_init(&edges, proc->module->allocator, 2); GB_ASSERT(te->y != NULL); irBlock *then = ir_new_block(proc, NULL, "if.then"); @@ -3753,7 +3753,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { } irValueArray edges = {}; - array_init_reserve(&edges, proc->module->allocator, 2); + array_init(&edges, proc->module->allocator, 2); GB_ASSERT(ie->else_expr != NULL); irBlock *then = ir_new_block(proc, expr, "if.then"); @@ -3881,7 +3881,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case_ast_node(ce, CallExpr, expr); if (map_tav_get(&proc->module->info->types, hash_pointer(ce->proc))->mode == Addressing_Type) { GB_ASSERT(ce->args.count == 1); - irValue *x = ir_build_expr(proc, ce->args.e[0]); + irValue *x = ir_build_expr(proc, ce->args[0]); irValue *y = ir_emit_conv(proc, x, tv.type); return y; } @@ -3893,21 +3893,21 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { Entity *e = *found; switch (e->Builtin.id) { case BuiltinProc_type_info: { - Type *t = default_type(type_of_expr(proc->module->info, ce->args.e[0])); + Type *t = default_type(type_of_expr(proc->module->info, ce->args[0])); return ir_type_info(proc, t); } break; case BuiltinProc_type_info_of_val: { - Type *t = default_type(type_of_expr(proc->module->info, ce->args.e[0])); + Type *t = default_type(type_of_expr(proc->module->info, ce->args[0])); return ir_type_info(proc, t); } break; case BuiltinProc_transmute: { - irValue *x = ir_build_expr(proc, ce->args.e[1]); + irValue *x = ir_build_expr(proc, ce->args[1]); return ir_emit_transmute(proc, x, tv.type); } case BuiltinProc_len: { - irValue *v = ir_build_expr(proc, ce->args.e[0]); + irValue *v = ir_build_expr(proc, ce->args[0]); Type *t = base_type(ir_type(v)); if (is_type_pointer(t)) { // IMPORTANT TODO(bill): Should there be a nil pointer check? @@ -3934,7 +3934,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { } break; case BuiltinProc_cap: { - irValue *v = ir_build_expr(proc, ce->args.e[0]); + irValue *v = ir_build_expr(proc, ce->args[0]); Type *t = base_type(ir_type(v)); if (is_type_pointer(t)) { // IMPORTANT TODO(bill): Should there be a nil pointer check? @@ -3965,7 +3965,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { // new :: proc(Type) -> ^Type gbAllocator allocator = proc->module->allocator; - Type *type = type_of_expr(proc->module->info, ce->args.e[0]); + Type *type = type_of_expr(proc->module->info, ce->args[0]); Type *ptr_type = make_type_pointer(allocator, type); i64 s = type_size_of(allocator, type); @@ -3986,7 +3986,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { // new_slice :: proc(Type, len, cap: int) -> []Type gbAllocator allocator = proc->module->allocator; - Type *type = type_of_expr(proc->module->info, ce->args.e[0]); + Type *type = type_of_expr(proc->module->info, ce->args[0]); Type *ptr_type = make_type_pointer(allocator, type); Type *slice_type = make_type_slice(allocator, type); @@ -3996,14 +3996,14 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *elem_size = ir_const_int(allocator, s); irValue *elem_align = ir_const_int(allocator, a); - irValue *count = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); + irValue *count = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t_int); irValue *capacity = count; if (ce->args.count == 3) { - capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[2]), t_int); + capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args[2]), t_int); } - ir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[1]), v_zero, count, capacity, false); + ir_emit_slice_bounds_check(proc, ast_node_token(ce->args[1]), v_zero, count, capacity, false); irValue *slice_size = ir_emit_arith(proc, Token_Mul, elem_size, capacity, t_int); @@ -4022,7 +4022,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_make: { ir_emit_comment(proc, str_lit("make")); gbAllocator a = proc->module->allocator; - Type *type = type_of_expr(proc->module->info, ce->args.e[0]); + Type *type = type_of_expr(proc->module->info, ce->args[0]); if (is_type_slice(type)) { Type *elem_type = core_type(type)->Slice.elem; @@ -4031,14 +4031,14 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *elem_size = ir_const_int(a, type_size_of(a, elem_type)); irValue *elem_align = ir_const_int(a, type_align_of(a, elem_type)); - irValue *count = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); + irValue *count = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t_int); irValue *capacity = count; if (ce->args.count == 3) { - capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[2]), t_int); + capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args[2]), t_int); } - ir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[1]), v_zero, count, capacity, false); + ir_emit_slice_bounds_check(proc, ast_node_token(ce->args[1]), v_zero, count, capacity, false); irValue *slice_size = ir_emit_arith(proc, Token_Mul, elem_size, capacity, t_int); @@ -4056,7 +4056,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *int_16 = ir_const_int(a, 16); irValue *cap = int_16; if (ce->args.count == 2) { - cap = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); + cap = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t_int); } irValue *cond = ir_emit_comp(proc, Token_Gt, cap, v_zero); @@ -4074,14 +4074,14 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { Type *elem_type = base_type(type)->DynamicArray.elem; irValue *len = v_zero; if (ce->args.count > 1) { - len = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); + len = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t_int); } irValue *cap = len; if (ce->args.count > 2) { - cap = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[2]), t_int); + cap = ir_emit_conv(proc, ir_build_expr(proc, ce->args[2]), t_int); } - ir_emit_slice_bounds_check(proc, ast_node_token(ce->args.e[0]), v_zero, len, cap, false); + ir_emit_slice_bounds_check(proc, ast_node_token(ce->args[0]), v_zero, len, cap, false); irValue *array = ir_add_local_generated(proc, type); irValue **args = gb_alloc_array(a, irValue *, 5); @@ -4101,7 +4101,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { gbAllocator a = proc->module->allocator; - AstNode *node = ce->args.e[0]; + AstNode *node = ce->args[0]; TypeAndValue tav = type_and_value_of_expr(proc->module->info, node); Type *type = base_type(tav.type); @@ -4174,12 +4174,12 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_emit_comment(proc, str_lit("reserve")); gbAllocator a = proc->module->allocator; - irValue *ptr = ir_build_addr(proc, ce->args.e[0]).addr; + irValue *ptr = ir_build_addr(proc, ce->args[0]).addr; Type *type = ir_type(ptr); GB_ASSERT(is_type_pointer(type)); type = base_type(type_deref(type)); - irValue *capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t_int); + irValue *capacity = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t_int); if (is_type_dynamic_array(type)) { Type *elem = type->DynamicArray.elem; @@ -4207,8 +4207,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_clear: { ir_emit_comment(proc, str_lit("clear")); - Type *original_type = type_of_expr(proc->module->info, ce->args.e[0]); - irAddr addr = ir_build_addr(proc, ce->args.e[0]); + Type *original_type = type_of_expr(proc->module->info, ce->args[0]); + irAddr addr = ir_build_addr(proc, ce->args[0]); irValue *ptr = addr.addr; if (is_double_pointer(ir_type(ptr))) { ptr = ir_addr_load(proc, addr); @@ -4235,15 +4235,15 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_emit_comment(proc, str_lit("append")); gbAllocator a = proc->module->allocator; - Type *value_type = type_of_expr(proc->module->info, ce->args.e[0]); - irAddr array_addr = ir_build_addr(proc, ce->args.e[0]); + Type *value_type = type_of_expr(proc->module->info, ce->args[0]); + irAddr array_addr = ir_build_addr(proc, ce->args[0]); irValue *array_ptr = array_addr.addr; if (is_double_pointer(ir_type(array_ptr))) { array_ptr = ir_addr_load(proc, array_addr); } Type *type = ir_type(array_ptr); { - TokenPos pos = ast_node_token(ce->args.e[0]).pos; + TokenPos pos = ast_node_token(ce->args[0]).pos; GB_ASSERT_MSG(is_type_pointer(type), "%.*s(%td) %s", LIT(pos.file), pos.line, type_to_string(type)); @@ -4268,7 +4268,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { isize arg_index = 0; isize arg_count = 0; for_array(i, ce->args) { - AstNode *a = ce->args.e[i]; + AstNode *a = ce->args[i]; Type *at = base_type(type_of_expr(proc->module->info, a)); if (at->kind == Type_Tuple) { arg_count += at->Tuple.variable_count; @@ -4281,7 +4281,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { bool vari_expand = ce->ellipsis.pos.line != 0; for_array(i, ce->args) { - irValue *a = ir_build_expr(proc, ce->args.e[i]); + irValue *a = ir_build_expr(proc, ce->args[i]); Type *at = ir_type(a); if (at->kind == Type_Tuple) { for (isize i = 0; i < at->Tuple.variable_count; i++) { @@ -4342,8 +4342,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_delete: { ir_emit_comment(proc, str_lit("delete")); - irValue *map = ir_build_expr(proc, ce->args.e[0]); - irValue *key = ir_build_expr(proc, ce->args.e[1]); + irValue *map = ir_build_expr(proc, ce->args[0]); + irValue *key = ir_build_expr(proc, ce->args[1]); Type *map_type = ir_type(map); GB_ASSERT(is_type_dynamic_map(map_type)); Type *key_type = base_type(map_type)->Map.key; @@ -4360,7 +4360,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_assert: { ir_emit_comment(proc, str_lit("assert")); - irValue *cond = ir_build_expr(proc, ce->args.e[0]); + irValue *cond = ir_build_expr(proc, ce->args[0]); GB_ASSERT(is_type_boolean(ir_type(cond))); cond = ir_emit_comp(proc, Token_CmpEq, cond, v_false); @@ -4371,9 +4371,9 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_start_block(proc, err); // TODO(bill): Cleanup allocations here - Token token = ast_node_token(ce->args.e[0]); + Token token = ast_node_token(ce->args[0]); TokenPos pos = token.pos; - gbString expr = expr_to_string(ce->args.e[0]); + gbString expr = expr_to_string(ce->args[0]); isize expr_len = gb_string_length(expr); String expr_str = {}; expr_str.text = cast(u8 *)gb_alloc_copy_align(proc->module->allocator, expr, expr_len, 1); @@ -4396,10 +4396,10 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_panic: { ir_emit_comment(proc, str_lit("panic")); - irValue *msg = ir_build_expr(proc, ce->args.e[0]); + irValue *msg = ir_build_expr(proc, ce->args[0]); GB_ASSERT(is_type_string(ir_type(msg))); - Token token = ast_node_token(ce->args.e[0]); + Token token = ast_node_token(ce->args[0]); TokenPos pos = token.pos; irValue **args = gb_alloc_array(proc->module->allocator, irValue *, 4); @@ -4416,8 +4416,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_copy: { ir_emit_comment(proc, str_lit("copy")); // copy :: proc(dst, src: []Type) -> int - AstNode *dst_node = ce->args.e[0]; - AstNode *src_node = ce->args.e[1]; + AstNode *dst_node = ce->args[0]; + AstNode *src_node = ce->args[1]; irValue *dst_slice = ir_build_expr(proc, dst_node); irValue *src_slice = ir_build_expr(proc, src_node); Type *slice_type = base_type(ir_type(dst_slice)); @@ -4448,7 +4448,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { } break; case BuiltinProc_swizzle: { ir_emit_comment(proc, str_lit("swizzle.begin")); - irAddr vector_addr = ir_build_addr(proc, ce->args.e[0]); + irAddr vector_addr = ir_build_addr(proc, ce->args[0]); isize index_count = ce->args.count-1; if (index_count == 0) { return ir_addr_load(proc, vector_addr); @@ -4457,7 +4457,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *dst = ir_add_local_generated(proc, tv.type); for (i32 i = 1; i < ce->args.count; i++) { - TypeAndValue tv = type_and_value_of_expr(proc->module->info, ce->args.e[i]); + TypeAndValue tv = type_and_value_of_expr(proc->module->info, ce->args[i]); GB_ASSERT(is_type_integer(tv.type)); GB_ASSERT(tv.value.kind == ExactValue_Integer); @@ -4476,8 +4476,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_complex: { ir_emit_comment(proc, str_lit("complex")); - irValue *real = ir_build_expr(proc, ce->args.e[0]); - irValue *imag = ir_build_expr(proc, ce->args.e[1]); + irValue *real = ir_build_expr(proc, ce->args[0]); + irValue *imag = ir_build_expr(proc, ce->args[1]); irValue *dst = ir_add_local_generated(proc, tv.type); Type *ft = base_complex_elem_type(tv.type); @@ -4491,20 +4491,20 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_real: { ir_emit_comment(proc, str_lit("real")); - irValue *val = ir_build_expr(proc, ce->args.e[0]); + irValue *val = ir_build_expr(proc, ce->args[0]); irValue *real = ir_emit_struct_ev(proc, val, 0); return ir_emit_conv(proc, real, tv.type); } break; case BuiltinProc_imag: { ir_emit_comment(proc, str_lit("imag")); - irValue *val = ir_build_expr(proc, ce->args.e[0]); + irValue *val = ir_build_expr(proc, ce->args[0]); irValue *imag = ir_emit_struct_ev(proc, val, 1); return ir_emit_conv(proc, imag, tv.type); } break; case BuiltinProc_conj: { ir_emit_comment(proc, str_lit("conj")); - irValue *val = ir_build_expr(proc, ce->args.e[0]); + irValue *val = ir_build_expr(proc, ce->args[0]); irValue *res = NULL; Type *t = ir_type(val); if (is_type_complex(t)) { @@ -4520,12 +4520,12 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_slice_ptr: { ir_emit_comment(proc, str_lit("slice_ptr")); - irValue *ptr = ir_build_expr(proc, ce->args.e[0]); - irValue *count = ir_build_expr(proc, ce->args.e[1]); + irValue *ptr = ir_build_expr(proc, ce->args[0]); + irValue *count = ir_build_expr(proc, ce->args[1]); count = ir_emit_conv(proc, count, t_int); irValue *capacity = count; if (ce->args.count > 2) { - capacity = ir_build_expr(proc, ce->args.e[2]); + capacity = ir_build_expr(proc, ce->args[2]); capacity = ir_emit_conv(proc, capacity, t_int); } @@ -4537,7 +4537,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_slice_to_bytes: { ir_emit_comment(proc, str_lit("slice_to_bytes")); - irValue *s = ir_build_expr(proc, ce->args.e[0]); + irValue *s = ir_build_expr(proc, ce->args[0]); Type *t = base_type(ir_type(s)); if (is_type_u8_slice(t)) { return ir_emit_conv(proc, s, tv.type); @@ -4557,8 +4557,8 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_min: { ir_emit_comment(proc, str_lit("min")); Type *t = type_of_expr(proc->module->info, expr); - irValue *x = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[0]), t); - irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t); + irValue *x = ir_emit_conv(proc, ir_build_expr(proc, ce->args[0]), t); + irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t); irValue *cond = ir_emit_comp(proc, Token_Lt, x, y); return ir_emit_select(proc, cond, x, y); } break; @@ -4566,15 +4566,15 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case BuiltinProc_max: { ir_emit_comment(proc, str_lit("max")); Type *t = type_of_expr(proc->module->info, expr); - irValue *x = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[0]), t); - irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args.e[1]), t); + irValue *x = ir_emit_conv(proc, ir_build_expr(proc, ce->args[0]), t); + irValue *y = ir_emit_conv(proc, ir_build_expr(proc, ce->args[1]), t); irValue *cond = ir_emit_comp(proc, Token_Gt, x, y); return ir_emit_select(proc, cond, x, y); } break; case BuiltinProc_abs: { ir_emit_comment(proc, str_lit("abs")); - irValue *x = ir_build_expr(proc, ce->args.e[0]); + irValue *x = ir_build_expr(proc, ce->args[0]); Type *t = ir_type(x); if (is_type_complex(t)) { gbAllocator a = proc->module->allocator; @@ -4597,9 +4597,9 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_emit_comment(proc, str_lit("clamp")); Type *t = type_of_expr(proc->module->info, expr); return ir_emit_clamp(proc, t, - ir_build_expr(proc, ce->args.e[0]), - ir_build_expr(proc, ce->args.e[1]), - ir_build_expr(proc, ce->args.e[2])); + ir_build_expr(proc, ce->args[0]), + ir_build_expr(proc, ce->args[1]), + ir_build_expr(proc, ce->args[2])); } break; } } @@ -4616,7 +4616,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { isize arg_count = 0; for_array(i, ce->args) { - AstNode *a = ce->args.e[i]; + AstNode *a = ce->args[i]; Type *at = base_type(type_of_expr(proc->module->info, a)); if (at->kind == Type_Tuple) { arg_count += at->Tuple.variable_count; @@ -4629,7 +4629,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { bool vari_expand = ce->ellipsis.pos.line != 0; for_array(i, ce->args) { - irValue *a = ir_build_expr(proc, ce->args.e[i]); + irValue *a = ir_build_expr(proc, ce->args[i]); Type *at = ir_type(a); if (at->kind == Type_Tuple) { for (isize i = 0; i < at->Tuple.variable_count; i++) { @@ -4840,12 +4840,12 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *bft = type_deref(ir_addr_type(addr)); if (sel.index.count == 1) { GB_ASSERT(is_type_bit_field(bft)); - i32 index = sel.index.e[0]; + i32 index = sel.index[0]; return ir_addr_bit_field(addr.addr, index); } else { Selection s = sel; s.index.count--; - i32 index = s.index.e[s.index.count-1]; + i32 index = s.index[s.index.count-1]; irValue *a = addr.addr; a = ir_emit_deep_field_gep(proc, a, s); return ir_addr_bit_field(a, index); @@ -5171,14 +5171,14 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { case Type_Vector: { if (cl->elems.count == 1 && bt->Vector.count > 1) { isize index_count = bt->Vector.count; - irValue *elem_val = ir_build_expr(proc, cl->elems.e[0]); + irValue *elem_val = ir_build_expr(proc, cl->elems[0]); for (isize i = 0; i < index_count; i++) { ir_emit_store(proc, ir_emit_array_epi(proc, v, i), elem_val); } } else if (cl->elems.count > 0) { ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr))); for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (ir_is_elem_const(proc->module, elem, et)) { continue; } @@ -5201,7 +5201,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { if (cl->elems.count > 0) { ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr))); for_array(field_index, cl->elems) { - AstNode *elem = cl->elems.e[field_index]; + AstNode *elem = cl->elems[field_index]; irValue *field_expr = NULL; Entity *field = NULL; @@ -5211,12 +5211,12 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ast_node(fv, FieldValue, elem); String name = fv->field->Ident.string; Selection sel = lookup_field(proc->module->allocator, bt, name, false); - index = sel.index.e[0]; + index = sel.index[0]; elem = fv->value; } else { TypeAndValue tav = type_and_value_of_expr(proc->module->info, elem); Selection sel = lookup_field_from_index(proc->module->allocator, bt, st->fields_in_src_order[field_index]->Variable.field_index); - index = sel.index.e[0]; + index = sel.index[0]; } field = st->fields[index]; @@ -5258,7 +5258,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *items = ir_generate_array(proc->module, elem, item_count, str_lit("__dacl$"), cast(i64)cast(intptr)expr); for_array(field_index, cl->elems) { - AstNode *f = cl->elems.e[field_index]; + AstNode *f = cl->elems[field_index]; irValue *value = ir_emit_conv(proc, ir_build_expr(proc, f), elem); irValue *ep = ir_emit_array_epi(proc, items, field_index); ir_emit_store(proc, ep, value); @@ -5287,7 +5287,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { ir_emit_global_call(proc, "__dynamic_map_reserve", args, 2); } for_array(field_index, cl->elems) { - AstNode *elem = cl->elems.e[field_index]; + AstNode *elem = cl->elems[field_index]; ast_node(fv, FieldValue, elem); irValue *key = ir_build_expr(proc, fv->field); @@ -5300,7 +5300,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { if (cl->elems.count > 0) { ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr))); for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (ir_is_elem_const(proc->module, elem, et)) { continue; } @@ -5324,7 +5324,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { irValue *data = ir_emit_array_ep(proc, slice->ConstantSlice.backing_array, v_zero32); for_array(i, cl->elems) { - AstNode *elem = cl->elems.e[i]; + AstNode *elem = cl->elems[i]; if (ir_is_elem_const(proc->module, elem, et)) { continue; } @@ -5356,7 +5356,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { }; for_array(field_index, cl->elems) { - AstNode *elem = cl->elems.e[field_index]; + AstNode *elem = cl->elems[field_index]; irValue *field_expr = NULL; isize index = field_index; @@ -5364,12 +5364,12 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { if (elem->kind == AstNode_FieldValue) { ast_node(fv, FieldValue, elem); Selection sel = lookup_field(proc->module->allocator, bt, fv->field->Ident.string, false); - index = sel.index.e[0]; + index = sel.index[0]; elem = fv->value; } else { TypeAndValue tav = type_and_value_of_expr(proc->module->info, elem); Selection sel = lookup_field(proc->module->allocator, bt, field_names[field_index], false); - index = sel.index.e[0]; + index = sel.index[0]; } field_expr = ir_build_expr(proc, elem); @@ -5452,7 +5452,7 @@ irValue *ir_build_cond(irProcedure *proc, AstNode *cond, irBlock *true_block, ir void ir_build_stmt_list(irProcedure *proc, AstNodeArray stmts) { for_array(i, stmts) { - ir_build_stmt(proc, stmts.e[i]); + ir_build_stmt(proc, stmts[i]); } } @@ -5753,7 +5753,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { case_ast_node(us, UsingStmt, node); for_array(i, us->list) { - AstNode *decl = unparen_expr(us->list.e[i]); + AstNode *decl = unparen_expr(us->list[i]); if (decl->kind == AstNode_ValueDecl) { ir_build_stmt(proc, decl); } @@ -5780,19 +5780,19 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (vd->values.count == 0) { // declared and zero-initialized for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; if (!ir_is_blank_ident(name)) { ir_add_local_for_identifier(proc, name, true); } } } else { // Tuple(s) - Array(irAddr) lvals = {}; + Array lvals = {}; irValueArray inits = {}; - array_init_reserve(&lvals, m->tmp_allocator, vd->names.count); - array_init_reserve(&inits, m->tmp_allocator, vd->names.count); + array_init(&lvals, m->tmp_allocator, vd->names.count); + array_init(&inits, m->tmp_allocator, vd->names.count); for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; irAddr lval = ir_addr(NULL); if (!ir_is_blank_ident(name)) { ir_add_local_for_identifier(proc, name, false); @@ -5803,7 +5803,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } for_array(i, vd->values) { - irValue *init = ir_build_expr(proc, vd->values.e[i]); + irValue *init = ir_build_expr(proc, vd->values[i]); Type *t = ir_type(init); if (t->kind == Type_Tuple) { for (isize i = 0; i < t->Tuple.variable_count; i++) { @@ -5818,14 +5818,14 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { for_array(i, inits) { - ir_addr_store(proc, lvals.e[i], inits.e[i]); + ir_addr_store(proc, lvals[i], inits[i]); } } gb_temp_arena_memory_end(tmp); } else { for_array(i, vd->names) { - AstNode *ident = vd->names.e[i]; + AstNode *ident = vd->names[i]; GB_ASSERT(ident->kind == AstNode_Ident); Entity *e = entity_of_ident(proc->module->info, ident); GB_ASSERT(e != NULL); @@ -5925,11 +5925,11 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { switch (as->op.kind) { case Token_Eq: { - Array(irAddr) lvals; + Array lvals; array_init(&lvals, m->tmp_allocator); for_array(i, as->lhs) { - AstNode *lhs = as->lhs.e[i]; + AstNode *lhs = as->lhs[i]; irAddr lval = {}; if (!ir_is_blank_ident(lhs)) { lval = ir_build_addr(proc, lhs); @@ -5939,28 +5939,28 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (as->lhs.count == as->rhs.count) { if (as->lhs.count == 1) { - AstNode *rhs = as->rhs.e[0]; + AstNode *rhs = as->rhs[0]; irValue *init = ir_build_expr(proc, rhs); - ir_addr_store(proc, lvals.e[0], init); + ir_addr_store(proc, lvals[0], init); } else { irValueArray inits; - array_init_reserve(&inits, m->tmp_allocator, lvals.count); + array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { - irValue *init = ir_build_expr(proc, as->rhs.e[i]); + irValue *init = ir_build_expr(proc, as->rhs[i]); array_add(&inits, init); } for_array(i, inits) { - ir_addr_store(proc, lvals.e[i], inits.e[i]); + ir_addr_store(proc, lvals[i], inits[i]); } } } else { irValueArray inits; - array_init_reserve(&inits, m->tmp_allocator, lvals.count); + array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { - irValue *init = ir_build_expr(proc, as->rhs.e[i]); + irValue *init = ir_build_expr(proc, as->rhs[i]); Type *t = ir_type(init); // TODO(bill): refactor for code reuse as this is repeated a bit if (t->kind == Type_Tuple) { @@ -5975,7 +5975,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } for_array(i, inits) { - ir_addr_store(proc, lvals.e[i], inits.e[i]); + ir_addr_store(proc, lvals[i], inits[i]); } } @@ -5986,8 +5986,8 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { // +=, -=, etc i32 op = cast(i32)as->op.kind; op += Token_Add - Token_AddEq; // Convert += to + - irAddr lhs = ir_build_addr(proc, as->lhs.e[0]); - irValue *value = ir_build_expr(proc, as->rhs.e[0]); + irAddr lhs = ir_build_addr(proc, as->lhs[0]); + irValue *value = ir_build_expr(proc, as->rhs[0]); ir_build_assign_op(proc, lhs, value, cast(TokenKind)op); } break; } @@ -6024,16 +6024,16 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { // No return values } else if (return_count == 1) { Entity *e = return_type_tuple->variables[0]; - v = ir_build_expr(proc, rs->results.e[0]); + v = ir_build_expr(proc, rs->results[0]); v = ir_emit_conv(proc, v, e->type); } else { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena); irValueArray results; - array_init_reserve(&results, proc->module->tmp_allocator, return_count); + array_init(&results, proc->module->tmp_allocator, return_count); for_array(res_index, rs->results) { - irValue *res = ir_build_expr(proc, rs->results.e[res_index]); + irValue *res = ir_build_expr(proc, rs->results[res_index]); Type *t = ir_type(res); if (t->kind == Type_Tuple) { for (isize i = 0; i < t->Tuple.variable_count; i++) { @@ -6050,7 +6050,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { v = ir_add_local_generated(proc, ret_type); for_array(i, results) { Entity *e = return_type_tuple->variables[i]; - irValue *res = ir_emit_conv(proc, results.e[i], e->type); + irValue *res = ir_emit_conv(proc, results[i], e->type); irValue *field = ir_emit_struct_ep(proc, v, i); ir_emit_store(proc, field, res); } @@ -6347,7 +6347,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { isize case_count = body->stmts.count; for_array(i, body->stmts) { - AstNode *clause = body->stmts.e[i]; + AstNode *clause = body->stmts[i]; irBlock *body = fall; ast_node(cc, CaseClause, clause); @@ -6379,7 +6379,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irBlock *next_cond = NULL; for_array(j, cc->list) { - AstNode *expr = unparen_expr(cc->list.e[j]); + AstNode *expr = unparen_expr(cc->list[j]); next_cond = ir_new_block(proc, clause, "match.case.next"); irValue *cond = v_false; if (is_ast_node_a_range(expr)) { @@ -6439,7 +6439,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { GB_ASSERT(as->lhs.count == 1); GB_ASSERT(as->rhs.count == 1); - irValue *parent = ir_build_expr(proc, as->rhs.e[0]); + irValue *parent = ir_build_expr(proc, as->rhs[0]); Type *parent_type = ir_type(parent); bool is_parent_ptr = is_type_pointer(ir_type(parent)); @@ -6474,7 +6474,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { gb_local_persist i32 weird_count = 0; for_array(i, body->stmts) { - AstNode *clause = body->stmts.e[i]; + AstNode *clause = body->stmts[i]; ast_node(cc, CaseClause, clause); if (cc->list.count == 0) { default_ = clause; @@ -6486,7 +6486,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { Type *case_type = NULL; for_array(type_index, cc->list) { next = ir_new_block(proc, NULL, "typematch.next"); - case_type = type_of_expr(proc->module->info, cc->list.e[type_index]); + case_type = type_of_expr(proc->module->info, cc->list[type_index]); irValue *cond = NULL; if (match_type_kind == MatchType_Union) { Type *bt = type_deref(case_type); @@ -6660,10 +6660,10 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { void ir_number_proc_registers(irProcedure *proc) { i32 reg_index = 0; for_array(i, proc->blocks) { - irBlock *b = proc->blocks.e[i]; + irBlock *b = proc->blocks[i]; b->index = i; for_array(j, b->instrs) { - irValue *value = b->instrs.e[j]; + irValue *value = b->instrs[j]; GB_ASSERT(value->kind == irValue_Instr); irInstr *instr = &value->Instr; if (ir_instr_type(instr) == NULL) { // NOTE(bill): Ignore non-returning instructions @@ -6689,7 +6689,7 @@ void ir_begin_procedure_body(irProcedure *proc) { if (found != NULL) { DeclInfo *decl = *found; for_array(i, decl->labels) { - BlockLabel bl = decl->labels.e[i]; + BlockLabel bl = decl->labels[i]; irBranchBlocks bb = {bl.label, NULL, NULL}; array_add(&proc->branch_blocks, bb); } @@ -6723,13 +6723,13 @@ void ir_begin_procedure_body(irProcedure *proc) { for (isize i = 0; i < params->variable_count; i++) { ast_node(fl, FieldList, pt->params); GB_ASSERT(fl->list.count > 0); - GB_ASSERT(fl->list.e[0]->kind == AstNode_Field); - if (q_index == fl->list.e[param_index]->Field.names.count) { + GB_ASSERT(fl->list[0]->kind == AstNode_Field); + if (q_index == fl->list[param_index]->Field.names.count) { q_index = 0; param_index++; } - ast_node(field, Field, fl->list.e[param_index]); - AstNode *name = field->names.e[q_index++]; + ast_node(field, Field, fl->list[param_index]); + AstNode *name = field->names[q_index++]; Entity *e = params->variables[i]; Type *abi_type = proc->type->Proc.abi_compat_params[i]; @@ -6867,7 +6867,7 @@ void ir_init_module(irModule *m, Checker *c) { { isize max_index = -1; for_array(type_info_map_index, m->info->type_info_map.entries) { - MapIsizeEntry *entry = &m->info->type_info_map.entries.e[type_info_map_index]; + MapIsizeEntry *entry = &m->info->type_info_map.entries[type_info_map_index]; Type *t = cast(Type *)cast(uintptr)entry->key.key; t = default_type(t); isize entry_index = ir_type_info_index(m->info, t); @@ -6892,7 +6892,7 @@ void ir_init_module(irModule *m, Checker *c) { isize count = 0; for_array(entry_index, m->info->type_info_map.entries) { - MapIsizeEntry *entry = &m->info->type_info_map.entries.e[entry_index]; + MapIsizeEntry *entry = &m->info->type_info_map.entries[entry_index]; Type *t = cast(Type *)cast(uintptr)entry->key.key; switch (t->kind) { @@ -6956,7 +6956,7 @@ void ir_init_module(irModule *m, Checker *c) { { irDebugInfo *di = ir_alloc_debug_info(m->allocator, irDebugInfo_CompileUnit); - di->CompileUnit.file = m->info->files.entries.e[0].value; // Zeroth is the init file + di->CompileUnit.file = m->info->files.entries[0].value; // Zeroth is the init file di->CompileUnit.producer = str_lit("odin"); map_ir_debug_info_set(&m->debug_info, hash_pointer(m), di); @@ -7060,7 +7060,7 @@ void ir_add_foreign_library_path(irModule *m, Entity *e) { } for_array(path_index, m->foreign_library_paths) { - String path = m->foreign_library_paths.e[path_index]; + String path = m->foreign_library_paths[path_index]; #if defined(GB_SYSTEM_WINDOWS) if (str_eq_ignore_case(path, library_path)) { #else @@ -7095,7 +7095,7 @@ void ir_gen_tree(irGen *s) { bool has_win_main = false; for_array(i, info->entities.entries) { - MapDeclInfoEntry *entry = &info->entities.entries.e[i]; + MapDeclInfoEntry *entry = &info->entities.entries[i]; Entity *e = cast(Entity *)cast(uintptr)entry->key.key; String name = e->token.string; if (e->kind == Entity_Variable) { @@ -7120,14 +7120,14 @@ void ir_gen_tree(irGen *s) { irValue *var, *init; DeclInfo *decl; } irGlobalVariable; - Array(irGlobalVariable) global_variables; - array_init_reserve(&global_variables, m->tmp_allocator, global_variable_max_count); + Array global_variables; + array_init(&global_variables, m->tmp_allocator, global_variable_max_count); m->entry_point_entity = entry_point; m->min_dep_map = generate_minimum_dependency_map(info, entry_point); for_array(i, info->entities.entries) { - MapDeclInfoEntry *entry = &info->entities.entries.e[i]; + MapDeclInfoEntry *entry = &info->entities.entries[i]; Entity *e = cast(Entity *)entry->key.ptr; String name = e->token.string; DeclInfo *decl = entry->value; @@ -7221,20 +7221,20 @@ void ir_gen_tree(irGen *s) { } for_array(i, m->members.entries) { - MapIrValueEntry *entry = &m->members.entries.e[i]; + MapIrValueEntry *entry = &m->members.entries[i]; irValue *v = entry->value; if (v->kind == irValue_Proc) { ir_build_proc(v, NULL); } } - irDebugInfo *compile_unit = m->debug_info.entries.e[0].value; + irDebugInfo *compile_unit = m->debug_info.entries[0].value; GB_ASSERT(compile_unit->kind == irDebugInfo_CompileUnit); irDebugInfo *all_procs = ir_alloc_debug_info(m->allocator, irDebugInfo_AllProcs); isize all_proc_max_count = 0; for_array(i, m->debug_info.entries) { - MapIrDebugInfoEntry *entry = &m->debug_info.entries.e[i]; + MapIrDebugInfoEntry *entry = &m->debug_info.entries[i]; irDebugInfo *di = entry->value; di->id = i; if (di->kind == irDebugInfo_Proc) { @@ -7242,13 +7242,13 @@ void ir_gen_tree(irGen *s) { } } - array_init_reserve(&all_procs->AllProcs.procs, m->allocator, all_proc_max_count); + array_init(&all_procs->AllProcs.procs, m->allocator, all_proc_max_count); map_ir_debug_info_set(&m->debug_info, hash_pointer(all_procs), all_procs); // NOTE(bill): This doesn't need to be mapped compile_unit->CompileUnit.all_procs = all_procs; for_array(i, m->debug_info.entries) { - MapIrDebugInfoEntry *entry = &m->debug_info.entries.e[i]; + MapIrDebugInfoEntry *entry = &m->debug_info.entries[i]; irDebugInfo *di = entry->value; if (di->kind == irDebugInfo_Proc) { array_add(&all_procs->AllProcs.procs, di); @@ -7390,7 +7390,7 @@ void ir_gen_tree(irGen *s) { // TODO(bill): Should do a dependency graph do check which order to initialize them in? for_array(i, global_variables) { - irGlobalVariable *var = &global_variables.e[i]; + irGlobalVariable *var = &global_variables[i]; if (var->decl->init_expr != NULL) { var->init = ir_build_expr(proc, var->decl->init_expr); } @@ -7398,7 +7398,7 @@ void ir_gen_tree(irGen *s) { // NOTE(bill): Initialize constants first for_array(i, global_variables) { - irGlobalVariable *var = &global_variables.e[i]; + irGlobalVariable *var = &global_variables[i]; if (var->init != NULL && var->init->kind == irValue_Constant) { Type *t = type_deref(ir_type(var->var)); if (is_type_any(t)) { @@ -7416,7 +7416,7 @@ void ir_gen_tree(irGen *s) { } for_array(i, global_variables) { - irGlobalVariable *var = &global_variables.e[i]; + irGlobalVariable *var = &global_variables[i]; if (var->init != NULL && var->init->kind != irValue_Constant) { Type *t = type_deref(ir_type(var->var)); if (is_type_any(t)) { @@ -7458,7 +7458,7 @@ void ir_gen_tree(irGen *s) { i32 type_info_member_offsets_index = 0; for_array(type_info_map_index, info->type_info_map.entries) { - MapIsizeEntry *entry = &info->type_info_map.entries.e[type_info_map_index]; + MapIsizeEntry *entry = &info->type_info_map.entries[type_info_map_index]; Type *t = cast(Type *)cast(uintptr)entry->key.key; t = default_type(t); isize entry_index = ir_type_info_index(info, t); @@ -7921,7 +7921,7 @@ void ir_gen_tree(irGen *s) { } for_array(type_info_map_index, info->type_info_map.entries) { - MapIsizeEntry *entry = &info->type_info_map.entries.e[type_info_map_index]; + MapIsizeEntry *entry = &info->type_info_map.entries[type_info_map_index]; Type *t = cast(Type *)cast(uintptr)entry->key.key; t = default_type(t); isize entry_index = entry->value; @@ -7935,12 +7935,12 @@ void ir_gen_tree(irGen *s) { for_array(i, m->procs_to_generate) { - ir_build_proc(m->procs_to_generate.e[i], m->procs_to_generate.e[i]->Proc.parent); + ir_build_proc(m->procs_to_generate[i], m->procs_to_generate[i]->Proc.parent); } // Number debug info for_array(i, m->debug_info.entries) { - MapIrDebugInfoEntry *entry = &m->debug_info.entries.e[i]; + MapIrDebugInfoEntry *entry = &m->debug_info.entries[i]; irDebugInfo *di = entry->value; di->id = i; } diff --git a/src/ir_opt.cpp b/src/ir_opt.cpp index e9d83941d..856d8aaf0 100644 --- a/src/ir_opt.cpp +++ b/src/ir_opt.cpp @@ -48,7 +48,7 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) { break; case irInstr_Phi: for_array(j, i->Phi.edges) { - array_add(ops, i->Phi.edges.e[j]); + array_add(ops, i->Phi.edges[j]); } break; case irInstr_Unreachable: @@ -97,24 +97,24 @@ void ir_opt_add_operands(irValueArray *ops, irInstr *i) { void ir_opt_block_replace_pred(irBlock *b, irBlock *from, irBlock *to) { for_array(i, b->preds) { - irBlock *pred = b->preds.e[i]; + irBlock *pred = b->preds[i]; if (pred == from) { - b->preds.e[i] = to; + b->preds[i] = to; } } } void ir_opt_block_replace_succ(irBlock *b, irBlock *from, irBlock *to) { for_array(i, b->succs) { - irBlock *succ = b->succs.e[i]; + irBlock *succ = b->succs[i]; if (succ == from) { - b->succs.e[i] = to; + b->succs[i] = to; } } } bool ir_opt_block_has_phi(irBlock *b) { - return b->instrs.e[0]->Instr.kind == irInstr_Phi; + return b->instrs[0]->Instr.kind == irInstr_Phi; } @@ -129,7 +129,7 @@ bool ir_opt_block_has_phi(irBlock *b) { irValueArray ir_get_block_phi_nodes(irBlock *b) { irValueArray phis = {0}; for_array(i, b->instrs) { - irInstr *instr = &b->instrs.e[i]->Instr; + irInstr *instr = &b->instrs[i]->Instr; if (instr->kind != irInstr_Phi) { phis = b->instrs; phis.count = i; @@ -143,19 +143,19 @@ void ir_remove_pred(irBlock *b, irBlock *p) { irValueArray phis = ir_get_block_phi_nodes(b); isize i = 0; for_array(j, b->preds) { - irBlock *pred = b->preds.e[j]; + irBlock *pred = b->preds[j]; if (pred != p) { - b->preds.e[i] = b->preds.e[j]; + b->preds[i] = b->preds[j]; for_array(k, phis) { - irInstrPhi *phi = &phis.e[k]->Instr.Phi; - phi->edges.e[i] = phi->edges.e[j]; + irInstrPhi *phi = &phis[k]->Instr.Phi; + phi->edges[i] = phi->edges[j]; } i++; } } b->preds.count = i; for_array(k, phis) { - irInstrPhi *phi = &phis.e[k]->Instr.Phi; + irInstrPhi *phi = &phis[k]->Instr.Phi; phi->edges.count = i; } @@ -164,13 +164,13 @@ void ir_remove_pred(irBlock *b, irBlock *p) { void ir_remove_dead_blocks(irProcedure *proc) { isize j = 0; for_array(i, proc->blocks) { - irBlock *b = proc->blocks.e[i]; + irBlock *b = proc->blocks[i]; if (b == NULL) { continue; } // NOTE(bill): Swap order b->index = j; - proc->blocks.e[j++] = b; + proc->blocks[j++] = b; } proc->blocks.count = j; } @@ -180,7 +180,7 @@ void ir_mark_reachable(irBlock *b) { isize const BLACK = -1; b->index = BLACK; for_array(i, b->succs) { - irBlock *succ = b->succs.e[i]; + irBlock *succ = b->succs[i]; if (succ->index == WHITE) { ir_mark_reachable(succ); } @@ -191,23 +191,23 @@ void ir_remove_unreachable_blocks(irProcedure *proc) { isize const WHITE = 0; isize const BLACK = -1; for_array(i, proc->blocks) { - proc->blocks.e[i]->index = WHITE; + proc->blocks[i]->index = WHITE; } - ir_mark_reachable(proc->blocks.e[0]); + ir_mark_reachable(proc->blocks[0]); for_array(i, proc->blocks) { - irBlock *b = proc->blocks.e[i]; + irBlock *b = proc->blocks[i]; if (b->index == WHITE) { for_array(j, b->succs) { - irBlock *c = b->succs.e[j]; + irBlock *c = b->succs[j]; if (c->index == BLACK) { ir_remove_pred(c, b); } } // NOTE(bill): Mark as empty but don't actually free it // As it's been allocated with an arena - proc->blocks.e[i] = NULL; + proc->blocks[i] = NULL; } } ir_remove_dead_blocks(proc); @@ -217,7 +217,7 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) { if (a->succs.count != 1) { return false; } - irBlock *b = a->succs.e[0]; + irBlock *b = a->succs[0]; if (b->preds.count != 1) { return false; } @@ -228,21 +228,21 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) { array_pop(&a->instrs); // Remove branch at end for_array(i, b->instrs) { - array_add(&a->instrs, b->instrs.e[i]); - ir_set_instr_parent(b->instrs.e[i], a); + array_add(&a->instrs, b->instrs[i]); + ir_set_instr_parent(b->instrs[i], a); } array_clear(&a->succs); for_array(i, b->succs) { - array_add(&a->succs, b->succs.e[i]); + array_add(&a->succs, b->succs[i]); } // Fix preds links for_array(i, b->succs) { - ir_opt_block_replace_pred(b->succs.e[i], b, a); + ir_opt_block_replace_pred(b->succs[i], b, a); } - proc->blocks.e[b->index] = NULL; + proc->blocks[b->index] = NULL; return true; } @@ -254,7 +254,7 @@ void ir_opt_blocks(irProcedure *proc) { while (changed) { changed = false; for_array(i, proc->blocks) { - irBlock *b = proc->blocks.e[i]; + irBlock *b = proc->blocks[i]; if (b == NULL) { continue; } @@ -274,15 +274,15 @@ void ir_opt_build_referrers(irProcedure *proc) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena); irValueArray ops = {0}; // NOTE(bill): Act as a buffer - array_init_reserve(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena + array_init(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena for_array(i, proc->blocks) { - irBlock *b = proc->blocks.e[i]; + irBlock *b = proc->blocks[i]; for_array(j, b->instrs) { - irValue *instr = b->instrs.e[j]; + irValue *instr = b->instrs[j]; array_clear(&ops); ir_opt_add_operands(&ops, &instr->Instr); for_array(k, ops) { - irValue *op = ops.e[k]; + irValue *op = ops[k]; if (op == NULL) { continue; } @@ -324,7 +324,7 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde lt->sdom[p->index] = p; ir_lt_link(lt, NULL, p); for_array(index, p->succs) { - irBlock *q = p->succs.e[index]; + irBlock *q = p->succs[index]; if (lt->sdom[q->index] == NULL) { lt->parent[q->index] = p; i = ir_lt_depth_first_search(lt, q, i, preorder); @@ -354,7 +354,7 @@ irDomPrePost ir_opt_number_dom_tree(irBlock *v, i32 pre, i32 post) { v->dom.pre = pre++; for_array(i, v->dom.children) { - result = ir_opt_number_dom_tree(v->dom.children.e[i], result.pre, result.post); + result = ir_opt_number_dom_tree(v->dom.children[i], result.pre, result.post); } v->dom.post = post++; @@ -381,7 +381,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) { irBlock **preorder = &buf[3*n]; irBlock **buckets = &buf[4*n]; - irBlock *root = proc->blocks.e[0]; + irBlock *root = proc->blocks[0]; // Step 1 - number vertices i32 pre_num = ir_lt_depth_first_search(<, root, 0, preorder); @@ -403,7 +403,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) { // Step 2 - Compute all sdoms lt.sdom[w->index] = lt.parent[w->index]; for_array(pred_index, w->preds) { - irBlock *v = w->preds.e[pred_index]; + irBlock *v = w->preds[pred_index]; irBlock *u = ir_lt_eval(<, v); if (lt.sdom[u->index]->dom.pre < lt.sdom[w->index]->dom.pre) { lt.sdom[w->index] = lt.sdom[u->index]; @@ -438,7 +438,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) { } // Calculate children relation as inverse of idom - if (w->dom.idom->dom.children.e == NULL) { + if (w->dom.idom->dom.children.data == NULL) { // TODO(bill): Is this good enough for memory allocations? array_init(&w->dom.idom->dom.children, heap_allocator()); } @@ -461,7 +461,7 @@ void ir_opt_tree(irGen *s) { s->opt_called = true; for_array(member_index, s->module.procs) { - irProcedure *proc = s->module.procs.e[member_index]; + irProcedure *proc = s->module.procs[member_index]; if (proc->blocks.count == 0) { // Prototype/external procedure continue; } diff --git a/src/ir_print.cpp b/src/ir_print.cpp index 5bbe83e05..81809fa0a 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -497,7 +497,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * if (i > 0) { ir_fprintf(f, ", "); } - TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems.e[i]); + TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems[i]); GB_ASSERT(tav.mode != Addressing_Invalid); ir_print_compound_element(f, m, tav.value, elem_type); } @@ -527,7 +527,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * ir_fprintf(f, "]["); if (elem_count == 1 && type->Vector.count > 1) { - TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems.e[0]); + TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems[0]); GB_ASSERT(tav.mode != Addressing_Invalid); for (isize i = 0; i < type->Vector.count; i++) { @@ -541,7 +541,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * if (i > 0) { ir_fprintf(f, ", "); } - TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems.e[i]); + TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems[i]); GB_ASSERT(tav.mode != Addressing_Invalid); ir_print_compound_element(f, m, tav.value, elem_type); } @@ -563,24 +563,24 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * ExactValue *values = gb_alloc_array(m->tmp_allocator, ExactValue, value_count); - if (cl->elems.e[0]->kind == AstNode_FieldValue) { + if (cl->elems[0]->kind == AstNode_FieldValue) { isize elem_count = cl->elems.count; for (isize i = 0; i < elem_count; i++) { - ast_node(fv, FieldValue, cl->elems.e[i]); + ast_node(fv, FieldValue, cl->elems[i]); String name = fv->field->Ident.string; TypeAndValue tav = type_and_value_of_expr(m->info, fv->value); GB_ASSERT(tav.mode != Addressing_Invalid); Selection sel = lookup_field(m->allocator, type, name, false); - Entity *f = type->Record.fields[sel.index.e[0]]; + Entity *f = type->Record.fields[sel.index[0]]; values[f->Variable.field_index] = tav.value; } } else { for (isize i = 0; i < value_count; i++) { Entity *f = type->Record.fields_in_src_order[i]; - TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems.e[i]); + TypeAndValue tav = type_and_value_of_expr(m->info, cl->elems[i]); ExactValue val = {}; if (tav.mode != Addressing_Invalid) { val = tav.value; @@ -891,11 +891,11 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) { ir_fprintf(f, ", "); } - irValue *edge = instr->Phi.edges.e[i]; + irValue *edge = instr->Phi.edges[i]; irBlock *block = NULL; if (instr->parent != NULL && i < instr->parent->preds.count) { - block = instr->parent->preds.e[i]; + block = instr->parent->preds[i]; } ir_fprintf(f, "[ "); @@ -1538,14 +1538,14 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) { ir_fprintf(f, "{\n"); for_array(i, proc->blocks) { - irBlock *block = proc->blocks.e[i]; + irBlock *block = proc->blocks[i]; if (i > 0) ir_fprintf(f, "\n"); ir_print_block_name(f, block); ir_fprintf(f, ":\n"); for_array(j, block->instrs) { - irValue *value = block->instrs.e[j]; + irValue *value = block->instrs[j]; ir_print_instr(f, m, value); } } @@ -1555,7 +1555,7 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) { } for_array(i, proc->children) { - ir_print_proc(f, m, proc->children.e[i]); + ir_print_proc(f, m, proc->children[i]); } } @@ -1606,7 +1606,7 @@ void print_llvm_ir(irGen *ir) { for_array(member_index, m->members.entries) { - MapIrValueEntry *entry = &m->members.entries.e[member_index]; + MapIrValueEntry *entry = &m->members.entries[member_index]; irValue *v = entry->value; if (v->kind != irValue_TypeName) { continue; @@ -1619,7 +1619,7 @@ void print_llvm_ir(irGen *ir) { bool dll_main_found = false; for_array(member_index, m->members.entries) { - MapIrValueEntry *entry = &m->members.entries.e[member_index]; + MapIrValueEntry *entry = &m->members.entries[member_index]; irValue *v = entry->value; if (v->kind != irValue_Proc) { continue; @@ -1631,7 +1631,7 @@ void print_llvm_ir(irGen *ir) { } for_array(member_index, m->members.entries) { - MapIrValueEntry *entry = &m->members.entries.e[member_index]; + MapIrValueEntry *entry = &m->members.entries[member_index]; irValue *v = entry->value; if (v->kind != irValue_Proc) { continue; @@ -1643,7 +1643,7 @@ void print_llvm_ir(irGen *ir) { } for_array(member_index, m->members.entries) { - MapIrValueEntry *entry = &m->members.entries.e[member_index]; + MapIrValueEntry *entry = &m->members.entries[member_index]; irValue *v = entry->value; if (v->kind != irValue_Global) { continue; @@ -1707,7 +1707,7 @@ void print_llvm_ir(irGen *ir) { ir_fprintf(f, "!%d = !{!\"clang version 3.9.0 (branches/release_39)\"}\n", diec+3); for_array(di_index, m->debug_info.entries) { - MapIrDebugInfoEntry *entry = &m->debug_info.entries.e[di_index]; + MapIrDebugInfoEntry *entry = &m->debug_info.entries[di_index]; irDebugInfo *di = entry->value; ir_fprintf(f, "!%d = ", di->id); @@ -1752,7 +1752,7 @@ void print_llvm_ir(irGen *ir) { case irDebugInfo_AllProcs: ir_fprintf(f, "!{"); for_array(proc_index, di->AllProcs.procs) { - irDebugInfo *p = di->AllProcs.procs.e[proc_index]; + irDebugInfo *p = di->AllProcs.procs[proc_index]; if (proc_index > 0) {ir_fprintf(f, ",");} ir_fprintf(f, "!%d", p->id); } diff --git a/src/main.cpp b/src/main.cpp index 296a9e921..e4c6e6606 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -309,7 +309,7 @@ int main(int argc, char **argv) { // defer (gb_string_free(lib_str)); char lib_str_buf[1024] = {0}; for_array(i, ir_gen.module.foreign_library_paths) { - String lib = ir_gen.module.foreign_library_paths.e[i]; + String lib = ir_gen.module.foreign_library_paths[i]; // gb_printf_err("Linking lib: %.*s\n", LIT(lib)); isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), " \"%.*s\"", LIT(lib)); @@ -371,7 +371,7 @@ int main(int argc, char **argv) { // defer (gb_string_free(lib_str)); char lib_str_buf[1024] = {0}; for_array(i, ir_gen.module.foreign_library_paths) { - String lib = ir_gen.module.foreign_library_paths.e[i]; + String lib = ir_gen.module.foreign_library_paths[i]; // NOTE(zangent): Sometimes, you have to use -framework on MacOS. // This allows you to specify '-f' in a #foreign_system_library, diff --git a/src/map.cpp b/src/map.cpp index 49ca604d0..f03e83424 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -92,8 +92,8 @@ typedef struct MAP_ENTRY { } MAP_ENTRY; typedef struct MAP_NAME { - Array(isize) hashes; - Array(MAP_ENTRY) entries; + Array hashes; + Array entries; } MAP_NAME; void _J2(MAP_PROC,init) (MAP_NAME *h, gbAllocator a); @@ -124,8 +124,8 @@ gb_inline void _J2(MAP_PROC,init)(MAP_NAME *h, gbAllocator a) { } gb_inline void _J2(MAP_PROC,init_with_reserve)(MAP_NAME *h, gbAllocator a, isize capacity) { - array_init_reserve(&h->hashes, a, capacity); - array_init_reserve(&h->entries, a, capacity); + array_init(&h->hashes, a, capacity); + array_init(&h->entries, a, capacity); } gb_inline void _J2(MAP_PROC,destroy)(MAP_NAME *h) { @@ -145,13 +145,13 @@ gb_internal MapFindResult _J2(MAP_PROC,_find)(MAP_NAME *h, HashKey key) { MapFindResult fr = {-1, -1, -1}; if (h->hashes.count > 0) { fr.hash_index = key.key % h->hashes.count; - fr.entry_index = h->hashes.e[fr.hash_index]; + fr.entry_index = h->hashes[fr.hash_index]; while (fr.entry_index >= 0) { - if (hash_key_equal(h->entries.e[fr.entry_index].key, key)) { + if (hash_key_equal(h->entries[fr.entry_index].key, key)) { return fr; } fr.entry_prev = fr.entry_index; - fr.entry_index = h->entries.e[fr.entry_index].next; + fr.entry_index = h->entries[fr.entry_index].next; } } return fr; @@ -161,13 +161,13 @@ gb_internal MapFindResult _J2(MAP_PROC,_find_from_entry)(MAP_NAME *h, MAP_ENTRY MapFindResult fr = {-1, -1, -1}; if (h->hashes.count > 0) { fr.hash_index = e->key.key % h->hashes.count; - fr.entry_index = h->hashes.e[fr.hash_index]; + fr.entry_index = h->hashes[fr.hash_index]; while (fr.entry_index >= 0) { - if (&h->entries.e[fr.entry_index] == e) { + if (&h->entries[fr.entry_index] == e) { return fr; } fr.entry_prev = fr.entry_index; - fr.entry_index = h->entries.e[fr.entry_index].next; + fr.entry_index = h->entries[fr.entry_index].next; } } return fr; @@ -190,10 +190,10 @@ void _J2(MAP_PROC,rehash)(MAP_NAME *h, isize new_count) { array_resize(&nh.hashes, new_count); array_reserve(&nh.entries, h->entries.count); for (i = 0; i < new_count; i++) { - nh.hashes.e[i] = -1; + nh.hashes[i] = -1; } for (i = 0; i < h->entries.count; i++) { - MAP_ENTRY *e = &h->entries.e[i]; + MAP_ENTRY *e = &h->entries[i]; MapFindResult fr; if (nh.hashes.count == 0) { _J2(MAP_PROC,grow)(&nh); @@ -201,12 +201,12 @@ void _J2(MAP_PROC,rehash)(MAP_NAME *h, isize new_count) { fr = _J2(MAP_PROC,_find)(&nh, e->key); j = _J2(MAP_PROC,_add_entry)(&nh, e->key); if (fr.entry_prev < 0) { - nh.hashes.e[fr.hash_index] = j; + nh.hashes[fr.hash_index] = j; } else { - nh.entries.e[fr.entry_prev].next = j; + nh.entries[fr.entry_prev].next = j; } - nh.entries.e[j].next = fr.entry_index; - nh.entries.e[j].value = e->value; + nh.entries[j].next = fr.entry_index; + nh.entries[j].value = e->value; if (_J2(MAP_PROC,_full)(&nh)) { _J2(MAP_PROC,grow)(&nh); } @@ -218,7 +218,7 @@ void _J2(MAP_PROC,rehash)(MAP_NAME *h, isize new_count) { gb_inline MAP_TYPE *_J2(MAP_PROC,get)(MAP_NAME *h, HashKey key) { isize index = _J2(MAP_PROC,_find)(h, key).entry_index; if (index >= 0) { - return &h->entries.e[index].value; + return &h->entries[index].value; } return NULL; } @@ -234,12 +234,12 @@ void _J2(MAP_PROC,set)(MAP_NAME *h, HashKey key, MAP_TYPE value) { } else { index = _J2(MAP_PROC,_add_entry)(h, key); if (fr.entry_prev >= 0) { - h->entries.e[fr.entry_prev].next = index; + h->entries[fr.entry_prev].next = index; } else { - h->hashes.e[fr.hash_index] = index; + h->hashes[fr.hash_index] = index; } } - h->entries.e[index].value = value; + h->entries[index].value = value; if (_J2(MAP_PROC,_full)(h)) { _J2(MAP_PROC,grow)(h); @@ -251,20 +251,20 @@ void _J2(MAP_PROC,set)(MAP_NAME *h, HashKey key, MAP_TYPE value) { void _J2(MAP_PROC,_erase)(MAP_NAME *h, MapFindResult fr) { MapFindResult last; if (fr.entry_prev < 0) { - h->hashes.e[fr.hash_index] = h->entries.e[fr.entry_index].next; + h->hashes[fr.hash_index] = h->entries[fr.entry_index].next; } else { - h->entries.e[fr.entry_prev].next = h->entries.e[fr.entry_index].next; + h->entries[fr.entry_prev].next = h->entries[fr.entry_index].next; } if (fr.entry_index == h->entries.count-1) { array_pop(&h->entries); return; } - h->entries.e[fr.entry_index] = h->entries.e[h->entries.count-1]; - last = _J2(MAP_PROC,_find)(h, h->entries.e[fr.entry_index].key); + h->entries[fr.entry_index] = h->entries[h->entries.count-1]; + last = _J2(MAP_PROC,_find)(h, h->entries[fr.entry_index].key); if (last.entry_prev >= 0) { - h->entries.e[last.entry_prev].next = fr.entry_index; + h->entries[last.entry_prev].next = fr.entry_index; } else { - h->hashes.e[last.hash_index] = fr.entry_index; + h->hashes[last.hash_index] = fr.entry_index; } } @@ -287,16 +287,16 @@ MAP_ENTRY *_J2(MAP_PROC,multi_find_first)(MAP_NAME *h, HashKey key) { if (i < 0) { return NULL; } - return &h->entries.e[i]; + return &h->entries[i]; } MAP_ENTRY *_J2(MAP_PROC,multi_find_next)(MAP_NAME *h, MAP_ENTRY *e) { isize i = e->next; while (i >= 0) { - if (hash_key_equal(h->entries.e[i].key, e->key)) { - return &h->entries.e[i]; + if (hash_key_equal(h->entries[i].key, e->key)) { + return &h->entries[i]; } - i = h->entries.e[i].next; + i = h->entries[i].next; } return NULL; } @@ -330,12 +330,12 @@ void _J2(MAP_PROC,multi_insert)(MAP_NAME *h, HashKey key, MAP_TYPE value) { fr = _J2(MAP_PROC,_find)(h, key); i = _J2(MAP_PROC,_add_entry)(h, key); if (fr.entry_prev < 0) { - h->hashes.e[fr.hash_index] = i; + h->hashes[fr.hash_index] = i; } else { - h->entries.e[fr.entry_prev].next = i; + h->entries[fr.entry_prev].next = i; } - h->entries.e[i].next = fr.entry_index; - h->entries.e[i].value = value; + h->entries[i].next = fr.entry_index; + h->entries[i].value = value; // Grow if needed if (_J2(MAP_PROC,_full)(h)) { _J2(MAP_PROC,grow)(h); diff --git a/src/parser.cpp b/src/parser.cpp index 01510343e..2fc9f124d 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -15,13 +15,13 @@ typedef enum ParseFileError { ParseFile_Count, } ParseFileError; -typedef Array(AstNode *) AstNodeArray; +typedef Array AstNodeArray; typedef struct AstFile { i32 id; gbArena arena; Tokenizer tokenizer; - Array(Token) tokens; + Array tokens; isize curr_token_index; Token curr_token; Token prev_token; // previous non-comment @@ -54,8 +54,8 @@ typedef struct ImportedFile { typedef struct Parser { String init_fullpath; - Array(AstFile) files; - Array(ImportedFile) imports; + Array files; + Array imports; gbAtomic32 import_index; isize total_token_count; isize total_line_count; @@ -525,7 +525,7 @@ Token ast_node_token(AstNode *node) { case AstNode_PushContext: return node->PushContext.token; case AstNode_BadDecl: return node->BadDecl.begin; - case AstNode_ValueDecl: return ast_node_token(node->ValueDecl.names.e[0]); + case AstNode_ValueDecl: return ast_node_token(node->ValueDecl.names[0]); case AstNode_ImportDecl: return node->ImportDecl.token; case AstNode_ForeignLibrary: return node->ForeignLibrary.token; case AstNode_Label: return node->Label.token; @@ -533,7 +533,7 @@ Token ast_node_token(AstNode *node) { case AstNode_Field: if (node->Field.names.count > 0) { - return ast_node_token(node->Field.names.e[0]); + return ast_node_token(node->Field.names[0]); } return ast_node_token(node->Field.type); case AstNode_FieldList: @@ -565,7 +565,7 @@ AstNodeArray clone_ast_node_array(gbAllocator a, AstNodeArray array) { if (array.count > 0) { array_init_count(&result, a, array.count); for_array(i, array) { - result.e[i] = clone_ast_node(a, array.e[i]); + result[i] = clone_ast_node(a, array[i]); } } return result; @@ -1457,7 +1457,7 @@ bool next_token(AstFile *f) { } f->curr_token_index++; - f->curr_token = f->tokens.e[f->curr_token_index]; + f->curr_token = f->tokens[f->curr_token_index]; if (f->curr_token.kind == Token_Comment) { return next_token(f); } @@ -1474,7 +1474,7 @@ TokenKind look_ahead_token_kind(AstFile *f, isize amount) { isize index = f->curr_token_index; while (amount > 0) { index++; - kind = f->tokens.e[index].kind; + kind = f->tokens[index].kind; if (kind != Token_Comment) { amount--; } @@ -1647,7 +1647,7 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { case AstNode_ValueDecl: if (!s->ValueDecl.is_var) { if (s->ValueDecl.values.count > 0) { - AstNode *last = s->ValueDecl.values.e[s->ValueDecl.values.count-1]; + AstNode *last = s->ValueDecl.values[s->ValueDecl.values.count-1]; return is_semicolon_optional_for_node(f, last); } } @@ -1961,7 +1961,7 @@ AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) { } syntax_error(f->curr_token, "Expected `%.*s`, found a simple statement.", LIT(kind)); - return ast_bad_expr(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); + return ast_bad_expr(f, f->curr_token, f->tokens[f->curr_token_index+1]); } @@ -1990,20 +1990,20 @@ AstNode *parse_operand(AstFile *f, bool lhs) { // NOTE(bill): Allow neighbouring string literals to be merge together to // become one big string String s = f->curr_token.string; - Array(u8) data; - array_init_reserve(&data, heap_allocator(), token.string.len+s.len); - gb_memmove(data.e, token.string.text, token.string.len); + Array data; + array_init(&data, heap_allocator(), token.string.len+s.len); + gb_memmove(data.data, token.string.text, token.string.len); data.count += token.string.len; while (f->curr_token.kind == Token_String) { String s = f->curr_token.string; isize old_count = data.count; array_resize(&data, data.count + s.len); - gb_memmove(data.e+old_count, s.text, s.len); + gb_memmove(data.data+old_count, s.text, s.len); next_token(f); } - token.string = make_string(data.e, data.count); + token.string = make_string(data.data, data.count); array_add(&f->tokenizer.allocated_strings, token.string); } @@ -2512,12 +2512,12 @@ AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) { } } - if (values.e == NULL) { + if (values.data == NULL) { values = make_ast_node_array(f); } AstNodeArray specs = {}; - array_init_reserve(&specs, heap_allocator(), 1); + array_init(&specs, heap_allocator(), 1); return ast_value_decl(f, is_mutable, lhs, type, values); } @@ -2566,7 +2566,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { AstNodeArray rhs = {}; array_init_count(&rhs, heap_allocator(), 1); - rhs.e[0] = expr; + rhs[0] = expr; return ast_assign_stmt(f, token, lhs, rhs); } @@ -2579,7 +2579,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { case Token_for: case Token_match: { next_token(f); - AstNode *name = lhs.e[0]; + AstNode *name = lhs[0]; AstNode *label = ast_label_decl(f, ast_node_token(name), name); AstNode *stmt = parse_stmt(f); #define _SET_LABEL(Kind_, label_) case GB_JOIN2(AstNode_, Kind_): (stmt->Kind_).label = label_; break @@ -2612,10 +2612,10 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { case Token_Inc: case Token_Dec: next_token(f); - return ast_inc_dec_stmt(f, token, lhs.e[0]); + return ast_inc_dec_stmt(f, token, lhs[0]); } - return ast_expr_stmt(f, lhs.e[0]); + return ast_expr_stmt(f, lhs[0]); } @@ -2786,14 +2786,12 @@ typedef struct AstNodeAndFlags { u32 flags; } AstNodeAndFlags; -typedef Array(AstNodeAndFlags) AstNodeAndFlagsArray; - -AstNodeArray convert_to_ident_list(AstFile *f, AstNodeAndFlagsArray list, bool ignore_flags) { +AstNodeArray convert_to_ident_list(AstFile *f, Array list, bool ignore_flags) { AstNodeArray idents = {}; - array_init_reserve(&idents, heap_allocator(), list.count); + array_init(&idents, heap_allocator(), list.count); // Convert to ident list for_array(i, list) { - AstNode *ident = list.e[i].node; + AstNode *ident = list[i].node; if (!ignore_flags) { if (i != 0) { @@ -2834,7 +2832,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok Token start_token = f->curr_token; AstNodeArray params = make_ast_node_array(f); - AstNodeAndFlagsArray list = {}; array_init(&list, heap_allocator()); // LEAK(bill): + Array list = {}; array_init(&list, heap_allocator()); // LEAK(bill): isize total_name_count = 0; bool allow_ellipsis = allowed_flags&FieldFlag_ellipsis; @@ -2858,7 +2856,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok } u32 set_flags = 0; if (list.count > 0) { - set_flags = list.e[0].flags; + set_flags = list[0].flags; } set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags); total_name_count += names.count; @@ -2897,15 +2895,15 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok for_array(i, list) { AstNodeArray names = {}; - AstNode *type = list.e[i].node; + AstNode *type = list[i].node; Token token = blank_token; array_init_count(&names, heap_allocator(), 1); token.pos = ast_node_token(type).pos; - names.e[0] = ast_ident(f, token); - u32 flags = check_field_prefixes(f, list.count, allowed_flags, list.e[i].flags); + names[0] = ast_ident(f, token); + u32 flags = check_field_prefixes(f, list.count, allowed_flags, list[i].flags); - AstNode *param = ast_field(f, names, list.e[i].node, flags); + AstNode *param = ast_field(f, names, list[i].node, flags); array_add(¶ms, param); } @@ -3095,7 +3093,7 @@ AstNode *parse_type_or_ident(AstFile *f) { AstNode *type = parse_var_type(f, false); array_add(&decls, ast_field(f, names, type, set_flags)); } else { - AstNode *name = names.e[0]; + AstNode *name = names[0]; Token open = expect_token(f, Token_OpenBrace); isize decl_count = 0; AstNode *list = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("union")); @@ -3273,7 +3271,7 @@ AstNode *parse_if_stmt(AstFile *f) { break; default: syntax_error(f->curr_token, "Expected if statement block statement"); - else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); + else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens[f->curr_token_index+1]); break; } } @@ -3310,7 +3308,7 @@ AstNode *parse_when_stmt(AstFile *f) { break; default: syntax_error(f->curr_token, "Expected when statement block statement"); - else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); + else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens[f->curr_token_index+1]); break; } } @@ -3337,7 +3335,11 @@ AstNode *parse_return_stmt(AstFile *f) { results = make_ast_node_array(f); } - expect_semicolon(f, results.e[0]); + AstNode *end = NULL; + if (results.count > 0) { + end = results[results.count-1]; + } + expect_semicolon(f, end); return ast_return_stmt(f, token, results); } @@ -3413,11 +3415,11 @@ AstNode *parse_for_stmt(AstFile *f) { AstNode *index = NULL; switch (cond->AssignStmt.lhs.count) { case 1: - value = cond->AssignStmt.lhs.e[0]; + value = cond->AssignStmt.lhs[0]; break; case 2: - value = cond->AssignStmt.lhs.e[0]; - index = cond->AssignStmt.lhs.e[1]; + value = cond->AssignStmt.lhs[0]; + index = cond->AssignStmt.lhs[1]; break; default: error_node(cond, "Expected at 1 or 2 identifiers"); @@ -3426,7 +3428,7 @@ AstNode *parse_for_stmt(AstFile *f) { AstNode *rhs = NULL; if (cond->AssignStmt.rhs.count > 0) { - rhs = cond->AssignStmt.rhs.e[0]; + rhs = cond->AssignStmt.rhs[0]; } return ast_range_stmt(f, token, value, index, in_token, rhs, body); } @@ -3613,7 +3615,7 @@ AstNode *parse_stmt(AstFile *f) { } if (f->curr_token.kind != Token_Colon) { - expect_semicolon(f, list.e[list.count-1]); + expect_semicolon(f, list[list.count-1]); return ast_using_stmt(f, token, list); } @@ -3920,8 +3922,8 @@ ParseFileError init_ast_file(AstFile *f, String fullpath) { } f->curr_token_index = 0; - f->prev_token = f->tokens.e[f->curr_token_index]; - f->curr_token = f->tokens.e[f->curr_token_index]; + f->prev_token = f->tokens[f->curr_token_index]; + f->curr_token = f->tokens[f->curr_token_index]; // NOTE(bill): Is this big enough or too small? isize arena_size = gb_size_of(AstNode); @@ -3962,7 +3964,7 @@ bool init_parser(Parser *p) { void destroy_parser(Parser *p) { // TODO(bill): Fix memory leak for_array(i, p->files) { - destroy_ast_file(&p->files.e[i]); + destroy_ast_file(&p->files[i]); } #if 0 for_array(i, p->imports) { @@ -3982,7 +3984,7 @@ bool try_add_import_path(Parser *p, String path, String rel_path, TokenPos pos) rel_path = string_trim_whitespace(rel_path); for_array(i, p->imports) { - String import = p->imports.e[i].path; + String import = p->imports[i].path; if (import == path) { return false; } @@ -4042,7 +4044,7 @@ bool is_import_path_valid(String path) { void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray decls) { for_array(i, decls) { - AstNode *node = decls.e[i]; + AstNode *node = decls[i]; if (!is_ast_node_decl(node) && node->kind != AstNode_BadStmt && node->kind != AstNode_EmptyStmt) { @@ -4072,7 +4074,7 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray if (collection_name.len == 0) { syntax_error_node(node, "Missing import collection for path: `%.*s`", LIT(oirignal_string)); - decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); continue; } @@ -4089,7 +4091,7 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray } } else { syntax_error_node(node, "Unknown import collection: `%.*s`", LIT(collection_name)); - decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); continue; } @@ -4100,7 +4102,7 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); } // NOTE(bill): It's a naughty name - decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); continue; } @@ -4112,7 +4114,7 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); } // NOTE(bill): It's a naughty name - decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); continue; } @@ -4140,7 +4142,7 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray syntax_error_node(node, "Invalid `foreign_library` path"); } // NOTE(bill): It's a naughty name - f->decls.e[i] = ast_bad_decl(f, fl->token, fl->token); + f->decls[i] = ast_bad_decl(f, fl->token, fl->token); continue; } @@ -4192,7 +4194,7 @@ ParseFileError parse_files(Parser *p, char *init_filename) { p->init_fullpath = init_fullpath; for_array(i, p->imports) { - ImportedFile imported_file = p->imports.e[i]; + ImportedFile imported_file = p->imports[i]; String import_path = imported_file.path; String import_rel_path = imported_file.rel_path; TokenPos pos = imported_file.pos; @@ -4245,7 +4247,7 @@ ParseFileError parse_files(Parser *p, char *init_filename) { } for_array(i, p->files) { - p->total_token_count += p->files.e[i].tokens.count; + p->total_token_count += p->files[i].tokens.count; } diff --git a/src/ssa.cpp b/src/ssa.cpp index b6bdb290a..ebda96c31 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -19,7 +19,7 @@ String ssa_mangle_name(ssaModule *m, String path, Entity *e); #define MAP_NAME MapSsaValue #include "map.cpp" -typedef Array(ssaValue *) ssaValueArray; +typedef Array ssaValueArray; #include "ssa_op.cpp" @@ -30,6 +30,15 @@ struct ssaValueArgs { isize capacity; ssaValue * backing[SSA_DEFAULT_VALUE_ARG_CAPACITY]; gbAllocator allocator; + + ssaValue *&operator[](isize i) { + GB_ASSERT(0 <= i && i <= count); + return e[i]; + } + ssaValue * const &operator[](isize i) const { + GB_ASSERT(0 <= i && i <= count); + return e[i]; + } }; struct ssaValue { @@ -97,7 +106,7 @@ struct ssaEdge { isize index; }; -typedef Array(ssaEdge) ssaEdgeArray; +typedef Array ssaEdgeArray; struct ssaBlock { i32 id; // Unique identifier but the pointer could be used too @@ -134,7 +143,7 @@ struct ssaProc { Entity * entity; DeclInfo * decl_info; - Array(ssaBlock *) blocks; + Array blocks; ssaBlock * entry; // Entry block ssaBlock * exit; // Exit block ssaBlock * curr_block; @@ -145,7 +154,7 @@ struct ssaProc { i32 value_id; MapSsaValue values; // Key: Entity * - Array(ssaDefer) defer_stmts; + Array defer_stmts; i32 scope_level; }; @@ -164,7 +173,7 @@ struct ssaModule { MapEntity min_dep_map; // Key: Entity * MapSsaValue values; // Key: Entity * // List of registers for the specific architecture - Array(ssaRegister) registers; + Array registers; ssaProc *proc; // current procedure @@ -172,7 +181,7 @@ struct ssaModule { u32 stmt_state_flags; - Array(ssaProc *) procs; + Array procs; ssaValueArray procs_to_generate; }; @@ -406,7 +415,7 @@ ssaValue *ssa_emit_deep_field_ptr_index(ssaProc *p, ssaValue *e, Selection sel); void ssa_reset_value_args(ssaValue *v) { for_array(i, v->args) { - v->args.e[i]->uses--; + v->args[i]->uses--; } v->args.count = 0; } @@ -425,7 +434,7 @@ ssaValue *ssa_get_last_value(ssaBlock *b) { if (len <= 0) { return 0; } - ssaValue *v = b->values.e[len-1]; + ssaValue *v = b->values[len-1]; return v; } @@ -451,7 +460,7 @@ void ssa_build_defer_stmt(ssaProc *p, ssaDefer d) { void ssa_emit_defer_stmts(ssaProc *p, ssaDeferExitKind kind, ssaBlock *b) { isize count = p->defer_stmts.count; for (isize i = count-1; i >= 0; i--) { - ssaDefer d = p->defer_stmts.e[i]; + ssaDefer d = p->defer_stmts[i]; if (kind == ssaDeferExit_Default) { gb_printf_err("scope_level %d %d\n", p->scope_level, d.scope_level); if (p->scope_level == d.scope_level && @@ -782,7 +791,7 @@ ssaValue *ssa_emit_conv(ssaProc *p, ssaValue *v, Type *t) { // NOTE(bill): Returns NULL if not possible ssaValue *ssa_address_from_load_or_generate_local(ssaProc *p, ssaValue *v) { if (v->op == ssaOp_Load) { - return v->args.e[0]; + return v->args[0]; } ssaAddr addr = ssa_add_local_generated(p, v->type); ssa_new_value2(p, ssaOp_Store, addr.addr->type, addr.addr, v); @@ -863,7 +872,7 @@ ssaValue *ssa_emit_ptr_index(ssaProc *p, ssaValue *s, i64 index) { ssaValue *ssa_emit_value_index(ssaProc *p, ssaValue *s, i64 index) { if (s->op == ssaOp_Load) { if (!can_ssa_type(s->type)) { - ssaValue *e = ssa_emit_ptr_index(p, s->args.e[0], index); + ssaValue *e = ssa_emit_ptr_index(p, s->args[0], index); return ssa_emit_load(p, e); } } @@ -930,7 +939,7 @@ ssaValue *ssa_emit_deep_field_ptr_index(ssaProc *p, ssaValue *e, Selection sel) Type *type = type_deref(e->type); for_array(i, sel.index) { - i32 index = cast(i32)sel.index.e[i]; + i32 index = cast(i32)sel.index[i]; if (is_type_pointer(type)) { type = type_deref(type); e = ssa_emit_load(p, e); @@ -994,14 +1003,14 @@ ssaValue *ssa_emit_deep_field_value_index(ssaProc *p, ssaValue *e, Selection sel Type *type = e->type; if (e->op == ssaOp_Load) { if (!can_ssa_type(e->type)) { - ssaValue *ptr = ssa_emit_deep_field_ptr_index(p, e->args.e[0], sel); + ssaValue *ptr = ssa_emit_deep_field_ptr_index(p, e->args[0], sel); return ssa_emit_load(p, ptr); } } GB_ASSERT(can_ssa_type(e->type)); for_array(i, sel.index) { - i32 index = cast(i32)sel.index.e[i]; + i32 index = cast(i32)sel.index[i]; if (is_type_pointer(type)) { e = ssa_emit_load(p, e); } @@ -1837,7 +1846,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) { case_ast_node(ce, CallExpr, expr); if (map_tav_get(&p->module->info->types, hash_pointer(ce->proc))->mode == Addressing_Type) { GB_ASSERT(ce->args.count == 1); - ssaValue *x = ssa_build_expr(p, ce->args.e[0]); + ssaValue *x = ssa_build_expr(p, ce->args[0]); return ssa_emit_conv(p, x, tv.type); } @@ -1863,7 +1872,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) { void ssa_build_stmt_list(ssaProc *p, AstNodeArray nodes) { for_array(i, nodes) { - ssa_build_stmt(p, nodes.e[i]); + ssa_build_stmt(p, nodes[i]); } } @@ -1946,7 +1955,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { case_ast_node(us, UsingStmt, node); for_array(i, us->list) { - AstNode *decl = unparen_expr(us->list.e[i]); + AstNode *decl = unparen_expr(us->list[i]); if (decl->kind == AstNode_ValueDecl) { ssa_build_stmt(p, decl); } @@ -1973,19 +1982,19 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); if (vd->values.count == 0) { for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; if (!ssa_is_blank_ident(name)) { ssa_add_local_for_ident(p, name); } } } else { - Array(ssaAddr) lvals = {0}; + Array lvals = {0}; ssaValueArray inits = {0}; - array_init_reserve(&lvals, m->tmp_allocator, vd->names.count); - array_init_reserve(&inits, m->tmp_allocator, vd->names.count); + array_init(&lvals, m->tmp_allocator, vd->names.count); + array_init(&inits, m->tmp_allocator, vd->names.count); for_array(i, vd->names) { - AstNode *name = vd->names.e[i]; + AstNode *name = vd->names[i]; ssaAddr lval = ssa_addr(NULL); if (!ssa_is_blank_ident(name)) { lval = ssa_add_local_for_ident(p, name); @@ -1995,7 +2004,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { } for_array(i, vd->values) { - ssaValue *init = ssa_build_expr(p, vd->values.e[i]); + ssaValue *init = ssa_build_expr(p, vd->values[i]); if (init == NULL) { // TODO(bill): remove this continue; } @@ -2012,7 +2021,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { } for_array(i, inits) { - ssa_addr_store(p, lvals.e[i], inits.e[i]); + ssa_addr_store(p, lvals[i], inits[i]); } } @@ -2030,11 +2039,11 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { switch (as->op.kind) { case Token_Eq: { - Array(ssaAddr) lvals = {0}; + Array lvals = {0}; array_init(&lvals, m->tmp_allocator); for_array(i, as->lhs) { - AstNode *lhs = as->lhs.e[i]; + AstNode *lhs = as->lhs[i]; ssaAddr lval = {0}; if (!ssa_is_blank_ident(lhs)) { lval = ssa_build_addr(p, lhs); @@ -2044,28 +2053,28 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { if (as->lhs.count == as->rhs.count) { if (as->lhs.count == 1) { - AstNode *rhs = as->rhs.e[0]; + AstNode *rhs = as->rhs[0]; ssaValue *init = ssa_build_expr(p, rhs); - ssa_addr_store(p, lvals.e[0], init); + ssa_addr_store(p, lvals[0], init); } else { ssaValueArray inits; - array_init_reserve(&inits, m->tmp_allocator, lvals.count); + array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { - ssaValue *init = ssa_build_expr(p, as->rhs.e[i]); + ssaValue *init = ssa_build_expr(p, as->rhs[i]); array_add(&inits, init); } for_array(i, inits) { - ssa_addr_store(p, lvals.e[i], inits.e[i]); + ssa_addr_store(p, lvals[i], inits[i]); } } } else { ssaValueArray inits; - array_init_reserve(&inits, m->tmp_allocator, lvals.count); + array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { - ssaValue *init = ssa_build_expr(p, as->rhs.e[i]); + ssaValue *init = ssa_build_expr(p, as->rhs[i]); Type *t = base_type(init->type); // TODO(bill): refactor for code reuse as this is repeated a bit if (t->kind == Type_Tuple) { @@ -2080,7 +2089,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { } for_array(i, inits) { - ssa_addr_store(p, lvals.e[i], inits.e[i]); + ssa_addr_store(p, lvals[i], inits[i]); } } } break; @@ -2091,8 +2100,8 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { // +=, -=, etc i32 op = cast(i32)as->op.kind; op += Token_Add - Token_AddEq; // Convert += to + - ssaAddr lhs = ssa_build_addr(p, as->lhs.e[0]); - ssaValue *value = ssa_build_expr(p, as->rhs.e[0]); + ssaAddr lhs = ssa_build_addr(p, as->lhs[0]); + ssaValue *value = ssa_build_expr(p, as->rhs[0]); ssa_build_assign_op(p, lhs, value, cast(TokenKind)op); } break; } @@ -2316,7 +2325,7 @@ void ssa_print_reg_value(gbFile *f, ssaValue *v) { for_array(i, v->args) { gb_fprintf(f, " "); - ssa_print_value(f, v->args.e[i]); + ssa_print_value(f, v->args[i]); } if (v->comment_string.len > 0) { @@ -2335,12 +2344,12 @@ void ssa_print_proc(gbFile *f, ssaProc *p) { bool *printed = gb_alloc_array(heap_allocator(), bool, p->value_id+1); for_array(i, p->blocks) { - ssaBlock *b = p->blocks.e[i]; + ssaBlock *b = p->blocks[i]; gb_fprintf(f, " b%d:", b->id); if (b->preds.count > 0) { gb_fprintf(f, " <-"); for_array(j, b->preds) { - ssaBlock *pred = b->preds.e[j].block; + ssaBlock *pred = b->preds[j].block; gb_fprintf(f, " b%d", pred->id); } } @@ -2351,7 +2360,7 @@ void ssa_print_proc(gbFile *f, ssaProc *p) { isize n = 0; for_array(j, b->values) { - ssaValue *v = b->values.e[j]; + ssaValue *v = b->values[j]; if (v->op != ssaOp_Phi) { continue; } @@ -2363,13 +2372,13 @@ void ssa_print_proc(gbFile *f, ssaProc *p) { while (n < b->values.count) { isize m = 0; for_array(j, b->values) { - ssaValue *v = b->values.e[j]; + ssaValue *v = b->values[j]; if (printed[v->id]) { continue; } bool skip = false; for_array(k, v->args) { - ssaValue *w = v->args.e[k]; + ssaValue *w = v->args[k]; if (w != NULL && w->block == b && !printed[w->id]) { skip = true; break; @@ -2387,7 +2396,7 @@ void ssa_print_proc(gbFile *f, ssaProc *p) { if (m == n) { gb_fprintf(f, "!!!!DepCycle!!!!\n"); for_array(k, b->values) { - ssaValue *v = b->values.e[k]; + ssaValue *v = b->values[k]; if (printed[v->id]) { continue; } @@ -2401,14 +2410,14 @@ void ssa_print_proc(gbFile *f, ssaProc *p) { if (b->kind == ssaBlock_Plain) { GB_ASSERT(b->succs.count == 1); - ssaBlock *next = b->succs.e[0].block; + ssaBlock *next = b->succs[0].block; gb_fprintf(f, " "); gb_fprintf(f, "jump b%d", next->id); gb_fprintf(f, "\n"); } else if (b->kind == ssaBlock_If) { GB_ASSERT(b->succs.count == 2); - ssaBlock *yes = b->succs.e[0].block; - ssaBlock *no = b->succs.e[1].block; + ssaBlock *yes = b->succs[0].block; + ssaBlock *no = b->succs[1].block; gb_fprintf(f, " "); gb_fprintf(f, "branch v%d, b%d, b%d", b->control->id, yes->id, no->id); gb_fprintf(f, "\n"); @@ -2491,7 +2500,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) { bool has_win_main = false; for_array(i, info->entities.entries) { - MapDeclInfoEntry *entry = &info->entities.entries.e[i]; + MapDeclInfoEntry *entry = &info->entities.entries[i]; Entity *e = cast(Entity *)cast(uintptr)entry->key.key; String name = e->token.string; if (e->kind == Entity_Variable) { @@ -2517,7 +2526,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) { m.min_dep_map = generate_minimum_dependency_map(info, entry_point); for_array(i, info->entities.entries) { - MapDeclInfoEntry *entry = &info->entities.entries.e[i]; + MapDeclInfoEntry *entry = &info->entities.entries[i]; Entity *e = cast(Entity *)entry->key.ptr; String name = e->token.string; DeclInfo *decl = entry->value; diff --git a/src/timings.cpp b/src/timings.cpp index 046f476fe..04c1667f4 100644 --- a/src/timings.cpp +++ b/src/timings.cpp @@ -6,7 +6,7 @@ typedef struct TimeStamp { typedef struct Timings { TimeStamp total; - Array(TimeStamp) sections; + Array sections; u64 freq; } Timings; @@ -83,7 +83,7 @@ TimeStamp make_time_stamp(String label) { } void timings_init(Timings *t, String label, isize buffer_size) { - array_init_reserve(&t->sections, heap_allocator(), buffer_size); + array_init(&t->sections, heap_allocator(), buffer_size); t->total = make_time_stamp(label); t->freq = time_stamp__freq(); } @@ -94,7 +94,7 @@ void timings_destroy(Timings *t) { void timings__stop_current_section(Timings *t) { if (t->sections.count > 0) { - t->sections.e[t->sections.count-1].finish = time_stamp_time_now(); + t->sections[t->sections.count-1].finish = time_stamp_time_now(); } } @@ -117,7 +117,7 @@ void timings_print_all(Timings *t) { max_len = t->total.label.len; for_array(i, t->sections) { - TimeStamp ts = t->sections.e[i]; + TimeStamp ts = t->sections[i]; max_len = gb_max(max_len, ts.label.len); } @@ -129,7 +129,7 @@ void timings_print_all(Timings *t) { time_stamp_as_ms(t->total, t->freq)); for_array(i, t->sections) { - TimeStamp ts = t->sections.e[i]; + TimeStamp ts = t->sections[i]; gb_printf("%.*s%.*s - %.3f ms\n", LIT(ts.label), cast(int)(max_len-ts.label.len), SPACES, diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 5c9809bd1..9e4151c50 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -338,7 +338,7 @@ typedef struct Tokenizer { isize line_count; isize error_count; - Array(String) allocated_strings; + Array allocated_strings; } Tokenizer; @@ -460,7 +460,7 @@ gb_inline void destroy_tokenizer(Tokenizer *t) { gb_free(heap_allocator(), t->start); } for_array(i, t->allocated_strings) { - gb_free(heap_allocator(), t->allocated_strings.e[i].text); + gb_free(heap_allocator(), t->allocated_strings[i].text); } array_free(&t->allocated_strings); } diff --git a/src/types.cpp b/src/types.cpp index 41fc1f901..5ec5a40e9 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -197,13 +197,13 @@ typedef struct Type { // TODO(bill): Should I add extra information here specifying the kind of selection? // e.g. field, constant, vector field, type field, etc. typedef struct Selection { - Entity * entity; - Array_i32 index; - bool indirect; // Set if there was a pointer deref anywhere down the line + Entity * entity; + Array index; + bool indirect; // Set if there was a pointer deref anywhere down the line } Selection; Selection empty_selection = {0}; -Selection make_selection(Entity *entity, Array_i32 index, bool indirect) { +Selection make_selection(Entity *entity, Array index, bool indirect) { Selection s = {entity, index, indirect}; return s; } @@ -212,10 +212,10 @@ void selection_add_index(Selection *s, isize index) { // IMPORTANT NOTE(bill): this requires a stretchy buffer/dynamic array so it requires some form // of heap allocation // TODO(bill): Find a way to use a backing buffer for initial use as the general case is probably .count<3 - if (s->index.e == NULL) { + if (s->index.data == NULL) { array_init(&s->index, heap_allocator()); } - array_add(&s->index, index); + array_add(&s->index, cast(i32)index); } @@ -1297,9 +1297,9 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) { Entity *f = type->Record.fields[i]; if (f->kind == Entity_Variable) { if (f->Variable.field_src_index == index) { - Array_i32 sel_array = {0}; + Array sel_array = {0}; array_init_count(&sel_array, a, 1); - sel_array.e[0] = i; + sel_array[0] = i; return make_selection(f, sel_array, false); } } @@ -1309,18 +1309,18 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) { for (isize i = 0; i < max_count; i++) { Entity *f = type->Tuple.variables[i]; if (i == index) { - Array_i32 sel_array = {0}; + Array sel_array = {0}; array_init_count(&sel_array, a, 1); - sel_array.e[0] = i; + sel_array[0] = i; return make_selection(f, sel_array, false); } } break; case Type_BitField: { - Array_i32 sel_array = {0}; + Array sel_array = {0}; array_init_count(&sel_array, a, 1); - sel_array.e[0] = cast(i32)index; + sel_array[0] = cast(i32)index; return make_selection(type->BitField.fields[index], sel_array, false); } break; @@ -1509,7 +1509,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n typedef struct TypePath { - Array(Type *) path; // Entity_TypeName; + Array path; // Entity_TypeName; bool failure; } TypePath; @@ -1526,7 +1526,7 @@ void type_path_print_illegal_cycle(TypePath *tp, isize start_index) { GB_ASSERT(tp != NULL); GB_ASSERT(start_index < tp->path.count); - Type *t = tp->path.e[start_index]; + Type *t = tp->path[start_index]; GB_ASSERT(t != NULL); GB_ASSERT_MSG(is_type_named(t), "%s", type_to_string(t)); @@ -1534,7 +1534,7 @@ void type_path_print_illegal_cycle(TypePath *tp, isize start_index) { error(e->token, "Illegal declaration cycle of `%.*s`", LIT(t->Named.name)); // NOTE(bill): Print cycle, if it's deep enough for (isize j = start_index; j < tp->path.count; j++) { - Type *t = tp->path.e[j]; + Type *t = tp->path[j]; GB_ASSERT_MSG(is_type_named(t), "%s", type_to_string(t)); Entity *e = t->Named.type_name; error(e->token, "\t%.*s refers to", LIT(t->Named.name)); @@ -1549,7 +1549,7 @@ TypePath *type_path_push(TypePath *tp, Type *t) { GB_ASSERT(tp != NULL); for (isize i = 0; i < tp->path.count; i++) { - if (tp->path.e[i] == t) { + if (tp->path[i] == t) { type_path_print_illegal_cycle(tp, i); } } @@ -2082,7 +2082,7 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s Type *t = type; i64 offset = 0; for_array(i, sel.index) { - isize index = sel.index.e[i]; + isize index = sel.index[i]; t = base_type(t); offset += type_offset_of(allocator, t, index); if (t->kind == Type_Record && t->Record.kind == TypeRecord_Struct) {