mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2025-12-29 09:24:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

typedef struct and start removing auto

Browse Source
This commit is contained in:
Ginger Bill
2016-11-23 11:07:35 +00:00
parent 8ecfca0c9b
commit aa2bcb166f
12 changed files with 286 additions and 308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
src/checker/checker.cpp
View File

@@ -7,7 +7,7 @@
#define MAP_NAME MapEntity
#include "../map.c"
enum AddressingMode {
typedef enum AddressingMode {
Addressing_Invalid,
Addressing_NoValue,
Addressing_Value,
@@ -16,25 +16,25 @@ enum AddressingMode {
Addressing_Type,
Addressing_Builtin,
Addressing_Count,
};
} AddressingMode;
struct Operand {
typedef struct Operand {
AddressingMode mode;
Type * type;
ExactValue value;
AstNode * expr;
BuiltinProcId builtin_id;
};
} Operand;
struct TypeAndValue {
typedef struct TypeAndValue {
AddressingMode mode;
Type * type;
ExactValue value;
};
} TypeAndValue;
struct DeclInfo {
typedef struct DeclInfo {
Scope *scope;
Entity **entities;
@@ -46,30 +46,30 @@ struct DeclInfo {
u32 var_decl_tags;
MapBool deps; // Key: Entity *
};
} DeclInfo;
struct ExprInfo {
typedef 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};
return ei;
}
struct ProcedureInfo {
typedef struct ProcedureInfo {
AstFile * file;
Token token;
DeclInfo *decl;
Type * type; // Type_Procedure
AstNode * body; // AstNode_BlockStatement
u32 tags;
};
} ProcedureInfo;
struct Scope {
typedef struct Scope {
Scope * parent;
Scope * prev, *next;
Scope * first_child;
@@ -84,15 +84,15 @@ struct Scope {
bool is_file;
bool is_init;
AstFile * file;
};
} Scope;
gb_global Scope *universal_scope = NULL;
enum ExprKind {
typedef enum ExprKind {
Expr_Expr,
Expr_Stmt,
};
} ExprKind;
enum BuiltinProcId {
typedef enum BuiltinProcId {
BuiltinProc_Invalid,
BuiltinProc_new,
@@ -129,13 +129,13 @@ enum BuiltinProcId {
BuiltinProc_enum_to_string,
BuiltinProc_Count,
};
struct BuiltinProc {
} BuiltinProcId;
typedef struct BuiltinProc {
String name;
isize arg_count;
bool variadic;
ExprKind kind;
};
} BuiltinProc;
gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = {
{STR_LIT(""), 0, false, Expr_Stmt},
@@ -173,28 +173,28 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = {
{STR_LIT("enum_to_string"), 1, false, Expr_Expr},
};
enum ImplicitValueId {
typedef enum ImplicitValueId {
ImplicitValue_Invalid,
ImplicitValue_context,
ImplicitValue_Count,
};
struct ImplicitValueInfo {
} ImplicitValueId;
typedef struct ImplicitValueInfo {
String name;
String backing_name;
Type * type;
};
} ImplicitValueInfo;
// NOTE(bill): This is initialized later
gb_global ImplicitValueInfo implicit_value_infos[ImplicitValue_Count] = {};
struct CheckerContext {
typedef struct CheckerContext {
Scope * scope;
DeclInfo *decl;
u32 stmt_state_flags;
};
} CheckerContext;
#define MAP_TYPE TypeAndValue
#define MAP_FUNC map_tav_
@@ -223,7 +223,7 @@ struct CheckerContext {
// NOTE(bill): Symbol tables
struct CheckerInfo {
typedef struct CheckerInfo {
MapTypeAndValue types; // Key: AstNode * | Expression -> Type (and value)
MapEntity definitions; // Key: AstNode * | Identifier -> Entity
MapEntity uses; // Key: AstNode * | Identifier -> Entity
@@ -235,9 +235,9 @@ struct CheckerInfo {
MapIsize type_info_map; // Key: Type *
isize type_info_count;
Entity * implicit_values[ImplicitValue_Count];
};
} CheckerInfo;
struct Checker {
typedef struct Checker {
Parser * parser;
CheckerInfo info;
@@ -255,11 +255,11 @@ struct Checker {
Array(Type *) proc_stack;
bool in_defer; // TODO(bill): Actually handle correctly
};
} Checker;
struct CycleChecker {
typedef struct CycleChecker {
Array(Entity *) path; // Entity_TypeName
};
} CycleChecker;
@@ -766,7 +766,7 @@ void add_type_info_type(Checker *c, Type *t) {
isize ti_index = -1;
for_array(i, c->info.type_info_map.entries) {
auto *e = &c->info.type_info_map.entries.e[i];
MapIsizeEntry *e = &c->info.type_info_map.entries.e[i];
Type *prev_type = cast(Type *)e->key.ptr;
if (are_types_identical(t, prev_type)) {
// Duplicate entry
@@ -931,7 +931,7 @@ MapEntity generate_minimum_dependency_map(CheckerInfo *info, Entity *start) {
map_entity_init(&map, heap_allocator());
for_array(i, info->entities.entries) {
auto *entry = &info->entities.entries.e[i];
MapDeclInfoEntry *entry = &info->entities.entries.e[i];
Entity *e = cast(Entity *)cast(uintptr)entry->key.key;
if (e->scope->is_global) {
// NOTE(bill): Require runtime stuff
@@ -1023,7 +1023,7 @@ void add_implicit_value(Checker *c, ImplicitValueId id, String name, String back
void check_global_entity(Checker *c, EntityKind kind) {
for_array(i, c->info.entities.entries) {
auto *entry = &c->info.entities.entries.e[i];
MapDeclInfoEntry *entry = &c->info.entities.entries.e[i];
Entity *e = cast(Entity *)cast(uintptr)entry->key.key;
if (e->kind == kind) {
DeclInfo *d = entry->value;
@@ -1203,7 +1203,7 @@ void check_parsed_files(Checker *c) {
ast_node(id, ImportDecl, decl);
HashKey key = hash_string(id->fullpath);
auto found = map_scope_get(&file_scopes, key);
Scope **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;
@@ -1338,7 +1338,7 @@ void check_parsed_files(Checker *c) {
// Add untyped expression values
for_array(i, c->info.untyped.entries) {
auto *entry = &c->info.untyped.entries.e[i];
MapExprInfoEntry *entry = &c->info.untyped.entries.e[i];
HashKey key = entry->key;
AstNode *expr = cast(AstNode *)cast(uintptr)key.key;
ExprInfo *info = &entry->value;
@@ -1364,29 +1364,6 @@ void check_parsed_files(Checker *c) {
}
}
// for_array(i, c->info.type_info_map.entries) {
// auto *e = &c->info.type_info_map.entries[i];
// Type *prev_type = cast(Type *)e->key.ptr;
// gb_printf("%td - %s\n", i, type_to_string(prev_type));
// }
// for_array(i, c->info.type_info_map.entries) {
// auto *p = &c->info.type_info_map.entries[i];
// for (isize j = 0; j < i-1; j++) {
// auto *q = &c->info.type_info_map.entries[j];
// Type *a = cast(Type *)p->key.ptr;
// Type *b = cast(Type *)q->key.ptr;
// p->value = i;
// // GB_ASSERT(!are_types_identical(a, b));
// }
// }
// for_array(i, c->info.type_info_map.entries) {
// auto *e = &c->info.type_info_map.entries[i];
// Type *prev_type = cast(Type *)e->key.ptr;
// gb_printf("%td - %s\n", e->value, type_to_string(prev_type));
// }
map_scope_destroy(&file_scopes);
array_free(&import_decls);
}

22
src/checker/entity.cpp
View File

@@ -1,8 +1,8 @@
struct Scope;
struct Checker;
struct Type;
enum BuiltinProcId;
enum ImplicitValueId;
typedef struct Scope Scope;
typedef struct Checker Checker;
typedef struct Type Type;
typedef enum BuiltinProcId BuiltinProcId;
typedef enum ImplicitValueId ImplicitValueId;
#define ENTITY_KINDS \
ENTITY_KIND(Invalid) \
@@ -16,11 +16,11 @@ enum ImplicitValueId;
ENTITY_KIND(ImplicitValue) \
ENTITY_KIND(Count)
enum EntityKind {
typedef enum EntityKind {
#define ENTITY_KIND(k) GB_JOIN2(Entity_, k),
ENTITY_KINDS
#undef ENTITY_KIND
};
} EntityKind;
String const entity_strings[] = {
#define ENTITY_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1},
@@ -28,16 +28,16 @@ String const entity_strings[] = {
#undef ENTITY_KIND
};
enum EntityFlag : u32 {
typedef enum EntityFlag {
EntityFlag_Visited = 1<<0,
EntityFlag_Used = 1<<1,
EntityFlag_Anonymous = 1<<2,
EntityFlag_Field = 1<<3,
EntityFlag_Param = 1<<4,
EntityFlag_VectorElem = 1<<5,
};
} EntityFlag;
struct Entity {
typedef struct Entity {
EntityKind kind;
u32 flags;
Token token;
@@ -75,7 +75,7 @@ struct Entity {
Entity * backing;
} ImplicitValue;
};
};
} Entity;
bool is_entity_exported(Entity *e) {
if (e->kind == Entity_ImportName) {

91
src/checker/expr.cpp
View File

@@ -3573,6 +3573,49 @@ void check_expr_with_type_hint(Checker *c, Operand *o, AstNode *e, Type *t) {
}
}
bool check_set_index_data(Operand *o, Type *t, i64 *max_count) {
t = base_type(type_deref(t));
switch (t->kind) {
case Type_Basic:
if (is_type_string(t)) {
if (o->mode == Addressing_Constant) {
*max_count = o->value.value_string.len;
}
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t_u8;
return true;
}
break;
case Type_Array:
*max_count = t->Array.count;
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t->Array.elem;
return true;
case Type_Vector:
*max_count = t->Vector.count;
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t->Vector.elem;
return true;
case Type_Slice:
o->type = t->Slice.elem;
o->mode = Addressing_Variable;
return true;
}
return false;
}
ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint) {
ExprKind kind = Expr_Stmt;
@@ -3892,52 +3935,8 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
Type *t = base_type(type_deref(o->type));
bool is_const = o->mode == Addressing_Constant;
auto set_index_data = [](Operand *o, Type *t, i64 *max_count) -> bool {
t = base_type(type_deref(t));
switch (t->kind) {
case Type_Basic:
if (is_type_string(t)) {
if (o->mode == Addressing_Constant) {
*max_count = o->value.value_string.len;
}
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t_u8;
return true;
}
break;
case Type_Array:
*max_count = t->Array.count;
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t->Array.elem;
return true;
case Type_Vector:
*max_count = t->Vector.count;
if (o->mode != Addressing_Variable) {
o->mode = Addressing_Value;
}
o->type = t->Vector.elem;
return true;
case Type_Slice:
o->type = t->Slice.elem;
o->mode = Addressing_Variable;
return true;
}
return false;
};
i64 max_count = -1;
bool valid = set_index_data(o, t, &max_count);
bool valid = check_set_index_data(o, t, &max_count);
if (is_const) {
valid = false;
@@ -3946,7 +3945,7 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
if (!valid && (is_type_struct(t) || is_type_raw_union(t))) {
Entity *found = find_using_index_expr(t);
if (found != NULL) {
valid = set_index_data(o, found->type, &max_count);
valid = check_set_index_data(o, found->type, &max_count);
}
}

98
src/checker/types.cpp
View File

@@ -1,6 +1,6 @@
struct Scope;
typedef struct Scope Scope;
enum BasicKind {
typedef enum BasicKind {
Basic_Invalid,
Basic_bool,
Basic_i8,
@@ -34,9 +34,9 @@ enum BasicKind {
Basic_byte = Basic_u8,
Basic_rune = Basic_i32,
};
} BasicKind;
enum BasicFlag : u32 {
typedef enum BasicFlag {
BasicFlag_Boolean = GB_BIT(0),
BasicFlag_Integer = GB_BIT(1),
BasicFlag_Unsigned = GB_BIT(2),
@@ -49,14 +49,14 @@ enum BasicFlag : u32 {
BasicFlag_Numeric = BasicFlag_Integer | BasicFlag_Float,
BasicFlag_Ordered = BasicFlag_Numeric | BasicFlag_String | BasicFlag_Pointer,
BasicFlag_ConstantType = BasicFlag_Boolean | BasicFlag_Numeric | BasicFlag_Pointer | BasicFlag_String | BasicFlag_Rune,
};
} BasicFlag;
struct BasicType {
typedef struct BasicType {
BasicKind kind;
u32 flags;
i64 size; // -1 if arch. dep.
String name;
};
} BasicType;
@@ -74,19 +74,19 @@ struct BasicType {
TYPE_KIND(Proc), \
TYPE_KIND(Count),
enum TypeKind {
#define TYPE_KIND(k) GB_JOIN2(Type_, k)
typedef enum TypeKind {
#define TYPE_KIND(k, ...) GB_JOIN2(Type_, k)
TYPE_KINDS
#undef TYPE_KIND
};
} TypeKind;
String const type_strings[] = {
#define TYPE_KIND(k) {cast(u8 *)#k, gb_size_of(#k)-1}
#define TYPE_KIND(k, ...) {cast(u8 *)#k, gb_size_of(#k)-1}
TYPE_KINDS
#undef TYPE_KIND
};
enum TypeRecordKind {
typedef enum TypeRecordKind {
TypeRecord_Invalid,
TypeRecord_Struct,
@@ -95,9 +95,9 @@ enum TypeRecordKind {
TypeRecord_Union, // Tagged
TypeRecord_Count,
};
} TypeRecordKind;
struct Type {
typedef struct Type {
TypeKind kind;
union {
BasicType Basic;
@@ -167,7 +167,42 @@ struct Type {
bool variadic;
} Proc;
};
};
} Type;
// NOTE(bill): Internal sizes of certain types
// string: 2*word_size (ptr+len)
// slice: 3*word_size (ptr+len+cap)
// array: count*size_of(elem) aligned
// NOTE(bill): Alignment of structures and other types are to be compatible with C
typedef struct BaseTypeSizes {
i64 word_size;
i64 max_align;
} BaseTypeSizes;
typedef Array(isize) Array_isize;
typedef struct Selection {
Entity * entity;
Array_isize index;
bool indirect; // Set if there was a pointer deref anywhere down the line
} Selection;
Selection empty_selection = {};
Selection make_selection(Entity *entity, Array_isize index, bool indirect) {
Selection s = {entity, index, indirect};
return s;
}
void selection_add_index(Selection *s, isize index) {
// IMPORTANT NOTE(bill): this requires a stretchy buffer/dynamic array so it requires some form
// of heap allocation
if (s->index.e == NULL) {
array_init(&s->index, heap_allocator());
}
array_add(&s->index, index);
}
@@ -793,40 +828,7 @@ Type *default_type(Type *type) {
}
// NOTE(bill): Internal sizes of certain types
// string: 2*word_size (ptr+len)
// slice: 3*word_size (ptr+len+cap)
// array: count*size_of(elem) aligned
// NOTE(bill): Alignment of structures and other types are to be compatible with C
struct BaseTypeSizes {
i64 word_size;
i64 max_align;
};
typedef Array(isize) Array_isize;
struct Selection {
Entity * entity;
Array_isize index;
bool indirect; // Set if there was a pointer deref anywhere down the line
};
Selection empty_selection = {};
Selection make_selection(Entity *entity, Array_isize index, bool indirect) {
Selection s = {entity, index, indirect};
return s;
}
void selection_add_index(Selection *s, isize index) {
// IMPORTANT NOTE(bill): this requires a stretchy buffer/dynamic array so it requires some form
// of heap allocation
if (s->index.e == NULL) {
array_init(&s->index, heap_allocator());
}
array_add(&s->index, index);
}
gb_global Entity *entity__any_type_info = NULL;
gb_global Entity *entity__any_data = NULL;

10
src/exact_value.cpp
View File

@@ -3,9 +3,9 @@
// TODO(bill): Big numbers
// IMPORTANT TODO(bill): This needs to be completely fixed!!!!!!!!
struct AstNode;
typedef struct AstNode AstNode;
enum ExactValueKind {
typedef enum ExactValueKind {
ExactValue_Invalid,
ExactValue_Bool,
@@ -16,9 +16,9 @@ enum ExactValueKind {
ExactValue_Compound, // TODO(bill): Is this good enough?
ExactValue_Count,
};
} ExactValueKind;
struct ExactValue {
typedef struct ExactValue {
ExactValueKind kind;
union {
bool value_bool;
@@ -28,7 +28,7 @@ struct ExactValue {
i64 value_pointer;
AstNode *value_compound;
};
};
} ExactValue;
HashKey hash_exact_value(ExactValue v) {
return hashing_proc(&v, gb_size_of(ExactValue));

4
src/main.cpp
View File

@@ -56,12 +56,12 @@ i32 win32_exec_command_line_app(char *name, char *fmt, ...) {
return exit_code;
}
typedef enum {
typedef enum ArchKind {
ArchKind_x64,
ArchKind_x86,
} ArchKind;
typedef struct {
typedef struct ArchData {
BaseTypeSizes sizes;
String llc_flags;
String link_flags;

46
src/parser.cpp
View File

@@ -1,8 +1,8 @@
struct AstNode;
struct Scope;
struct DeclInfo;
typedef struct AstNode AstNode;
typedef struct Scope Scope;
typedef struct DeclInfo DeclInfo;
enum ParseFileError {
typedef enum ParseFileError {
ParseFile_None,
ParseFile_WrongExtension,
@@ -13,11 +13,11 @@ enum ParseFileError {
ParseFile_InvalidToken,
ParseFile_Count,
};
} ParseFileError;
typedef Array(AstNode *) AstNodeArray;
struct AstFile {
typedef struct AstFile {
i32 id;
gbArena arena;
Tokenizer tokenizer;
@@ -43,15 +43,15 @@ struct AstFile {
#define PARSER_MAX_FIX_COUNT 6
isize fix_count;
TokenPos fix_prev_pos;
};
} AstFile;
struct ImportedFile {
typedef struct ImportedFile {
String path;
String rel_path;
TokenPos pos; // #import
};
} ImportedFile;
struct Parser {
typedef struct Parser {
String init_fullpath;
Array(AstFile) files;
Array(ImportedFile) imports;
@@ -59,9 +59,9 @@ struct Parser {
Array(String) foreign_libraries;
isize total_token_count;
gbMutex mutex;
};
} Parser;
enum ProcTag : u64 {
typedef enum ProcTag {
ProcTag_bounds_check = GB_BIT(0),
ProcTag_no_bounds_check = GB_BIT(1),
@@ -75,23 +75,23 @@ enum ProcTag : u64 {
ProcTag_stdcall = GB_BIT(16),
ProcTag_fastcall = GB_BIT(17),
// ProcTag_cdecl = GB_BIT(18),
};
} ProcTag;
enum VarDeclTag {
typedef enum VarDeclTag {
VarDeclTag_thread_local = GB_BIT(0),
};
} VarDeclTag;
enum StmtStateFlag : u32 {
typedef enum StmtStateFlag {
StmtStateFlag_bounds_check = GB_BIT(0),
StmtStateFlag_no_bounds_check = GB_BIT(1),
};
} StmtStateFlag;
enum CallExprKind {
typedef enum CallExprKind {
CallExpr_Prefix, // call(...)
CallExpr_Postfix, // a'call
CallExpr_Infix, // a ''call b
};
} CallExprKind;
AstNodeArray make_ast_node_array(AstFile *f) {
AstNodeArray a;
@@ -320,11 +320,11 @@ AST_NODE_KIND(_TypeBegin, "", struct{}) \
AST_NODE_KIND(_TypeEnd, "", struct{}) \
AST_NODE_KIND(Count, "", struct{})
enum AstNodeKind {
typedef enum AstNodeKind {
#define AST_NODE_KIND(_kind_name_, ...) GB_JOIN2(AstNode_, _kind_name_),
AST_NODE_KINDS
#undef AST_NODE_KIND
};
} AstNodeKind;
String const ast_node_strings[] = {
#define AST_NODE_KIND(_kind_name_, name, ...) {cast(u8 *)name, gb_size_of(name)-1},
@@ -336,7 +336,7 @@ String const ast_node_strings[] = {
AST_NODE_KINDS
#undef AST_NODE_KIND
struct AstNode {
typedef struct AstNode {
AstNodeKind kind;
// AstNode *prev, *next; // NOTE(bill): allow for Linked list
u32 stmt_state_flags;
@@ -345,7 +345,7 @@ 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_))

171
src/ssa.cpp
View File

@@ -15,7 +15,7 @@ typedef Array(ssaValue *) ssaValueArray;
#define MAP_NAME MapSsaDebugInfo
#include "map.c"
struct ssaModule {
typedef struct ssaModule {
CheckerInfo * info;
BaseTypeSizes sizes;
gbArena arena;
@@ -41,17 +41,17 @@ struct ssaModule {
Array(ssaProcedure *) procs; // NOTE(bill): All procedures with bodies
ssaValueArray procs_to_generate; // NOTE(bill): Procedures to generate
};
} ssaModule;
// NOTE(bill): For more info, see https://en.wikipedia.org/wiki/Dominator_(graph_theory)
struct ssaDomNode {
typedef struct ssaDomNode {
ssaBlock * idom; // Parent (Immediate Dominator)
Array(ssaBlock *) children;
i32 pre, post; // Ordering in tree
};
} ssaDomNode;
struct ssaBlock {
typedef struct ssaBlock {
i32 index;
String label;
ssaProcedure *parent;
@@ -66,8 +66,9 @@ struct ssaBlock {
Array(ssaBlock *) preds;
Array(ssaBlock *) succs;
};
} ssaBlock;
typedef struct ssaTargetList ssaTargetList;
struct ssaTargetList {
ssaTargetList *prev;
ssaBlock * break_;
@@ -75,17 +76,17 @@ struct ssaTargetList {
ssaBlock * fallthrough_;
};
enum ssaDeferExitKind {
typedef enum ssaDeferExitKind {
ssaDeferExit_Default,
ssaDeferExit_Return,
ssaDeferExit_Branch,
};
enum ssaDeferKind {
} ssaDeferExitKind;
typedef enum ssaDeferKind {
ssaDefer_Node,
ssaDefer_Instr,
};
} ssaDeferKind;
struct ssaDefer {
typedef struct ssaDefer {
ssaDeferKind kind;
isize scope_index;
ssaBlock * block;
@@ -94,8 +95,9 @@ struct ssaDefer {
// NOTE(bill): `instr` will be copied every time to create a new one
ssaValue *instr;
};
};
} ssaDefer;
typedef struct ssaProcedure ssaProcedure;
struct ssaProcedure {
ssaProcedure * parent;
Array(ssaProcedure *) children;
@@ -172,11 +174,11 @@ struct ssaProcedure {
SSA_CONV_KIND(inttoptr), \
SSA_CONV_KIND(bitcast),
enum ssaInstrKind {
typedef enum ssaInstrKind {
#define SSA_INSTR_KIND(x) GB_JOIN2(ssaInstr_, x)
SSA_INSTR_KINDS
#undef SSA_INSTR_KIND
};
} ssaInstrKind;
String const ssa_instr_strings[] = {
#define SSA_INSTR_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1}
@@ -184,11 +186,11 @@ String const ssa_instr_strings[] = {
#undef SSA_INSTR_KIND
};
enum ssaConvKind {
typedef enum ssaConvKind {
#define SSA_CONV_KIND(x) GB_JOIN2(ssaConv_, x)
SSA_CONV_KINDS
#undef SSA_CONV_KIND
};
} ssaConvKind;
String const ssa_conv_strings[] = {
#define SSA_CONV_KIND(x) {cast(u8 *)#x, gb_size_of(#x)-1}
@@ -196,6 +198,7 @@ String const ssa_conv_strings[] = {
#undef SSA_CONV_KIND
};
typedef struct ssaInstr ssaInstr;
struct ssaInstr {
ssaInstrKind kind;
@@ -330,7 +333,7 @@ struct ssaInstr {
};
enum ssaValueKind {
typedef enum ssaValueKind {
ssaValue_Invalid,
ssaValue_Constant,
@@ -345,9 +348,9 @@ enum ssaValueKind {
ssaValue_Instr,
ssaValue_Count,
};
} ssaValueKind;
struct ssaValue {
typedef struct ssaValue {
ssaValueKind kind;
i32 index;
union {
@@ -387,7 +390,7 @@ struct ssaValue {
ssaBlock Block;
ssaInstr Instr;
};
};
} ssaValue;
gb_global ssaValue *v_zero = NULL;
gb_global ssaValue *v_one = NULL;
@@ -397,19 +400,19 @@ gb_global ssaValue *v_two32 = NULL;
gb_global ssaValue *v_false = NULL;
gb_global ssaValue *v_true = NULL;
enum ssaAddrKind {
typedef enum ssaAddrKind {
ssaAddr_Default,
ssaAddr_Vector,
};
} ssaAddrKind;
struct ssaAddr {
typedef struct ssaAddr {
ssaValue * addr;
AstNode * expr; // NOTE(bill): Just for testing - probably remove later
ssaAddrKind kind;
union {
struct { ssaValue *index; } Vector;
};
};
} ssaAddr;
ssaAddr ssa_make_addr(ssaValue *addr, AstNode *expr) {
ssaAddr v = {addr, expr};
@@ -424,7 +427,7 @@ ssaAddr ssa_make_addr_vector(ssaValue *addr, ssaValue *index, AstNode *expr) {
enum ssaDebugEncoding {
typedef enum ssaDebugEncoding {
ssaDebugBasicEncoding_Invalid = 0,
ssaDebugBasicEncoding_address = 1,
@@ -444,9 +447,9 @@ enum ssaDebugEncoding {
ssaDebugBasicEncoding_structure_type = 19,
ssaDebugBasicEncoding_union_type = 23,
};
} ssaDebugEncoding;
enum ssaDebugInfoKind {
typedef enum ssaDebugInfoKind {
ssaDebugInfo_Invalid,
ssaDebugInfo_CompileUnit,
@@ -465,8 +468,9 @@ enum ssaDebugInfoKind {
ssaDebugInfo_Count,
};
} ssaDebugInfoKind;
typedef struct ssaDebugInfo ssaDebugInfo;
struct ssaDebugInfo {
ssaDebugInfoKind kind;
i32 id;
@@ -547,11 +551,11 @@ struct ssaDebugInfo {
};
};
struct ssaGen {
typedef struct ssaGen {
ssaModule module;
gbFile output_file;
bool opt_called;
};
} ssaGen;
ssaValue *ssa_lookup_member(ssaModule *m, String name) {
ssaValue **v = map_ssa_value_get(&m->members, hash_string(name));
@@ -2348,7 +2352,7 @@ isize ssa_type_info_index(CheckerInfo *info, Type *type) {
// NOTE(bill): Do manual search
// TODO(bill): This is O(n) and can be very slow
for_array(i, info->type_info_map.entries){
auto *e = &info->type_info_map.entries.e[i];
MapIsizeEntry *e = &info->type_info_map.entries.e[i];
Type *prev_type = cast(Type *)e->key.ptr;
if (are_types_identical(prev_type, type)) {
entry_index = e->value;
@@ -3277,6 +3281,18 @@ ssaValue *ssa_add_using_variable(ssaProcedure *proc, Entity *e) {
return var;
}
bool ssa_is_elem_const(ssaModule *m, AstNode *elem, Type *elem_type) {
if (base_type(elem_type) == t_any) {
return false;
}
if (elem->kind == AstNode_FieldValue) {
elem = elem->FieldValue.value;
}
TypeAndValue *tav = type_and_value_of_expression(m->info, elem);
GB_ASSERT(tav != NULL);
return tav->value.kind != ExactValue_Invalid;
}
ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
switch (expr->kind) {
case_ast_node(i, Ident, expr);
@@ -3608,18 +3624,6 @@ 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) -> bool {
if (base_type(elem_type) == t_any) {
return false;
}
if (elem->kind == AstNode_FieldValue) {
elem = elem->FieldValue.value;
}
TypeAndValue *tav = type_and_value_of_expression(m->info, elem);
GB_ASSERT(tav != NULL);
return tav->value.kind != ExactValue_Invalid;
};
switch (bt->kind) {
default: GB_PANIC("Unknown CompoundLit type: %s", type_to_string(type)); break;
@@ -3627,7 +3631,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
ssaValue *result = ssa_add_module_constant(proc->module, type, make_exact_value_compound(expr));
for_array(index, cl->elems) {
AstNode *elem = cl->elems.e[index];
if (is_elem_const(proc->module, elem, et)) {
if (ssa_is_elem_const(proc->module, elem, et)) {
continue;
}
ssaValue *field_elem = ssa_build_expr(proc, elem);
@@ -3675,7 +3679,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
}
field = st->fields[index];
if (is_elem_const(proc->module, elem, field->type)) {
if (ssa_is_elem_const(proc->module, elem, field->type)) {
continue;
}
@@ -3695,7 +3699,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
ssa_emit_store(proc, v, ssa_add_module_constant(proc->module, type, make_exact_value_compound(expr)));
for_array(i, cl->elems) {
AstNode *elem = cl->elems.e[i];
if (is_elem_const(proc->module, elem, et)) {
if (ssa_is_elem_const(proc->module, elem, et)) {
continue;
}
ssaValue *field_expr = ssa_build_expr(proc, elem);
@@ -3719,7 +3723,7 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
for_array(i, cl->elems) {
AstNode *elem = cl->elems.e[i];
if (is_elem_const(proc->module, elem, et)) {
if (ssa_is_elem_const(proc->module, elem, et)) {
continue;
}
@@ -3911,7 +3915,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) {
case_ast_node(pd, ProcDecl, node);
if (pd->body != NULL) {
auto *info = proc->module->info;
CheckerInfo *info = proc->module->info;
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));
@@ -3948,7 +3952,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) {
array_add(&proc->children, &value->Proc);
array_add(&proc->module->procs_to_generate, value);
} else {
auto *info = proc->module->info;
CheckerInfo *info = proc->module->info;
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));
@@ -4709,7 +4713,7 @@ void ssa_init_module(ssaModule *m, Checker *c) {
isize count = 0;
for_array(entry_index, m->info->type_info_map.entries) {
auto *entry = &m->info->type_info_map.entries.e[entry_index];
MapIsizeEntry *entry = &m->info->type_info_map.entries.e[entry_index];
Type *t = cast(Type *)cast(uintptr)entry->key.key;
switch (t->kind) {
@@ -4824,6 +4828,17 @@ String ssa_mangle_name(ssaGen *s, String path, String name) {
return make_string(new_name, new_name_len-1);
}
ssaValue *ssa_get_type_info_ptr(ssaProcedure *proc, ssaValue *type_info_data, Type *type) {
i32 index = cast(i32)ssa_type_info_index(proc->module->info, type);
// gb_printf_err("%d %s\n", index, type_to_string(type));
return ssa_emit_array_ep(proc, type_info_data, index);
}
ssaValue *ssa_type_info_member_offset(ssaProcedure *proc, ssaValue *data, isize count, i32 *index) {
ssaValue *offset = ssa_emit_array_ep(proc, data, *index);
*index += count;
return offset;
}
void ssa_gen_tree(ssaGen *s) {
ssaModule *m = &s->module;
@@ -4844,7 +4859,7 @@ void ssa_gen_tree(ssaGen *s) {
Entity *entry_point = NULL;
for_array(i, info->entities.entries) {
auto *entry = &info->entities.entries.e[i];
MapDeclInfoEntry *entry = &info->entities.entries.e[i];
Entity *e = cast(Entity *)cast(uintptr)entry->key.key;
String name = e->token.string;
if (e->kind == Entity_Variable) {
@@ -4866,7 +4881,7 @@ void ssa_gen_tree(ssaGen *s) {
m->min_dep_map = generate_minimum_dependency_map(info, entry_point);
for_array(i, info->entities.entries) {
auto *entry = &info->entities.entries.e[i];
MapDeclInfoEntry *entry = &info->entities.entries.e[i];
Entity *e = cast(Entity *)entry->key.ptr;
String name = e->token.string;
DeclInfo *decl = entry->value;
@@ -4948,7 +4963,7 @@ void ssa_gen_tree(ssaGen *s) {
}
for_array(i, m->members.entries) {
auto *entry = &m->members.entries.e[i];
MapSsaValueEntry *entry = &m->members.entries.e[i];
ssaValue *v = entry->value;
if (v->kind == ssaValue_Proc)
ssa_build_proc(v, NULL);
@@ -4960,7 +4975,7 @@ void ssa_gen_tree(ssaGen *s) {
isize all_proc_max_count = 0;
for_array(i, m->debug_info.entries) {
auto *entry = &m->debug_info.entries.e[i];
MapSsaDebugInfoEntry *entry = &m->debug_info.entries.e[i];
ssaDebugInfo *di = entry->value;
di->id = i;
if (di->kind == ssaDebugInfo_Proc) {
@@ -4974,7 +4989,7 @@ void ssa_gen_tree(ssaGen *s) {
for_array(i, m->debug_info.entries) {
auto *entry = &m->debug_info.entries.e[i];
MapSsaDebugInfoEntry *entry = &m->debug_info.entries.e[i];
ssaDebugInfo *di = entry->value;
di->id = i;
if (di->kind == ssaDebugInfo_Proc) {
@@ -5050,24 +5065,10 @@ void ssa_gen_tree(ssaGen *s) {
Type *t_i64_slice_ptr = make_type_pointer(a, make_type_slice(a, t_i64));
Type *t_string_slice_ptr = make_type_pointer(a, make_type_slice(a, t_string));
auto get_type_info_ptr = [](ssaProcedure *proc, ssaValue *type_info_data, Type *type) -> ssaValue * {
i32 index = cast(i32)ssa_type_info_index(proc->module->info, type);
// gb_printf_err("%d %s\n", index, type_to_string(type));
return ssa_emit_array_ep(proc, type_info_data, index);
};
i32 type_info_member_index = 0;
auto type_info_member_offset = [](ssaProcedure *proc, ssaValue *data, isize count, i32 *index) -> ssaValue * {
ssaValue *offset = ssa_emit_array_ep(proc, data, *index);
*index += count;
return offset;
};
for_array(type_info_map_index, info->type_info_map.entries) {
auto *entry = &info->type_info_map.entries.e[type_info_map_index];
MapIsizeEntry *entry = &info->type_info_map.entries.e[type_info_map_index];
Type *t = cast(Type *)cast(uintptr)entry->key.key;
t = default_type(t);
isize entry_index = entry->value;
@@ -5080,7 +5081,7 @@ void ssa_gen_tree(ssaGen *s) {
// TODO(bill): Which is better? The mangled name or actual name?
ssaValue *name = ssa_make_const_string(a, t->Named.type_name->token.string);
ssaValue *gtip = get_type_info_ptr(proc, type_info_data, t->Named.base);
ssaValue *gtip = ssa_get_type_info_ptr(proc, type_info_data, t->Named.base);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), name);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 1), gtip);
@@ -5137,17 +5138,17 @@ void ssa_gen_tree(ssaGen *s) {
case Type_Pointer: {
tag = ssa_add_local_generated(proc, t_type_info_pointer);
ssaValue *gep = get_type_info_ptr(proc, type_info_data, t->Pointer.elem);
ssaValue *gep = ssa_get_type_info_ptr(proc, type_info_data, t->Pointer.elem);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), gep);
} break;
case Type_Maybe: {
tag = ssa_add_local_generated(proc, t_type_info_maybe);
ssaValue *gep = get_type_info_ptr(proc, type_info_data, t->Maybe.elem);
ssaValue *gep = ssa_get_type_info_ptr(proc, type_info_data, t->Maybe.elem);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), gep);
} break;
case Type_Array: {
tag = ssa_add_local_generated(proc, t_type_info_array);
ssaValue *gep = get_type_info_ptr(proc, type_info_data, t->Array.elem);
ssaValue *gep = ssa_get_type_info_ptr(proc, type_info_data, t->Array.elem);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Array.elem);
@@ -5160,7 +5161,7 @@ void ssa_gen_tree(ssaGen *s) {
} break;
case Type_Slice: {
tag = ssa_add_local_generated(proc, t_type_info_slice);
ssaValue *gep = get_type_info_ptr(proc, type_info_data, t->Slice.elem);
ssaValue *gep = ssa_get_type_info_ptr(proc, type_info_data, t->Slice.elem);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Slice.elem);
@@ -5170,7 +5171,7 @@ void ssa_gen_tree(ssaGen *s) {
} break;
case Type_Vector: {
tag = ssa_add_local_generated(proc, t_type_info_vector);
ssaValue *gep = get_type_info_ptr(proc, type_info_data, t->Vector.elem);
ssaValue *gep = ssa_get_type_info_ptr(proc, type_info_data, t->Vector.elem);
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 0), gep);
isize ez = type_size_of(m->sizes, a, t->Vector.elem);
@@ -5200,13 +5201,13 @@ void ssa_gen_tree(ssaGen *s) {
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 4), ordered);
}
ssaValue *memory = type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);
ssaValue *memory = ssa_type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);
type_set_offsets(m->sizes, a, t); // NOTE(bill): Just incase the offsets have not been set yet
for (isize source_index = 0; source_index < t->Record.field_count; source_index++) {
// TODO(bill): Order fields in source order not layout order
Entity *f = t->Record.fields_in_src_order[source_index];
ssaValue *tip = get_type_info_ptr(proc, type_info_data, f->type);
ssaValue *tip = ssa_get_type_info_ptr(proc, type_info_data, f->type);
i64 foffset = t->Record.struct_offsets[f->Variable.field_index];
GB_ASSERT(f->kind == Entity_Variable && f->flags & EntityFlag_Field);
@@ -5253,7 +5254,7 @@ void ssa_gen_tree(ssaGen *s) {
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 2), align);
}
ssaValue *memory = type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);
ssaValue *memory = ssa_type_info_member_offset(proc, type_info_member_data, t->Record.field_count, &type_info_member_index);
for (isize i = 0; i < t->Record.field_count; i++) {
ssaValue *field = ssa_emit_ptr_offset(proc, memory, ssa_make_const_int(a, i));
@@ -5262,7 +5263,7 @@ void ssa_gen_tree(ssaGen *s) {
ssaValue *offset = ssa_emit_struct_ep(proc, field, 2);
Entity *f = t->Record.fields[i];
ssaValue *tip = get_type_info_ptr(proc, type_info_data, f->type);
ssaValue *tip = ssa_get_type_info_ptr(proc, type_info_data, f->type);
if (f->token.string.len > 0) {
ssa_emit_store(proc, name, ssa_make_const_string(a, f->token.string));
@@ -5291,7 +5292,7 @@ void ssa_gen_tree(ssaGen *s) {
enum_base = t_int;
}
ssaValue *base = ssa_emit_struct_ep(proc, tag, 0);
ssa_emit_store(proc, base, get_type_info_ptr(proc, type_info_data, enum_base));
ssa_emit_store(proc, base, ssa_get_type_info_ptr(proc, type_info_data, enum_base));
if (t->Record.other_field_count > 0) {
Entity **fields = t->Record.other_fields;
@@ -5368,7 +5369,7 @@ void ssa_gen_tree(ssaGen *s) {
ssa_emit_store(proc, ssa_emit_struct_ep(proc, tag, 2), align);
}
ssaValue *memory = type_info_member_offset(proc, type_info_member_data, t->Tuple.variable_count, &type_info_member_index);
ssaValue *memory = ssa_type_info_member_offset(proc, type_info_member_data, t->Tuple.variable_count, &type_info_member_index);
for (isize i = 0; i < t->Tuple.variable_count; i++) {
ssaValue *field = ssa_emit_ptr_offset(proc, memory, ssa_make_const_int(a, i));
@@ -5377,7 +5378,7 @@ void ssa_gen_tree(ssaGen *s) {
// NOTE(bill): offset is not used for tuples
Entity *f = t->Tuple.variables[i];
ssaValue *tip = get_type_info_ptr(proc, type_info_data, f->type);
ssaValue *tip = ssa_get_type_info_ptr(proc, type_info_data, f->type);
if (f->token.string.len > 0) {
ssa_emit_store(proc, name, ssa_make_const_string(a, f->token.string));
@@ -5407,10 +5408,10 @@ void ssa_gen_tree(ssaGen *s) {
ssaValue *variadic = ssa_emit_struct_ep(proc, tag, 2);
if (t->Proc.params) {
ssa_emit_store(proc, params, get_type_info_ptr(proc, type_info_data, t->Proc.params));
ssa_emit_store(proc, params, ssa_get_type_info_ptr(proc, type_info_data, t->Proc.params));
}
if (t->Proc.results) {
ssa_emit_store(proc, results, get_type_info_ptr(proc, type_info_data, t->Proc.results));
ssa_emit_store(proc, results, ssa_get_type_info_ptr(proc, type_info_data, t->Proc.results));
}
ssa_emit_store(proc, variadic, ssa_make_const_bool(a, t->Proc.variadic));

19
src/ssa_opt.cpp
View File

@@ -142,7 +142,7 @@ ssaValueArray ssa_get_block_phi_nodes(ssaBlock *b) {
}
void ssa_remove_pred(ssaBlock *b, ssaBlock *p) {
auto phis = ssa_get_block_phi_nodes(b);
ssaValueArray phis = ssa_get_block_phi_nodes(b);
isize i = 0;
for_array(j, b->preds) {
ssaBlock *pred = b->preds.e[j];
@@ -288,7 +288,7 @@ void ssa_opt_build_referrers(ssaProcedure *proc) {
if (op == NULL) {
continue;
}
auto *refs = ssa_value_referrers(op);
ssaValueArray *refs = ssa_value_referrers(op);
if (refs != NULL) {
array_add(refs, instr);
}
@@ -307,13 +307,13 @@ void ssa_opt_build_referrers(ssaProcedure *proc) {
// State of Lengauer-Tarjan algorithm
// Based on this paper: http://jgaa.info/accepted/2006/GeorgiadisTarjanWerneck2006.10.1.pdf
struct ssaLTState {
typedef struct ssaLTState {
isize count;
// NOTE(bill): These are arrays
ssaBlock **sdom; // Semidominator
ssaBlock **parent; // Parent in DFS traversal of CFG
ssaBlock **ancestor;
};
} ssaLTState;
// §2.2 - bottom of page
void ssa_lt_link(ssaLTState *lt, ssaBlock *p, ssaBlock *q) {
@@ -347,9 +347,9 @@ ssaBlock *ssa_lt_eval(ssaLTState *lt, ssaBlock *v) {
return u;
}
struct ssaDomPrePost {
typedef struct ssaDomPrePost {
i32 pre, post;
};
} ssaDomPrePost;
ssaDomPrePost ssa_opt_number_dom_tree(ssaBlock *v, i32 pre, i32 post) {
ssaDomPrePost result = {pre, post};
@@ -440,12 +440,11 @@ void ssa_opt_build_dom_tree(ssaProcedure *proc) {
}
// Calculate children relation as inverse of idom
auto *children = &w->dom.idom->dom.children;
if (children->e == NULL) {
if (w->dom.idom->dom.children.e == NULL) {
// TODO(bill): Is this good enough for memory allocations?
array_init(children, heap_allocator());
array_init(&w->dom.idom->dom.children, heap_allocator());
}
array_add(children, w);
array_add(&w->dom.idom->dom.children, w);
}
}

4
src/ssa_print.cpp
View File

@@ -1,8 +1,8 @@
struct ssaFileBuffer {
typedef struct ssaFileBuffer {
gbVirtualMemory vm;
isize offset;
gbFile * output;
};
} ssaFileBuffer;
void ssa_file_buffer_init(ssaFileBuffer *f, gbFile *output) {
isize size = 8*gb_virtual_memory_page_size(NULL);

8
src/timings.cpp
View File

@@ -1,14 +1,14 @@
struct TimeStamp {
typedef struct TimeStamp {
u64 start;
u64 finish;
String label;
};
} TimeStamp;
struct Timings {
typedef struct Timings {
TimeStamp total;
Array(TimeStamp) sections;
u64 freq;
};
} Timings;
u64 win32_time_stamp_time_now(void) {

24
src/tokenizer.cpp
View File

@@ -113,11 +113,11 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \
TOKEN_KIND(Token_Count, "")
enum TokenKind {
typedef 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}
@@ -126,11 +126,11 @@ String const token_strings[] = {
};
struct TokenPos {
typedef struct TokenPos {
String file;
isize line;
isize column;
};
} TokenPos;
i32 token_pos_cmp(TokenPos a, TokenPos b) {
if (a.line == b.line) {
@@ -149,11 +149,11 @@ bool token_pos_are_equal(TokenPos a, TokenPos b) {
}
// NOTE(bill): Text is UTF-8, thus why u8 and not char
struct Token {
typedef struct Token {
TokenKind kind;
String string;
TokenPos pos;
};
} Token;
Token empty_token = {Token_Invalid};
Token blank_token = {Token_Identifier, {cast(u8 *)"_", 1}};
@@ -164,12 +164,12 @@ Token make_token_ident(String s) {
}
struct ErrorCollector {
typedef struct ErrorCollector {
TokenPos prev;
i64 count;
i64 warning_count;
gbMutex mutex;
};
} ErrorCollector;
gb_global ErrorCollector global_error_collector;
@@ -272,7 +272,7 @@ gb_inline bool token_is_shift(Token t) {
gb_inline void print_token(Token t) { gb_printf("%.*s\n", LIT(t.string)); }
enum TokenizerInitError {
typedef enum TokenizerInitError {
TokenizerInit_None,
TokenizerInit_Invalid,
@@ -281,10 +281,10 @@ enum TokenizerInitError {
TokenizerInit_Empty,
TokenizerInit_Count,
};
} TokenizerInitError;
struct Tokenizer {
typedef struct Tokenizer {
String fullpath;
u8 *start;
u8 *end;
@@ -297,7 +297,7 @@ struct Tokenizer {
isize error_count;
Array(String) allocated_strings;
};
} Tokenizer;
void tokenizer_err(Tokenizer *t, char *msg, ...) {