diff --git a/src/build_settings.cpp b/src/build_settings.cpp index dac763010..eb8a50c6a 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -1,5 +1,5 @@ // This stores the information for the specify architecture of this build -typedef struct BuildContext { +struct BuildContext { // Constants String ODIN_OS; // target operating system String ODIN_ARCH; // target architecture @@ -15,7 +15,7 @@ typedef struct BuildContext { String llc_flags; String link_flags; bool is_dll; -} BuildContext; +}; gb_global BuildContext build_context = {0}; diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 1e7e23398..356cd488b 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -58,7 +58,7 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex return e->type; } -void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArray inits, String context_name) { +void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array inits, String context_name) { if ((lhs == NULL || lhs_count == 0) && inits.count == 0) { return; } @@ -431,7 +431,7 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count } } - AstNodeArray inits; + Array inits; array_init(&inits, c->allocator, 1); array_add(&inits, init_expr); check_init_variables(c, entities, entity_count, inits, str_lit("variable declaration")); diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 55670f7e5..2af676831 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -16,7 +16,7 @@ void update_expr_type (Checker *c, AstNode *e, Type *type, boo bool check_is_terminating (AstNode *node); bool check_has_break (AstNode *stmt, bool implicit); void check_stmt (Checker *c, AstNode *node, u32 flags); -void check_stmt_list (Checker *c, AstNodeArray stmts, u32 flags); +void check_stmt_list (Checker *c, Array stmts, u32 flags); void check_init_constant (Checker *c, Entity *e, Operand *operand); bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type, ExactValue *out_value); Type * check_call_arguments (Checker *c, Operand *operand, Type *proc_type, AstNode *call); @@ -46,7 +46,7 @@ void error_operand_no_value(Operand *o) { } -void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) { +void check_scope_decls(Checker *c, Array nodes, isize reserve_size) { Scope *s = c->context.scope; GB_ASSERT(!s->is_file); @@ -385,7 +385,7 @@ void populate_using_entity_map(Checker *c, AstNode *node, Type *t, MapEntity *en // Returns filled field_count -isize check_fields(Checker *c, AstNode *node, AstNodeArray decls, +isize check_fields(Checker *c, AstNode *node, Array decls, Entity **fields, isize field_count, String context) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); @@ -692,7 +692,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) { ast_node(fl, FieldList, f->list); // NOTE(bill): Copy the contents for the common fields for now - AstNodeArray list = {}; + Array list = {}; array_init_count(&list, c->allocator, ut->fields.count+fl->list.count); gb_memmove_array(list.data, ut->fields.data, ut->fields.count); gb_memmove_array(list.data+ut->fields.count, fl->list.data, fl->list.count); @@ -1033,7 +1033,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari return NULL; } ast_node(field_list, FieldList, _params); - AstNodeArray params = field_list->list; + Array params = field_list->list; if (params.count == 0) { return NULL; @@ -1118,7 +1118,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) { return NULL; } ast_node(field_list, FieldList, _results); - AstNodeArray results = field_list->list; + Array results = field_list->list; if (results.count == 0) { return NULL; @@ -4698,7 +4698,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id return true; } -typedef enum CallArgumentError { +enum CallArgumentError { CallArgumentError_None, CallArgumentError_WrongTypes, CallArgumentError_NonVariadicExpand, @@ -4707,12 +4707,12 @@ typedef enum CallArgumentError { CallArgumentError_ArgumentCount, CallArgumentError_TooFewArguments, CallArgumentError_TooManyArguments, -} CallArgumentError; +}; -typedef enum CallArgumentErrorMode { +enum CallArgumentErrorMode { CallArgumentMode_NoErrors, CallArgumentMode_ShowErrors, -} CallArgumentErrorMode; +}; CallArgumentError check_call_arguments_internal(Checker *c, AstNode *call, Type *proc_type, Operand *operands, isize operand_count, CallArgumentErrorMode show_error_mode, i64 *score_) { @@ -4823,10 +4823,10 @@ CallArgumentError check_call_arguments_internal(Checker *c, AstNode *call, Type return err; } -typedef struct ValidProcAndScore { +struct ValidProcAndScore { isize index; i64 score; -} ValidProcAndScore; +}; int valid_proc_and_score_cmp(void const *a, void const *b) { i64 si = (cast(ValidProcAndScore const *)a)->score; @@ -4834,7 +4834,7 @@ int valid_proc_and_score_cmp(void const *a, void const *b) { return sj < si ? -1 : sj > si; } -bool check_unpack_arguments(Checker *c, isize lhs_count, Array *operands, AstNodeArray rhs, bool allow_ok) { +bool check_unpack_arguments(Checker *c, isize lhs_count, Array *operands, Array rhs, bool allow_ok) { bool optional_ok = false; for_array(i, rhs) { Operand o = {}; @@ -6139,7 +6139,7 @@ void check_expr_or_type(Checker *c, Operand *o, AstNode *e) { gbString write_expr_to_string(gbString str, AstNode *node); -gbString write_record_fields_to_string(gbString str, AstNodeArray params) { +gbString write_record_fields_to_string(gbString str, Array params) { for_array(i, params) { if (i > 0) { str = gb_string_appendc(str, ", "); diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 9a0f6afa5..859aa593d 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1,4 +1,4 @@ -void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { +void check_stmt_list(Checker *c, Array stmts, u32 flags) { if (stmts.count == 0) { return; } @@ -40,7 +40,7 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) { } -bool check_is_terminating_list(AstNodeArray stmts) { +bool check_is_terminating_list(Array stmts) { // Iterate backwards for (isize n = stmts.count-1; n >= 0; n--) { AstNode *stmt = stmts[n]; @@ -52,7 +52,7 @@ bool check_is_terminating_list(AstNodeArray stmts) { return false; } -bool check_has_break_list(AstNodeArray stmts, bool implicit) { +bool check_has_break_list(Array stmts, bool implicit) { for_array(i, stmts) { AstNode *stmt = stmts[i]; if (check_has_break(stmt, implicit)) { @@ -340,11 +340,11 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) { return rhs->type; } -typedef enum MatchTypeKind { +enum MatchTypeKind { MatchType_Invalid, MatchType_Union, MatchType_Any, -} MatchTypeKind; +}; MatchTypeKind check_valid_type_match_type(Type *type) { type = type_deref(type); @@ -384,10 +384,10 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) { -typedef struct TypeAndToken { +struct TypeAndToken { Type *type; Token token; -} TypeAndToken; +}; #define MAP_TYPE TypeAndToken #define MAP_PROC map_type_and_token_ diff --git a/src/checker.cpp b/src/checker.cpp index 6a9011df1..389740694 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -1,27 +1,27 @@ #include "exact_value.cpp" #include "entity.cpp" -typedef enum ExprKind { +enum ExprKind { Expr_Expr, Expr_Stmt, -} ExprKind; +}; // Statements and Declarations -typedef enum StmtFlag { +enum StmtFlag { Stmt_BreakAllowed = 1<<0, Stmt_ContinueAllowed = 1<<1, Stmt_FallthroughAllowed = 1<<2, Stmt_CheckScopeDecls = 1<<5, -} StmtFlag; +}; -typedef struct BuiltinProc { +struct BuiltinProc { String name; isize arg_count; bool variadic; ExprKind kind; -} BuiltinProc; -typedef enum BuiltinProcId { +}; +enum BuiltinProcId { BuiltinProc_Invalid, BuiltinProc_len, @@ -71,7 +71,7 @@ typedef enum BuiltinProcId { BuiltinProc_transmute, BuiltinProc_Count, -} BuiltinProcId; +}; gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = { {STR_LIT(""), 0, false, Expr_Stmt}, @@ -125,7 +125,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = { #include "types.cpp" -typedef enum AddressingMode { +enum AddressingMode { Addressing_Invalid, // invalid addressing mode Addressing_NoValue, // no value (void in C) Addressing_Value, // computed value (rvalue) @@ -139,14 +139,14 @@ typedef enum AddressingMode { // lhs: acts like a Variable // rhs: acts like OptionalOk Addressing_OptionalOk, // rhs: acts like a value with an optional boolean part (for existence check) -} AddressingMode; +}; // Operand is used as an intermediate value whilst checking // Operands store an addressing mode, the expression being evaluated, // its type and node, and other specific information for certain // addressing modes // Its zero-value is a valid "invalid operand" -typedef struct Operand { +struct Operand { AddressingMode mode; Type * type; ExactValue value; @@ -154,13 +154,13 @@ typedef struct Operand { BuiltinProcId builtin_id; isize overload_count; Entity ** overload_entities; -} Operand; +}; -typedef struct TypeAndValue { +struct TypeAndValue { AddressingMode mode; Type * type; ExactValue value; -} TypeAndValue; +}; bool is_operand_value(Operand o) { switch (o.mode) { @@ -178,13 +178,12 @@ bool is_operand_nil(Operand o) { } -typedef struct BlockLabel { +struct BlockLabel { String name; AstNode *label; // AstNode_Label; -} BlockLabel; +}; // DeclInfo is used to store information of certain declarations to allow for "any order" usage -typedef struct DeclInfo DeclInfo; struct DeclInfo { DeclInfo * parent; // NOTE(bill): only used for procedure literals at the moment Scope * scope; @@ -203,22 +202,22 @@ struct DeclInfo { // ProcedureInfo stores the information needed for checking a procedure -typedef struct ProcedureInfo { +struct ProcedureInfo { AstFile * file; Token token; DeclInfo * decl; Type * type; // Type_Procedure AstNode * body; // AstNode_BlockStmt u32 tags; -} ProcedureInfo; +}; // ExprInfo stores information used for "untyped" expressions -typedef struct ExprInfo { +struct ExprInfo { bool is_lhs; // Debug info AddressingMode mode; Type * type; // Type_Basic ExactValue value; -} ExprInfo; +}; ExprInfo make_expr_info(bool is_lhs, AddressingMode mode, Type *type, ExactValue value) { ExprInfo ei = {is_lhs, mode, type, value}; @@ -232,7 +231,7 @@ ExprInfo make_expr_info(bool is_lhs, AddressingMode mode, Type *type, ExactValue #define MAP_NAME MapEntity #include "map.cpp" -typedef struct Scope { +struct Scope { Scope * parent; Scope * prev, *next; Scope * first_child; @@ -248,7 +247,7 @@ typedef struct Scope { bool is_init; bool has_been_imported; // This is only applicable to file scopes AstFile * file; -} Scope; +}; gb_global Scope *universal_scope = NULL; @@ -280,19 +279,19 @@ gb_global Scope *universal_scope = NULL; #define MAP_NAME MapExprInfo #include "map.cpp" -typedef struct DelayedDecl { +struct DelayedDecl { Scope * parent; AstNode *decl; -} DelayedDecl; +}; -typedef struct CheckerFileNode { +struct CheckerFileNode { i32 id; Array wheres; Array whats; i32 score; // Higher the score, the better -} CheckerFileNode; +}; -typedef struct CheckerContext { +struct CheckerContext { Scope * file_scope; Scope * scope; DeclInfo * decl; @@ -301,10 +300,10 @@ typedef struct CheckerContext { String proc_name; Type * type_hint; DeclInfo * curr_proc_decl; -} CheckerContext; +}; // CheckerInfo stores all the symbol information for a type-checked program -typedef struct CheckerInfo { +struct CheckerInfo { MapTypeAndValue types; // Key: AstNode * | Expression -> Type (and value) MapEntity definitions; // Key: AstNode * | Identifier -> Entity MapEntity uses; // Key: AstNode * | Identifier -> Entity @@ -316,9 +315,9 @@ typedef struct CheckerInfo { MapAstFile files; // Key: String (full path) MapIsize type_info_map; // Key: Type * isize type_info_count; -} CheckerInfo; +}; -typedef struct Checker { +struct Checker { Parser * parser; CheckerInfo info; @@ -338,14 +337,14 @@ typedef struct Checker { Array proc_stack; bool done_preload; -} Checker; +}; -typedef struct DelayedEntity { +struct DelayedEntity { AstNode * ident; Entity * entity; DeclInfo * decl; -} DelayedEntity; +}; @@ -1281,7 +1280,7 @@ void init_preload(Checker *c) { bool check_arity_match(Checker *c, AstNodeValueDecl *d); -void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope); +void check_collect_entities(Checker *c, Array nodes, bool is_file_scope); void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws, bool is_file_scope); bool check_is_entity_overloaded(Entity *e) { @@ -1455,7 +1454,7 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws, bool } // NOTE(bill): If file_scopes == NULL, this will act like a local scope -void check_collect_entities(Checker *c, AstNodeArray nodes, bool is_file_scope) { +void check_collect_entities(Checker *c, Array nodes, bool is_file_scope) { // NOTE(bill): File scope and local scope are different kinds of scopes if (is_file_scope) { GB_ASSERT(c->context.scope->is_file); diff --git a/src/common.cpp b/src/common.cpp index 0aa37a001..c61f22a62 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -43,8 +43,6 @@ gbAllocator scratch_allocator(void) { return gb_scratch_allocator(&scratch_memory); } -typedef struct DynamicArenaBlock DynamicArenaBlock; -typedef struct DynamicArena DynamicArena; struct DynamicArenaBlock { DynamicArenaBlock *prev; diff --git a/src/entity.cpp b/src/entity.cpp index 042f6f39f..d8159d449 100644 --- a/src/entity.cpp +++ b/src/entity.cpp @@ -1,7 +1,7 @@ -typedef struct Scope Scope; -typedef struct Checker Checker; -typedef struct Type Type; -typedef struct DeclInfo DeclInfo; +struct Scope; +struct Checker; +struct Type; +struct DeclInfo; // typedef enum BuiltinProcId BuiltinProcId; @@ -19,12 +19,12 @@ typedef struct DeclInfo DeclInfo; ENTITY_KIND(Nil) \ ENTITY_KIND(Label) -typedef enum EntityKind { +enum EntityKind { #define ENTITY_KIND(k) GB_JOIN2(Entity_, k), ENTITY_KINDS #undef ENTITY_KIND Entity_Count, -} EntityKind; +}; String const entity_strings[] = { #define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1}, @@ -32,7 +32,7 @@ String const entity_strings[] = { #undef ENTITY_KIND }; -typedef enum EntityFlag { +enum EntityFlag { EntityFlag_Visited = 1<<0, EntityFlag_Used = 1<<1, EntityFlag_Using = 1<<2, @@ -45,24 +45,23 @@ typedef enum EntityFlag { EntityFlag_Value = 1<<9, EntityFlag_Sret = 1<<10, EntityFlag_BitFieldValue = 1<<11, -} EntityFlag; +}; // Zero value means the overloading process is not yet done -typedef enum OverloadKind { +enum OverloadKind { Overload_Unknown, Overload_No, Overload_Yes, -} OverloadKind; +}; -typedef enum EntityAliasKind { +enum EntityAliasKind { EntityAlias_Invalid, EntityAlias_Type, EntityAlias_Entity, -} EntityAliasKind; +}; // An Entity is a named "thing" in the language -typedef struct Entity Entity; struct Entity { EntityKind kind; u64 id; diff --git a/src/exact_value.cpp b/src/exact_value.cpp index 2bdf3fdf5..62ab326ea 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -3,13 +3,13 @@ // TODO(bill): Big numbers // IMPORTANT TODO(bill): This needs to be completely fixed!!!!!!!! -typedef struct AstNode AstNode; +struct AstNode; -typedef struct Complex128 { +struct Complex128 { f64 real, imag; -} Complex128; +}; -typedef enum ExactValueKind { +enum ExactValueKind { ExactValue_Invalid, ExactValue_Bool, @@ -21,9 +21,9 @@ typedef enum ExactValueKind { ExactValue_Compound, // TODO(bill): Is this good enough? ExactValue_Count, -} ExactValueKind; +}; -typedef struct ExactValue { +struct ExactValue { ExactValueKind kind; union { bool value_bool; @@ -34,7 +34,7 @@ typedef struct ExactValue { Complex128 value_complex; AstNode * value_compound; }; -} ExactValue; +}; gb_global ExactValue const empty_exact_value = {}; diff --git a/src/ir.cpp b/src/ir.cpp index c9afb05ba..4cd1734aa 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -1,9 +1,7 @@ -typedef struct irProcedure irProcedure; -typedef struct irBlock irBlock; -typedef struct irValue irValue; -typedef struct irDebugInfo irDebugInfo; - -typedef Array irValueArray; +struct irProcedure; +struct irBlock; +struct irValue; +struct irDebugInfo; #define MAP_TYPE irValue * #define MAP_PROC map_ir_value_ @@ -16,7 +14,7 @@ typedef Array irValueArray; #include "map.cpp" -typedef struct irModule { +struct irModule { CheckerInfo * info; gbArena arena; gbArena tmp_arena; @@ -42,20 +40,20 @@ typedef struct irModule { Entity * entry_point_entity; Array procs; // NOTE(bill): All procedures with bodies - irValueArray procs_to_generate; // NOTE(bill): Procedures to generate + Array procs_to_generate; // NOTE(bill): Procedures to generate Array foreign_library_paths; // Only the ones that were used -} irModule; +}; // NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory) -typedef struct irDomNode { +struct irDomNode { irBlock * idom; // Parent (Immediate Dominator) Array children; i32 pre, post; // Ordering in tree -} irDomNode; +}; -typedef struct irBlock { +struct irBlock { i32 index; String label; irProcedure *parent; @@ -65,14 +63,13 @@ typedef struct irBlock { irDomNode dom; i32 gaps; - irValueArray instrs; - irValueArray locals; + Array instrs; + Array locals; Array preds; Array succs; -} irBlock; +}; -typedef struct irTargetList irTargetList; struct irTargetList { irTargetList *prev; irBlock * break_; @@ -80,17 +77,17 @@ struct irTargetList { irBlock * fallthrough_; }; -typedef enum irDeferExitKind { +enum irDeferExitKind { irDeferExit_Default, irDeferExit_Return, irDeferExit_Branch, -} irDeferExitKind; -typedef enum irDeferKind { +}; +enum irDeferKind { irDefer_Node, irDefer_Instr, -} irDeferKind; +}; -typedef struct irDefer { +struct irDefer { irDeferKind kind; isize scope_index; irBlock * block; @@ -99,14 +96,14 @@ typedef struct irDefer { // NOTE(bill): `instr` will be copied every time to create a new one irValue *instr; }; -} irDefer; +}; -typedef struct irBranchBlocks { +struct irBranchBlocks { AstNode *label; irBlock *break_; irBlock *continue_; -} irBranchBlocks; +}; struct irProcedure { @@ -122,7 +119,7 @@ struct irProcedure { u64 tags; irValue * return_ptr; - irValueArray params; + Array params; Array defer_stmts; Array blocks; i32 scope_index; @@ -130,7 +127,7 @@ struct irProcedure { irBlock * entry_block; irBlock * curr_block; irTargetList * target_list; - irValueArray referrers; + Array referrers; Array branch_blocks; @@ -153,7 +150,7 @@ struct irProcedure { Entity * entity; \ Type * type; \ bool zero_initialized; \ - irValueArray referrers; \ + Array referrers; \ i64 alignment; \ }) \ IR_INSTR_KIND(ZeroInit, struct { irValue *address; }) \ @@ -205,7 +202,7 @@ struct irProcedure { irValue *true_value; \ irValue *false_value; \ }) \ - IR_INSTR_KIND(Phi, struct { irValueArray edges; Type *type; }) \ + IR_INSTR_KIND(Phi, struct { Array edges; Type *type; }) \ IR_INSTR_KIND(Unreachable, i32) \ IR_INSTR_KIND(UnaryOp, struct { \ Type * type; \ @@ -261,12 +258,12 @@ struct irProcedure { IR_CONV_KIND(inttoptr) \ IR_CONV_KIND(bitcast) -typedef enum irInstrKind { +enum irInstrKind { irInstr_Invalid, #define IR_INSTR_KIND(x, ...) GB_JOIN2(irInstr_, x), IR_INSTR_KINDS #undef IR_INSTR_KIND -} irInstrKind; +}; String const ir_instr_strings[] = { {cast(u8 *)"Invalid", gb_size_of("Invalid")-1}, @@ -275,12 +272,12 @@ String const ir_instr_strings[] = { #undef IR_INSTR_KIND }; -typedef enum irConvKind { +enum irConvKind { irConv_Invalid, #define IR_CONV_KIND(x) GB_JOIN2(irConv_, x), IR_CONV_KINDS #undef IR_CONV_KIND -} irConvKind; +}; String const ir_conv_strings[] = { {cast(u8 *)"Invalid", gb_size_of("Invalid")-1}, @@ -293,7 +290,6 @@ String const ir_conv_strings[] = { IR_INSTR_KINDS #undef IR_INSTR_KIND -typedef struct irInstr irInstr; struct irInstr { irInstrKind kind; @@ -308,7 +304,7 @@ struct irInstr { }; -typedef enum irValueKind { +enum irValueKind { irValue_Invalid, irValue_Constant, @@ -323,58 +319,58 @@ typedef enum irValueKind { irValue_Instr, irValue_Count, -} irValueKind; +}; -typedef struct irValueConstant { +struct irValueConstant { Type * type; ExactValue value; -} irValueConstant; +}; -typedef struct irValueConstantSlice { +struct irValueConstantSlice { Type * type; irValue *backing_array; i64 count; -} irValueConstantSlice; +}; -typedef struct irValueNil { +struct irValueNil { Type *type; -} irValueNil; +}; -typedef struct irValueTypeName { +struct irValueTypeName { Type * type; String name; -} irValueTypeName; +}; -typedef struct irValueGlobal { +struct irValueGlobal { String name; Entity * entity; Type * type; irValue * value; - irValueArray referrers; + Array referrers; bool is_constant; bool is_private; bool is_thread_local; bool is_foreign; bool is_unnamed_addr; -} irValueGlobal; +}; -typedef enum irParamPasskind { +enum irParamPasskind { irParamPass_Value, // Pass by value irParamPass_Pointer, // Pass as a pointer rather than by value irParamPass_Integer, // Pass as an integer of the same size -} irParamPasskind; +}; -typedef struct irValueParam { +struct irValueParam { irParamPasskind kind; irProcedure * parent; Entity * entity; Type * type; Type * original_type; - irValueArray referrers; -} irValueParam; + Array referrers; +}; -typedef struct irValue { +struct irValue { irValueKind kind; i32 index; bool index_set; @@ -389,7 +385,7 @@ typedef struct irValue { irBlock Block; irInstr Instr; }; -} irValue; +}; gb_global irValue *v_zero = NULL; gb_global irValue *v_one = NULL; @@ -400,14 +396,14 @@ gb_global irValue *v_false = NULL; gb_global irValue *v_true = NULL; gb_global irValue *v_raw_nil = NULL; -typedef enum irAddrKind { +enum irAddrKind { irAddr_Default, // irAddr_Vector, irAddr_Map, irAddr_BitField, -} irAddrKind; +}; -typedef struct irAddr { +struct irAddr { irAddrKind kind; irValue * addr; union { @@ -423,7 +419,7 @@ typedef struct irAddr { // union { // struct { irValue *index; } Vector; // }; -} irAddr; +}; irAddr ir_addr(irValue *addr) { irAddr v = {irAddr_Default, addr}; @@ -444,7 +440,7 @@ irAddr ir_addr_bit_field(irValue *addr, isize bit_field_value_index) { return v; } -typedef enum irDebugEncoding { +enum irDebugEncoding { irDebugBasicEncoding_Invalid = 0, irDebugBasicEncoding_address = 1, @@ -464,9 +460,9 @@ typedef enum irDebugEncoding { irDebugBasicEncoding_structure_type = 19, irDebugBasicEncoding_union_type = 23, -} irDebugEncoding; +}; -typedef enum irDebugInfoKind { +enum irDebugInfoKind { irDebugInfo_Invalid, irDebugInfo_CompileUnit, @@ -485,9 +481,8 @@ typedef enum irDebugInfoKind { irDebugInfo_Count, -} irDebugInfoKind; +}; -typedef struct irDebugInfo irDebugInfo; struct irDebugInfo { irDebugInfoKind kind; i32 id; @@ -569,14 +564,13 @@ struct irDebugInfo { }; - -typedef struct irGen { +struct irGen { irModule module; gbFile output_file; bool opt_called; String output_base; String output_name; -} irGen; +}; @@ -698,7 +692,7 @@ void ir_set_instr_parent(irValue *instr, irBlock *parent) { } } -irValueArray *ir_value_referrers(irValue *v) { +Array *ir_value_referrers(irValue *v) { switch (v->kind) { case irValue_Global: return &v->Global.referrers; @@ -969,7 +963,7 @@ irValue *ir_instr_if(irProcedure *p, irValue *cond, irBlock *true_block, irBlock } -irValue *ir_instr_phi(irProcedure *p, irValueArray edges, Type *type) { +irValue *ir_instr_phi(irProcedure *p, Array edges, Type *type) { irValue *v = ir_alloc_instr(p, irInstr_Phi); irInstr *i = &v->Instr; i->Phi.edges = edges; @@ -3387,7 +3381,7 @@ irValue *ir_emit_logical_binary_expr(irProcedure *proc, AstNode *expr) { return ir_build_expr(proc, be->right); } - irValueArray edges = {}; + Array edges = {}; array_init(&edges, proc->module->allocator, done->preds.count+1); for_array(i, done->preds) { array_add(&edges, short_circuit); @@ -3613,7 +3607,7 @@ irValue *ir_find_global_variable(irProcedure *proc, String name) { return *value; } -void ir_build_stmt_list(irProcedure *proc, AstNodeArray stmts); +void ir_build_stmt_list(irProcedure *proc, Array stmts); bool is_double_pointer(Type *t) { @@ -3712,7 +3706,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { case_ast_node(te, TernaryExpr, expr); ir_emit_comment(proc, str_lit("TernaryExpr")); - irValueArray edges = {}; + Array edges = {}; array_init(&edges, proc->module->allocator, 2); GB_ASSERT(te->y != NULL); @@ -3752,7 +3746,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { ir_build_stmt(proc, ie->init); } - irValueArray edges = {}; + Array edges = {}; array_init(&edges, proc->module->allocator, 2); GB_ASSERT(ie->else_expr != NULL); @@ -5450,7 +5444,7 @@ irValue *ir_build_cond(irProcedure *proc, AstNode *cond, irBlock *true_block, ir -void ir_build_stmt_list(irProcedure *proc, AstNodeArray stmts) { +void ir_build_stmt_list(irProcedure *proc, Array stmts) { for_array(i, stmts) { ir_build_stmt(proc, stmts[i]); } @@ -5787,7 +5781,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } } else { // Tuple(s) Array lvals = {}; - irValueArray inits = {}; + Array inits = {}; array_init(&lvals, m->tmp_allocator, vd->names.count); array_init(&inits, m->tmp_allocator, vd->names.count); @@ -5943,7 +5937,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { irValue *init = ir_build_expr(proc, rhs); ir_addr_store(proc, lvals[0], init); } else { - irValueArray inits; + Array inits; array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { @@ -5956,7 +5950,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } } } else { - irValueArray inits; + Array inits; array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { @@ -6029,7 +6023,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } else { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena); - irValueArray results; + Array results; array_init(&results, proc->module->tmp_allocator, return_count); for_array(res_index, rs->results) { @@ -6338,7 +6332,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { ast_node(body, BlockStmt, ms->body); - AstNodeArray default_stmts = {}; + Array default_stmts = {}; irBlock *default_fall = NULL; irBlock *default_block = NULL; @@ -7116,10 +7110,10 @@ void ir_gen_tree(irGen *s) { } } - typedef struct irGlobalVariable { + struct irGlobalVariable { irValue *var, *init; DeclInfo *decl; - } irGlobalVariable; + }; Array global_variables; array_init(&global_variables, m->tmp_allocator, global_variable_max_count); diff --git a/src/ir_opt.cpp b/src/ir_opt.cpp index 856d8aaf0..c2c952b87 100644 --- a/src/ir_opt.cpp +++ b/src/ir_opt.cpp @@ -1,6 +1,6 @@ // Optimizations for the IR code -void ir_opt_add_operands(irValueArray *ops, irInstr *i) { +void ir_opt_add_operands(Array *ops, irInstr *i) { switch (i->kind) { case irInstr_Comment: break; @@ -126,8 +126,8 @@ bool ir_opt_block_has_phi(irBlock *b) { -irValueArray ir_get_block_phi_nodes(irBlock *b) { - irValueArray phis = {0}; +Array ir_get_block_phi_nodes(irBlock *b) { + Array phis = {0}; for_array(i, b->instrs) { irInstr *instr = &b->instrs[i]->Instr; if (instr->kind != irInstr_Phi) { @@ -140,7 +140,7 @@ irValueArray ir_get_block_phi_nodes(irBlock *b) { } void ir_remove_pred(irBlock *b, irBlock *p) { - irValueArray phis = ir_get_block_phi_nodes(b); + Array phis = ir_get_block_phi_nodes(b); isize i = 0; for_array(j, b->preds) { irBlock *pred = b->preds[j]; @@ -273,7 +273,7 @@ void ir_opt_blocks(irProcedure *proc) { void ir_opt_build_referrers(irProcedure *proc) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena); - irValueArray ops = {0}; // NOTE(bill): Act as a buffer + Array ops = {0}; // NOTE(bill): Act as a buffer array_init(&ops, proc->module->tmp_allocator, 64); // HACK(bill): This _could_ overflow the temp arena for_array(i, proc->blocks) { irBlock *b = proc->blocks[i]; @@ -286,7 +286,7 @@ void ir_opt_build_referrers(irProcedure *proc) { if (op == NULL) { continue; } - irValueArray *refs = ir_value_referrers(op); + Array *refs = ir_value_referrers(op); if (refs != NULL) { array_add(refs, instr); } diff --git a/src/ir_print.cpp b/src/ir_print.cpp index 81809fa0a..823960352 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -1,8 +1,8 @@ -typedef struct irFileBuffer { +struct irFileBuffer { gbVirtualMemory vm; isize offset; gbFile * output; -} irFileBuffer; +}; void ir_file_buffer_init(irFileBuffer *f, gbFile *output) { isize size = 8*gb_virtual_memory_page_size(NULL); diff --git a/src/parser.cpp b/src/parser.cpp index 2fc9f124d..120bb63cc 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -1,8 +1,8 @@ -typedef struct AstNode AstNode; -typedef struct Scope Scope; -typedef struct DeclInfo DeclInfo; +struct AstNode; +struct Scope; +struct DeclInfo; -typedef enum ParseFileError { +enum ParseFileError { ParseFile_None, ParseFile_WrongExtension, @@ -13,11 +13,10 @@ typedef enum ParseFileError { ParseFile_InvalidToken, ParseFile_Count, -} ParseFileError; +}; -typedef Array AstNodeArray; -typedef struct AstFile { +struct AstFile { i32 id; gbArena arena; Tokenizer tokenizer; @@ -32,8 +31,8 @@ typedef struct AstFile { isize expr_level; bool allow_range; // NOTE(bill): Ranges are only allowed in certain cases - AstNodeArray decls; - bool is_global_scope; + Array decls; + bool is_global_scope; AstNode * curr_proc; isize scope_level; @@ -44,15 +43,15 @@ typedef struct AstFile { #define PARSER_MAX_FIX_COUNT 6 isize fix_count; TokenPos fix_prev_pos; -} AstFile; +}; -typedef struct ImportedFile { +struct ImportedFile { String path; String rel_path; TokenPos pos; // #import -} ImportedFile; +}; -typedef struct Parser { +struct Parser { String init_fullpath; Array files; Array imports; @@ -60,9 +59,9 @@ typedef struct Parser { isize total_token_count; isize total_line_count; gbMutex mutex; -} Parser; +}; -typedef enum ProcTag { +enum ProcTag { ProcTag_bounds_check = 1<<0, ProcTag_no_bounds_check = 1<<1, @@ -75,47 +74,47 @@ typedef enum ProcTag { ProcTag_no_inline = 1<<14, // ProcTag_dll_import = 1<<15, // ProcTag_dll_export = 1<<16, -} ProcTag; +}; -typedef enum ProcCallingConvention { +enum ProcCallingConvention { ProcCC_Odin = 0, ProcCC_C = 1, ProcCC_Std = 2, ProcCC_Fast = 3, ProcCC_Invalid, -} ProcCallingConvention; +}; -typedef enum VarDeclFlag { +enum VarDeclFlag { VarDeclFlag_using = 1<<0, VarDeclFlag_immutable = 1<<1, VarDeclFlag_thread_local = 1<<2, -} VarDeclFlag; +}; -typedef enum StmtStateFlag { +enum StmtStateFlag { StmtStateFlag_bounds_check = 1<<0, StmtStateFlag_no_bounds_check = 1<<1, -} StmtStateFlag; +}; -typedef enum FieldFlag { +enum FieldFlag { FieldFlag_ellipsis = 1<<0, FieldFlag_using = 1<<1, FieldFlag_no_alias = 1<<2, FieldFlag_immutable = 1<<3, FieldFlag_Signature = FieldFlag_ellipsis|FieldFlag_using|FieldFlag_no_alias|FieldFlag_immutable, -} FieldListTag; +}; -typedef enum StmtAllowFlag { +enum StmtAllowFlag { StmtAllowFlag_None = 0, StmtAllowFlag_In = 1<<0, StmtAllowFlag_Label = 1<<1, -} StmtAllowFlag; +}; -AstNodeArray make_ast_node_array(AstFile *f) { - AstNodeArray a; +Array make_ast_node_array(AstFile *f) { + Array a; // array_init(&a, gb_arena_allocator(&f->arena)); array_init(&a, heap_allocator()); return a; @@ -147,7 +146,7 @@ AstNodeArray make_ast_node_array(AstFile *f) { }) \ AST_NODE_KIND(CompoundLit, "compound literal", struct { \ AstNode *type; \ - AstNodeArray elems; \ + Array elems; \ Token open, close; \ }) \ AST_NODE_KIND(Alias, "alias", struct { \ @@ -174,7 +173,7 @@ AST_NODE_KIND(_ExprBegin, "", i32) \ }) \ AST_NODE_KIND(CallExpr, "call expression", struct { \ AstNode * proc; \ - AstNodeArray args; \ + Array args; \ Token open; \ Token close; \ Token ellipsis; \ @@ -182,7 +181,7 @@ AST_NODE_KIND(_ExprBegin, "", i32) \ AST_NODE_KIND(MacroCallExpr, "macro call expression", struct { \ AstNode * macro; \ Token bang; \ - AstNodeArray args; \ + Array args; \ Token open; \ Token close; \ }) \ @@ -201,7 +200,7 @@ AST_NODE_KIND(_StmtBegin, "", i32) \ }) \ AST_NODE_KIND(AssignStmt, "assign statement", struct { \ Token op; \ - AstNodeArray lhs, rhs; \ + Array lhs, rhs; \ }) \ AST_NODE_KIND(IncDecStmt, "increment decrement statement", struct { \ Token op; \ @@ -209,7 +208,7 @@ AST_NODE_KIND(_StmtBegin, "", i32) \ }) \ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ AST_NODE_KIND(BlockStmt, "block statement", struct { \ - AstNodeArray stmts; \ + Array stmts; \ Token open, close; \ }) \ AST_NODE_KIND(IfStmt, "if statement", struct { \ @@ -227,7 +226,7 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ }) \ AST_NODE_KIND(ReturnStmt, "return statement", struct { \ Token token; \ - AstNodeArray results; \ + Array results; \ }) \ AST_NODE_KIND(ForStmt, "for statement", struct { \ Token token; \ @@ -248,8 +247,8 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ }) \ AST_NODE_KIND(CaseClause, "case clause", struct { \ Token token; \ - AstNodeArray list; \ - AstNodeArray stmts; \ + Array list; \ + Array stmts; \ }) \ AST_NODE_KIND(MatchStmt, "match statement", struct { \ Token token; \ @@ -268,7 +267,7 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ AST_NODE_KIND(BranchStmt, "branch statement", struct { Token token; AstNode *label; }) \ AST_NODE_KIND(UsingStmt, "using statement", struct { \ Token token; \ - AstNodeArray list; \ + Array list; \ }) \ AST_NODE_KIND(AsmOperand, "assembly operand", struct { \ Token string; \ @@ -300,9 +299,9 @@ AST_NODE_KIND(_DeclBegin, "", i32) \ AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ AST_NODE_KIND(ValueDecl, "value declaration", struct { \ bool is_var; \ - AstNodeArray names; \ + Array names; \ AstNode * type; \ - AstNodeArray values; \ + Array values; \ u32 flags; \ }) \ AST_NODE_KIND(ImportDecl, "import declaration", struct { \ @@ -327,13 +326,13 @@ AST_NODE_KIND(_DeclBegin, "", i32) \ }) \ AST_NODE_KIND(_DeclEnd, "", i32) \ AST_NODE_KIND(Field, "field", struct { \ - AstNodeArray names; \ + Array names; \ AstNode * type; \ u32 flags; \ }) \ AST_NODE_KIND(FieldList, "field list", struct { \ Token token; \ - AstNodeArray list; \ + Array list; \ }) \ AST_NODE_KIND(UnionField, "union field", struct { \ AstNode *name; \ @@ -375,7 +374,7 @@ AST_NODE_KIND(_TypeBegin, "", i32) \ }) \ AST_NODE_KIND(StructType, "struct type", struct { \ Token token; \ - AstNodeArray fields; \ + Array fields; \ isize field_count; \ bool is_packed; \ bool is_ordered; \ @@ -383,23 +382,23 @@ AST_NODE_KIND(_TypeBegin, "", i32) \ }) \ AST_NODE_KIND(UnionType, "union type", struct { \ Token token; \ - AstNodeArray fields; \ + Array fields; \ isize field_count; \ - AstNodeArray variants; \ + Array variants; \ }) \ AST_NODE_KIND(RawUnionType, "raw union type", struct { \ Token token; \ - AstNodeArray fields; \ + Array fields; \ isize field_count; \ }) \ AST_NODE_KIND(EnumType, "enum type", struct { \ Token token; \ AstNode *base_type; \ - AstNodeArray fields; /* FieldValue */ \ + Array fields; /* FieldValue */ \ }) \ AST_NODE_KIND(BitFieldType, "bit field type", struct { \ Token token; \ - AstNodeArray fields; /* FieldValue with : */ \ + Array fields; /* FieldValue with : */ \ AstNode *align; \ }) \ AST_NODE_KIND(MapType, "map type", struct { \ @@ -410,13 +409,13 @@ AST_NODE_KIND(_TypeBegin, "", i32) \ }) \ AST_NODE_KIND(_TypeEnd, "", i32) -typedef enum AstNodeKind { +enum AstNodeKind { AstNode_Invalid, #define AST_NODE_KIND(_kind_name_, ...) GB_JOIN2(AstNode_, _kind_name_), AST_NODE_KINDS #undef AST_NODE_KIND AstNode_Count, -} AstNodeKind; +}; String const ast_node_strings[] = { {cast(u8 *)"invalid node", gb_size_of("invalid node")}, @@ -429,7 +428,7 @@ String const ast_node_strings[] = { AST_NODE_KINDS #undef AST_NODE_KIND -typedef struct AstNode { +struct AstNode { AstNodeKind kind; u32 stmt_state_flags; union { @@ -437,7 +436,7 @@ typedef struct AstNode { AST_NODE_KINDS #undef AST_NODE_KIND }; -} AstNode; +}; #define ast_node(n_, Kind_, node_) GB_JOIN2(AstNode, Kind_) *n_ = &(node_)->Kind_; GB_ASSERT((node_)->kind == GB_JOIN2(AstNode_, Kind_)) @@ -560,8 +559,8 @@ Token ast_node_token(AstNode *node) { } AstNode *clone_ast_node(gbAllocator a, AstNode *node); -AstNodeArray clone_ast_node_array(gbAllocator a, AstNodeArray array) { - AstNodeArray result = {}; +Array clone_ast_node_array(gbAllocator a, Array array) { + Array result = {}; if (array.count > 0) { array_init_count(&result, a, array.count); for_array(i, array) { @@ -933,7 +932,7 @@ AstNode *ast_paren_expr(AstFile *f, AstNode *expr, Token open, Token close) { return result; } -AstNode *ast_call_expr(AstFile *f, AstNode *proc, AstNodeArray args, Token open, Token close, Token ellipsis) { +AstNode *ast_call_expr(AstFile *f, AstNode *proc, Array args, Token open, Token close, Token ellipsis) { AstNode *result = make_ast_node(f, AstNode_CallExpr); result->CallExpr.proc = proc; result->CallExpr.args = args; @@ -943,7 +942,7 @@ AstNode *ast_call_expr(AstFile *f, AstNode *proc, AstNodeArray args, Token open, return result; } -AstNode *ast_macro_call_expr(AstFile *f, AstNode *macro, Token bang, AstNodeArray args, Token open, Token close) { +AstNode *ast_macro_call_expr(AstFile *f, AstNode *macro, Token bang, Array args, Token open, Token close) { AstNode *result = make_ast_node(f, AstNode_MacroCallExpr); result->MacroCallExpr.macro = macro; result->MacroCallExpr.bang = bang; @@ -1048,7 +1047,7 @@ AstNode *ast_field_value(AstFile *f, AstNode *field, AstNode *value, Token eq) { return result; } -AstNode *ast_compound_lit(AstFile *f, AstNode *type, AstNodeArray elems, Token open, Token close) { +AstNode *ast_compound_lit(AstFile *f, AstNode *type, Array elems, Token open, Token close) { AstNode *result = make_ast_node(f, AstNode_CompoundLit); result->CompoundLit.type = type; result->CompoundLit.elems = elems; @@ -1101,7 +1100,7 @@ AstNode *ast_expr_stmt(AstFile *f, AstNode *expr) { return result; } -AstNode *ast_assign_stmt(AstFile *f, Token op, AstNodeArray lhs, AstNodeArray rhs) { +AstNode *ast_assign_stmt(AstFile *f, Token op, Array lhs, Array rhs) { AstNode *result = make_ast_node(f, AstNode_AssignStmt); result->AssignStmt.op = op; result->AssignStmt.lhs = lhs; @@ -1119,7 +1118,7 @@ AstNode *ast_inc_dec_stmt(AstFile *f, Token op, AstNode *expr) { -AstNode *ast_block_stmt(AstFile *f, AstNodeArray stmts, Token open, Token close) { +AstNode *ast_block_stmt(AstFile *f, Array stmts, Token open, Token close) { AstNode *result = make_ast_node(f, AstNode_BlockStmt); result->BlockStmt.stmts = stmts; result->BlockStmt.open = open; @@ -1147,7 +1146,7 @@ AstNode *ast_when_stmt(AstFile *f, Token token, AstNode *cond, AstNode *body, As } -AstNode *ast_return_stmt(AstFile *f, Token token, AstNodeArray results) { +AstNode *ast_return_stmt(AstFile *f, Token token, Array results) { AstNode *result = make_ast_node(f, AstNode_ReturnStmt); result->ReturnStmt.token = token; result->ReturnStmt.results = results; @@ -1194,7 +1193,7 @@ AstNode *ast_type_match_stmt(AstFile *f, Token token, AstNode *tag, AstNode *bod return result; } -AstNode *ast_case_clause(AstFile *f, Token token, AstNodeArray list, AstNodeArray stmts) { +AstNode *ast_case_clause(AstFile *f, Token token, Array list, Array stmts) { AstNode *result = make_ast_node(f, AstNode_CaseClause); result->CaseClause.token = token; result->CaseClause.list = list; @@ -1217,7 +1216,7 @@ AstNode *ast_branch_stmt(AstFile *f, Token token, AstNode *label) { return result; } -AstNode *ast_using_stmt(AstFile *f, Token token, AstNodeArray list) { +AstNode *ast_using_stmt(AstFile *f, Token token, Array list) { AstNode *result = make_ast_node(f, AstNode_UsingStmt); result->UsingStmt.token = token; result->UsingStmt.list = list; @@ -1277,7 +1276,7 @@ AstNode *ast_bad_decl(AstFile *f, Token begin, Token end) { return result; } -AstNode *ast_field(AstFile *f, AstNodeArray names, AstNode *type, u32 flags) { +AstNode *ast_field(AstFile *f, Array names, AstNode *type, u32 flags) { AstNode *result = make_ast_node(f, AstNode_Field); result->Field.names = names; result->Field.type = type; @@ -1285,7 +1284,7 @@ AstNode *ast_field(AstFile *f, AstNodeArray names, AstNode *type, u32 flags) { return result; } -AstNode *ast_field_list(AstFile *f, Token token, AstNodeArray list) { +AstNode *ast_field_list(AstFile *f, Token token, Array list) { AstNode *result = make_ast_node(f, AstNode_FieldList); result->FieldList.token = token; result->FieldList.list = list; @@ -1354,7 +1353,7 @@ AstNode *ast_vector_type(AstFile *f, Token token, AstNode *count, AstNode *elem) return result; } -AstNode *ast_struct_type(AstFile *f, Token token, AstNodeArray fields, isize field_count, +AstNode *ast_struct_type(AstFile *f, Token token, Array fields, isize field_count, bool is_packed, bool is_ordered, AstNode *align) { AstNode *result = make_ast_node(f, AstNode_StructType); result->StructType.token = token; @@ -1367,7 +1366,7 @@ AstNode *ast_struct_type(AstFile *f, Token token, AstNodeArray fields, isize fie } -AstNode *ast_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count, AstNodeArray variants) { +AstNode *ast_union_type(AstFile *f, Token token, Array fields, isize field_count, Array variants) { AstNode *result = make_ast_node(f, AstNode_UnionType); result->UnionType.token = token; result->UnionType.fields = fields; @@ -1376,7 +1375,7 @@ AstNode *ast_union_type(AstFile *f, Token token, AstNodeArray fields, isize fiel return result; } -AstNode *ast_raw_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count) { +AstNode *ast_raw_union_type(AstFile *f, Token token, Array fields, isize field_count) { AstNode *result = make_ast_node(f, AstNode_RawUnionType); result->RawUnionType.token = token; result->RawUnionType.fields = fields; @@ -1385,7 +1384,7 @@ AstNode *ast_raw_union_type(AstFile *f, Token token, AstNodeArray fields, isize } -AstNode *ast_enum_type(AstFile *f, Token token, AstNode *base_type, AstNodeArray fields) { +AstNode *ast_enum_type(AstFile *f, Token token, AstNode *base_type, Array fields) { AstNode *result = make_ast_node(f, AstNode_EnumType); result->EnumType.token = token; result->EnumType.base_type = base_type; @@ -1393,7 +1392,7 @@ AstNode *ast_enum_type(AstFile *f, Token token, AstNode *base_type, AstNodeArray return result; } -AstNode *ast_bit_field_type(AstFile *f, Token token, AstNodeArray fields, AstNode *align) { +AstNode *ast_bit_field_type(AstFile *f, Token token, Array fields, AstNode *align) { AstNode *result = make_ast_node(f, AstNode_BitFieldType); result->BitFieldType.token = token; result->BitFieldType.fields = fields; @@ -1411,7 +1410,7 @@ AstNode *ast_map_type(AstFile *f, Token token, AstNode *count, AstNode *key, Ast } -AstNode *ast_value_decl(AstFile *f, bool is_var, AstNodeArray names, AstNode *type, AstNodeArray values) { +AstNode *ast_value_decl(AstFile *f, bool is_var, Array names, AstNode *type, Array values) { AstNode *result = make_ast_node(f, AstNode_ValueDecl); result->ValueDecl.is_var = is_var; result->ValueDecl.names = names; @@ -1693,7 +1692,7 @@ void expect_semicolon(AstFile *f, AstNode *s) { AstNode * parse_expr(AstFile *f, bool lhs); AstNode * parse_proc_type(AstFile *f, AstNode **foreign_library, String *foreign_name, String *link_name); -AstNodeArray parse_stmt_list(AstFile *f); +Array parse_stmt_list(AstFile *f); AstNode * parse_stmt(AstFile *f); AstNode * parse_body(AstFile *f); @@ -1731,8 +1730,8 @@ AstNode *unparen_expr(AstNode *node) { AstNode *parse_value(AstFile *f); -AstNodeArray parse_element_list(AstFile *f) { - AstNodeArray elems = make_ast_node_array(f); +Array parse_element_list(AstFile *f) { + Array elems = make_ast_node_array(f); while (f->curr_token.kind != Token_CloseBrace && f->curr_token.kind != Token_EOF) { @@ -1754,7 +1753,7 @@ AstNodeArray parse_element_list(AstFile *f) { } AstNode *parse_literal_value(AstFile *f, AstNode *type) { - AstNodeArray elems = {}; + Array elems = {}; Token open = expect_token(f, Token_OpenBrace); f->expr_level++; if (f->curr_token.kind != Token_CloseBrace) { @@ -1946,8 +1945,8 @@ void parse_proc_tags(AstFile *f, u64 *tags, AstNode **foreign_library_token, Str } -AstNodeArray parse_lhs_expr_list(AstFile *f); -AstNodeArray parse_rhs_expr_list(AstFile *f); +Array parse_lhs_expr_list(AstFile *f); +Array parse_rhs_expr_list(AstFile *f); AstNode * parse_simple_stmt (AstFile *f, StmtAllowFlag flags); AstNode * parse_type (AstFile *f); @@ -2109,7 +2108,7 @@ bool is_literal_type(AstNode *node) { } AstNode *parse_call_expr(AstFile *f, AstNode *operand) { - AstNodeArray args = make_ast_node_array(f); + Array args = make_ast_node_array(f); Token open_paren, close_paren; Token ellipsis = {}; @@ -2144,7 +2143,7 @@ AstNode *parse_call_expr(AstFile *f, AstNode *operand) { AstNode *parse_macro_call_expr(AstFile *f, AstNode *operand) { - AstNodeArray args = make_ast_node_array(f); + Array args = make_ast_node_array(f); Token bang, open_paren, close_paren; bang = expect_token(f, Token_Not); @@ -2411,8 +2410,8 @@ AstNode *parse_expr(AstFile *f, bool lhs) { } -AstNodeArray parse_expr_list(AstFile *f, bool lhs) { - AstNodeArray list = make_ast_node_array(f); +Array parse_expr_list(AstFile *f, bool lhs) { + Array list = make_ast_node_array(f); for (;;) { AstNode *e = parse_expr(f, lhs); array_add(&list, e); @@ -2426,16 +2425,16 @@ AstNodeArray parse_expr_list(AstFile *f, bool lhs) { return list; } -AstNodeArray parse_lhs_expr_list(AstFile *f) { +Array parse_lhs_expr_list(AstFile *f) { return parse_expr_list(f, true); } -AstNodeArray parse_rhs_expr_list(AstFile *f) { +Array parse_rhs_expr_list(AstFile *f) { return parse_expr_list(f, false); } -AstNodeArray parse_ident_list(AstFile *f) { - AstNodeArray list = make_ast_node_array(f); +Array parse_ident_list(AstFile *f) { + Array list = make_ast_node_array(f); do { array_add(&list, parse_ident(f)); @@ -2470,9 +2469,9 @@ AstNode *parse_type(AstFile *f) { } -AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) { +AstNode *parse_value_decl(AstFile *f, Array lhs) { AstNode *type = NULL; - AstNodeArray values = {}; + Array values = {}; bool is_mutable = true; if (allow_token(f, Token_Colon)) { @@ -2516,7 +2515,7 @@ AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) { values = make_ast_node_array(f); } - AstNodeArray specs = {}; + Array specs = {}; array_init(&specs, heap_allocator(), 1); return ast_value_decl(f, is_mutable, lhs, type, values); } @@ -2524,7 +2523,7 @@ AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) { AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { - AstNodeArray lhs = parse_lhs_expr_list(f); + Array lhs = parse_lhs_expr_list(f); Token token = f->curr_token; switch (token.kind) { case Token_Eq: @@ -2548,7 +2547,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { return ast_bad_stmt(f, f->curr_token, f->curr_token); } next_token(f); - AstNodeArray rhs = parse_rhs_expr_list(f); + Array rhs = parse_rhs_expr_list(f); if (rhs.count == 0) { syntax_error(token, "No right-hand side in assignment statement."); return ast_bad_stmt(f, token, f->curr_token); @@ -2564,7 +2563,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { AstNode *expr = parse_expr(f, false); f->allow_range = prev_allow_range; - AstNodeArray rhs = {}; + Array rhs = {}; array_init_count(&rhs, heap_allocator(), 1); rhs[0] = expr; @@ -2638,8 +2637,8 @@ AstNode *parse_results(AstFile *f) { if (f->curr_token.kind != Token_OpenParen) { Token begin_token = f->curr_token; - AstNodeArray empty_names = {}; - AstNodeArray list = make_ast_node_array(f); + Array empty_names = {}; + Array list = make_ast_node_array(f); AstNode *type = parse_type(f); array_add(&list, ast_field(f, empty_names, type, 0)); return ast_field_list(f, begin_token, list); @@ -2698,13 +2697,13 @@ AstNode *parse_var_type(AstFile *f, bool allow_ellipsis) { } -typedef enum FieldPrefixKind { +enum FieldPrefixKind { FieldPrefix_Invalid, FieldPrefix_Using, FieldPrefix_Immutable, FieldPrefix_NoAlias, -} FieldPrefixKind; +}; FieldPrefixKind is_token_field_prefix(AstFile *f) { switch (f->curr_token.kind) { @@ -2781,13 +2780,13 @@ u32 check_field_prefixes(AstFile *f, isize name_count, u32 allowed_flags, u32 se return set_flags; } -typedef struct AstNodeAndFlags { +struct AstNodeAndFlags { AstNode *node; u32 flags; -} AstNodeAndFlags; +}; -AstNodeArray convert_to_ident_list(AstFile *f, Array list, bool ignore_flags) { - AstNodeArray idents = {}; +Array convert_to_ident_list(AstFile *f, Array list, bool ignore_flags) { + Array idents = {}; array_init(&idents, heap_allocator(), list.count); // Convert to ident list for_array(i, list) { @@ -2831,7 +2830,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok TokenKind separator = Token_Comma; Token start_token = f->curr_token; - AstNodeArray params = make_ast_node_array(f); + Array params = make_ast_node_array(f); Array list = {}; array_init(&list, heap_allocator()); // LEAK(bill): isize total_name_count = 0; bool allow_ellipsis = allowed_flags&FieldFlag_ellipsis; @@ -2850,7 +2849,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok } if (f->curr_token.kind == Token_Colon) { - AstNodeArray names = convert_to_ident_list(f, list, true); // Copy for semantic reasons + Array names = convert_to_ident_list(f, list, true); // Copy for semantic reasons if (names.count == 0) { syntax_error(f->curr_token, "Empty field declaration"); } @@ -2871,7 +2870,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok while (f->curr_token.kind != follow && f->curr_token.kind != Token_EOF) { u32 set_flags = parse_field_prefixes(f); - AstNodeArray names = parse_ident_list(f); + Array names = parse_ident_list(f); if (names.count == 0) { syntax_error(f->curr_token, "Empty field declaration"); break; @@ -2894,7 +2893,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok } for_array(i, list) { - AstNodeArray names = {}; + Array names = {}; AstNode *type = list[i].node; Token token = blank_token; @@ -3052,7 +3051,7 @@ AstNode *parse_type_or_ident(AstFile *f) { AstNode *fields = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("struct")); Token close = expect_token(f, Token_CloseBrace); - AstNodeArray decls = {}; + Array decls = {}; if (fields != NULL) { GB_ASSERT(fields->kind == AstNode_FieldList); decls = fields->FieldList.list; @@ -3064,15 +3063,15 @@ AstNode *parse_type_or_ident(AstFile *f) { case Token_union: { Token token = expect_token(f, Token_union); Token open = expect_token_after(f, Token_OpenBrace, "union"); - AstNodeArray decls = make_ast_node_array(f); - AstNodeArray variants = make_ast_node_array(f); + Array decls = make_ast_node_array(f); + Array variants = make_ast_node_array(f); isize total_decl_name_count = 0; while (f->curr_token.kind != Token_CloseBrace && f->curr_token.kind != Token_EOF) { u32 decl_flags = parse_field_prefixes(f); if (decl_flags != 0) { - AstNodeArray names = parse_ident_list(f); + Array names = parse_ident_list(f); if (names.count == 0) { syntax_error(f->curr_token, "Empty field declaration"); } @@ -3082,7 +3081,7 @@ AstNode *parse_type_or_ident(AstFile *f) { AstNode *type = parse_var_type(f, false); array_add(&decls, ast_field(f, names, type, set_flags)); } else { - AstNodeArray names = parse_ident_list(f); + Array names = parse_ident_list(f); if (names.count == 0) { break; } @@ -3121,7 +3120,7 @@ AstNode *parse_type_or_ident(AstFile *f) { AstNode *fields = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("raw_union")); Token close = expect_token(f, Token_CloseBrace); - AstNodeArray decls = {}; + Array decls = {}; if (fields != NULL) { GB_ASSERT(fields->kind == AstNode_FieldList); decls = fields->FieldList.list; @@ -3138,7 +3137,7 @@ AstNode *parse_type_or_ident(AstFile *f) { } Token open = expect_token(f, Token_OpenBrace); - AstNodeArray values = parse_element_list(f); + Array values = parse_element_list(f); Token close = expect_token(f, Token_CloseBrace); return ast_enum_type(f, token, base_type, values); @@ -3146,7 +3145,7 @@ AstNode *parse_type_or_ident(AstFile *f) { case Token_bit_field: { Token token = expect_token(f, Token_bit_field); - AstNodeArray fields = make_ast_node_array(f); + Array fields = make_ast_node_array(f); AstNode *align = NULL; Token open, close; @@ -3212,7 +3211,7 @@ AstNode *parse_type_or_ident(AstFile *f) { AstNode *parse_body(AstFile *f) { - AstNodeArray stmts = {}; + Array stmts = {}; Token open, close; isize prev_expr_level = f->expr_level; @@ -3328,7 +3327,7 @@ AstNode *parse_return_stmt(AstFile *f) { } Token token = expect_token(f, Token_return); - AstNodeArray results; + Array results; if (f->curr_token.kind != Token_Semicolon && f->curr_token.kind != Token_CloseBrace) { results = parse_rhs_expr_list(f); } else { @@ -3355,7 +3354,7 @@ AstNode *parse_return_stmt(AstFile *f) { // } // Token token = expect_token(f, Token_give); -// AstNodeArray results; +// Array results; // if (f->curr_token.kind != Token_Semicolon && f->curr_token.kind != Token_CloseBrace) { // results = parse_rhs_expr_list(f); // } else { @@ -3440,7 +3439,7 @@ AstNode *parse_for_stmt(AstFile *f) { AstNode *parse_case_clause(AstFile *f, bool is_type) { Token token = f->curr_token; - AstNodeArray list = make_ast_node_array(f); + Array list = make_ast_node_array(f); expect_token(f, Token_case); bool prev_allow_range = f->allow_range; f->allow_range = !is_type; @@ -3449,7 +3448,7 @@ AstNode *parse_case_clause(AstFile *f, bool is_type) { } f->allow_range = prev_allow_range; expect_token(f, Token_Colon); // TODO(bill): Is this the best syntax? - AstNodeArray stmts = parse_stmt_list(f); + Array stmts = parse_stmt_list(f); return ast_case_clause(f, token, list, stmts); } @@ -3467,7 +3466,7 @@ AstNode *parse_match_stmt(AstFile *f) { AstNode *body = NULL; Token open, close; bool is_type_match = false; - AstNodeArray list = make_ast_node_array(f); + Array list = make_ast_node_array(f); if (f->curr_token.kind != Token_OpenBrace) { isize prev_level = f->expr_level; @@ -3607,7 +3606,7 @@ AstNode *parse_stmt(AstFile *f) { case Token_using: { // TODO(bill): Make using statements better Token token = expect_token(f, Token_using); - AstNodeArray list = parse_lhs_expr_list(f); + Array list = parse_lhs_expr_list(f); if (list.count == 0) { syntax_error(token, "Illegal use of `using` statement"); expect_semicolon(f, NULL); @@ -3878,8 +3877,8 @@ AstNode *parse_stmt(AstFile *f) { return ast_bad_stmt(f, token, f->curr_token); } -AstNodeArray parse_stmt_list(AstFile *f) { - AstNodeArray list = make_ast_node_array(f); +Array parse_stmt_list(AstFile *f) { + Array list = make_ast_node_array(f); while (f->curr_token.kind != Token_case && f->curr_token.kind != Token_CloseBrace && @@ -4042,7 +4041,7 @@ bool is_import_path_valid(String path) { return false; } -void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray decls) { +void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, Array decls) { for_array(i, decls) { AstNode *node = decls[i]; if (!is_ast_node_decl(node) && diff --git a/src/ssa.cpp b/src/ssa.cpp index ebda96c31..010d11e6c 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -1,15 +1,15 @@ -typedef struct ssaModule ssaModule; -typedef struct ssaValue ssaValue; -typedef struct ssaValueArgs ssaValueArgs; -typedef struct ssaDefer ssaDefer; -typedef struct ssaBlock ssaBlock; -typedef struct ssaProc ssaProc; -typedef struct ssaEdge ssaEdge; -typedef struct ssaRegister ssaRegister; -typedef struct ssaTargetList ssaTargetList; -typedef enum ssaBlockKind ssaBlockKind; -typedef enum ssaBranchPrediction ssaBranchPrediction; -typedef enum ssaDeferExitKind ssaDeferExitKind; +struct ssaModule; +struct ssaValue; +struct ssaValueArgs; +struct ssaDefer; +struct ssaBlock; +struct ssaProc; +struct ssaEdge; +struct ssaRegister; +struct ssaTargetList; +enum ssaBlockKind; +enum ssaBranchPrediction; +enum ssaDeferExitKind; String ssa_mangle_name(ssaModule *m, String path, Entity *e); @@ -19,8 +19,6 @@ String ssa_mangle_name(ssaModule *m, String path, Entity *e); #define MAP_NAME MapSsaValue #include "map.cpp" -typedef Array ssaValueArray; - #include "ssa_op.cpp" #define SSA_DEFAULT_VALUE_ARG_CAPACITY 8 @@ -76,10 +74,10 @@ enum ssaBranchPrediction { ssaBranch_Unlikely = -1, }; -typedef enum ssaDeferKind { +enum ssaDeferKind { ssaDefer_Node, ssaDefer_Instr, -} ssaDeferKind; +}; struct ssaDefer { ssaDeferKind kind; @@ -106,8 +104,6 @@ struct ssaEdge { isize index; }; -typedef Array ssaEdgeArray; - struct ssaBlock { i32 id; // Unique identifier but the pointer could be used too ssaBlockKind kind; @@ -124,9 +120,9 @@ struct ssaBlock { // - BlockExit will be a memory control value ssaValue *control; - ssaValueArray values; - ssaEdgeArray preds; - ssaEdgeArray succs; + Array values; + Array preds; + Array succs; }; struct ssaTargetList { @@ -182,18 +178,18 @@ struct ssaModule { u32 stmt_state_flags; Array procs; - ssaValueArray procs_to_generate; + Array procs_to_generate; }; -typedef enum ssaAddrKind { +enum ssaAddrKind { ssaAddr_Default, ssaAddr_Map, -} ssaAddrKind; +}; -typedef struct ssaAddr { +struct ssaAddr { ssaValue * addr; ssaAddrKind kind; -} ssaAddr; +}; @@ -408,7 +404,7 @@ ssaValue *ssa_const_int(ssaProc *p, Type *t, i64 c) { ssaAddr ssa_build_addr (ssaProc *p, AstNode *expr); ssaValue *ssa_build_expr (ssaProc *p, AstNode *expr); void ssa_build_stmt (ssaProc *p, AstNode *node); -void ssa_build_stmt_list(ssaProc *p, AstNodeArray nodes); +void ssa_build_stmt_list(ssaProc *p, Array nodes); ssaValue *ssa_emit_deep_field_ptr_index(ssaProc *p, ssaValue *e, Selection sel); @@ -1870,7 +1866,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) { -void ssa_build_stmt_list(ssaProc *p, AstNodeArray nodes) { +void ssa_build_stmt_list(ssaProc *p, Array nodes) { for_array(i, nodes) { ssa_build_stmt(p, nodes[i]); } @@ -1989,7 +1985,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { } } else { Array lvals = {0}; - ssaValueArray inits = {0}; + Array inits = {0}; array_init(&lvals, m->tmp_allocator, vd->names.count); array_init(&inits, m->tmp_allocator, vd->names.count); @@ -2057,7 +2053,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { ssaValue *init = ssa_build_expr(p, rhs); ssa_addr_store(p, lvals[0], init); } else { - ssaValueArray inits; + Array inits; array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { @@ -2070,7 +2066,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { } } } else { - ssaValueArray inits; + Array inits; array_init(&inits, m->tmp_allocator, lvals.count); for_array(i, as->rhs) { diff --git a/src/ssa_op.cpp b/src/ssa_op.cpp index 4c1921065..c62e7cf77 100644 --- a/src/ssa_op.cpp +++ b/src/ssa_op.cpp @@ -267,7 +267,6 @@ enum ssaOp { SSA_OPS #undef SSA_OP }; -typedef enum ssaOp ssaOp; String const ssa_op_strings[] = { #define SSA_OP(k) {cast(u8 *)#k, gb_size_of(#k)-1}, diff --git a/src/string.cpp b/src/string.cpp index 105e9961b..6b6302ede 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -9,7 +9,7 @@ void init_string_buffer_memory(void) { // NOTE(bill): Used for UTF-8 strings -typedef struct String { +struct String { u8 * text; isize len; @@ -21,7 +21,7 @@ typedef struct String { GB_ASSERT(0 <= i && i < len); return text[i]; } -} String; +}; // NOTE(bill): used for printf style arguments #define LIT(x) ((int)(x).len), (x).text #define STR_LIT(c_str) {cast(u8 *)c_str, gb_size_of(c_str)-1} @@ -29,7 +29,7 @@ typedef struct String { // NOTE(bill): String16 is only used for Windows due to its file directories -typedef struct String16 { +struct String16 { wchar_t *text; isize len; wchar_t &operator[](isize i) { @@ -40,7 +40,7 @@ typedef struct String16 { GB_ASSERT(0 <= i && i < len); return text[i]; } -} String16; +}; gb_inline String make_string(u8 *text, isize len) { diff --git a/src/timings.cpp b/src/timings.cpp index 04c1667f4..d00d5d0ba 100644 --- a/src/timings.cpp +++ b/src/timings.cpp @@ -1,14 +1,14 @@ -typedef struct TimeStamp { +struct TimeStamp { u64 start; u64 finish; String label; -} TimeStamp; +}; -typedef struct Timings { +struct Timings { TimeStamp total; Array sections; u64 freq; -} Timings; +}; #if defined(GB_SYSTEM_WINDOWS) diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 9e4151c50..38026deeb 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -117,11 +117,11 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \ TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \ TOKEN_KIND(Token_Count, "") -typedef enum TokenKind { +enum TokenKind { #define TOKEN_KIND(e, s) e TOKEN_KINDS #undef TOKEN_KIND -} TokenKind; +}; String const token_strings[] = { #define TOKEN_KIND(e, s) {cast(u8 *)s, gb_size_of(s)-1} @@ -130,11 +130,11 @@ String const token_strings[] = { }; -typedef struct TokenPos { +struct TokenPos { String file; isize line; isize column; -} TokenPos; +}; i32 token_pos_cmp(TokenPos a, TokenPos b) { if (a.line == b.line) { @@ -152,11 +152,11 @@ bool token_pos_eq(TokenPos a, TokenPos b) { return token_pos_cmp(a, b) == 0; } -typedef struct Token { +struct Token { TokenKind kind; String string; TokenPos pos; -} Token; +}; Token empty_token = {Token_Invalid}; Token blank_token = {Token_Ident, {cast(u8 *)"_", 1}}; @@ -167,12 +167,12 @@ Token make_token_ident(String s) { } -typedef struct ErrorCollector { +struct ErrorCollector { TokenPos prev; i64 count; i64 warning_count; gbMutex mutex; -} ErrorCollector; +}; gb_global ErrorCollector global_error_collector; @@ -306,7 +306,7 @@ gb_inline bool token_is_shift(TokenKind t) { gb_inline void print_token(Token t) { gb_printf("%.*s\n", LIT(t.string)); } -typedef enum TokenizerInitError { +enum TokenizerInitError { TokenizerInit_None, TokenizerInit_Invalid, @@ -315,18 +315,18 @@ typedef enum TokenizerInitError { TokenizerInit_Empty, TokenizerInit_Count, -} TokenizerInitError; +}; -typedef struct TokenizerState { +struct TokenizerState { Rune curr_rune; // current character u8 * curr; // character pos u8 * read_curr; // pos from start u8 * line; // current line pos isize line_count; -} TokenizerState; +}; -typedef struct Tokenizer { +struct Tokenizer { String fullpath; u8 *start; u8 *end; @@ -339,7 +339,7 @@ typedef struct Tokenizer { isize error_count; Array allocated_strings; -} Tokenizer; +}; TokenizerState save_tokenizer_state(Tokenizer *t) { diff --git a/src/types.cpp b/src/types.cpp index 5ec5a40e9..4c02e2283 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -1,6 +1,6 @@ -typedef struct Scope Scope; +struct Scope; -typedef enum BasicKind { +enum BasicKind { Basic_Invalid, Basic_bool, Basic_i8, @@ -41,9 +41,9 @@ typedef enum BasicKind { Basic_COUNT, Basic_byte = Basic_u8, -} BasicKind; +}; -typedef enum BasicFlag { +enum BasicFlag { BasicFlag_Boolean = GB_BIT(0), BasicFlag_Integer = GB_BIT(1), BasicFlag_Unsigned = GB_BIT(2), @@ -57,16 +57,16 @@ typedef enum BasicFlag { BasicFlag_Numeric = BasicFlag_Integer | BasicFlag_Float | BasicFlag_Complex, BasicFlag_Ordered = BasicFlag_Integer | BasicFlag_Float | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune, BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_String | BasicFlag_Pointer | BasicFlag_Rune, -} BasicFlag; +}; -typedef struct BasicType { +struct BasicType { BasicKind kind; u32 flags; i64 size; // -1 if arch. dep. String name; -} BasicType; +}; -typedef enum TypeRecordKind { +enum TypeRecordKind { TypeRecord_Invalid, TypeRecord_Struct, @@ -75,9 +75,9 @@ typedef enum TypeRecordKind { TypeRecord_Enum, TypeRecord_Count, -} TypeRecordKind; +}; -typedef struct TypeRecord { +struct TypeRecord { TypeRecordKind kind; // All record types @@ -109,7 +109,7 @@ typedef struct TypeRecord { Entity * enum_count; Entity * enum_min_value; Entity * enum_max_value; -} TypeRecord; +}; #define TYPE_KINDS \ TYPE_KIND(Basic, BasicType) \ @@ -164,13 +164,13 @@ typedef struct TypeRecord { -typedef enum TypeKind { +enum TypeKind { Type_Invalid, #define TYPE_KIND(k, ...) GB_JOIN2(Type_, k), TYPE_KINDS #undef TYPE_KIND Type_Count, -} TypeKind; +}; String const type_strings[] = { {cast(u8 *)"Invalid", gb_size_of("Invalid")}, @@ -183,7 +183,7 @@ String const type_strings[] = { TYPE_KINDS #undef TYPE_KIND -typedef struct Type { +struct Type { TypeKind kind; union { #define TYPE_KIND(k, ...) GB_JOIN2(Type, k) k; @@ -191,16 +191,16 @@ typedef struct Type { #undef TYPE_KIND }; bool failure; -} Type; +}; // TODO(bill): Should I add extra information here specifying the kind of selection? // e.g. field, constant, vector field, type field, etc. -typedef struct Selection { +struct Selection { Entity * entity; Array index; bool indirect; // Set if there was a pointer deref anywhere down the line -} Selection; +}; Selection empty_selection = {0}; Selection make_selection(Entity *entity, Array index, bool indirect) { @@ -1199,7 +1199,7 @@ bool is_type_cte_safe(Type *type) { return false; } -typedef enum ProcTypeOverloadKind { +enum ProcTypeOverloadKind { ProcOverload_Identical, // The types are identical ProcOverload_CallingConvention, @@ -1211,7 +1211,7 @@ typedef enum ProcTypeOverloadKind { ProcOverload_NotProcedure, -} ProcTypeOverloadKind; +}; ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) { if (x == NULL && y == NULL) return ProcOverload_NotProcedure; @@ -1508,10 +1508,10 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n } -typedef struct TypePath { +struct TypePath { Array path; // Entity_TypeName; bool failure; -} TypePath; +}; void type_path_init(TypePath *tp) { // TODO(bill): Use an allocator that uses a backing array if it can and then use alternative allocator when exhausted