diff options
| author | Ginger Bill <bill@gingerbill.org> | 2016-11-23 10:36:48 +0000 |
|---|---|---|
| committer | Ginger Bill <bill@gingerbill.org> | 2016-11-23 10:36:48 +0000 |
| commit | 8ecfca0c9b4d8a8f7c553f99b0bf10142eea88e6 (patch) | |
| tree | d04d929f7cd07cddf064704b7171ad3524f092a7 | |
| parent | cb7b9a413d66b1dce30a4d810f17ed8453c0a738 (diff) | |
Remove templated Map; replace with #include macro "templates" trick
| -rw-r--r-- | src/checker/checker.cpp | 223 | ||||
| -rw-r--r-- | src/checker/decl.cpp | 42 | ||||
| -rw-r--r-- | src/checker/entity.cpp | 8 | ||||
| -rw-r--r-- | src/checker/expr.cpp | 196 | ||||
| -rw-r--r-- | src/checker/stmt.cpp | 107 | ||||
| -rw-r--r-- | src/checker/types.cpp | 92 | ||||
| -rw-r--r-- | src/common.cpp | 38 | ||||
| -rw-r--r-- | src/exact_value.cpp | 6 | ||||
| -rw-r--r-- | src/main.cpp | 4 | ||||
| -rw-r--r-- | src/parser.cpp | 99 | ||||
| -rw-r--r-- | src/profiler.cpp | 120 | ||||
| -rw-r--r-- | src/ssa.cpp | 216 | ||||
| -rw-r--r-- | src/ssa_opt.cpp | 6 | ||||
| -rw-r--r-- | src/ssa_print.cpp | 16 | ||||
| -rw-r--r-- | src/string.cpp | 16 | ||||
| -rw-r--r-- | src/tokenizer.cpp | 18 | ||||
| -rw-r--r-- | src/unicode.cpp | 10 |
17 files changed, 519 insertions, 698 deletions
diff --git a/src/checker/checker.cpp b/src/checker/checker.cpp index ee99a4713..e0d51f84c 100644 --- a/src/checker/checker.cpp +++ b/src/checker/checker.cpp @@ -2,6 +2,11 @@ #include "entity.cpp" #include "types.cpp" +#define MAP_TYPE Entity * +#define MAP_FUNC map_entity_ +#define MAP_NAME MapEntity +#include "../map.c" + enum AddressingMode { Addressing_Invalid, Addressing_NoValue, @@ -27,6 +32,8 @@ struct TypeAndValue { ExactValue value; }; + + struct DeclInfo { Scope *scope; @@ -38,18 +45,18 @@ struct DeclInfo { AstNode *proc_decl; // AstNode_ProcDecl u32 var_decl_tags; - Map<b32> deps; // Key: Entity * + MapBool deps; // Key: Entity * }; -struct ExpressionInfo { - b32 is_lhs; // Debug info +struct ExprInfo { + bool is_lhs; // Debug info AddressingMode mode; Type * type; // Type_Basic ExactValue value; }; -ExpressionInfo make_expression_info(b32 is_lhs, AddressingMode mode, Type *type, ExactValue value) { - ExpressionInfo ei = {is_lhs, mode, type, value}; +ExprInfo make_expr_info(bool is_lhs, AddressingMode mode, Type *type, ExactValue value) { + ExprInfo ei = {is_lhs, mode, type, value}; return ei; } @@ -67,15 +74,15 @@ struct Scope { Scope * prev, *next; Scope * first_child; Scope * last_child; - Map<Entity *> elements; // Key: String - Map<Entity *> implicit; // Key: String + MapEntity elements; // Key: String + MapEntity implicit; // Key: String Array(Scope *) shared; Array(Scope *) imported; - b32 is_proc; - b32 is_global; - b32 is_file; - b32 is_init; + bool is_proc; + bool is_global; + bool is_file; + bool is_init; AstFile * file; }; gb_global Scope *universal_scope = NULL; @@ -126,7 +133,7 @@ enum BuiltinProcId { struct BuiltinProc { String name; isize arg_count; - b32 variadic; + bool variadic; ExprKind kind; }; gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = { @@ -189,19 +196,45 @@ struct CheckerContext { u32 stmt_state_flags; }; +#define MAP_TYPE TypeAndValue +#define MAP_FUNC map_tav_ +#define MAP_NAME MapTypeAndValue +#include "../map.c" + +#define MAP_TYPE Scope * +#define MAP_FUNC map_scope_ +#define MAP_NAME MapScope +#include "../map.c" + +#define MAP_TYPE DeclInfo * +#define MAP_FUNC map_decl_info_ +#define MAP_NAME MapDeclInfo +#include "../map.c" + +#define MAP_TYPE AstFile * +#define MAP_FUNC map_ast_file_ +#define MAP_NAME MapAstFile +#include "../map.c" + +#define MAP_TYPE ExprInfo +#define MAP_FUNC map_expr_info_ +#define MAP_NAME MapExprInfo +#include "../map.c" + + // NOTE(bill): Symbol tables struct CheckerInfo { - Map<TypeAndValue> types; // Key: AstNode * | Expression -> Type (and value) - Map<Entity *> definitions; // Key: AstNode * | Identifier -> Entity - Map<Entity *> uses; // Key: AstNode * | Identifier -> Entity - Map<Scope *> scopes; // Key: AstNode * | Node -> Scope - Map<ExpressionInfo> untyped; // Key: AstNode * | Expression -> ExpressionInfo - Map<DeclInfo *> entities; // Key: Entity * - Map<Entity *> foreign_procs; // Key: String - Map<AstFile *> files; // Key: String (full path) - Map<isize> type_info_map; // Key: Type * - isize type_info_count; - Entity * implicit_values[ImplicitValue_Count]; + MapTypeAndValue types; // Key: AstNode * | Expression -> Type (and value) + MapEntity definitions; // Key: AstNode * | Identifier -> Entity + MapEntity uses; // Key: AstNode * | Identifier -> Entity + MapScope scopes; // Key: AstNode * | Node -> Scope + MapExprInfo untyped; // Key: AstNode * | Expression -> ExprInfo + MapDeclInfo entities; // Key: Entity * + MapEntity foreign_procs; // Key: String + MapAstFile files; // Key: String (full path) + MapIsize type_info_map; // Key: Type * + isize type_info_count; + Entity * implicit_values[ImplicitValue_Count]; }; struct Checker { @@ -221,7 +254,7 @@ struct Checker { CheckerContext context; Array(Type *) proc_stack; - b32 in_defer; // TODO(bill): Actually handle correctly + bool in_defer; // TODO(bill): Actually handle correctly }; struct CycleChecker { @@ -252,7 +285,7 @@ void cycle_checker_destroy(CycleChecker *cc) { void init_declaration_info(DeclInfo *d, Scope *scope) { d->scope = scope; - map_init(&d->deps, heap_allocator()); + map_bool_init(&d->deps, heap_allocator()); } DeclInfo *make_declaration_info(gbAllocator a, Scope *scope) { @@ -262,10 +295,10 @@ DeclInfo *make_declaration_info(gbAllocator a, Scope *scope) { } void destroy_declaration_info(DeclInfo *d) { - map_destroy(&d->deps); + map_bool_destroy(&d->deps); } -b32 decl_info_has_init(DeclInfo *d) { +bool decl_info_has_init(DeclInfo *d) { if (d->init_expr != NULL) { return true; } @@ -286,8 +319,8 @@ b32 decl_info_has_init(DeclInfo *d) { Scope *make_scope(Scope *parent, gbAllocator allocator) { Scope *s = gb_alloc_item(allocator, Scope); s->parent = parent; - map_init(&s->elements, heap_allocator()); - map_init(&s->implicit, heap_allocator()); + map_entity_init(&s->elements, heap_allocator()); + map_entity_init(&s->implicit, heap_allocator()); array_init(&s->shared, heap_allocator()); array_init(&s->imported, heap_allocator()); @@ -313,8 +346,8 @@ void destroy_scope(Scope *scope) { destroy_scope(child); } - map_destroy(&scope->elements); - map_destroy(&scope->implicit); + map_entity_destroy(&scope->elements); + map_entity_destroy(&scope->implicit); array_free(&scope->shared); array_free(&scope->imported); @@ -324,7 +357,7 @@ void destroy_scope(Scope *scope) { void add_scope(Checker *c, AstNode *node, Scope *scope) { GB_ASSERT(node != NULL); GB_ASSERT(scope != NULL); - map_set(&c->info.scopes, hash_pointer(node), scope); + map_scope_set(&c->info.scopes, hash_pointer(node), scope); } @@ -347,10 +380,10 @@ void check_close_scope(Checker *c) { } void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entity **entity_) { - b32 gone_thru_proc = false; + bool gone_thru_proc = false; HashKey key = hash_string(name); for (Scope *s = scope; s != NULL; s = s->parent) { - Entity **found = map_get(&s->elements, key); + Entity **found = map_entity_get(&s->elements, key); if (found) { Entity *e = *found; if (gone_thru_proc) { @@ -372,7 +405,7 @@ void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entit // Check shared scopes - i.e. other files @ global scope for_array(i, s->shared) { Scope *shared = s->shared.e[i]; - Entity **found = map_get(&shared->elements, key); + Entity **found = map_entity_get(&shared->elements, key); if (found) { Entity *e = *found; if (e->kind == Entity_Variable && @@ -409,12 +442,12 @@ Entity *scope_lookup_entity(Scope *s, String name) { Entity *current_scope_lookup_entity(Scope *s, String name) { HashKey key = hash_string(name); - Entity **found = map_get(&s->elements, key); + Entity **found = map_entity_get(&s->elements, key); if (found) { return *found; } for_array(i, s->shared) { - Entity **found = map_get(&s->shared.e[i]->elements, key); + Entity **found = map_entity_get(&s->shared.e[i]->elements, key); if (found) { return *found; } @@ -427,11 +460,11 @@ Entity *current_scope_lookup_entity(Scope *s, String name) { Entity *scope_insert_entity(Scope *s, Entity *entity) { String name = entity->token.string; HashKey key = hash_string(name); - Entity **found = map_get(&s->elements, key); + Entity **found = map_entity_get(&s->elements, key); if (found) { return *found; } - map_set(&s->elements, key, entity); + map_entity_set(&s->elements, key, entity); if (entity->scope == NULL) { entity->scope = s; } @@ -460,7 +493,7 @@ void check_scope_usage(Checker *c, Scope *scope) { void add_dependency(DeclInfo *d, Entity *e) { - map_set(&d->deps, hash_pointer(e), cast(b32)true); + map_bool_set(&d->deps, hash_pointer(e), cast(bool)true); } void add_declaration_dependency(Checker *c, Entity *e) { @@ -468,7 +501,7 @@ void add_declaration_dependency(Checker *c, Entity *e) { return; } if (c->context.decl != NULL) { - auto found = map_get(&c->info.entities, hash_pointer(e)); + DeclInfo **found = map_decl_info_get(&c->info.entities, hash_pointer(e)); if (found) { add_dependency(c->context.decl, e); } @@ -530,35 +563,33 @@ void init_universal_scope(void) { void init_checker_info(CheckerInfo *i) { gbAllocator a = heap_allocator(); - map_init(&i->types, a); - map_init(&i->definitions, a); - map_init(&i->uses, a); - map_init(&i->scopes, a); - map_init(&i->entities, a); - map_init(&i->untyped, a); - map_init(&i->foreign_procs, a); - map_init(&i->type_info_map, a); - map_init(&i->files, a); + map_tav_init(&i->types, a); + map_entity_init(&i->definitions, a); + map_entity_init(&i->uses, a); + map_scope_init(&i->scopes, a); + map_decl_info_init(&i->entities, a); + map_expr_info_init(&i->untyped, a); + map_entity_init(&i->foreign_procs, a); + map_isize_init(&i->type_info_map, a); + map_ast_file_init(&i->files, a); i->type_info_count = 0; } void destroy_checker_info(CheckerInfo *i) { - map_destroy(&i->types); - map_destroy(&i->definitions); - map_destroy(&i->uses); - map_destroy(&i->scopes); - map_destroy(&i->entities); - map_destroy(&i->untyped); - map_destroy(&i->foreign_procs); - map_destroy(&i->type_info_map); - map_destroy(&i->files); + map_tav_destroy(&i->types); + map_entity_destroy(&i->definitions); + map_entity_destroy(&i->uses); + map_scope_destroy(&i->scopes); + map_decl_info_destroy(&i->entities); + map_expr_info_destroy(&i->untyped); + map_entity_destroy(&i->foreign_procs); + map_isize_destroy(&i->type_info_map); + map_ast_file_destroy(&i->files); } void init_checker(Checker *c, Parser *parser, BaseTypeSizes sizes) { - PROF_PROC(); - gbAllocator a = heap_allocator(); c->parser = parser; @@ -598,18 +629,18 @@ void destroy_checker(Checker *c) { TypeAndValue *type_and_value_of_expression(CheckerInfo *i, AstNode *expression) { - TypeAndValue *found = map_get(&i->types, hash_pointer(expression)); + TypeAndValue *found = map_tav_get(&i->types, hash_pointer(expression)); return found; } Entity *entity_of_ident(CheckerInfo *i, AstNode *identifier) { if (identifier->kind == AstNode_Ident) { - Entity **found = map_get(&i->definitions, hash_pointer(identifier)); + Entity **found = map_entity_get(&i->definitions, hash_pointer(identifier)); if (found) { return *found; } - found = map_get(&i->uses, hash_pointer(identifier)); + found = map_entity_get(&i->uses, hash_pointer(identifier)); if (found) { return *found; } @@ -633,8 +664,8 @@ Type *type_of_expr(CheckerInfo *i, AstNode *expression) { } -void add_untyped(CheckerInfo *i, AstNode *expression, b32 lhs, AddressingMode mode, Type *basic_type, ExactValue value) { - map_set(&i->untyped, hash_pointer(expression), make_expression_info(lhs, mode, basic_type, value)); +void add_untyped(CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode mode, Type *basic_type, ExactValue value) { + map_expr_info_set(&i->untyped, hash_pointer(expression), make_expr_info(lhs, mode, basic_type, value)); } void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value) { @@ -656,7 +687,7 @@ void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode tv.type = type; tv.value = value; tv.mode = mode; - map_set(&i->types, hash_pointer(expression), tv); + map_tav_set(&i->types, hash_pointer(expression), tv); } void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) { @@ -664,13 +695,13 @@ void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) if (identifier->kind == AstNode_Ident) { GB_ASSERT(identifier->kind == AstNode_Ident); HashKey key = hash_pointer(identifier); - map_set(&i->definitions, key, entity); + map_entity_set(&i->definitions, key, entity); } else { // NOTE(bill): Error should handled elsewhere } } -b32 add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { +bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { if (str_ne(entity->token.string, str_lit("_"))) { Entity *insert_entity = scope_insert_entity(scope, entity); if (insert_entity) { @@ -708,7 +739,7 @@ void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { if (identifier->kind != AstNode_Ident) { return; } - map_set(&c->info.uses, hash_pointer(identifier), entity); + map_entity_set(&c->info.uses, hash_pointer(identifier), entity); add_declaration_dependency(c, entity); // TODO(bill): Should this be here? } @@ -716,7 +747,7 @@ void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d) { GB_ASSERT(str_eq(identifier->Ident.string, e->token.string)); add_entity(c, e->scope, identifier, e); - map_set(&c->info.entities, hash_pointer(e), d); + map_decl_info_set(&c->info.entities, hash_pointer(e), d); } void add_type_info_type(Checker *c, Type *t) { @@ -728,7 +759,7 @@ void add_type_info_type(Checker *c, Type *t) { return; // Could be nil } - if (map_get(&c->info.type_info_map, hash_pointer(t)) != NULL) { + if (map_isize_get(&c->info.type_info_map, hash_pointer(t)) != NULL) { // Types have already been added return; } @@ -749,7 +780,7 @@ void add_type_info_type(Checker *c, Type *t) { ti_index = c->info.type_info_count; c->info.type_info_count++; } - map_set(&c->info.type_info_map, hash_pointer(t), ti_index); + map_isize_set(&c->info.type_info_map, hash_pointer(t), ti_index); @@ -873,17 +904,17 @@ void add_curr_ast_file(Checker *c, AstFile *file) { -void add_dependency_to_map(Map<Entity *> *map, CheckerInfo *info, Entity *node) { +void add_dependency_to_map(MapEntity *map, CheckerInfo *info, Entity *node) { if (node == NULL) { return; } - if (map_get(map, hash_pointer(node)) != NULL) { + if (map_entity_get(map, hash_pointer(node)) != NULL) { return; } - map_set(map, hash_pointer(node), node); + map_entity_set(map, hash_pointer(node), node); - DeclInfo **found = map_get(&info->entities, hash_pointer(node)); + DeclInfo **found = map_decl_info_get(&info->entities, hash_pointer(node)); if (found == NULL) { return; } @@ -895,9 +926,9 @@ void add_dependency_to_map(Map<Entity *> *map, CheckerInfo *info, Entity *node) } } -Map<Entity *> generate_minimum_dependency_map(CheckerInfo *info, Entity *start) { - Map<Entity *> map = {}; // Key: Entity * - map_init(&map, heap_allocator()); +MapEntity generate_minimum_dependency_map(CheckerInfo *info, Entity *start) { + MapEntity map = {}; // Key: Entity * + map_entity_init(&map, heap_allocator()); for_array(i, info->entities.entries) { auto *entry = &info->entities.entries.e[i]; @@ -921,9 +952,6 @@ Map<Entity *> generate_minimum_dependency_map(CheckerInfo *info, Entity *start) #include "stmt.cpp" void init_preload_types(Checker *c) { - PROF_PROC(); - - if (t_type_info == NULL) { Entity *e = current_scope_lookup_entity(c->global_scope, str_lit("Type_Info")); if (e == NULL) { @@ -994,7 +1022,6 @@ void add_implicit_value(Checker *c, ImplicitValueId id, String name, String back void check_global_entity(Checker *c, EntityKind kind) { - PROF_SCOPED("check_global_entity"); for_array(i, c->info.entities.entries) { auto *entry = &c->info.entities.entries.e[i]; Entity *e = cast(Entity *)cast(uintptr)entry->key.key; @@ -1026,8 +1053,8 @@ void check_parsed_files(Checker *c) { AstNodeArray import_decls; array_init(&import_decls, heap_allocator()); - Map<Scope *> file_scopes; // Key: String (fullpath) - map_init(&file_scopes, heap_allocator()); + MapScope file_scopes; // Key: String (fullpath) + map_scope_init(&file_scopes, heap_allocator()); // Map full filepaths to Scopes for_array(i, c->parser->files) { @@ -1050,14 +1077,12 @@ void check_parsed_files(Checker *c) { f->scope = scope; f->decl_info = make_declaration_info(c->allocator, f->scope); HashKey key = hash_string(f->tokenizer.fullpath); - map_set(&file_scopes, key, scope); - map_set(&c->info.files, key, f); + map_scope_set(&file_scopes, key, scope); + map_ast_file_set(&c->info.files, key, f); } // Collect Entities for_array(i, c->parser->files) { - PROF_SCOPED("Collect Entities"); - AstFile *f = &c->parser->files.e[i]; add_curr_ast_file(c, f); @@ -1165,8 +1190,6 @@ void check_parsed_files(Checker *c) { } for_array(i, c->parser->files) { - PROF_SCOPED("Import Entities"); - AstFile *f = &c->parser->files.e[i]; add_curr_ast_file(c, f); @@ -1180,7 +1203,7 @@ void check_parsed_files(Checker *c) { ast_node(id, ImportDecl, decl); HashKey key = hash_string(id->fullpath); - auto found = map_get(&file_scopes, key); + auto found = map_scope_get(&file_scopes, key); GB_ASSERT_MSG(found != NULL, "Unable to find scope for file: %.*s", LIT(id->fullpath)); Scope *scope = *found; @@ -1189,7 +1212,7 @@ void check_parsed_files(Checker *c) { continue; } - b32 previously_added = false; + bool previously_added = false; for_array(import_index, file_scope->imported) { Scope *prev = file_scope->imported.e[import_index]; if (prev == scope) { @@ -1216,7 +1239,7 @@ void check_parsed_files(Checker *c) { add_entity(c, file_scope, NULL, e); if (!id->is_load) { // `#import`ed entities don't get exported HashKey key = hash_string(e->token.string); - map_set(&file_scope->implicit, key, e); + map_entity_set(&file_scope->implicit, key, e); } } } @@ -1295,8 +1318,8 @@ void check_parsed_files(Checker *c) { ProcedureInfo *pi = &c->procs.e[i]; add_curr_ast_file(c, pi->file); - b32 bounds_check = (pi->tags & ProcTag_bounds_check) != 0; - b32 no_bounds_check = (pi->tags & ProcTag_no_bounds_check) != 0; + bool bounds_check = (pi->tags & ProcTag_bounds_check) != 0; + bool no_bounds_check = (pi->tags & ProcTag_no_bounds_check) != 0; CheckerContext prev_context = c->context; @@ -1315,12 +1338,10 @@ void check_parsed_files(Checker *c) { // Add untyped expression values for_array(i, c->info.untyped.entries) { - PROF_SCOPED("Untyped expr values"); - auto *entry = &c->info.untyped.entries.e[i]; HashKey key = entry->key; AstNode *expr = cast(AstNode *)cast(uintptr)key.key; - ExpressionInfo *info = &entry->value; + ExprInfo *info = &entry->value; if (info != NULL && expr != NULL) { if (is_type_typed(info->type)) { compiler_error("%s (type %s) is typed!", expr_to_string(expr), type_to_string(info->type)); @@ -1366,7 +1387,7 @@ void check_parsed_files(Checker *c) { // gb_printf("%td - %s\n", e->value, type_to_string(prev_type)); // } - map_destroy(&file_scopes); + map_scope_destroy(&file_scopes); array_free(&import_decls); } diff --git a/src/checker/decl.cpp b/src/checker/decl.cpp index 79b712522..d8e1fbdb7 100644 --- a/src/checker/decl.cpp +++ b/src/checker/decl.cpp @@ -1,4 +1,4 @@ -b32 check_is_terminating(AstNode *node); +bool check_is_terminating(AstNode *node); void check_stmt (Checker *c, AstNode *node, u32 flags); void check_stmt_list (Checker *c, AstNodeArray stmts, u32 flags); void check_type_decl (Checker *c, Entity *e, AstNode *type_expr, Type *def, CycleChecker *cycle_checker); @@ -8,8 +8,6 @@ void check_var_decl (Checker *c, Entity *e, Entity **entities, isize entity_ // NOTE(bill): `content_name` is for debugging and error messages Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String context_name) { - PROF_PROC(); - if (operand->mode == Addressing_Invalid || operand->type == t_invalid || e->type == t_invalid) { @@ -58,8 +56,6 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex } void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArray inits, String context_name) { - PROF_PROC(); - if ((lhs == NULL || lhs_count == 0) && inits.count == 0) { return; } @@ -109,14 +105,12 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArra void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type, CycleChecker *cycle_checker) { - PROF_PROC(); - if (e->type != NULL) { return; } if (d == NULL) { - DeclInfo **found = map_get(&c->info.entities, hash_pointer(e)); + DeclInfo **found = map_decl_info_get(&c->info.entities, hash_pointer(e)); if (found) { d = *found; } else { @@ -153,8 +147,6 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type, Cyc void check_var_decl_node(Checker *c, AstNode *node) { - PROF_PROC(); - ast_node(vd, VarDecl, node); isize entity_count = vd->names.count; isize entity_index = 0; @@ -224,8 +216,6 @@ void check_var_decl_node(Checker *c, AstNode *node) { void check_init_constant(Checker *c, Entity *e, Operand *operand) { - PROF_PROC(); - if (operand->mode == Addressing_Invalid || operand->type == t_invalid || e->type == t_invalid) { @@ -269,8 +259,6 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) { void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init_expr) { - PROF_PROC(); - GB_ASSERT(e->type == NULL); if (e->flags & EntityFlag_Visited) { @@ -300,8 +288,6 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init_e } void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, CycleChecker *cycle_checker) { - PROF_PROC(); - GB_ASSERT(e->type == NULL); Type *named = make_type_named(c->allocator, e->token.string, NULL, e); named->Named.type_name = e; @@ -326,7 +312,7 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, Cycle } -b32 are_signatures_similar_enough(Type *a_, Type *b_) { +bool are_signatures_similar_enough(Type *a_, Type *b_) { GB_ASSERT(a_->kind == Type_Proc); GB_ASSERT(b_->kind == Type_Proc); auto *a = &a_->Proc; @@ -365,8 +351,6 @@ b32 are_signatures_similar_enough(Type *a_, Type *b_) { } void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { - PROF_PROC(); - GB_ASSERT(e->type == NULL); Type *proc_type = make_type_proc(c->allocator, e->scope, NULL, 0, NULL, 0, false); @@ -376,10 +360,10 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { check_open_scope(c, pd->type); check_procedure_type(c, proc_type, pd->type); - b32 is_foreign = (pd->tags & ProcTag_foreign) != 0; - b32 is_link_name = (pd->tags & ProcTag_link_name) != 0; - b32 is_inline = (pd->tags & ProcTag_inline) != 0; - b32 is_no_inline = (pd->tags & ProcTag_no_inline) != 0; + bool is_foreign = (pd->tags & ProcTag_foreign) != 0; + bool is_link_name = (pd->tags & ProcTag_link_name) != 0; + bool is_inline = (pd->tags & ProcTag_inline) != 0; + bool is_no_inline = (pd->tags & ProcTag_no_inline) != 0; if ((d->scope->is_file || d->scope->is_global) && str_eq(e->token.string, str_lit("main"))) { @@ -425,7 +409,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { name = proc_decl->foreign_name; } HashKey key = hash_string(name); - auto *found = map_get(fp, key); + Entity **found = map_entity_get(fp, key); if (found) { Entity *f = *found; TokenPos pos = f->token.pos; @@ -438,7 +422,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { LIT(name), LIT(pos.file), pos.line, pos.column); } } else { - map_set(fp, key, e); + map_entity_set(fp, key, e); } } else if (is_link_name) { auto *fp = &c->info.foreign_procs; @@ -446,7 +430,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { String name = proc_decl->link_name; HashKey key = hash_string(name); - auto *found = map_get(fp, key); + Entity **found = map_entity_get(fp, key); if (found) { Entity *f = *found; TokenPos pos = f->token.pos; @@ -455,7 +439,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { "\tother at %.*s(%td:%td)", LIT(name), LIT(pos.file), pos.line, pos.column); } else { - map_set(fp, key, e); + map_entity_set(fp, key, e); } } @@ -463,8 +447,6 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { } void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) { - PROF_PROC(); - GB_ASSERT(e->type == NULL); GB_ASSERT(e->kind == Entity_Variable); @@ -520,7 +502,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod String name = e->token.string; Type *t = base_type(type_deref(e->type)); if (is_type_struct(t) || is_type_raw_union(t)) { - Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node)); + 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; diff --git a/src/checker/entity.cpp b/src/checker/entity.cpp index 4c0e86ab8..2fdc0f480 100644 --- a/src/checker/entity.cpp +++ b/src/checker/entity.cpp @@ -66,7 +66,7 @@ struct Entity { String path; String name; Scope *scope; - b32 used; + bool used; } ImportName; struct {} Nil; struct { @@ -77,7 +77,7 @@ struct Entity { }; }; -b32 is_entity_exported(Entity *e) { +bool is_entity_exported(Entity *e) { if (e->kind == Entity_ImportName) { return false; } @@ -125,7 +125,7 @@ Entity *make_entity_type_name(gbAllocator a, Scope *scope, Token token, Type *ty return entity; } -Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, b32 anonymous) { +Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous) { Entity *entity = make_entity_variable(a, scope, token, type); entity->flags |= EntityFlag_Used; entity->flags |= EntityFlag_Anonymous*(anonymous != 0); @@ -133,7 +133,7 @@ Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, return entity; } -Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, b32 anonymous, i32 field_src_index) { +Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous, i32 field_src_index) { Entity *entity = make_entity_variable(a, scope, token, type); entity->Variable.field_src_index = field_src_index; entity->Variable.field_index = field_src_index; diff --git a/src/checker/expr.cpp b/src/checker/expr.cpp index 787df12e4..e6ddc0d07 100644 --- a/src/checker/expr.cpp +++ b/src/checker/expr.cpp @@ -6,22 +6,22 @@ Type * check_type (Checker *c, AstNode *expression, Type *named void check_type_decl (Checker *c, Entity *e, AstNode *type_expr, Type *def, CycleChecker *cycle_checker); Entity * check_selector (Checker *c, Operand *operand, AstNode *node); void check_not_tuple (Checker *c, Operand *operand); -b32 check_value_is_expressible(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value); +bool check_value_is_expressible(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value); void convert_to_typed (Checker *c, Operand *operand, Type *target_type, i32 level = 0); gbString expr_to_string (AstNode *expression); void check_entity_decl (Checker *c, Entity *e, DeclInfo *decl, Type *named_type, CycleChecker *cycle_checker = NULL); void check_proc_body (Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body); -void update_expr_type (Checker *c, AstNode *e, Type *type, b32 final); +void update_expr_type (Checker *c, AstNode *e, Type *type, bool final); -b32 check_is_assignable_to_using_subtype(Type *dst, Type *src) { +bool check_is_assignable_to_using_subtype(Type *dst, Type *src) { Type *prev_src = src; // Type *prev_dst = dst; src = base_type(type_deref(src)); // dst = base_type(type_deref(dst)); - b32 src_is_ptr = src != prev_src; - // b32 dst_is_ptr = dst != prev_dst; + bool src_is_ptr = src != prev_src; + // bool dst_is_ptr = dst != prev_dst; if (is_type_struct(src)) { for (isize i = 0; i < src->Record.field_count; i++) { @@ -35,7 +35,7 @@ b32 check_is_assignable_to_using_subtype(Type *dst, Type *src) { return true; } } - b32 ok = check_is_assignable_to_using_subtype(dst, f->type); + bool ok = check_is_assignable_to_using_subtype(dst, f->type); if (ok) { return true; } @@ -46,9 +46,7 @@ b32 check_is_assignable_to_using_subtype(Type *dst, Type *src) { } -b32 check_is_assignable_to(Checker *c, Operand *operand, Type *type, b32 is_argument = false) { - PROF_PROC(); - +bool check_is_assignable_to(Checker *c, Operand *operand, Type *type, bool is_argument = false) { if (operand->mode == Addressing_Invalid || type == t_invalid) { return true; @@ -152,9 +150,7 @@ b32 check_is_assignable_to(Checker *c, Operand *operand, Type *type, b32 is_argu // NOTE(bill): `content_name` is for debugging and error messages -void check_assignment(Checker *c, Operand *operand, Type *type, String context_name, b32 is_argument = false) { - PROF_PROC(); - +void check_assignment(Checker *c, Operand *operand, Type *type, String context_name, bool is_argument = false) { check_not_tuple(c, operand); if (operand->mode == Addressing_Invalid) { return; @@ -211,9 +207,7 @@ void check_assignment(Checker *c, Operand *operand, Type *type, String context_n } -void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map<Entity *> *entity_map) { - PROF_PROC(); - +void populate_using_entity_map(Checker *c, AstNode *node, Type *t, MapEntity *entity_map) { t = base_type(type_deref(t)); gbString str = expr_to_string(node); @@ -223,13 +217,13 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, Map<Entity *> GB_ASSERT(f->kind == Entity_Variable); String name = f->token.string; HashKey key = hash_string(name); - Entity **found = map_get(entity_map, key); + Entity **found = map_entity_get(entity_map, key); if (found != NULL) { Entity *e = *found; // TODO(bill): Better type error error(e->token, "`%.*s` is already declared in `%s`", LIT(name), str); } else { - map_set(entity_map, key, f); + map_entity_set(entity_map, key, f); add_entity(c, c->context.scope, NULL, f); if (f->flags & EntityFlag_Anonymous) { populate_using_entity_map(c, node, f->type, entity_map); @@ -247,12 +241,10 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, Entity **fields, isize field_count, Entity **other_fields, isize other_field_count, CycleChecker *cycle_checker, String context) { - PROF_PROC(); - gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); - Map<Entity *> entity_map = {}; - map_init_with_reserve(&entity_map, c->tmp_allocator, 2*(field_count+other_field_count)); + MapEntity entity_map = {}; + map_entity_init_with_reserve(&entity_map, c->tmp_allocator, 2*(field_count+other_field_count)); isize other_field_index = 0; Entity *using_index_expr = NULL; @@ -306,11 +298,11 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, other_fields[other_field_index++] = e; } else { HashKey key = hash_string(name_token.string); - if (map_get(&entity_map, key) != NULL) { + if (map_entity_get(&entity_map, key) != NULL) { // TODO(bill): Scope checking already checks the declaration error(name_token, "`%.*s` is already declared in this structure", LIT(name_token.string)); } else { - map_set(&entity_map, key, e); + map_entity_set(&entity_map, key, e); other_fields[other_field_index++] = e; } add_entity(c, c->context.scope, name, e); @@ -328,11 +320,11 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, other_fields[other_field_index++] = e; } else { HashKey key = hash_string(name_token.string); - if (map_get(&entity_map, key) != NULL) { + if (map_entity_get(&entity_map, key) != NULL) { // TODO(bill): Scope checking already checks the declaration error(name_token, "`%.*s` is already declared in this structure", LIT(name_token.string)); } else { - map_set(&entity_map, key, e); + map_entity_set(&entity_map, key, e); other_fields[other_field_index++] = e; } add_entity(c, c->context.scope, td->name, e); @@ -375,11 +367,11 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, } HashKey key = hash_string(name_token.string); - if (map_get(&entity_map, key) != NULL) { + if (map_entity_get(&entity_map, key) != NULL) { // TODO(bill): Scope checking already checks the declaration error(name_token, "`%.*s` is already declared in this union", LIT(name_token.string)); } else { - map_set(&entity_map, key, e); + map_entity_set(&entity_map, key, e); fields[field_index++] = e; } add_entity_use(c, name, e); @@ -413,11 +405,11 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, fields[field_index++] = e; } else { HashKey key = hash_string(name_token.string); - if (map_get(&entity_map, key) != NULL) { + if (map_entity_get(&entity_map, key) != NULL) { // TODO(bill): Scope checking already checks the declaration error(name_token, "`%.*s` is already declared in this type", LIT(name_token.string)); } else { - map_set(&entity_map, key, e); + map_entity_set(&entity_map, key, e); fields[field_index++] = e; add_entity(c, c->context.scope, name, e); } @@ -431,7 +423,7 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls, if (!is_type_struct(t) && !is_type_raw_union(t)) { Token name_token = vd->names.e[0]->Ident; if (is_type_indexable(t)) { - b32 ok = true; + bool ok = true; for_array(emi, entity_map.entries) { Entity *e = entity_map.entries.e[emi].value; if (e->kind == Entity_Variable && e->flags & EntityFlag_Anonymous) { @@ -497,8 +489,6 @@ GB_COMPARE_PROC(cmp_struct_entity_size) { } void check_struct_type(Checker *c, Type *struct_type, AstNode *node, CycleChecker *cycle_checker) { - PROF_PROC(); - GB_ASSERT(is_type_struct(struct_type)); ast_node(st, StructType, node); @@ -563,8 +553,6 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, CycleChecke } void check_union_type(Checker *c, Type *union_type, AstNode *node, CycleChecker *cycle_checker) { - PROF_PROC(); - GB_ASSERT(is_type_union(union_type)); ast_node(ut, UnionType, node); @@ -599,8 +587,6 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node, CycleChecker } void check_raw_union_type(Checker *c, Type *union_type, AstNode *node, CycleChecker *cycle_checker) { - PROF_PROC(); - GB_ASSERT(node->kind == AstNode_RawUnionType); GB_ASSERT(is_type_raw_union(union_type)); ast_node(ut, RawUnionType, node); @@ -657,8 +643,6 @@ GB_COMPARE_PROC(cmp_enum_order) { void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *node) { - PROF_PROC(); - GB_ASSERT(node->kind == AstNode_EnumType); GB_ASSERT(is_type_enum(enum_type)); ast_node(et, EnumType, node); @@ -693,8 +677,8 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); - Map<Entity *> entity_map = {}; - map_init_with_reserve(&entity_map, c->tmp_allocator, 2*(et->fields.count)); + MapEntity entity_map = {}; + map_entity_init_with_reserve(&entity_map, c->tmp_allocator, 2*(et->fields.count)); Entity *blank_entity = make_entity_constant(c->allocator, c->context.scope, blank_token, constant_type, make_exact_value_integer(0));; @@ -749,11 +733,11 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod } HashKey key = hash_string(name_token.string); - if (map_get(&entity_map, key)) { + if (map_entity_get(&entity_map, key)) { // TODO(bill): Scope checking already checks the declaration error(name_token, "`%.*s` is already declared in this enumeration", LIT(name_token.string)); } else { - map_set(&entity_map, key, e); + map_entity_set(&entity_map, key, e); add_entity(c, c->context.scope, NULL, e); fields[field_index++] = e; } @@ -777,14 +761,12 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod gb_temp_arena_memory_end(tmp); } -Type *check_get_params(Checker *c, Scope *scope, AstNodeArray params, b32 *is_variadic_) { - PROF_PROC(); - +Type *check_get_params(Checker *c, Scope *scope, AstNodeArray params, bool *is_variadic_) { if (params.count == 0) { return NULL; } - b32 is_variadic = false; + bool is_variadic = false; Type *tuple = make_type_tuple(c->allocator); @@ -843,8 +825,6 @@ Type *check_get_params(Checker *c, Scope *scope, AstNodeArray params, b32 *is_va } Type *check_get_results(Checker *c, Scope *scope, AstNodeArray results) { - PROF_PROC(); - if (results.count == 0) { return NULL; } @@ -870,11 +850,9 @@ Type *check_get_results(Checker *c, Scope *scope, AstNodeArray results) { void check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node) { - PROF_PROC(); - ast_node(pt, ProcType, proc_type_node); - b32 variadic = false; + bool variadic = false; Type *params = check_get_params(c, c->context.scope, pt->params, &variadic); Type *results = check_get_results(c, c->context.scope, pt->results); @@ -895,8 +873,6 @@ void check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node) { void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type, CycleChecker *cycle_checker) { - PROF_PROC(); - GB_ASSERT(n->kind == AstNode_Ident); o->mode = Addressing_Invalid; o->expr = n; @@ -1011,8 +987,6 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type, Cycl } i64 check_array_count(Checker *c, AstNode *e) { - PROF_PROC(); - if (e == NULL) { return 0; } @@ -1040,8 +1014,6 @@ i64 check_array_count(Checker *c, AstNode *e) { } Type *check_type(Checker *c, AstNode *e, Type *named_type, CycleChecker *cycle_checker) { - PROF_PROC(); - ExactValue null_value = {ExactValue_Invalid}; Type *type = NULL; gbString err_str = NULL; @@ -1221,7 +1193,7 @@ end: } -b32 check_unary_op(Checker *c, Operand *o, Token op) { +bool check_unary_op(Checker *c, Operand *o, Token op) { // TODO(bill): Handle errors correctly Type *type = base_type(base_vector_type(o->type)); gbString str = NULL; @@ -1257,7 +1229,7 @@ b32 check_unary_op(Checker *c, Operand *o, Token op) { return true; } -b32 check_binary_op(Checker *c, Operand *o, Token op) { +bool check_binary_op(Checker *c, Operand *o, Token op) { // TODO(bill): Handle errors correctly Type *type = base_type(base_vector_type(o->type)); switch (op.kind) { @@ -1331,9 +1303,7 @@ b32 check_binary_op(Checker *c, Operand *o, Token op) { return true; } -b32 check_value_is_expressible(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value) { - PROF_PROC(); - +bool check_value_is_expressible(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value) { if (in_value.kind == ExactValue_Invalid) { // NOTE(bill): There's already been an error return true; @@ -1416,8 +1386,6 @@ b32 check_value_is_expressible(Checker *c, ExactValue in_value, Type *type, Exac } void check_is_expressible(Checker *c, Operand *o, Type *type) { - PROF_PROC(); - GB_ASSERT(type->kind == Type_Basic); GB_ASSERT(o->mode == Addressing_Constant); if (!check_value_is_expressible(c, o->value, type, &o->value)) { @@ -1439,7 +1407,7 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) { } } -b32 check_is_expr_vector_index(Checker *c, AstNode *expr) { +bool check_is_expr_vector_index(Checker *c, AstNode *expr) { // HACK(bill): Handle this correctly. Maybe with a custom AddressingMode expr = unparen_expr(expr); if (expr->kind == AstNode_IndexExpr) { @@ -1452,7 +1420,7 @@ b32 check_is_expr_vector_index(Checker *c, AstNode *expr) { return false; } -b32 check_is_vector_elem(Checker *c, AstNode *expr) { +bool check_is_vector_elem(Checker *c, AstNode *expr) { // HACK(bill): Handle this correctly. Maybe with a custom AddressingMode expr = unparen_expr(expr); if (expr->kind == AstNode_SelectorExpr) { @@ -1466,8 +1434,6 @@ b32 check_is_vector_elem(Checker *c, AstNode *expr) { } void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { - PROF_PROC(); - switch (op.kind) { case Token_Pointer: { // Pointer address if (o->mode != Addressing_Variable || @@ -1487,7 +1453,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { case Token_Maybe: { // Make maybe Type *t = default_type(o->type); - b32 is_value = + bool is_value = o->mode == Addressing_Variable || o->mode == Addressing_Value || o->mode == Addressing_Constant; @@ -1543,8 +1509,6 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) { } void check_comparison(Checker *c, Operand *x, Operand *y, Token op) { - PROF_PROC(); - gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); gbString err_str = NULL; @@ -1552,7 +1516,7 @@ void check_comparison(Checker *c, Operand *x, Operand *y, Token op) { if (check_is_assignable_to(c, x, y->type) || check_is_assignable_to(c, y, x->type)) { Type *err_type = x->type; - b32 defined = false; + bool defined = false; switch (op.kind) { case Token_CmpEq: case Token_NotEq: @@ -1619,8 +1583,6 @@ void check_comparison(Checker *c, Operand *x, Operand *y, Token op) { } void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { - PROF_PROC(); - GB_ASSERT(node->kind == AstNode_BinaryExpr); ast_node(be, BinaryExpr, node); @@ -1629,7 +1591,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { x_val = exact_value_to_integer(x->value); } - b32 x_is_untyped = is_type_untyped(x->type); + bool x_is_untyped = is_type_untyped(x->type); if (!(is_type_integer(x->type) || (x_is_untyped && x_val.kind == ExactValue_Integer))) { gbString err_str = expr_to_string(x->expr); error(ast_node_token(node), @@ -1694,7 +1656,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { } if (x_is_untyped) { - ExpressionInfo *info = map_get(&c->info.untyped, hash_pointer(x->expr)); + ExprInfo *info = map_expr_info_get(&c->info.untyped, hash_pointer(x->expr)); if (info != NULL) { info->is_lhs = true; } @@ -1713,9 +1675,7 @@ void check_shift(Checker *c, Operand *x, Operand *y, AstNode *node) { x->mode = Addressing_Value; } -b32 check_is_castable_to(Checker *c, Operand *operand, Type *y) { - PROF_PROC(); - +bool check_is_castable_to(Checker *c, Operand *operand, Type *y) { if (check_is_assignable_to(c, operand, y)) { return true; } @@ -1848,8 +1808,6 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs } void check_binary_expr(Checker *c, Operand *x, AstNode *node) { - PROF_PROC(); - GB_ASSERT(node->kind == AstNode_BinaryExpr); Operand y_ = {}, *y = &y_; @@ -1862,8 +1820,8 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { return; } - b32 is_const_expr = x->mode == Addressing_Constant; - b32 can_convert = false; + bool is_const_expr = x->mode == Addressing_Constant; + bool can_convert = false; Type *bt = base_type(type); if (is_const_expr && is_type_constant_type(bt)) { @@ -2027,8 +1985,8 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { return; } - b32 src_is_ptr = is_type_pointer(x->type); - b32 dst_is_ptr = is_type_pointer(type); + bool src_is_ptr = is_type_pointer(x->type); + bool dst_is_ptr = is_type_pointer(type); Type *src = type_deref(x->type); Type *dst = type_deref(type); Type *bsrc = base_type(src); @@ -2050,7 +2008,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { return; } - b32 ok = false; + bool ok = false; for (isize i = 1; i < bsrc->Record.field_count; i++) { Entity *f = bsrc->Record.fields[i]; if (are_types_identical(f->type, dst)) { @@ -2163,7 +2121,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { case Token_ModEq: if ((x->mode == Addressing_Constant || is_type_integer(x->type)) && y->mode == Addressing_Constant) { - b32 fail = false; + bool fail = false; switch (y->value.kind) { case ExactValue_Integer: if (y->value.value_integer == 0) { @@ -2226,11 +2184,9 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) { } -void update_expr_type(Checker *c, AstNode *e, Type *type, b32 final) { - PROF_PROC(); - +void update_expr_type(Checker *c, AstNode *e, Type *type, bool final) { HashKey key = hash_pointer(e); - ExpressionInfo *found = map_get(&c->info.untyped, key); + ExprInfo *found = map_expr_info_get(&c->info.untyped, key); if (found == NULL) { return; } @@ -2260,10 +2216,10 @@ void update_expr_type(Checker *c, AstNode *e, Type *type, b32 final) { if (!final && is_type_untyped(type)) { found->type = base_type(type); - map_set(&c->info.untyped, key, *found); + map_expr_info_set(&c->info.untyped, key, *found); } else { - ExpressionInfo old = *found; - map_remove(&c->info.untyped, key); + ExprInfo old = *found; + map_expr_info_remove(&c->info.untyped, key); if (old.is_lhs && !is_type_integer(type)) { gbString expr_str = expr_to_string(e); @@ -2279,7 +2235,7 @@ void update_expr_type(Checker *c, AstNode *e, Type *type, b32 final) { } void update_expr_value(Checker *c, AstNode *e, ExactValue value) { - ExpressionInfo *found = map_get(&c->info.untyped, hash_pointer(e)); + ExprInfo *found = map_expr_info_get(&c->info.untyped, hash_pointer(e)); if (found) { found->value = value; } @@ -2306,8 +2262,6 @@ void convert_untyped_error(Checker *c, Operand *operand, Type *target_type) { } void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level) { - PROF_PROC(); - GB_ASSERT_NOT_NULL(target_type); if (operand->mode == Addressing_Invalid || is_type_typed(operand->type) || @@ -2386,9 +2340,7 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level operand->type = target_type; } -b32 check_index_value(Checker *c, AstNode *index_value, i64 max_count, i64 *value) { - PROF_PROC(); - +bool check_index_value(Checker *c, AstNode *index_value, i64 max_count, i64 *value) { Operand operand = {Addressing_Invalid}; check_expr(c, &operand, index_value); if (operand.mode == Addressing_Invalid) { @@ -2443,11 +2395,9 @@ b32 check_index_value(Checker *c, AstNode *index_value, i64 max_count, i64 *valu } Entity *check_selector(Checker *c, Operand *operand, AstNode *node) { - PROF_PROC(); - ast_node(se, SelectorExpr, node); - b32 check_op_expr = true; + bool check_op_expr = true; Entity *expr_entity = NULL; Entity *entity = NULL; Selection sel = {}; // NOTE(bill): Not used if it's an import name @@ -2478,11 +2428,11 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node) { check_entity_decl(c, entity, NULL, NULL); } GB_ASSERT(entity->type != NULL); - b32 is_not_exported = !is_entity_exported(entity); + bool is_not_exported = !is_entity_exported(entity); // TODO(bill): Fix this for `#import "file.odin" as .` if (is_not_exported) { - auto found = map_get(&e->ImportName.scope->implicit, hash_string(sel_name)); + Entity **found = map_entity_get(&e->ImportName.scope->implicit, hash_string(sel_name)); if (!found && e->ImportName.scope != entity->scope) { is_not_exported = false; } @@ -2577,9 +2527,7 @@ error: return NULL; } -b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id) { - PROF_PROC(); - +bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id) { GB_ASSERT(call->kind == AstNode_CallExpr); ast_node(ce, CallExpr, call); BuiltinProc *bp = &builtin_procs[id]; @@ -3416,15 +3364,13 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id) void check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNode *call) { - PROF_PROC(); - GB_ASSERT(call->kind == AstNode_CallExpr); GB_ASSERT(proc_type->kind == Type_Proc); ast_node(ce, CallExpr, call); isize param_count = 0; - b32 variadic = proc_type->Proc.variadic; - b32 vari_expand = (ce->ellipsis.pos.line != 0); + bool variadic = proc_type->Proc.variadic; + bool vari_expand = (ce->ellipsis.pos.line != 0); if (proc_type->Proc.params != NULL) { param_count = proc_type->Proc.params->Tuple.variable_count; @@ -3501,7 +3447,7 @@ void check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNode } if (variadic) { - b32 variadic_expand = false; + bool variadic_expand = false; Type *slice = sig_params[param_count]->type; GB_ASSERT(is_type_slice(slice)); Type *elem = base_type(slice)->Slice.elem; @@ -3548,8 +3494,6 @@ Entity *find_using_index_expr(Type *t) { } ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) { - PROF_PROC(); - GB_ASSERT(call->kind == AstNode_CallExpr); ast_node(ce, CallExpr, call); check_expr_or_type(c, operand, ce->proc); @@ -3681,11 +3625,9 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint case_end; case_ast_node(cl, CompoundLit, node); - PROF_SCOPED("check__expr_base - CompoundLit"); - Type *type = type_hint; - b32 ellipsis_array = false; - b32 is_constant = true; + bool ellipsis_array = false; + bool is_constant = true; if (cl->type != NULL) { type = NULL; @@ -3722,7 +3664,7 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint { // Checker values isize field_count = t->Record.field_count; if (cl->elems.e[0]->kind == AstNode_FieldValue) { - b32 *fields_visited = gb_alloc_array(c->allocator, b32, field_count); + bool *fields_visited = gb_alloc_array(c->allocator, bool, field_count); for_array(i, cl->elems) { AstNode *elem = cl->elems.e[i]; @@ -3942,18 +3884,16 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint case_ast_node(ie, IndexExpr, node); - PROF_SCOPED("check__expr_base - IndexExpr"); - check_expr(c, o, ie->expr); if (o->mode == Addressing_Invalid) { goto error; } Type *t = base_type(type_deref(o->type)); - b32 is_const = o->mode == Addressing_Constant; + bool is_const = o->mode == Addressing_Constant; - auto set_index_data = [](Operand *o, Type *t, i64 *max_count) -> b32 { + auto set_index_data = [](Operand *o, Type *t, i64 *max_count) -> bool { t = base_type(type_deref(t)); switch (t->kind) { @@ -3997,7 +3937,7 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint }; i64 max_count = -1; - b32 valid = set_index_data(o, t, &max_count); + bool valid = set_index_data(o, t, &max_count); if (is_const) { valid = false; @@ -4029,21 +3969,19 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint } i64 index = 0; - b32 ok = check_index_value(c, ie->index, max_count, &index); + bool ok = check_index_value(c, ie->index, max_count, &index); case_end; case_ast_node(se, SliceExpr, node); - PROF_SCOPED("check__expr_base - SliceExpr"); - check_expr(c, o, se->expr); if (o->mode == Addressing_Invalid) { goto error; } - b32 valid = false; + bool valid = false; i64 max_count = -1; Type *t = base_type(type_deref(o->type)); switch (t->kind) { diff --git a/src/checker/stmt.cpp b/src/checker/stmt.cpp index ad7778f9f..9a5f820cf 100644 --- a/src/checker/stmt.cpp +++ b/src/checker/stmt.cpp @@ -1,5 +1,5 @@ -b32 check_is_terminating(AstNode *node); -b32 check_has_break (AstNode *stmt, b32 implicit); +bool check_is_terminating(AstNode *node); +bool check_has_break (AstNode *stmt, bool implicit); void check_stmt (Checker *c, AstNode *node, u32 flags); @@ -80,7 +80,7 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { check_entity_decl(c, delayed_const.e[i].e, delayed_const.e[i].d, NULL); } - b32 ft_ok = (flags & Stmt_FallthroughAllowed) != 0; + bool ft_ok = (flags & Stmt_FallthroughAllowed) != 0; u32 f = flags & (~Stmt_FallthroughAllowed); for_array(i, stmts) { @@ -98,7 +98,7 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { gb_temp_arena_memory_end(tmp); } -b32 check_is_terminating_list(AstNodeArray stmts) { +bool check_is_terminating_list(AstNodeArray stmts) { // Iterate backwards for (isize n = stmts.count-1; n >= 0; n--) { @@ -111,7 +111,7 @@ b32 check_is_terminating_list(AstNodeArray stmts) { return false; } -b32 check_has_break_list(AstNodeArray stmts, b32 implicit) { +bool check_has_break_list(AstNodeArray stmts, bool implicit) { for_array(i, stmts) { AstNode *stmt = stmts.e[i]; if (check_has_break(stmt, implicit)) { @@ -122,9 +122,7 @@ b32 check_has_break_list(AstNodeArray stmts, b32 implicit) { } -b32 check_has_break(AstNode *stmt, b32 implicit) { - PROF_PROC(); - +bool check_has_break(AstNode *stmt, bool implicit) { switch (stmt->kind) { case AstNode_BranchStmt: if (stmt->BranchStmt.token.kind == Token_break) { @@ -153,9 +151,7 @@ b32 check_has_break(AstNode *stmt, b32 implicit) { // NOTE(bill): The last expression has to be a `return` statement // TODO(bill): This is a mild hack and should be probably handled properly // TODO(bill): Warn/err against code after `return` that it won't be executed -b32 check_is_terminating(AstNode *node) { - PROF_PROC(); - +bool check_is_terminating(AstNode *node) { switch (node->kind) { case_ast_node(rs, ReturnStmt, node); return true; @@ -185,7 +181,7 @@ b32 check_is_terminating(AstNode *node) { case_end; case_ast_node(ms, MatchStmt, node); - b32 has_default = false; + bool has_default = false; for_array(i, ms->body->BlockStmt.stmts) { AstNode *clause = ms->body->BlockStmt.stmts.e[i]; ast_node(cc, CaseClause, clause); @@ -201,7 +197,7 @@ b32 check_is_terminating(AstNode *node) { case_end; case_ast_node(ms, TypeMatchStmt, node); - b32 has_default = false; + bool has_default = false; for_array(i, ms->body->BlockStmt.stmts) { AstNode *clause = ms->body->BlockStmt.stmts.e[i]; ast_node(cc, CaseClause, clause); @@ -228,8 +224,6 @@ b32 check_is_terminating(AstNode *node) { } Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) { - PROF_PROC(); - if (op_a->mode == Addressing_Invalid || op_a->type == t_invalid) { return NULL; @@ -248,7 +242,7 @@ Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) { } Entity *e = NULL; - b32 used = false; + bool used = false; if (node->kind == AstNode_Ident) { ast_node(i, Ident, node); e = scope_lookup_entity(c->context.scope, i->string); @@ -303,7 +297,7 @@ Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) { return op_a->type; } -b32 check_valid_type_match_type(Type *type, b32 *is_union_ptr, b32 *is_any) { +bool check_valid_type_match_type(Type *type, bool *is_union_ptr, bool *is_any) { if (is_type_pointer(type)) { *is_union_ptr = is_type_union(type_deref(type)); return *is_union_ptr; @@ -339,6 +333,16 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) { c->context.stmt_state_flags = prev_stmt_state_flags; } +typedef struct TypeAndToken { + Type *type; + Token token; +} TypeAndToken; + +#define MAP_TYPE TypeAndToken +#define MAP_FUNC map_type_and_token_ +#define MAP_NAME MapTypeAndToken +#include "../map.c" + void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { u32 mod_flags = flags & (~Stmt_FallthroughAllowed); switch (node->kind) { @@ -347,8 +351,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_ast_node(_, BadDecl, node); case_end; case_ast_node(es, ExprStmt, node) - PROF_SCOPED("check_stmt - ExprStmt"); - Operand operand = {Addressing_Invalid}; ExprKind kind = check_expr_base(c, &operand, es->expr); switch (operand.mode) { @@ -378,8 +380,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(ids, IncDecStmt, node); - PROF_SCOPED("check_stmt - IncDecStmt"); - Token op = ids->op; switch (ids->op.kind) { case Token_Increment: @@ -419,8 +419,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(as, AssignStmt, node); - PROF_SCOPED("check_stmt - AssignStmt"); - switch (as->op.kind) { case Token_Eq: { // a, b, c = 1, 2, 3; // Multisided @@ -504,8 +502,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(is, IfStmt, node); - PROF_SCOPED("check_stmt - IfStmt"); - check_open_scope(c, node); if (is->init != NULL) { @@ -539,8 +535,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(rs, ReturnStmt, node); - PROF_SCOPED("check_stmt - ReturnStmt"); - GB_ASSERT(c->proc_stack.count > 0); if (c->in_defer) { @@ -574,8 +568,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(fs, ForStmt, node); - PROF_SCOPED("check_stmt - ForStmt"); - u32 new_flags = mod_flags | Stmt_BreakAllowed | Stmt_ContinueAllowed; check_open_scope(c, node); @@ -600,8 +592,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(ms, MatchStmt, node); - PROF_SCOPED("check_stmt - MatchStmt"); - Operand x = {}; mod_flags |= Stmt_BreakAllowed; @@ -650,15 +640,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } } } +; - - struct TypeAndToken { - Type *type; - Token token; - }; - - Map<TypeAndToken> seen = {}; // NOTE(bill): Multimap - map_init(&seen, heap_allocator()); + MapTypeAndToken seen = {}; // NOTE(bill): Multimap + map_type_and_token_init(&seen, heap_allocator()); for_array(i, bs->stmts) { AstNode *stmt = bs->stmts.e[i]; @@ -696,14 +681,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (y.value.kind != ExactValue_Invalid) { HashKey key = hash_exact_value(y.value); - auto *found = map_get(&seen, key); + TypeAndToken *found = map_type_and_token_get(&seen, key); if (found != NULL) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); - isize count = multi_map_count(&seen, key); + isize count = map_type_and_token_multi_count(&seen, key); TypeAndToken *taps = gb_alloc_array(c->tmp_allocator, TypeAndToken, count); - multi_map_get_all(&seen, key, taps); - b32 continue_outer = false; + map_type_and_token_multi_get_all(&seen, key, taps); + bool continue_outer = false; for (isize i = 0; i < count; i++) { TypeAndToken tap = taps[i]; @@ -728,7 +713,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } } TypeAndToken tap = {y.type, ast_node_token(y.expr)}; - multi_map_insert(&seen, key, tap); + map_type_and_token_multi_insert(&seen, key, tap); } } @@ -741,21 +726,19 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_close_scope(c); } - map_destroy(&seen); + map_type_and_token_destroy(&seen); check_close_scope(c); case_end; case_ast_node(ms, TypeMatchStmt, node); - PROF_SCOPED("check_stmt - TypeMatchStmt"); - Operand x = {}; mod_flags |= Stmt_BreakAllowed; check_open_scope(c, node); - b32 is_union_ptr = false; - b32 is_any = false; + bool is_union_ptr = false; + bool is_any = false; check_expr(c, &x, ms->tag); check_assignment(c, &x, NULL, str_lit("type match expression")); @@ -800,8 +783,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } - Map<b32> seen = {}; - map_init(&seen, heap_allocator()); + MapBool seen = {}; + map_bool_init(&seen, heap_allocator()); for_array(i, bs->stmts) { AstNode *stmt = bs->stmts.e[i]; @@ -823,7 +806,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_union_ptr) { GB_ASSERT(is_type_union(bt)); - b32 tag_type_found = false; + bool tag_type_found = false; for (isize i = 0; i < bt->Record.field_count; i++) { Entity *f = bt->Record.fields[i]; if (are_types_identical(f->type, y.type)) { @@ -846,7 +829,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { } HashKey key = hash_pointer(y.type); - auto *found = map_get(&seen, key); + bool *found = map_bool_get(&seen, key); if (found) { TokenPos pos = cc->token.pos; gbString expr_str = expr_to_string(y.expr); @@ -858,7 +841,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { gb_string_free(expr_str); break; } - map_set(&seen, key, cast(b32)true); + map_bool_set(&seen, key, cast(bool)true); } check_open_scope(c, stmt); @@ -879,7 +862,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_stmt_list(c, cc->stmts, mod_flags); check_close_scope(c); } - map_destroy(&seen); + map_bool_destroy(&seen); check_close_scope(c); case_end; @@ -889,7 +872,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { if (is_ast_node_decl(ds->stmt)) { error(ds->token, "You cannot defer a declaration"); } else { - b32 out_in_defer = c->in_defer; + bool out_in_defer = c->in_defer; c->in_defer = true; check_stmt(c, ds->stmt, 0); c->in_defer = out_in_defer; @@ -921,14 +904,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(us, UsingStmt, node); - PROF_SCOPED("check_stmt - UsingStmt"); - switch (us->node->kind) { case_ast_node(es, ExprStmt, us->node); // TODO(bill): Allow for just a LHS expression list rather than this silly code Entity *e = NULL; - b32 is_selector = false; + bool is_selector = false; AstNode *expr = unparen_expr(es->expr); if (expr->kind == AstNode_Ident) { String name = expr->Ident.string; @@ -1009,7 +990,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case Entity_Variable: { Type *t = base_type(type_deref(e->type)); if (is_type_struct(t) || is_type_raw_union(t)) { - Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node)); + 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; @@ -1060,8 +1041,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(vd, VarDecl, us->node); - PROF_SCOPED("check_stmt - VarDecl"); - if (vd->names.count > 1 && vd->type != NULL) { error(us->token, "`using` can only be applied to one variable of the same type"); } @@ -1074,7 +1053,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { Entity *e = scope_lookup_entity(c->context.scope, name); Type *t = base_type(type_deref(e->type)); if (is_type_struct(t) || is_type_raw_union(t)) { - Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node)); + 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; @@ -1136,8 +1115,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { case_end; case_ast_node(pd, ProcDecl, node); - PROF_SCOPED("check_stmt - ProcDecl"); - // NOTE(bill): This must be handled here so it has access to the parent scope stuff // e.g. using Entity *e = make_entity_procedure(c->allocator, c->context.scope, pd->name->Ident, NULL); diff --git a/src/checker/types.cpp b/src/checker/types.cpp index 8e814b9b6..fc756ad52 100644 --- a/src/checker/types.cpp +++ b/src/checker/types.cpp @@ -136,9 +136,9 @@ struct Type { }; struct { // struct only i64 * struct_offsets; - b32 struct_are_offsets_set; - b32 struct_is_packed; - b32 struct_is_ordered; + bool struct_are_offsets_set; + bool struct_is_packed; + bool struct_is_ordered; Entity **fields_in_src_order; // Entity_Variable }; }; @@ -155,7 +155,7 @@ struct Type { struct { Entity **variables; // Entity_Variable i32 variable_count; - b32 are_offsets_set; + bool are_offsets_set; i64 * offsets; } Tuple; struct { @@ -164,7 +164,7 @@ struct Type { Type * results; // Type_Tuple i32 param_count; i32 result_count; - b32 variadic; + bool variadic; } Proc; }; }; @@ -378,7 +378,7 @@ Type *make_type_tuple(gbAllocator a) { return t; } -Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_count, Type *results, isize result_count, b32 variadic) { +Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_count, Type *results, isize result_count, bool variadic) { Type *t = alloc_type(a, Type_Proc); if (variadic) { @@ -423,34 +423,34 @@ Type *get_enum_base_type(Type *t) { return t; } -b32 is_type_named(Type *t) { +bool is_type_named(Type *t) { if (t->kind == Type_Basic) { return true; } return t->kind == Type_Named; } -b32 is_type_boolean(Type *t) { +bool is_type_boolean(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Boolean) != 0; } return false; } -b32 is_type_integer(Type *t) { +bool is_type_integer(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Integer) != 0; } return false; } -b32 is_type_unsigned(Type *t) { +bool is_type_unsigned(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Unsigned) != 0; } return false; } -b32 is_type_numeric(Type *t) { +bool is_type_numeric(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Numeric) != 0; @@ -460,28 +460,28 @@ b32 is_type_numeric(Type *t) { } return false; } -b32 is_type_string(Type *t) { +bool is_type_string(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_String) != 0; } return false; } -b32 is_type_typed(Type *t) { +bool is_type_typed(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Untyped) == 0; } return true; } -b32 is_type_untyped(Type *t) { +bool is_type_untyped(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Untyped) != 0; } return false; } -b32 is_type_ordered(Type *t) { +bool is_type_ordered(Type *t) { t = base_type(get_enum_base_type(t)); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Ordered) != 0; @@ -491,7 +491,7 @@ b32 is_type_ordered(Type *t) { } return false; } -b32 is_type_constant_type(Type *t) { +bool is_type_constant_type(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_ConstantType) != 0; @@ -501,82 +501,82 @@ b32 is_type_constant_type(Type *t) { } return false; } -b32 is_type_float(Type *t) { +bool is_type_float(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Float) != 0; } return false; } -b32 is_type_f32(Type *t) { +bool is_type_f32(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return t->Basic.kind == Basic_f32; } return false; } -b32 is_type_f64(Type *t) { +bool is_type_f64(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return t->Basic.kind == Basic_f64; } return false; } -b32 is_type_pointer(Type *t) { +bool is_type_pointer(Type *t) { t = base_type(t); if (t->kind == Type_Basic) { return (t->Basic.flags & BasicFlag_Pointer) != 0; } return t->kind == Type_Pointer; } -b32 is_type_maybe(Type *t) { +bool is_type_maybe(Type *t) { t = base_type(t); return t->kind == Type_Maybe; } -b32 is_type_tuple(Type *t) { +bool is_type_tuple(Type *t) { t = base_type(t); return t->kind == Type_Tuple; } -b32 is_type_int_or_uint(Type *t) { +bool is_type_int_or_uint(Type *t) { if (t->kind == Type_Basic) { return (t->Basic.kind == Basic_int) || (t->Basic.kind == Basic_uint); } return false; } -b32 is_type_rawptr(Type *t) { +bool is_type_rawptr(Type *t) { if (t->kind == Type_Basic) { return t->Basic.kind == Basic_rawptr; } return false; } -b32 is_type_u8(Type *t) { +bool is_type_u8(Type *t) { if (t->kind == Type_Basic) { return t->Basic.kind == Basic_u8; } return false; } -b32 is_type_array(Type *t) { +bool is_type_array(Type *t) { t = base_type(t); return t->kind == Type_Array; } -b32 is_type_slice(Type *t) { +bool is_type_slice(Type *t) { t = base_type(t); return t->kind == Type_Slice; } -b32 is_type_u8_slice(Type *t) { +bool is_type_u8_slice(Type *t) { t = base_type(t); if (t->kind == Type_Slice) { return is_type_u8(t->Slice.elem); } return false; } -b32 is_type_vector(Type *t) { +bool is_type_vector(Type *t) { t = base_type(t); return t->kind == Type_Vector; } -b32 is_type_proc(Type *t) { +bool is_type_proc(Type *t) { t = base_type(t); return t->kind == Type_Proc; } @@ -589,40 +589,40 @@ Type *base_vector_type(Type *t) { } -b32 is_type_enum(Type *t) { +bool is_type_enum(Type *t) { t = base_type(t); return (t->kind == Type_Record && t->Record.kind == TypeRecord_Enum); } -b32 is_type_struct(Type *t) { +bool is_type_struct(Type *t) { t = base_type(t); return (t->kind == Type_Record && t->Record.kind == TypeRecord_Struct); } -b32 is_type_union(Type *t) { +bool is_type_union(Type *t) { t = base_type(t); return (t->kind == Type_Record && t->Record.kind == TypeRecord_Union); } -b32 is_type_raw_union(Type *t) { +bool is_type_raw_union(Type *t) { t = base_type(t); return (t->kind == Type_Record && t->Record.kind == TypeRecord_RawUnion); } -b32 is_type_any(Type *t) { +bool is_type_any(Type *t) { t = base_type(t); return (t->kind == Type_Basic && t->Basic.kind == Basic_any); } -b32 is_type_untyped_nil(Type *t) { +bool is_type_untyped_nil(Type *t) { t = base_type(t); return (t->kind == Type_Basic && t->Basic.kind == Basic_UntypedNil); } -b32 is_type_indexable(Type *t) { +bool is_type_indexable(Type *t) { return is_type_array(t) || is_type_slice(t) || is_type_vector(t) || is_type_string(t); } -b32 type_has_nil(Type *t) { +bool type_has_nil(Type *t) { t = base_type(t); switch (t->kind) { case Type_Basic: @@ -642,7 +642,7 @@ b32 type_has_nil(Type *t) { } -b32 is_type_comparable(Type *t) { +bool is_type_comparable(Type *t) { t = base_type(get_enum_base_type(t)); switch (t->kind) { case Type_Basic: @@ -671,7 +671,7 @@ b32 is_type_comparable(Type *t) { return false; } -b32 are_types_identical(Type *x, Type *y) { +bool are_types_identical(Type *x, Type *y) { if (x == y) return true; @@ -810,11 +810,11 @@ typedef Array(isize) Array_isize; struct Selection { Entity * entity; Array_isize index; - b32 indirect; // Set if there was a pointer deref anywhere down the line + bool indirect; // Set if there was a pointer deref anywhere down the line }; Selection empty_selection = {}; -Selection make_selection(Entity *entity, Array_isize index, b32 indirect) { +Selection make_selection(Entity *entity, Array_isize index, bool indirect) { Selection s = {entity, index, indirect}; return s; } @@ -835,7 +835,7 @@ gb_global Entity *entity__string_count = NULL; gb_global Entity *entity__slice_count = NULL; gb_global Entity *entity__slice_capacity = NULL; -Selection lookup_field(gbAllocator a, Type *type_, String field_name, b32 is_type, Selection sel = empty_selection) { +Selection lookup_field(gbAllocator a, Type *type_, String field_name, bool is_type, Selection sel = empty_selection) { GB_ASSERT(type_ != NULL); if (str_eq(field_name, str_lit("_"))) { @@ -843,7 +843,7 @@ Selection lookup_field(gbAllocator a, Type *type_, String field_name, b32 is_typ } Type *type = type_deref(type_); - b32 is_ptr = type != type_; + bool is_ptr = type != type_; sel.indirect = sel.indirect || is_ptr; type = base_type(type); @@ -1131,7 +1131,7 @@ i64 type_align_of(BaseTypeSizes s, gbAllocator allocator, Type *t) { return gb_clamp(next_pow2(type_size_of(s, allocator, t)), 1, s.word_size); } -i64 *type_set_offsets_of(BaseTypeSizes s, gbAllocator allocator, Entity **fields, isize field_count, b32 is_packed) { +i64 *type_set_offsets_of(BaseTypeSizes s, gbAllocator allocator, Entity **fields, isize field_count, bool is_packed) { i64 *offsets = gb_alloc_array(allocator, i64, field_count); i64 curr_offset = 0; if (is_packed) { @@ -1151,7 +1151,7 @@ i64 *type_set_offsets_of(BaseTypeSizes s, gbAllocator allocator, Entity **fields return offsets; } -b32 type_set_offsets(BaseTypeSizes s, gbAllocator allocator, Type *t) { +bool type_set_offsets(BaseTypeSizes s, gbAllocator allocator, Type *t) { t = base_type(t); if (is_type_struct(t)) { if (!t->Record.struct_are_offsets_set) { diff --git a/src/common.cpp b/src/common.cpp index e61ebaa98..93f5e6d00 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -10,7 +10,7 @@ gbAllocator heap_allocator(void) { #include "array.cpp" gb_global String global_module_path = {0}; -gb_global b32 global_module_path_set = false; +gb_global bool global_module_path_set = false; String get_module_dir() { @@ -74,20 +74,20 @@ String path_to_fullpath(gbAllocator a, String s) { } // Hasing -enum HashKeyKind { +typedef enum HashKeyKind { HashKey_Default, HashKey_String, HashKey_Pointer, -}; +} HashKeyKind; -struct HashKey { +typedef struct HashKey { HashKeyKind kind; u64 key; union { String string; // if String, s.len > 0 void * ptr; }; -}; +} HashKey; gb_inline HashKey hashing_proc(void const *data, isize len) { HashKey h = {HashKey_Default}; @@ -112,7 +112,7 @@ gb_inline HashKey hash_pointer(void *ptr) { return h; } -b32 hash_key_equal(HashKey a, HashKey b) { +bool hash_key_equal(HashKey a, HashKey b) { if (a.key == b.key) { // NOTE(bill): If two string's hashes collide, compare the strings themselves if (a.kind == HashKey_String) { @@ -232,13 +232,32 @@ i16 f32_to_f16(f32 value) { //////////////////////////////////////////////////////////////// +#define MAP_TYPE String +#define MAP_FUNC map_string_ +#define MAP_NAME MapString +#include "map.c" + +#define MAP_TYPE bool +#define MAP_FUNC map_bool_ +#define MAP_NAME MapBool +#include "map.c" +#define MAP_TYPE isize +#define MAP_FUNC map_isize_ +#define MAP_NAME MapIsize +#include "map.c" -struct MapFindResult { + +#if 0 +#ifndef MAP_FIND_RESULT +#define MAP_FIND_RESULT +typedef struct MapFindResult { isize hash_index; isize entry_prev; isize entry_index; -}; +} MapFindResult; +#endif + template <typename T> struct MapEntry { @@ -338,7 +357,7 @@ gb_internal MapFindResult map__find(Map<T> *h, MapEntry<T> *e) { template <typename T> -gb_internal b32 map__full(Map<T> *h) { +gb_internal bool map__full(Map<T> *h) { return 0.75f * h->hashes.count <= h->entries.count; } @@ -529,3 +548,4 @@ void multi_map_remove_all(Map<T> *h, HashKey key) { +#endif diff --git a/src/exact_value.cpp b/src/exact_value.cpp index 15d03ba2b..890a0f33e 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -21,7 +21,7 @@ enum ExactValueKind { struct ExactValue { ExactValueKind kind; union { - b32 value_bool; + bool value_bool; String value_string; i64 value_integer; // NOTE(bill): This must be an integer and not a pointer f64 value_float; @@ -41,7 +41,7 @@ ExactValue make_exact_value_compound(AstNode *node) { return result; } -ExactValue make_exact_value_bool(b32 b) { +ExactValue make_exact_value_bool(bool b) { ExactValue result = {ExactValue_Bool}; result.value_bool = (b != 0); return result; @@ -339,7 +339,7 @@ i32 cmp_f64(f64 a, f64 b) { return (a > b) - (a < b); } -b32 compare_exact_values(Token op, ExactValue x, ExactValue y) { +bool compare_exact_values(Token op, ExactValue x, ExactValue y) { match_exact_values(&x, &y); switch (x.kind) { diff --git a/src/main.cpp b/src/main.cpp index bb5232c81..75505e7e0 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,7 +1,6 @@ #define VERSION_STRING "v0.0.3" #include "common.cpp" -#include "profiler.cpp" #include "timings.cpp" #include "unicode.cpp" #include "tokenizer.cpp" @@ -107,7 +106,6 @@ int main(int argc, char **argv) { usage(argv[0]); return 1; } - prof_init(); Timings timings = {0}; timings_init(&timings, str_lit("Total Time"), 128); @@ -122,7 +120,7 @@ int main(int argc, char **argv) { init_universal_scope(); char *init_filename = NULL; - b32 run_output = false; + bool run_output = false; String arg1 = make_string_c(argv[1]); if (str_eq(arg1, str_lit("run"))) { run_output = true; diff --git a/src/parser.cpp b/src/parser.cpp index 9956f5e3c..a55435581 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -32,7 +32,7 @@ struct AstFile { isize expr_level; AstNodeArray decls; - b32 is_global_scope; + bool is_global_scope; AstNode * curr_proc; isize scope_level; @@ -140,7 +140,7 @@ AST_NODE_KIND(_ExprBegin, "", struct{}) \ AstNode *expr; \ Token open, close; \ AstNode *low, *high, *max; \ - b32 triple_indexed; \ + bool triple_indexed; \ }) \ AST_NODE_KIND(FieldValue, "field value", struct { Token eq; AstNode *field, *value; }) \ AST_NODE_KIND(_ExprEnd, "", struct{}) \ @@ -202,7 +202,7 @@ AST_NODE_KIND(_ComplexStmtBegin, "", struct{}) \ }) \ AST_NODE_KIND(AsmStmt, "assembly statement", struct { \ Token token; \ - b32 is_volatile; \ + bool is_volatile; \ Token open, close; \ Token code_string; \ AstNode *output_list; \ @@ -227,7 +227,7 @@ AST_NODE_KIND(_DeclBegin, "", struct{}) \ AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ AST_NODE_KIND(VarDecl, "variable declaration", struct { \ u64 tags; \ - b32 is_using; \ + bool is_using; \ AstNodeArray names; \ AstNode * type; \ AstNodeArray values; \ @@ -258,19 +258,19 @@ AST_NODE_KIND(_DeclBegin, "", struct{}) \ Token token, relpath; \ String fullpath; \ Token import_name; \ - b32 is_load; \ + bool is_load; \ AstNode *note; \ }) \ AST_NODE_KIND(ForeignLibrary, "foreign library", struct { \ Token token, filepath; \ - b32 is_system; \ + bool is_system; \ }) \ AST_NODE_KIND(_DeclEnd, "", struct{}) \ AST_NODE_KIND(_TypeBegin, "", struct{}) \ AST_NODE_KIND(Parameter, "parameter", struct { \ AstNodeArray names; \ AstNode *type; \ - b32 is_using; \ + bool is_using; \ }) \ AST_NODE_KIND(ProcType, "procedure type", struct { \ Token token; \ @@ -299,8 +299,8 @@ AST_NODE_KIND(_TypeBegin, "", struct{}) \ Token token; \ AstNodeArray decls; \ isize decl_count; \ - b32 is_packed; \ - b32 is_ordered; \ + bool is_packed; \ + bool is_ordered; \ }) \ AST_NODE_KIND(UnionType, "union type", struct { \ Token token; \ @@ -355,19 +355,19 @@ struct AstNode { -gb_inline b32 is_ast_node_expr(AstNode *node) { +gb_inline bool is_ast_node_expr(AstNode *node) { return gb_is_between(node->kind, AstNode__ExprBegin+1, AstNode__ExprEnd-1); } -gb_inline b32 is_ast_node_stmt(AstNode *node) { +gb_inline bool is_ast_node_stmt(AstNode *node) { return gb_is_between(node->kind, AstNode__StmtBegin+1, AstNode__StmtEnd-1); } -gb_inline b32 is_ast_node_complex_stmt(AstNode *node) { +gb_inline bool is_ast_node_complex_stmt(AstNode *node) { return gb_is_between(node->kind, AstNode__ComplexStmtBegin+1, AstNode__ComplexStmtEnd-1); } -gb_inline b32 is_ast_node_decl(AstNode *node) { +gb_inline bool is_ast_node_decl(AstNode *node) { return gb_is_between(node->kind, AstNode__DeclBegin+1, AstNode__DeclEnd-1); } -gb_inline b32 is_ast_node_type(AstNode *node) { +gb_inline bool is_ast_node_type(AstNode *node) { return gb_is_between(node->kind, AstNode__TypeBegin+1, AstNode__TypeEnd-1); } @@ -598,7 +598,7 @@ AstNode *make_index_expr(AstFile *f, AstNode *expr, AstNode *index, Token open, } -AstNode *make_slice_expr(AstFile *f, AstNode *expr, Token open, Token close, AstNode *low, AstNode *high, AstNode *max, b32 triple_indexed) { +AstNode *make_slice_expr(AstFile *f, AstNode *expr, Token open, Token close, AstNode *low, AstNode *high, AstNode *max, bool triple_indexed) { AstNode *result = make_node(f, AstNode_SliceExpr); result->SliceExpr.expr = expr; result->SliceExpr.open = open; @@ -796,7 +796,7 @@ AstNode *make_asm_operand(AstFile *f, Token string, AstNode *operand) { } -AstNode *make_asm_stmt(AstFile *f, Token token, b32 is_volatile, Token open, Token close, Token code_string, +AstNode *make_asm_stmt(AstFile *f, Token token, bool is_volatile, Token open, Token close, Token code_string, AstNode *output_list, AstNode *input_list, AstNode *clobber_list, isize output_count, isize input_count, isize clobber_count) { AstNode *result = make_node(f, AstNode_AsmStmt); @@ -856,7 +856,7 @@ AstNode *make_const_decl(AstFile *f, AstNodeArray names, AstNode *type, AstNodeA return result; } -AstNode *make_parameter(AstFile *f, AstNodeArray names, AstNode *type, b32 is_using) { +AstNode *make_parameter(AstFile *f, AstNodeArray names, AstNode *type, bool is_using) { AstNode *result = make_node(f, AstNode_Parameter); result->Parameter.names = names; result->Parameter.type = type; @@ -913,7 +913,7 @@ AstNode *make_vector_type(AstFile *f, Token token, AstNode *count, AstNode *elem return result; } -AstNode *make_struct_type(AstFile *f, Token token, AstNodeArray decls, isize decl_count, b32 is_packed, b32 is_ordered) { +AstNode *make_struct_type(AstFile *f, Token token, AstNodeArray decls, isize decl_count, bool is_packed, bool is_ordered) { AstNode *result = make_node(f, AstNode_StructType); result->StructType.token = token; result->StructType.decls = decls; @@ -957,7 +957,7 @@ AstNode *make_type_decl(AstFile *f, Token token, AstNode *name, AstNode *type) { return result; } -AstNode *make_import_decl(AstFile *f, Token token, Token relpath, Token import_name, b32 is_load) { +AstNode *make_import_decl(AstFile *f, Token token, Token relpath, Token import_name, bool is_load) { AstNode *result = make_node(f, AstNode_ImportDecl); result->ImportDecl.token = token; result->ImportDecl.relpath = relpath; @@ -966,7 +966,7 @@ AstNode *make_import_decl(AstFile *f, Token token, Token relpath, Token import_n return result; } -AstNode *make_foreign_library(AstFile *f, Token token, Token filepath, b32 is_system) { +AstNode *make_foreign_library(AstFile *f, Token token, Token filepath, bool is_system) { AstNode *result = make_node(f, AstNode_ForeignLibrary); result->ForeignLibrary.token = token; result->ForeignLibrary.filepath = filepath; @@ -974,7 +974,7 @@ AstNode *make_foreign_library(AstFile *f, Token token, Token filepath, b32 is_sy return result; } -b32 next_token(AstFile *f) { +bool next_token(AstFile *f) { if (f->curr_token_index+1 < f->tokens.count) { if (f->curr_token.kind != Token_Comment) { f->prev_token = f->curr_token; @@ -1035,7 +1035,7 @@ Token expect_keyword(AstFile *f) { return prev; } -b32 allow_token(AstFile *f, TokenKind kind) { +bool allow_token(AstFile *f, TokenKind kind) { Token prev = f->curr_token; if (prev.kind == kind) { next_token(f); @@ -1045,7 +1045,7 @@ b32 allow_token(AstFile *f, TokenKind kind) { } -b32 is_blank_ident(String str) { +bool is_blank_ident(String str) { if (str.len == 1) { return str.text[0] == '_'; } @@ -1099,7 +1099,7 @@ void fix_advance_to_next_stmt(AstFile *f) { #endif } -b32 expect_semicolon_after_stmt(AstFile *f, AstNode *s) { +bool expect_semicolon_after_stmt(AstFile *f, AstNode *s) { if (allow_token(f, Token_Semicolon)) { return true; } @@ -1122,7 +1122,7 @@ b32 expect_semicolon_after_stmt(AstFile *f, AstNode *s) { } -AstNode * parse_expr(AstFile *f, b32 lhs); +AstNode * parse_expr(AstFile *f, bool lhs); AstNode * parse_proc_type(AstFile *f); AstNodeArray parse_stmt_list(AstFile *f); AstNode * parse_stmt(AstFile *f); @@ -1215,7 +1215,7 @@ void check_proc_add_tag(AstFile *f, AstNode *tag_expr, u64 *tags, ProcTag tag, S *tags |= tag; } -b32 is_foreign_name_valid(String name) { +bool is_foreign_name_valid(String name) { // TODO(bill): is_foreign_name_valid if (name.len == 0) return false; @@ -1340,7 +1340,7 @@ void parse_proc_tags(AstFile *f, u64 *tags, String *foreign_name, String *link_n } } -AstNode *parse_operand(AstFile *f, b32 lhs) { +AstNode *parse_operand(AstFile *f, bool lhs) { AstNode *operand = NULL; // Operand switch (f->curr_token.kind) { case Token_Identifier: @@ -1456,7 +1456,7 @@ AstNode *parse_operand(AstFile *f, b32 lhs) { return make_bad_expr(f, begin, f->curr_token); } -b32 is_literal_type(AstNode *node) { +bool is_literal_type(AstNode *node) { switch (node->kind) { case AstNode_BadExpr: case AstNode_Ident: @@ -1505,10 +1505,10 @@ AstNode *parse_call_expr(AstFile *f, AstNode *operand) { return make_call_expr(f, operand, args, open_paren, close_paren, ellipsis); } -AstNode *parse_atom_expr(AstFile *f, b32 lhs) { +AstNode *parse_atom_expr(AstFile *f, bool lhs) { AstNode *operand = parse_operand(f, lhs); - b32 loop = true; + bool loop = true; while (loop) { switch (f->curr_token.kind) { @@ -1580,7 +1580,7 @@ AstNode *parse_atom_expr(AstFile *f, b32 lhs) { if (colon_count == 0) { operand = make_index_expr(f, operand, indices[0], open, close); } else { - b32 triple_indexed = false; + bool triple_indexed = false; if (colon_count == 2) { triple_indexed = true; if (indices[1] == NULL) { @@ -1632,7 +1632,7 @@ AstNode *parse_atom_expr(AstFile *f, b32 lhs) { AstNode *parse_type(AstFile *f); -AstNode *parse_unary_expr(AstFile *f, b32 lhs) { +AstNode *parse_unary_expr(AstFile *f, bool lhs) { switch (f->curr_token.kind) { case Token_Pointer: case Token_Maybe: @@ -1690,7 +1690,7 @@ i32 token_precedence(Token t) { return 0; } -AstNode *parse_binary_expr(AstFile *f, b32 lhs, i32 prec_in) { +AstNode *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) { AstNode *expression = parse_unary_expr(f, lhs); for (i32 prec = token_precedence(f->curr_token); prec >= prec_in; prec--) { for (;;) { @@ -1748,12 +1748,12 @@ AstNode *parse_binary_expr(AstFile *f, b32 lhs, i32 prec_in) { return expression; } -AstNode *parse_expr(AstFile *f, b32 lhs) { +AstNode *parse_expr(AstFile *f, bool lhs) { return parse_binary_expr(f, lhs, 0+1); } -AstNodeArray parse_expr_list(AstFile *f, b32 lhs) { +AstNodeArray parse_expr_list(AstFile *f, bool lhs) { AstNodeArray list = make_ast_node_array(f); do { AstNode *e = parse_expr(f, lhs); @@ -1916,7 +1916,7 @@ AstNodeArray parse_parameter_list(AstFile *f) { while (f->curr_token.kind == Token_Identifier || f->curr_token.kind == Token_using) { - b32 is_using = false; + bool is_using = false; if (allow_token(f, Token_using)) { is_using = true; } @@ -1968,13 +1968,13 @@ AstNodeArray parse_parameter_list(AstFile *f) { } -AstNodeArray parse_struct_params(AstFile *f, isize *decl_count_, b32 using_allowed) { +AstNodeArray parse_struct_params(AstFile *f, isize *decl_count_, bool using_allowed) { AstNodeArray decls = make_ast_node_array(f); isize decl_count = 0; while (f->curr_token.kind == Token_Identifier || f->curr_token.kind == Token_using) { - b32 is_using = false; + bool is_using = false; if (allow_token(f, Token_using)) { is_using = true; } @@ -2082,8 +2082,8 @@ AstNode *parse_identifier_or_type(AstFile *f, u32 flags) { case Token_struct: { Token token = expect_token(f, Token_struct); - b32 is_packed = false; - b32 is_ordered = false; + bool is_packed = false; + bool is_ordered = false; while (allow_token(f, Token_Hash)) { Token tag = expect_token_after(f, Token_Identifier, "`#`"); if (str_eq(tag.string, str_lit("packed"))) { @@ -2299,7 +2299,7 @@ AstNode *parse_decl(AstFile *f, AstNodeArray names) { syntax_error(f->curr_token, "Expected type separator `:` or `=`"); } - b32 is_mutable = true; + bool is_mutable = true; if (f->curr_token.kind == Token_Eq || f->curr_token.kind == Token_Colon) { @@ -2621,7 +2621,7 @@ AstNode *parse_defer_stmt(AstFile *f) { AstNode *parse_asm_stmt(AstFile *f) { Token token = expect_token(f, Token_asm); - b32 is_volatile = false; + bool is_volatile = false; if (allow_token(f, Token_volatile)) { is_volatile = true; } @@ -2695,7 +2695,7 @@ AstNode *parse_stmt(AstFile *f) { next_token(f); node = parse_stmt(f); - b32 valid = false; + bool valid = false; switch (node->kind) { case AstNode_ExprStmt: { @@ -2876,7 +2876,6 @@ ParseFileError init_ast_file(AstFile *f, String fullpath) { if (err == TokenizerInit_None) { array_init(&f->tokens, heap_allocator()); { - PROF_SCOPED("Tokenize file"); for (;;) { Token token = tokenizer_get_token(&f->tokenizer); if (token.kind == Token_Invalid) { @@ -2923,7 +2922,7 @@ void destroy_ast_file(AstFile *f) { destroy_tokenizer(&f->tokenizer); } -b32 init_parser(Parser *p) { +bool init_parser(Parser *p) { array_init(&p->files, heap_allocator()); array_init(&p->imports, heap_allocator()); array_init(&p->foreign_libraries, heap_allocator()); @@ -2948,7 +2947,7 @@ void destroy_parser(Parser *p) { } // NOTE(bill): Returns true if it's added -b32 try_add_import_path(Parser *p, String path, String rel_path, TokenPos pos) { +bool try_add_import_path(Parser *p, String path, String rel_path, TokenPos pos) { gb_mutex_lock(&p->mutex); for_array(i, p->imports) { @@ -3005,7 +3004,7 @@ String get_fullpath_core(gbAllocator a, String path) { } // NOTE(bill): Returns true if it's added -b32 try_add_foreign_library_path(Parser *p, String import_file) { +bool try_add_foreign_library_path(Parser *p, String import_file) { gb_mutex_lock(&p->mutex); for_array(i, p->foreign_libraries) { @@ -3028,7 +3027,7 @@ gb_global Rune illegal_import_runes[] = { '|', ',', '<', '>', '?', }; -b32 is_import_path_valid(String path) { +bool is_import_path_valid(String path) { if (path.len > 0) { u8 *start = path.text; u8 *end = path.text + path.len; @@ -3060,7 +3059,7 @@ b32 is_import_path_valid(String path) { String get_filepath_extension(String path) { isize dot = 0; - b32 seen_slash = false; + bool seen_slash = false; for (isize i = path.len-1; i >= 0; i--) { u8 c = path.text[i]; if (c == '/' || c == '\\') { @@ -3080,8 +3079,6 @@ String get_filepath_extension(String path) { } void parse_file(Parser *p, AstFile *f) { - PROF_PROC(); - String filepath = f->tokenizer.fullpath; String base_dir = filepath; for (isize i = filepath.len-1; i >= 0; i--) { diff --git a/src/profiler.cpp b/src/profiler.cpp deleted file mode 100644 index 6d4093f8c..000000000 --- a/src/profiler.cpp +++ /dev/null @@ -1,120 +0,0 @@ -// #define PROF_TIMINGS - -struct ProfInfo { - String name; - HashKey hash; - i32 count; - i64 total_time; -}; - -struct Profiler { - Map<ProfInfo> info; // Key: String - isize max_name_len; - i64 start_time; -}; - -gb_global Profiler global_profiler; - -i64 prof_get_timestamp(void) { - LARGE_INTEGER counter; - QueryPerformanceCounter(&counter); - return counter.QuadPart; -} - -void prof_init(void) { -#if defined(PROF_TIMINGS) - map_init(&global_profiler.info, heap_allocator()); - global_profiler.start_time = prof_get_timestamp(); -#endif -} - - - - -ProfInfo prof_begin(String name) { - ProfInfo info = {}; - info.name = name; - info.hash = hash_pointer(name.text); // NOTE(bill): Requires it to be unique - - info.total_time = prof_get_timestamp(); - return info; -} - -void prof_end(ProfInfo info) { - i64 dt = prof_get_timestamp() - info.total_time; - info.total_time = dt; - - auto *found = map_get(&global_profiler.info, info.hash); - if (found) { - found->count++; - found->total_time += info.total_time; - } else { - info.count++; - map_set(&global_profiler.info, info.hash, info); - if (global_profiler.max_name_len < info.name.len) { - global_profiler.max_name_len = info.name.len; - } - } -} - -struct ScopedProfInfo { - ProfInfo info; - ScopedProfInfo(String name) { - info = prof_begin(name); - } - ~ScopedProfInfo() { - prof_end(info); - } -}; - -#if defined(PROF_TIMINGS) -#define PROF_SCOPED(msg) ScopedProfInfo scoped_prof_info_##__COUNTER__ = ScopedProfInfo(make_string(cast(u8 *)msg, gb_size_of(msg)-1)) -#else -#define PROF_SCOPED(msg) do {} while (0) -#endif -#define PROF_PROC() PROF_SCOPED(__FUNCTION__) - -void prof_print_all(void) { -#if defined(PROF_TIMINGS) - LARGE_INTEGER win32_perf_count_freq = {0}; - QueryPerformanceFrequency(&win32_perf_count_freq); - GB_ASSERT(win32_perf_count_freq.QuadPart != 0); - - gb_printf("Profiler Timings\n"); - - i32 string_offset = cast(int)global_profiler.max_name_len; - char spaces[] = " "; - char dashses[] = "--------------------------------------------------------------------------------"; - isize pad_len = gb_size_of(spaces)-1; - - isize info_count = global_profiler.info.entries.count; - ProfInfo *info_data = gb_alloc_array(heap_allocator(), ProfInfo, info_count); - defer (gb_free(heap_allocator(), info_data)); - for (isize i = 0; i < info_count; i++) { - info_data[i] = global_profiler.info.entries[i].value; - } - - gb_sort_array(info_data, info_count, gb_i64_cmp(gb_offset_of(ProfInfo, total_time))); - - for (isize i = info_count-1; i >= 0; i--) { - auto entry = info_data + i; - f64 dt = (1000.0*entry->total_time / cast(f64)win32_perf_count_freq.QuadPart); - int pad = global_profiler.max_name_len - entry->name.len; - pad = gb_max(pad, 0); - gb_printf("%.*s%*.*s - %.3f ms - %.3f us\n", - LIT(entry->name), - pad, pad, spaces, - dt, 1000.0*dt/cast(f64)entry->count); - } - - i64 total_time = prof_get_timestamp() - global_profiler.start_time; - f64 total_time_ms = (1000.0*total_time / cast(f64)win32_perf_count_freq.QuadPart); - - - gb_printf("%*.*s\n" - "%*.*s %.3f ms\n", - global_profiler.max_name_len, global_profiler.max_name_len, dashses, - global_profiler.max_name_len, global_profiler.max_name_len, spaces, - total_time_ms); -#endif -} diff --git a/src/ssa.cpp b/src/ssa.cpp index 244b33de1..ecd002540 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -5,6 +5,16 @@ typedef struct ssaDebugInfo ssaDebugInfo; typedef Array(ssaValue *) ssaValueArray; +#define MAP_TYPE ssaValue * +#define MAP_FUNC map_ssa_value_ +#define MAP_NAME MapSsaValue +#include "map.c" + +#define MAP_TYPE ssaDebugInfo * +#define MAP_FUNC map_ssa_debug_info_ +#define MAP_NAME MapSsaDebugInfo +#include "map.c" + struct ssaModule { CheckerInfo * info; BaseTypeSizes sizes; @@ -12,7 +22,7 @@ struct ssaModule { gbArena tmp_arena; gbAllocator allocator; gbAllocator tmp_allocator; - b32 generate_debug_info; + bool generate_debug_info; u32 stmt_state_flags; @@ -21,13 +31,13 @@ struct ssaModule { // String triple; - Map<Entity *> min_dep_map; // Key: Entity * - Map<ssaValue *> values; // Key: Entity * - Map<ssaValue *> members; // Key: String - Map<String> type_names; // Key: Type * - Map<ssaDebugInfo *> debug_info; // Key: Unique pointer - i32 global_string_index; - i32 global_array_index; // For ConstantSlice + MapEntity min_dep_map; // Key: Entity * + MapSsaValue values; // Key: Entity * + MapSsaValue members; // Key: String + MapString type_names; // Key: Type * + MapSsaDebugInfo debug_info; // Key: Unique pointer + i32 global_string_index; + i32 global_array_index; // For ConstantSlice Array(ssaProcedure *) procs; // NOTE(bill): All procedures with bodies ssaValueArray procs_to_generate; // NOTE(bill): Procedures to generate @@ -199,7 +209,7 @@ struct ssaInstr { struct { Entity * entity; Type * type; - b32 zero_initialized; + bool zero_initialized; ssaValueArray referrers; } Local; struct { @@ -314,7 +324,7 @@ struct ssaInstr { ssaValue *low; ssaValue *high; ssaValue *max; - b32 is_substring; + bool is_substring; } SliceBoundsCheck; }; }; @@ -358,14 +368,14 @@ struct ssaValue { String name; } TypeName; struct { - Entity * entity; - Type * type; - ssaValue * value; + Entity * entity; + Type * type; + ssaValue * value; ssaValueArray referrers; - b8 is_constant; - b8 is_private; - b8 is_thread_local; - b8 is_unnamed_addr; + bool is_constant; + bool is_private; + bool is_thread_local; + bool is_unnamed_addr; } Global; struct { ssaProcedure * parent; @@ -540,11 +550,11 @@ struct ssaDebugInfo { struct ssaGen { ssaModule module; gbFile output_file; - b32 opt_called; + bool opt_called; }; ssaValue *ssa_lookup_member(ssaModule *m, String name) { - ssaValue **v = map_get(&m->members, hash_string(name)); + ssaValue **v = map_ssa_value_get(&m->members, hash_string(name)); if (v != NULL) { return *v; } @@ -638,7 +648,7 @@ Type *ssa_addr_type(ssaAddr lval) { -b32 ssa_is_blank_ident(AstNode *node) { +bool ssa_is_blank_ident(AstNode *node) { if (node->kind == AstNode_Ident) { ast_node(i, Ident, node); return is_blank_ident(i->string); @@ -660,7 +670,7 @@ ssaInstr *ssa_get_last_instr(ssaBlock *block) { } -b32 ssa_is_instr_terminating(ssaInstr *i) { +bool ssa_is_instr_terminating(ssaInstr *i) { if (i != NULL) { switch (i->kind) { case ssaInstr_Return: @@ -786,7 +796,7 @@ ssaValue *ssa_make_value_nil(gbAllocator a, Type *type) { -ssaValue *ssa_make_instr_local(ssaProcedure *p, Entity *e, b32 zero_initialized) { +ssaValue *ssa_make_instr_local(ssaProcedure *p, Entity *e, bool zero_initialized) { ssaValue *v = ssa_alloc_instr(p, ssaInstr_Local); ssaInstr *i = &v->Instr; i->Local.entity = e; @@ -1014,7 +1024,7 @@ ssaValue *ssa_make_instr_bounds_check(ssaProcedure *p, TokenPos pos, ssaValue *i v->Instr.BoundsCheck.len = len; return v; } -ssaValue *ssa_make_instr_slice_bounds_check(ssaProcedure *p, TokenPos pos, ssaValue *low, ssaValue *high, ssaValue *max, b32 is_substring) { +ssaValue *ssa_make_instr_slice_bounds_check(ssaProcedure *p, TokenPos pos, ssaValue *low, ssaValue *high, ssaValue *max, bool is_substring) { ssaValue *v = ssa_alloc_instr(p, ssaInstr_SliceBoundsCheck); v->Instr.SliceBoundsCheck.pos = pos; v->Instr.SliceBoundsCheck.low = low; @@ -1051,7 +1061,7 @@ ssaValue *ssa_make_const_i32(gbAllocator a, i64 i) { ssaValue *ssa_make_const_i64(gbAllocator a, i64 i) { return ssa_make_value_constant(a, t_i64, make_exact_value_integer(i)); } -ssaValue *ssa_make_const_bool(gbAllocator a, b32 b) { +ssaValue *ssa_make_const_bool(gbAllocator a, bool b) { return ssa_make_value_constant(a, t_bool, make_exact_value_bool(b != 0)); } ssaValue *ssa_make_const_string(gbAllocator a, String s) { @@ -1078,7 +1088,7 @@ ssaValue *ssa_make_value_procedure(gbAllocator a, ssaModule *m, Entity *entity, ssaBlock *ssa_add_block(ssaProcedure *proc, AstNode *node, char *label) { Scope *scope = NULL; if (node != NULL) { - Scope **found = map_get(&proc->module->info->scopes, hash_pointer(node)); + Scope **found = map_scope_get(&proc->module->info->scopes, hash_pointer(node)); if (found) { scope = *found; } else { @@ -1157,7 +1167,7 @@ ssaValue *ssa_add_module_constant(ssaModule *m, Type *type, ExactValue value) { Entity *e = make_entity_constant(a, NULL, make_token_ident(name), t, value); ssaValue *g = ssa_make_value_global(a, e, backing_array); ssa_module_add_value(m, e, g); - map_set(&m->members, hash_string(name), g); + map_ssa_value_set(&m->members, hash_string(name), g); return ssa_make_value_constant_slice(a, type, g, count); } @@ -1188,7 +1198,7 @@ ssaValue *ssa_add_global_string_array(ssaModule *m, String string) { // g->Global.is_constant = true; ssa_module_add_value(m, entity, g); - map_set(&m->members, hash_string(name), g); + map_ssa_value_set(&m->members, hash_string(name), g); return g; } @@ -1196,7 +1206,7 @@ ssaValue *ssa_add_global_string_array(ssaModule *m, String string) { -ssaValue *ssa_add_local(ssaProcedure *proc, Entity *e, b32 zero_initialized = true) { +ssaValue *ssa_add_local(ssaProcedure *proc, Entity *e, bool zero_initialized = true) { ssaBlock *b = proc->decl_block; // all variables must be in the first block ssaValue *instr = ssa_make_instr_local(proc, e, zero_initialized); instr->Instr.parent = b; @@ -1211,8 +1221,8 @@ ssaValue *ssa_add_local(ssaProcedure *proc, Entity *e, b32 zero_initialized = tr return instr; } -ssaValue *ssa_add_local_for_identifier(ssaProcedure *proc, AstNode *name, b32 zero_initialized) { - Entity **found = map_get(&proc->module->info->definitions, hash_pointer(name)); +ssaValue *ssa_add_local_for_identifier(ssaProcedure *proc, AstNode *name, bool zero_initialized) { + Entity **found = map_entity_get(&proc->module->info->definitions, hash_pointer(name)); if (found) { Entity *e = *found; ssa_emit_comment(proc, e->token.string); @@ -1281,7 +1291,7 @@ ssaDebugInfo *ssa_add_debug_info_file(ssaProcedure *proc, AstFile *file) { di->File.filename = filename; di->File.directory = directory; - map_set(&proc->module->debug_info, hash_pointer(file), di); + map_ssa_debug_info_set(&proc->module->debug_info, hash_pointer(file), di); return di; } @@ -1298,7 +1308,7 @@ ssaDebugInfo *ssa_add_debug_info_proc(ssaProcedure *proc, Entity *entity, String di->Proc.file = file; di->Proc.pos = entity->token.pos; - map_set(&proc->module->debug_info, hash_pointer(entity), di); + map_ssa_debug_info_set(&proc->module->debug_info, hash_pointer(entity), di); return di; } @@ -1349,7 +1359,7 @@ ssaValue *ssa_emit_call(ssaProcedure *p, ssaValue *value, ssaValue **args, isize ssaValue *ssa_emit_global_call(ssaProcedure *proc, char *name_, ssaValue **args, isize arg_count) { String name = make_string_c(name_); - ssaValue **found = map_get(&proc->module->members, hash_string(name)); + ssaValue **found = map_ssa_value_get(&proc->module->members, hash_string(name)); GB_ASSERT_MSG(found != NULL, "%.*s", LIT(name)); ssaValue *gp = *found; return ssa_emit_call(proc, gp, args, arg_count); @@ -1875,8 +1885,8 @@ String lookup_polymorphic_field(CheckerInfo *info, Type *dst, Type *src) { // Type *prev_dst = dst; src = base_type(type_deref(src)); // dst = base_type(type_deref(dst)); - b32 src_is_ptr = src != prev_src; - // b32 dst_is_ptr = dst != prev_dst; + bool src_is_ptr = src != prev_src; + // bool dst_is_ptr = dst != prev_dst; GB_ASSERT(is_type_struct(src)); for (isize i = 0; i < src->Record.field_count; i++) { @@ -2041,7 +2051,7 @@ ssaValue *ssa_emit_conv(ssaProcedure *proc, ssaValue *value, Type *t) { // subtype polymorphism casting { Type *sb = base_type(type_deref(src)); - b32 src_is_ptr = src != sb; + bool src_is_ptr = src != sb; if (is_type_struct(sb)) { String field_name = lookup_polymorphic_field(proc->module->info, t, src); // gb_printf("field_name: %.*s\n", LIT(field_name)); @@ -2164,7 +2174,7 @@ ssaValue *ssa_emit_conv(ssaProcedure *proc, ssaValue *value, Type *t) { return NULL; } -b32 ssa_is_type_aggregate(Type *t) { +bool ssa_is_type_aggregate(Type *t) { t = base_type(get_enum_base_type(t)); switch (t->kind) { case Type_Basic: @@ -2245,7 +2255,7 @@ ssaValue *ssa_emit_union_cast(ssaProcedure *proc, ssaValue *value, Type *tuple) gbAllocator a = proc->module->allocator; Type *src_type = ssa_type(value); - b32 is_ptr = is_type_pointer(src_type); + bool is_ptr = is_type_pointer(src_type); ssaValue *v = ssa_add_local_generated(proc, tuple); @@ -2330,7 +2340,7 @@ isize ssa_type_info_index(CheckerInfo *info, Type *type) { isize entry_index = -1; HashKey key = hash_pointer(type); - auto *found_entry_index = map_get(&info->type_info_map, key); + isize *found_entry_index = map_isize_get(&info->type_info_map, key); if (found_entry_index) { entry_index = *found_entry_index; } @@ -2343,7 +2353,7 @@ isize ssa_type_info_index(CheckerInfo *info, Type *type) { if (are_types_identical(prev_type, type)) { entry_index = e->value; // NOTE(bill): Add it to the search map - map_set(&info->type_info_map, key, entry_index); + map_isize_set(&info->type_info_map, key, entry_index); break; } } @@ -2356,7 +2366,7 @@ isize ssa_type_info_index(CheckerInfo *info, Type *type) { } ssaValue *ssa_type_info(ssaProcedure *proc, Type *type) { - ssaValue **found = map_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_NAME))); + ssaValue **found = map_ssa_value_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_NAME))); GB_ASSERT(found != NULL); ssaValue *type_info_data = *found; CheckerInfo *info = proc->module->info; @@ -2456,7 +2466,7 @@ void ssa_emit_bounds_check(ssaProcedure *proc, Token token, ssaValue *index, ssa // ssa_emit_global_call(proc, "__bounds_check_error", args, 5); } -void ssa_emit_slice_bounds_check(ssaProcedure *proc, Token token, ssaValue *low, ssaValue *high, ssaValue *max, b32 is_substring) { +void ssa_emit_slice_bounds_check(ssaProcedure *proc, Token token, ssaValue *low, ssaValue *high, ssaValue *max, bool is_substring) { if ((proc->module->stmt_state_flags & StmtStateFlag_no_bounds_check) != 0) { return; } @@ -2522,14 +2532,14 @@ void ssa_mangle_sub_type_name(ssaModule *m, Entity *field, String parent) { child.text[i++] = '.'; gb_memmove(child.text+i, cn.text, cn.len); - map_set(&m->type_names, hash_pointer(field->type), child); + map_string_set(&m->type_names, hash_pointer(field->type), child); ssa_gen_global_type_name(m, field, child); } void ssa_gen_global_type_name(ssaModule *m, Entity *e, String name) { ssaValue *t = ssa_make_value_type_name(m->allocator, name, e->type); ssa_module_add_value(m, e, t); - map_set(&m->members, hash_string(name), t); + map_ssa_value_set(&m->members, hash_string(name), t); Type *bt = base_type(e->type); if (bt->kind == Type_Record) { @@ -2572,7 +2582,7 @@ void ssa_build_defer_stmt(ssaProcedure *proc, ssaDefer d) { ssaValue *ssa_find_global_variable(ssaProcedure *proc, String name) { - ssaValue **value = map_get(&proc->module->members, hash_string(name)); + ssaValue **value = map_ssa_value_get(&proc->module->members, hash_string(name)); GB_ASSERT_MSG(value != NULL, "Unable to find global variable `%.*s`", LIT(name)); return *value; } @@ -2581,7 +2591,7 @@ ssaValue *ssa_find_implicit_value_backing(ssaProcedure *proc, ImplicitValueId id Entity *e = proc->module->info->implicit_values[id]; GB_ASSERT(e->kind == Entity_ImplicitValue); Entity *backing = e->ImplicitValue.backing; - ssaValue **value = map_get(&proc->module->values, hash_pointer(backing)); + ssaValue **value = map_ssa_value_get(&proc->module->values, hash_pointer(backing)); GB_ASSERT_MSG(value != NULL, "Unable to find implicit value backing `%.*s`", LIT(backing->token.string)); return *value; } @@ -2596,7 +2606,7 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue case_end; case_ast_node(i, Ident, expr); - Entity *e = *map_get(&proc->module->info->uses, hash_pointer(expr)); + Entity *e = *map_entity_get(&proc->module->info->uses, hash_pointer(expr)); if (e->kind == Entity_Builtin) { Token token = ast_node_token(expr); GB_PANIC("TODO(bill): ssa_build_single_expr Entity_Builtin `%.*s`\n" @@ -2609,7 +2619,7 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue return ssa_emit_load(proc, ssa_find_implicit_value_backing(proc, e->ImplicitValue.id)); } - auto *found = map_get(&proc->module->values, hash_pointer(e)); + ssaValue **found = map_ssa_value_get(&proc->module->values, hash_pointer(e)); if (found) { ssaValue *v = *found; if (v->kind == ssaValue_Proc) { @@ -2633,7 +2643,7 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue case_end; case_ast_node(se, SelectorExpr, expr); - TypeAndValue *tav = map_get(&proc->module->info->types, hash_pointer(expr)); + TypeAndValue *tav = map_tav_get(&proc->module->info->types, hash_pointer(expr)); GB_ASSERT(tav != NULL); return ssa_addr_load(proc, ssa_build_addr(proc, expr)); case_end; @@ -2751,7 +2761,7 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue case_ast_node(ce, CallExpr, expr); AstNode *p = unparen_expr(ce->proc); if (p->kind == AstNode_Ident) { - Entity **found = map_get(&proc->module->info->uses, hash_pointer(p)); + Entity **found = map_entity_get(&proc->module->info->uses, hash_pointer(p)); if (found && (*found)->kind == Entity_Builtin) { Entity *e = *found; switch (e->Builtin.id) { @@ -3136,8 +3146,8 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue } } ssaValue **args = gb_alloc_array(proc->module->allocator, ssaValue *, arg_count); - b32 variadic = proc_type_->Proc.variadic; - b32 vari_expand = ce->ellipsis.pos.line != 0; + bool variadic = proc_type_->Proc.variadic; + bool vari_expand = ce->ellipsis.pos.line != 0; for_array(i, ce->args) { ssaValue *a = ssa_build_expr(proc, ce->args.e[i]); @@ -3231,7 +3241,7 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue ssaValue *ssa_build_expr(ssaProcedure *proc, AstNode *expr) { expr = unparen_expr(expr); - TypeAndValue *tv = map_get(&proc->module->info->types, hash_pointer(expr)); + TypeAndValue *tv = map_tav_get(&proc->module->info->types, hash_pointer(expr)); GB_ASSERT_NOT_NULL(tv); if (tv->value.kind != ExactValue_Invalid) { @@ -3254,7 +3264,7 @@ ssaValue *ssa_add_using_variable(ssaProcedure *proc, Entity *e) { Entity *parent = e->using_parent; Selection sel = lookup_field(proc->module->allocator, parent->type, name, false); GB_ASSERT(sel.entity != NULL); - ssaValue **pv = map_get(&proc->module->values, hash_pointer(parent)); + ssaValue **pv = map_ssa_value_get(&proc->module->values, hash_pointer(parent)); ssaValue *v = NULL; if (pv != NULL) { v = *pv; @@ -3263,7 +3273,7 @@ ssaValue *ssa_add_using_variable(ssaProcedure *proc, Entity *e) { } GB_ASSERT(v != NULL); ssaValue *var = ssa_emit_deep_field_gep(proc, parent->type, v, sel); - map_set(&proc->module->values, hash_pointer(e), var); + map_ssa_value_set(&proc->module->values, hash_pointer(e), var); return var; } @@ -3276,12 +3286,12 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) { } Entity *e = entity_of_ident(proc->module->info, expr); - TypeAndValue *tv = map_get(&proc->module->info->types, hash_pointer(expr)); + TypeAndValue *tv = map_tav_get(&proc->module->info->types, hash_pointer(expr)); GB_ASSERT(e->kind != Entity_Constant); ssaValue *v = NULL; - ssaValue **found = map_get(&proc->module->values, hash_pointer(e)); + ssaValue **found = map_ssa_value_get(&proc->module->values, hash_pointer(e)); if (found) { v = *found; } else if (e->kind == Entity_Variable && e->flags & EntityFlag_Anonymous) { @@ -3364,7 +3374,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) { gbAllocator a = proc->module->allocator; - b32 deref = is_type_pointer(t); + bool deref = is_type_pointer(t); t = type_deref(t); ssaValue *using_addr = NULL; @@ -3435,7 +3445,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) { } break; case Type_Basic: { // Basic_string - TypeAndValue *tv = map_get(&proc->module->info->types, hash_pointer(ie->expr)); + TypeAndValue *tv = map_tav_get(&proc->module->info->types, hash_pointer(ie->expr)); ssaValue *str; ssaValue *elem; ssaValue *len; @@ -3598,7 +3608,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) { case Type_Slice: et = bt->Slice.elem; break; } - auto is_elem_const = [](ssaModule *m, AstNode *elem, Type *elem_type) -> b32 { + auto is_elem_const = [](ssaModule *m, AstNode *elem, Type *elem_type) -> bool { if (base_type(elem_type) == t_any) { return false; } @@ -3903,12 +3913,12 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { if (pd->body != NULL) { auto *info = proc->module->info; - Entity **found = map_get(&info->definitions, hash_pointer(pd->name)); + Entity **found = map_entity_get(&info->definitions, hash_pointer(pd->name)); GB_ASSERT_MSG(found != NULL, "Unable to find: %.*s", LIT(pd->name->Ident.string)); Entity *e = *found; - if (map_get(&proc->module->min_dep_map, hash_pointer(e)) == NULL) { + if (map_entity_get(&proc->module->min_dep_map, hash_pointer(e)) == NULL) { // NOTE(bill): Nothing depends upon it so doesn't need to be built break; } @@ -3940,7 +3950,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { } else { auto *info = proc->module->info; - Entity **found = map_get(&info->definitions, hash_pointer(pd->name)); + Entity **found = map_entity_get(&info->definitions, hash_pointer(pd->name)); GB_ASSERT_MSG(found != NULL, "Unable to find: %.*s", LIT(pd->name->Ident.string)); Entity *e = *found; @@ -3961,10 +3971,10 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { if (value->Proc.tags & ProcTag_foreign) { HashKey key = hash_string(name); - auto *prev_value = map_get(&proc->module->members, key); + ssaValue **prev_value = map_ssa_value_get(&proc->module->members, key); if (prev_value == NULL) { // NOTE(bill): Don't do mutliple declarations in the IR - map_set(&proc->module->members, key, value); + map_ssa_value_set(&proc->module->members, key, value); } } else { array_add(&proc->children, &value->Proc); @@ -3983,12 +3993,12 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(td_name), guid); String name = make_string(name_text, name_len-1); - Entity **found = map_get(&proc->module->info->definitions, hash_pointer(td->name)); + Entity **found = map_entity_get(&proc->module->info->definitions, hash_pointer(td->name)); GB_ASSERT(found != NULL); Entity *e = *found; ssaValue *value = ssa_make_value_type_name(proc->module->allocator, name, e->type); - map_set(&proc->module->type_names, hash_pointer(e->type), name); + map_string_set(&proc->module->type_names, hash_pointer(e->type), name); ssa_gen_global_type_name(proc->module, e, name); case_end; @@ -4253,7 +4263,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { ssaBlock *default_block = NULL; ssaBlock *fall = NULL; - b32 append_fall = false; + bool append_fall = false; isize case_count = body->stmts.count; for_array(i, body->stmts) { @@ -4329,8 +4339,8 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { gbAllocator allocator = proc->module->allocator; ssaValue *parent = ssa_build_expr(proc, ms->tag); - b32 is_union_ptr = false; - b32 is_any = false; + bool is_union_ptr = false; + bool is_any = false; GB_ASSERT(check_valid_type_match_type(ssa_type(parent), &is_union_ptr, &is_any)); ssaValue *tag_index = NULL; @@ -4370,7 +4380,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) { ssaBlock *body = ssa_add_block(proc, clause, "type-match.case.body"); - Scope *scope = *map_get(&proc->module->info->scopes, hash_pointer(clause)); + Scope *scope = *map_scope_get(&proc->module->info->scopes, hash_pointer(clause)); Entity *tag_var_entity = current_scope_lookup_entity(scope, tag_var_name); GB_ASSERT_MSG(tag_var_entity != NULL, "%.*s", LIT(tag_var_name)); @@ -4599,12 +4609,12 @@ void ssa_build_proc(ssaValue *value, ssaProcedure *parent) { CheckerInfo *info = m->info; Entity *e = proc->entity; String filename = e->token.pos.file; - AstFile **found = map_get(&info->files, hash_string(filename)); + AstFile **found = map_ast_file_get(&info->files, hash_string(filename)); GB_ASSERT(found != NULL); AstFile *f = *found; ssaDebugInfo *di_file = NULL; - ssaDebugInfo **di_file_found = map_get(&m->debug_info, hash_pointer(f)); + ssaDebugInfo **di_file_found = map_ssa_debug_info_get(&m->debug_info, hash_pointer(f)); if (di_file_found) { di_file = *di_file_found; GB_ASSERT(di_file->kind == ssaDebugInfo_File); @@ -4656,7 +4666,7 @@ void ssa_build_proc(ssaValue *value, ssaProcedure *parent) { void ssa_module_add_value(ssaModule *m, Entity *e, ssaValue *v) { - map_set(&m->values, hash_pointer(e), v); + map_ssa_value_set(&m->values, hash_pointer(e), v); } void ssa_init_module(ssaModule *m, Checker *c) { @@ -4670,10 +4680,10 @@ void ssa_init_module(ssaModule *m, Checker *c) { m->info = &c->info; m->sizes = c->sizes; - map_init(&m->values, heap_allocator()); - map_init(&m->members, heap_allocator()); - map_init(&m->debug_info, heap_allocator()); - map_init(&m->type_names, heap_allocator()); + map_ssa_value_init(&m->values, heap_allocator()); + map_ssa_value_init(&m->members, heap_allocator()); + map_ssa_debug_info_init(&m->debug_info, heap_allocator()); + map_string_init(&m->type_names, heap_allocator()); array_init(&m->procs, heap_allocator()); array_init(&m->procs_to_generate, heap_allocator()); @@ -4690,7 +4700,7 @@ void ssa_init_module(ssaModule *m, Checker *c) { ssaValue *g = ssa_make_value_global(m->allocator, e, NULL); g->Global.is_private = true; ssa_module_add_value(m, e, g); - map_set(&m->members, hash_string(name), g); + map_ssa_value_set(&m->members, hash_string(name), g); } // Type info member buffer @@ -4721,7 +4731,7 @@ void ssa_init_module(ssaModule *m, Checker *c) { make_type_array(m->allocator, t_type_info_member, count)); ssaValue *g = ssa_make_value_global(m->allocator, e, NULL); ssa_module_add_value(m, e, g); - map_set(&m->members, hash_string(name), g); + map_ssa_value_set(&m->members, hash_string(name), g); } } @@ -4730,15 +4740,15 @@ void ssa_init_module(ssaModule *m, Checker *c) { di->CompileUnit.file = m->info->files.entries.e[0].value; // Zeroth is the init file di->CompileUnit.producer = str_lit("odin"); - map_set(&m->debug_info, hash_pointer(m), di); + map_ssa_debug_info_set(&m->debug_info, hash_pointer(m), di); } } void ssa_destroy_module(ssaModule *m) { - map_destroy(&m->values); - map_destroy(&m->members); - map_destroy(&m->type_names); - map_destroy(&m->debug_info); + map_ssa_value_destroy(&m->values); + map_ssa_value_destroy(&m->members); + map_string_destroy(&m->type_names); + map_ssa_debug_info_destroy(&m->debug_info); array_free(&m->procs_to_generate); gb_arena_free(&m->arena); } @@ -4752,7 +4762,7 @@ void ssa_destroy_module(ssaModule *m) { //////////////////////////////////////////////////////////////// -b32 ssa_gen_init(ssaGen *s, Checker *c) { +bool ssa_gen_init(ssaGen *s, Checker *c) { if (global_error_collector.count != 0) { return false; } @@ -4787,7 +4797,7 @@ String ssa_mangle_name(ssaGen *s, String path, String name) { ssaModule *m = &s->module; CheckerInfo *info = m->info; gbAllocator a = m->allocator; - AstFile *file = *map_get(&info->files, hash_string(path)); + AstFile *file = *map_ast_file_get(&info->files, hash_string(path)); char *str = gb_alloc_array(a, char, path.len+1); gb_memmove(str, path.text, path.len); @@ -4866,7 +4876,7 @@ void ssa_gen_tree(ssaGen *s) { continue; } - if (map_get(&m->min_dep_map, hash_pointer(e)) == NULL) { + if (map_entity_get(&m->min_dep_map, hash_pointer(e)) == NULL) { // NOTE(bill): Nothing depends upon it so doesn't need to be built continue; } @@ -4879,7 +4889,7 @@ void ssa_gen_tree(ssaGen *s) { switch (e->kind) { case Entity_TypeName: GB_ASSERT(e->type->kind == Type_Named); - map_set(&m->type_names, hash_pointer(e->type), name); + map_string_set(&m->type_names, hash_pointer(e->type), name); ssa_gen_global_type_name(m, e, name); break; @@ -4893,7 +4903,7 @@ void ssa_gen_tree(ssaGen *s) { var.decl = decl; if (decl->init_expr != NULL) { - TypeAndValue *tav = map_get(&info->types, hash_pointer(decl->init_expr)); + TypeAndValue *tav = map_tav_get(&info->types, hash_pointer(decl->init_expr)); if (tav != NULL) { if (tav->value.kind != ExactValue_Invalid) { ExactValue v = tav->value; @@ -4908,8 +4918,8 @@ void ssa_gen_tree(ssaGen *s) { array_add(&global_variables, var); } - map_set(&m->values, hash_pointer(e), g); - map_set(&m->members, hash_string(name), g); + map_ssa_value_set(&m->values, hash_pointer(e), g); + map_ssa_value_set(&m->members, hash_string(name), g); } break; case Entity_Procedure: { @@ -4928,10 +4938,10 @@ void ssa_gen_tree(ssaGen *s) { ssaValue *p = ssa_make_value_procedure(a, m, e, e->type, decl->type_expr, body, name); p->Proc.tags = pd->tags; - map_set(&m->values, hash_pointer(e), p); + map_ssa_value_set(&m->values, hash_pointer(e), p); HashKey hash_name = hash_string(name); - if (map_get(&m->members, hash_name) == NULL) { - map_set(&m->members, hash_name, p); + if (map_ssa_value_get(&m->members, hash_name) == NULL) { + map_ssa_value_set(&m->members, hash_name, p); } } break; } @@ -4959,7 +4969,7 @@ void ssa_gen_tree(ssaGen *s) { } array_init_reserve(&all_procs->AllProcs.procs, m->allocator, all_proc_max_count); - map_set(&m->debug_info, hash_pointer(all_procs), all_procs); // NOTE(bill): This doesn't need to be mapped + map_ssa_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; @@ -4985,8 +4995,8 @@ void ssa_gen_tree(ssaGen *s) { token.string = name; Entity *e = make_entity_procedure(a, NULL, token, proc_type); - map_set(&m->values, hash_pointer(e), p); - map_set(&m->members, hash_string(name), p); + map_ssa_value_set(&m->values, hash_pointer(e), p); + map_ssa_value_set(&m->members, hash_string(name), p); ssaProcedure *proc = &p->Proc; proc->tags = ProcTag_no_inline; // TODO(bill): is no_inline a good idea? @@ -5026,11 +5036,11 @@ void ssa_gen_tree(ssaGen *s) { ssaValue *type_info_member_data = NULL; ssaValue **found = NULL; - found = map_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_NAME))); + found = map_ssa_value_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_NAME))); GB_ASSERT(found != NULL); type_info_data = *found; - found = map_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_MEMBER_NAME))); + found = map_ssa_value_get(&proc->module->members, hash_string(str_lit(SSA_TYPE_INFO_DATA_MEMBER_NAME))); GB_ASSERT(found != NULL); type_info_member_data = *found; @@ -5094,7 +5104,7 @@ void ssa_gen_tree(ssaGen *s) { case Basic_int: case Basic_uint: { tag = ssa_add_local_generated(proc, t_type_info_integer); - b32 is_unsigned = (t->Basic.flags & BasicFlag_Unsigned) != 0; + bool is_unsigned = (t->Basic.flags & BasicFlag_Unsigned) != 0; ssaValue *bits = ssa_make_const_int(a, type_size_of(m->sizes, a, t)); ssaValue *is_signed = ssa_make_const_bool(a, !is_unsigned); ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), bits); @@ -5302,7 +5312,7 @@ void ssa_gen_tree(ssaGen *s) { value_array = ssa_make_value_global(a, e, NULL); value_array->Global.is_private = true; ssa_module_add_value(m, e, value_array); - map_set(&m->members, hash_string(token.string), value_array); + map_ssa_value_set(&m->members, hash_string(token.string), value_array); } { Token token = {Token_Identifier}; @@ -5316,7 +5326,7 @@ void ssa_gen_tree(ssaGen *s) { name_array = ssa_make_value_global(a, e, NULL); name_array->Global.is_private = true; ssa_module_add_value(m, e, name_array); - map_set(&m->members, hash_string(token.string), name_array); + map_ssa_value_set(&m->members, hash_string(token.string), name_array); } for (isize i = 0; i < count; i++) { diff --git a/src/ssa_opt.cpp b/src/ssa_opt.cpp index 63cdb7733..b15cd8f90 100644 --- a/src/ssa_opt.cpp +++ b/src/ssa_opt.cpp @@ -115,7 +115,7 @@ void ssa_opt_block_replace_succ(ssaBlock *b, ssaBlock *from, ssaBlock *to) { } } -b32 ssa_opt_block_has_phi(ssaBlock *b) { +bool ssa_opt_block_has_phi(ssaBlock *b) { return b->instrs.e[0]->Instr.kind == ssaInstr_Phi; } @@ -215,7 +215,7 @@ void ssa_remove_unreachable_blocks(ssaProcedure *proc) { ssa_remove_dead_blocks(proc); } -b32 ssa_opt_block_fusion(ssaProcedure *proc, ssaBlock *a) { +bool ssa_opt_block_fusion(ssaProcedure *proc, ssaBlock *a) { if (a->succs.count != 1) { return false; } @@ -252,7 +252,7 @@ void ssa_opt_blocks(ssaProcedure *proc) { ssa_remove_unreachable_blocks(proc); #if 1 - b32 changed = true; + bool changed = true; while (changed) { changed = false; for_array(i, proc->blocks) { diff --git a/src/ssa_print.cpp b/src/ssa_print.cpp index f4ed5544c..93b27dcae 100644 --- a/src/ssa_print.cpp +++ b/src/ssa_print.cpp @@ -51,7 +51,7 @@ void ssa_file_write(ssaFileBuffer *f, void *data, isize len) { } -b32 ssa_valid_char(u8 c) { +bool ssa_valid_char(u8 c) { if (c >= 0x80) { return false; } @@ -71,7 +71,7 @@ b32 ssa_valid_char(u8 c) { return false; } -void ssa_print_escape_string(ssaFileBuffer *f, String name, b32 print_quotes) { +void ssa_print_escape_string(ssaFileBuffer *f, String name, bool print_quotes) { isize extra = 0; for (isize i = 0; i < name.len; i++) { u8 c = name.text[i]; @@ -127,7 +127,7 @@ void ssa_print_encoded_local(ssaFileBuffer *f, String name) { ssa_print_escape_string(f, name, true); } -void ssa_print_encoded_global(ssaFileBuffer *f, String name, b32 global_scope) { +void ssa_print_encoded_global(ssaFileBuffer *f, String name, bool global_scope) { ssa_fprintf(f, "@"); if (!global_scope && str_ne(name, str_lit("main"))) { ssa_fprintf(f, "."); @@ -239,7 +239,7 @@ void ssa_print_type(ssaFileBuffer *f, ssaModule *m, Type *t) { case Type_Named: if (is_type_struct(t) || is_type_union(t)) { - String *name = map_get(&m->type_names, hash_pointer(t)); + String *name = map_string_get(&m->type_names, hash_pointer(t)); GB_ASSERT_MSG(name != NULL, "%.*s", LIT(t->Named.name)); ssa_print_encoded_local(f, *name); // ssa_print_encoded_local(f, t->Named.name); @@ -613,7 +613,7 @@ void ssa_print_value(ssaFileBuffer *f, ssaModule *m, ssaValue *value, Type *type break; case ssaValue_Global: { Scope *scope = value->Global.entity->scope; - b32 in_global_scope = false; + bool in_global_scope = false; if (scope != NULL) { in_global_scope = scope->is_global || scope->is_init; } @@ -1226,7 +1226,7 @@ void ssa_print_proc(ssaFileBuffer *f, ssaModule *m, ssaProcedure *proc) { if (proc->module->generate_debug_info && proc->entity != NULL) { if (proc->body != NULL) { - ssaDebugInfo *di = *map_get(&proc->module->debug_info, hash_pointer(proc->entity)); + ssaDebugInfo *di = *map_ssa_debug_info_get(&proc->module->debug_info, hash_pointer(proc->entity)); GB_ASSERT(di->kind == ssaDebugInfo_Proc); ssa_fprintf(f, "!dbg !%d ", di->id); } @@ -1337,7 +1337,7 @@ void ssa_print_llvm_ir(ssaGen *ssa) { } auto *g = &v->Global; Scope *scope = g->entity->scope; - b32 in_global_scope = false; + bool in_global_scope = false; if (scope != NULL) { in_global_scope = scope->is_global || scope->is_init; } @@ -1383,7 +1383,7 @@ void ssa_print_llvm_ir(ssaGen *ssa) { switch (di->kind) { case ssaDebugInfo_CompileUnit: { auto *cu = &di->CompileUnit; - ssaDebugInfo *file = *map_get(&m->debug_info, hash_pointer(cu->file)); + ssaDebugInfo *file = *map_ssa_debug_info_get(&m->debug_info, hash_pointer(cu->file)); ssa_fprintf(f, "distinct !DICompileUnit(" "language: DW_LANG_Go, " // Is this good enough? diff --git a/src/string.cpp b/src/string.cpp index 552ba2a4b..b52b8886e 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -49,14 +49,14 @@ gb_inline String make_string_c(char *text) { #define str_lit(c_str) make_string(cast(u8 *)c_str, gb_size_of(c_str)-1) -gb_inline b32 are_strings_equal(String a, String b) { +gb_inline bool are_strings_equal(String a, String b) { if (a.len == b.len) { return gb_memcompare(a.text, b.text, a.len) == 0; } return false; } -gb_inline b32 str_eq_ignore_case(String a, String b) { +gb_inline bool str_eq_ignore_case(String a, String b) { if (a.len == b.len) { for (isize i = 0; i < a.len; i++) { char x = cast(char)a.text[i]; @@ -137,7 +137,7 @@ gb_inline bool str_ge(String a, String b) { return string_compare(a, b) >= 0; gb_inline isize string_extension_position(String str) { isize dot_pos = -1; isize i = str.len; - b32 seen_dot = false; + bool seen_dot = false; while (i --> 0) { if (str.text[i] == GB_PATH_SEPARATOR) break; @@ -150,7 +150,7 @@ gb_inline isize string_extension_position(String str) { return dot_pos; } -gb_inline b32 string_has_extension(String str, String ext) { +gb_inline bool string_has_extension(String str, String ext) { if (str.len > ext.len+1) { u8 *s = str.text+str.len - ext.len-1; if (s[0] == '.') { @@ -162,7 +162,7 @@ gb_inline b32 string_has_extension(String str, String ext) { return false; } -b32 string_contains_char(String s, u8 c) { +bool string_contains_char(String s, u8 c) { for (isize i = 0; i < s.len; i++) { if (s.text[i] == c) return true; @@ -238,7 +238,7 @@ String string16_to_string(gbAllocator a, String16 s) { -b32 unquote_char(String s, u8 quote, Rune *rune, b32 *multiple_bytes, String *tail_string) { +bool unquote_char(String s, u8 quote, Rune *rune, bool *multiple_bytes, String *tail_string) { if (s.text[0] == quote && (quote == '$' || quote == '"')) { return false; @@ -396,8 +396,8 @@ i32 unquote_string(gbAllocator a, String *s_) { while (s.len > 0) { String tail_string = {0}; Rune r = 0; - b32 multiple_bytes = false; - b32 success = unquote_char(s, quote, &r, &multiple_bytes, &tail_string); + bool multiple_bytes = false; + bool success = unquote_char(s, quote, &r, &multiple_bytes, &tail_string); if (!success) { gb_free(a, buf); return 0; diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 331d5a1a9..3363f7f35 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -144,7 +144,7 @@ i32 token_pos_cmp(TokenPos a, TokenPos b) { return (a.line < b.line) ? -1 : +1; } -b32 token_pos_are_equal(TokenPos a, TokenPos b) { +bool token_pos_are_equal(TokenPos a, TokenPos b) { return token_pos_cmp(a, b) == 0; } @@ -253,19 +253,19 @@ void compiler_error(char *fmt, ...) { -gb_inline b32 token_is_literal(Token t) { +gb_inline bool token_is_literal(Token t) { return gb_is_between(t.kind, Token__LiteralBegin+1, Token__LiteralEnd-1); } -gb_inline b32 token_is_operator(Token t) { +gb_inline bool token_is_operator(Token t) { return gb_is_between(t.kind, Token__OperatorBegin+1, Token__OperatorEnd-1); } -gb_inline b32 token_is_keyword(Token t) { +gb_inline bool token_is_keyword(Token t) { return gb_is_between(t.kind, Token__KeywordBegin+1, Token__KeywordEnd-1); } -gb_inline b32 token_is_comparison(Token t) { +gb_inline bool token_is_comparison(Token t) { return gb_is_between(t.kind, Token__ComparisonBegin+1, Token__ComparisonEnd-1); } -gb_inline b32 token_is_shift(Token t) { +gb_inline bool token_is_shift(Token t) { return t.kind == Token_Shl || t.kind == Token_Shr; } @@ -350,8 +350,6 @@ void advance_to_next_rune(Tokenizer *t) { } TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) { - PROF_PROC(); - TokenizerInitError err = TokenizerInit_None; char *c_str = gb_alloc_array(heap_allocator(), char, fullpath.len+1); @@ -432,7 +430,7 @@ gb_inline void scan_mantissa(Tokenizer *t, i32 base) { } -Token scan_number_to_token(Tokenizer *t, b32 seen_decimal_point) { +Token scan_number_to_token(Tokenizer *t, bool seen_decimal_point) { Token token = {}; token.kind = Token_Integer; token.string = make_string(t->curr, 1); @@ -507,7 +505,7 @@ exponent: } // Quote == " for string -b32 scan_escape(Tokenizer *t, Rune quote) { +bool scan_escape(Tokenizer *t, Rune quote) { isize len = 0; u32 base = 0, max = 0, x = 0; diff --git a/src/unicode.cpp b/src/unicode.cpp index 872881414..5c9f91f46 100644 --- a/src/unicode.cpp +++ b/src/unicode.cpp @@ -6,7 +6,7 @@ #pragma warning(pop) -b32 rune_is_letter(Rune r) { +bool rune_is_letter(Rune r) { if ((r < 0x80 && gb_char_is_alpha(cast(char)r)) || r == '_') { return true; @@ -22,14 +22,14 @@ b32 rune_is_letter(Rune r) { return false; } -b32 rune_is_digit(Rune r) { +bool rune_is_digit(Rune r) { if (r < 0x80 && gb_is_between(r, '0', '9')) { return true; } return utf8proc_category(r) == UTF8PROC_CATEGORY_ND; } -b32 rune_is_whitespace(Rune r) { +bool rune_is_whitespace(Rune r) { switch (r) { case ' ': case '\t': @@ -41,13 +41,13 @@ b32 rune_is_whitespace(Rune r) { } -b32 is_string_an_identifier(String s) { +bool is_string_an_identifier(String s) { if (s.len < 1) { return false; } isize offset = 0; while (offset < s.len) { - b32 ok = false; + bool ok = false; Rune r = -1; isize size = gb_utf8_decode(s.text+offset, s.len-offset, &r); if (offset == 0) { |