ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-03 05:08:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix aprint* bug; NULL -> nullptr; Better error messages for overloaded functions

Browse Source
This commit is contained in:
Ginger Bill
2017-07-06 22:43:55 +01:00
parent eed873c6ec
commit 2db03cb4a5
22 changed files with 1319 additions and 1288 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/fmt.odin
+7 -5
View File
@@ -484,11 +484,11 @@ fmt_bool :: proc(using fi: ^FmtInfo, b: bool, verb: rune) {
fmt_write_padding :: proc(fi: ^FmtInfo, width: int) { fmt_write_padding :: proc(fi: ^FmtInfo, width: int) {
if width <= 0 do return; if width <= 0 do return;
pad_byte := u8(fi.space ? ' ' : '0'); pad_byte: u8 = fi.space ? ' ' : '0';
data := string_buffer_data(fi.buf^); for _ in 0..<width {
count := min(width, cap(data)-len(data)); write_byte(fi.buf, pad_byte);
for _ in 0..<count do write_byte(fi.buf, pad_byte); }
} }
_fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) { _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) {
@@ -531,7 +531,6 @@ _fmt_int :: proc(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: in
buf: [256]u8; buf: [256]u8;
start := 0; start := 0;
flags: strconv.IntFlag; flags: strconv.IntFlag;
if fi.hash && !fi.zero do flags |= strconv.IntFlag.Prefix; if fi.hash && !fi.zero do flags |= strconv.IntFlag.Prefix;
if fi.plus do flags |= strconv.IntFlag.Plus; if fi.plus do flags |= strconv.IntFlag.Plus;
@@ -578,6 +577,7 @@ fmt_int :: proc(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: run
case 'b': _fmt_int(fi, u, 2, is_signed, bit_size, __DIGITS_LOWER); case 'b': _fmt_int(fi, u, 2, is_signed, bit_size, __DIGITS_LOWER);
case 'o': _fmt_int(fi, u, 8, is_signed, bit_size, __DIGITS_LOWER); case 'o': _fmt_int(fi, u, 8, is_signed, bit_size, __DIGITS_LOWER);
case 'd': _fmt_int(fi, u, 10, is_signed, bit_size, __DIGITS_LOWER); case 'd': _fmt_int(fi, u, 10, is_signed, bit_size, __DIGITS_LOWER);
case 'z': _fmt_int(fi, u, 12, is_signed, bit_size, __DIGITS_LOWER);
case 'x': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_LOWER); case 'x': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_LOWER);
case 'X': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_UPPER); case 'X': _fmt_int(fi, u, 16, is_signed, bit_size, __DIGITS_UPPER);
case 'c', 'r': case 'c', 'r':
@@ -601,6 +601,8 @@ _pad :: proc(fi: ^FmtInfo, s: string) {
write_string(fi.buf, s); write_string(fi.buf, s);
return; return;
} }
width := fi.width - utf8.rune_count(s); width := fi.width - utf8.rune_count(s);
if fi.minus { // right pad if fi.minus { // right pad
write_string(fi.buf, s); write_string(fi.buf, s);
src/array.cpp
+5 -5
View File
@@ -61,7 +61,7 @@ Array<T> array_make(T *data, isize count, isize capacity) {
template <typename T> template <typename T>
void array_free(Array<T> *array) { void array_free(Array<T> *array) {
if (array->allocator.proc != NULL) { if (array->allocator.proc != nullptr) {
gb_free(array->allocator, array->data); gb_free(array->allocator, array->data);
} }
array->count = 0; array->count = 0;
@@ -123,7 +123,7 @@ void array_set_capacity(Array<T> *array, isize capacity) {
array_resize(array, capacity); array_resize(array, capacity);
} }
T *new_data = NULL; T *new_data = nullptr;
if (capacity > 0) { if (capacity > 0) {
new_data = gb_alloc_array(array->allocator, T, capacity); new_data = gb_alloc_array(array->allocator, T, capacity);
gb_memmove(new_data, array->data, gb_size_of(T) * array->capacity); gb_memmove(new_data, array->data, gb_size_of(T) * array->capacity);
@@ -147,7 +147,7 @@ typedef Array(void) ArrayVoid;
#define array_init_reserve(x_, allocator_, init_capacity_) do { \ #define array_init_reserve(x_, allocator_, init_capacity_) do { \
void **e = cast(void **)&((x_)->e); \ void **e = cast(void **)&((x_)->e); \
GB_ASSERT((x_) != NULL); \ GB_ASSERT((x_) != nullptr); \
(x_)->allocator = (allocator_); \ (x_)->allocator = (allocator_); \
(x_)->count = 0; \ (x_)->count = 0; \
(x_)->capacity = (init_capacity_); \ (x_)->capacity = (init_capacity_); \
@@ -156,7 +156,7 @@ typedef Array(void) ArrayVoid;
#define array_init_count(x_, allocator_, init_count_) do { \ #define array_init_count(x_, allocator_, init_count_) do { \
void **e = cast(void **)&((x_)->e); \ void **e = cast(void **)&((x_)->e); \
GB_ASSERT((x_) != NULL); \ GB_ASSERT((x_) != nullptr); \
(x_)->allocator = (allocator_); \ (x_)->allocator = (allocator_); \
(x_)->count = (init_count_); \ (x_)->count = (init_count_); \
(x_)->capacity = (init_count_); \ (x_)->capacity = (init_count_); \
@@ -203,7 +203,7 @@ typedef Array(void) ArrayVoid;
void array__set_capacity(void *ptr, isize capacity, isize element_size) { void array__set_capacity(void *ptr, isize capacity, isize element_size) {
ArrayVoid *x = cast(ArrayVoid *)ptr; ArrayVoid *x = cast(ArrayVoid *)ptr;
GB_ASSERT(ptr != NULL); GB_ASSERT(ptr != nullptr);
GB_ASSERT(element_size > 0); GB_ASSERT(element_size > 0);
src/build_settings.cpp
+7 -7
View File
@@ -53,9 +53,9 @@ String odin_root_dir(void) {
len = 0; len = 0;
for (;;) { for (;;) {
len = GetModuleFileNameW(NULL, &path_buf[0], path_buf.count); len = GetModuleFileNameW(nullptr, &path_buf[0], path_buf.count);
if (len == 0) { if (len == 0) {
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
if (len < path_buf.count) { if (len < path_buf.count) {
break; break;
@@ -69,7 +69,7 @@ String odin_root_dir(void) {
text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1); text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
GetModuleFileNameW(NULL, text, len); GetModuleFileNameW(nullptr, text, len);
path = string16_to_string(heap_allocator(), make_string16(text, len)); path = string16_to_string(heap_allocator(), make_string16(text, len));
for (i = path.len-1; i >= 0; i--) { for (i = path.len-1; i >= 0; i--) {
@@ -168,7 +168,7 @@ String odin_root_dir(void) {
// path without checking this link. Sorry. // path without checking this link. Sorry.
len = readlink("/proc/self/exe", &path_buf[0], path_buf.count); len = readlink("/proc/self/exe", &path_buf[0], path_buf.count);
if(len == 0) { if(len == 0) {
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
if (len < path_buf.count) { if (len < path_buf.count) {
break; break;
@@ -208,10 +208,10 @@ String path_to_fullpath(gbAllocator a, String s) {
String16 string16 = string_to_string16(string_buffer_allocator, s); String16 string16 = string_to_string16(string_buffer_allocator, s);
String result = {0}; String result = {0};
DWORD len = GetFullPathNameW(&string16[0], 0, NULL, NULL); DWORD len = GetFullPathNameW(&string16[0], 0, nullptr, nullptr);
if (len != 0) { if (len != 0) {
wchar_t *text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1); wchar_t *text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
GetFullPathNameW(&string16[0], len, text, NULL); GetFullPathNameW(&string16[0], len, text, nullptr);
text[len] = 0; text[len] = 0;
result = string16_to_string(a, make_string16(text, len)); result = string16_to_string(a, make_string16(text, len));
} }
@@ -221,7 +221,7 @@ String path_to_fullpath(gbAllocator a, String s) {
#elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX) #elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
String path_to_fullpath(gbAllocator a, String s) { String path_to_fullpath(gbAllocator a, String s) {
char *p = realpath(cast(char *)&s[0], 0); char *p = realpath(cast(char *)&s[0], 0);
if(p == NULL) return make_string_c(""); if(p == nullptr) return make_string_c("");
return make_string_c(p); return make_string_c(p);
} }
src/check_decl.cpp
+49 -49
View File
@@ -23,39 +23,39 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex
} }
if (e->type == NULL) { if (e->type == nullptr) {
e->type = t_invalid; e->type = t_invalid;
} }
return NULL; return nullptr;
} }
if (e->type == NULL) { if (e->type == nullptr) {
// NOTE(bill): Use the type of the operand // NOTE(bill): Use the type of the operand
Type *t = operand->type; Type *t = operand->type;
if (is_type_untyped(t)) { if (is_type_untyped(t)) {
if (t == t_invalid || is_type_untyped_nil(t)) { if (t == t_invalid || is_type_untyped_nil(t)) {
error(e->token, "Invalid use of untyped nil in %.*s", LIT(context_name)); error(e->token, "Invalid use of untyped nil in %.*s", LIT(context_name));
e->type = t_invalid; e->type = t_invalid;
return NULL; return nullptr;
} }
if (t == t_invalid || is_type_untyped_undef(t)) { if (t == t_invalid || is_type_untyped_undef(t)) {
error(e->token, "Invalid use of --- in %.*s", LIT(context_name)); error(e->token, "Invalid use of --- in %.*s", LIT(context_name));
e->type = t_invalid; e->type = t_invalid;
return NULL; return nullptr;
} }
t = default_type(t); t = default_type(t);
} }
if (is_type_polymorphic(t)) { if (is_type_polymorphic(t)) {
error(e->token, "Invalid use of a polymorphic type in %.*s", LIT(context_name)); error(e->token, "Invalid use of a polymorphic type in %.*s", LIT(context_name));
e->type = t_invalid; e->type = t_invalid;
return NULL; return nullptr;
} }
if (is_type_bit_field_value(t)) { if (is_type_bit_field_value(t)) {
t = default_bit_field_value_type(t); t = default_bit_field_value_type(t);
} }
if (is_type_variant(t)) { if (is_type_variant(t)) {
Type *st = base_type(t); Type *st = base_type(t);
GB_ASSERT(st->Record.variant_parent != NULL); GB_ASSERT(st->Record.variant_parent != nullptr);
t = st->Record.variant_parent; t = st->Record.variant_parent;
} }
GB_ASSERT(is_type_typed(t)); GB_ASSERT(is_type_typed(t));
@@ -66,14 +66,14 @@ Type *check_init_variable(Checker *c, Entity *e, Operand *operand, String contex
check_assignment(c, operand, e->type, context_name); check_assignment(c, operand, e->type, context_name);
if (operand->mode == Addressing_Invalid) { if (operand->mode == Addressing_Invalid) {
return NULL; return nullptr;
} }
return e->type; return e->type;
} }
void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNode *> inits, String context_name) { void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, Array<AstNode *> inits, String context_name) {
if ((lhs == NULL || lhs_count == 0) && inits.count == 0) { if ((lhs == nullptr || lhs_count == 0) && inits.count == 0) {
return; return;
} }
@@ -109,7 +109,7 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) {
if (operand->mode == Addressing_Invalid || if (operand->mode == Addressing_Invalid ||
operand->type == t_invalid || operand->type == t_invalid ||
e->type == t_invalid) { e->type == t_invalid) {
if (e->type == NULL) { if (e->type == nullptr) {
e->type = t_invalid; e->type = t_invalid;
} }
return; return;
@@ -120,7 +120,7 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) {
gbString str = expr_to_string(operand->expr); gbString str = expr_to_string(operand->expr);
error(operand->expr, "`%s` is not a constant", str); error(operand->expr, "`%s` is not a constant", str);
gb_string_free(str); gb_string_free(str);
if (e->type == NULL) { if (e->type == nullptr) {
e->type = t_invalid; e->type = t_invalid;
} }
return; return;
@@ -129,13 +129,13 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) {
gbString type_str = type_to_string(operand->type); gbString type_str = type_to_string(operand->type);
error(operand->expr, "Invalid constant type: `%s`", type_str); error(operand->expr, "Invalid constant type: `%s`", type_str);
gb_string_free(type_str); gb_string_free(type_str);
if (e->type == NULL) { if (e->type == nullptr) {
e->type = t_invalid; e->type = t_invalid;
} }
return; return;
} }
if (e->type == NULL) { // NOTE(bill): type inference if (e->type == nullptr) { // NOTE(bill): type inference
e->type = operand->type; e->type = operand->type;
} }
@@ -150,11 +150,11 @@ void check_init_constant(Checker *c, Entity *e, Operand *operand) {
} }
void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) { void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) {
GB_ASSERT(e->type == NULL); GB_ASSERT(e->type == nullptr);
String name = e->token.string; String name = e->token.string;
Type *named = make_type_named(c->allocator, name, NULL, e); Type *named = make_type_named(c->allocator, name, nullptr, e);
named->Named.type_name = e; named->Named.type_name = e;
if (def != NULL && def->kind == Type_Named) { if (def != nullptr && def->kind == Type_Named) {
def->Named.base = named; def->Named.base = named;
} }
e->type = named; e->type = named;
@@ -169,7 +169,7 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) {
} }
void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) { void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init, Type *named_type) {
GB_ASSERT(e->type == NULL); GB_ASSERT(e->type == nullptr);
GB_ASSERT(e->kind == Entity_Constant); GB_ASSERT(e->kind == Entity_Constant);
if (e->flags & EntityFlag_Visited) { if (e->flags & EntityFlag_Visited) {
@@ -192,10 +192,10 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init,
Operand operand = {}; Operand operand = {};
if (init != NULL) { if (init != nullptr) {
Entity *entity = NULL; Entity *entity = nullptr;
if (init->kind == AstNode_Ident) { if (init->kind == AstNode_Ident) {
entity = check_ident(c, &operand, init, NULL, e->type, true); entity = check_ident(c, &operand, init, nullptr, e->type, true);
} else if (init->kind == AstNode_SelectorExpr) { } else if (init->kind == AstNode_SelectorExpr) {
entity = check_selector(c, &operand, init, e->type); entity = check_selector(c, &operand, init, e->type);
} else { } else {
@@ -207,7 +207,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init,
e->kind = Entity_TypeName; e->kind = Entity_TypeName;
DeclInfo *d = c->context.decl; DeclInfo *d = c->context.decl;
if (d->type_expr != NULL) { if (d->type_expr != nullptr) {
error(e->token, "A type declaration cannot have an type parameter"); error(e->token, "A type declaration cannot have an type parameter");
} }
d->type_expr = d->init_expr; d->type_expr = d->init_expr;
@@ -217,7 +217,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init,
// NOTE(bill): Check to see if the expression it to be aliases // NOTE(bill): Check to see if the expression it to be aliases
case Addressing_Builtin: case Addressing_Builtin:
if (e->type != NULL) { if (e->type != nullptr) {
error(type_expr, "A constant alias of a built-in procedure may not have a type initializer"); error(type_expr, "A constant alias of a built-in procedure may not have a type initializer");
} }
e->kind = Entity_Builtin; e->kind = Entity_Builtin;
@@ -232,7 +232,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init,
return; return;
} }
if (entity != NULL) { if (entity != nullptr) {
switch (entity->kind) { switch (entity->kind) {
case Entity_Alias: case Entity_Alias:
e->kind = Entity_Alias; e->kind = Entity_Alias;
@@ -263,7 +263,7 @@ void check_const_decl(Checker *c, Entity *e, AstNode *type_expr, AstNode *init,
} }
} }
if (init != NULL) { if (init != nullptr) {
check_expr_or_type(c, &operand, init, e->type); check_expr_or_type(c, &operand, init, e->type);
} }
@@ -334,8 +334,8 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) {
} }
void init_entity_foreign_library(Checker *c, Entity *e) { void init_entity_foreign_library(Checker *c, Entity *e) {
AstNode *ident = NULL; AstNode *ident = nullptr;
Entity **foreign_library = NULL; Entity **foreign_library = nullptr;
switch (e->kind) { switch (e->kind) {
case Entity_Procedure: case Entity_Procedure:
@@ -350,14 +350,14 @@ void init_entity_foreign_library(Checker *c, Entity *e) {
return; return;
} }
if (ident == NULL) { if (ident == nullptr) {
error(e->token, "foreign entiies must declare which library they are from"); error(e->token, "foreign entiies must declare which library they are from");
} else if (ident->kind != AstNode_Ident) { } else if (ident->kind != AstNode_Ident) {
error(ident, "foreign library names must be an identifier"); error(ident, "foreign library names must be an identifier");
} else { } else {
String name = ident->Ident.token.string; String name = ident->Ident.token.string;
Entity *found = scope_lookup_entity(c->context.scope, name); Entity *found = scope_lookup_entity(c->context.scope, name);
if (found == NULL) { if (found == nullptr) {
if (name == "_") { if (name == "_") {
error(ident, "`_` cannot be used as a value type"); error(ident, "`_` cannot be used as a value type");
} else { } else {
@@ -374,7 +374,7 @@ void init_entity_foreign_library(Checker *c, Entity *e) {
} }
void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) { void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
GB_ASSERT(e->type == NULL); GB_ASSERT(e->type == nullptr);
if (d->proc_lit->kind != AstNode_ProcLit) { if (d->proc_lit->kind != AstNode_ProcLit) {
// TOOD(bill): Better error message // TOOD(bill): Better error message
error(d->proc_lit, "Expected a procedure to check"); error(d->proc_lit, "Expected a procedure to check");
@@ -382,10 +382,10 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
} }
Type *proc_type = e->type; Type *proc_type = e->type;
if (d->gen_proc_type != NULL) { if (d->gen_proc_type != nullptr) {
proc_type = d->gen_proc_type; proc_type = d->gen_proc_type;
} else { } else {
proc_type = make_type_proc(c->allocator, e->scope, NULL, 0, NULL, 0, false, ProcCC_Odin); proc_type = make_type_proc(c->allocator, e->scope, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
} }
e->type = proc_type; e->type = proc_type;
ast_node(pl, ProcLit, d->proc_lit); ast_node(pl, ProcLit, d->proc_lit);
@@ -437,7 +437,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
} }
if (pt->is_polymorphic) { if (pt->is_polymorphic) {
if (pl->body == NULL) { if (pl->body == nullptr) {
error(e->token, "Polymorphic procedures must have a body"); error(e->token, "Polymorphic procedures must have a body");
} }
@@ -447,7 +447,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
} }
} }
if (pl->body != NULL) { if (pl->body != nullptr) {
if (is_foreign) { if (is_foreign) {
error(pl->body, "A foreign procedure cannot have a body"); error(pl->body, "A foreign procedure cannot have a body");
} }
@@ -537,7 +537,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
} }
void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) { void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count, AstNode *type_expr, AstNode *init_expr) {
GB_ASSERT(e->type == NULL); GB_ASSERT(e->type == nullptr);
GB_ASSERT(e->kind == Entity_Variable); GB_ASSERT(e->kind == Entity_Variable);
if (e->flags & EntityFlag_Visited) { if (e->flags & EntityFlag_Visited) {
@@ -548,17 +548,17 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count
String context_name = str_lit("variable declaration"); String context_name = str_lit("variable declaration");
if (type_expr != NULL) { if (type_expr != nullptr) {
e->type = check_type(c, type_expr); e->type = check_type(c, type_expr);
} }
if (e->type != NULL && is_type_polymorphic(e->type)) { if (e->type != nullptr && is_type_polymorphic(e->type)) {
error(e->token, "Invalid use of a polymorphic type in %.*s", LIT(context_name)); error(e->token, "Invalid use of a polymorphic type in %.*s", LIT(context_name));
e->type = t_invalid; e->type = t_invalid;
} }
if (e->Variable.is_foreign) { if (e->Variable.is_foreign) {
if (init_expr != NULL) { if (init_expr != nullptr) {
error(e->token, "A foreign variable declaration cannot have a default value"); error(e->token, "A foreign variable declaration cannot have a default value");
} }
init_entity_foreign_library(c, e); init_entity_foreign_library(c, e);
@@ -583,21 +583,21 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count
} }
} }
if (init_expr == NULL) { if (init_expr == nullptr) {
if (type_expr == NULL) { if (type_expr == nullptr) {
e->type = t_invalid; e->type = t_invalid;
} }
return; return;
} }
if (entities == NULL || entity_count == 1) { if (entities == nullptr || entity_count == 1) {
GB_ASSERT(entities == NULL || entities[0] == e); GB_ASSERT(entities == nullptr || entities[0] == e);
Operand operand = {}; Operand operand = {};
check_expr(c, &operand, init_expr); check_expr(c, &operand, init_expr);
check_init_variable(c, e, &operand, context_name); check_init_variable(c, e, &operand, context_name);
} }
if (type_expr != NULL) { if (type_expr != nullptr) {
for (isize i = 0; i < entity_count; i++) { for (isize i = 0; i < entity_count; i++) {
entities[i]->type = e->type; entities[i]->type = e->type;
} }
@@ -611,13 +611,13 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count
} }
void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) { void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
if (e->type != NULL) { if (e->type != nullptr) {
return; return;
} }
if (d == NULL) { if (d == nullptr) {
d = decl_info_of_entity(&c->info, e); d = decl_info_of_entity(&c->info, e);
if (d == NULL) { if (d == nullptr) {
// TODO(bill): Err here? // TODO(bill): Err here?
e->type = t_invalid; e->type = t_invalid;
set_base_type(named_type, t_invalid); set_base_type(named_type, t_invalid);
@@ -653,7 +653,7 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) { void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNode *body) {
if (body == NULL) { if (body == nullptr) {
return; return;
} }
GB_ASSERT(body->kind == AstNode_BlockStmt); GB_ASSERT(body->kind == AstNode_BlockStmt);
@@ -690,14 +690,14 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod
Type *t = base_type(type_deref(e->type)); Type *t = base_type(type_deref(e->type));
if (is_type_struct(t) || is_type_raw_union(t)) { if (is_type_struct(t) || is_type_raw_union(t)) {
Scope *scope = scope_of_node(&c->info, t->Record.node); Scope *scope = scope_of_node(&c->info, t->Record.node);
GB_ASSERT(scope != NULL); GB_ASSERT(scope != nullptr);
for_array(i, scope->elements.entries) { for_array(i, scope->elements.entries) {
Entity *f = scope->elements.entries[i].value; Entity *f = scope->elements.entries[i].value;
if (f->kind == Entity_Variable) { if (f->kind == Entity_Variable) {
Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
uvar->Variable.is_immutable = is_immutable; uvar->Variable.is_immutable = is_immutable;
Entity *prev = scope_insert_entity(c->context.scope, uvar); Entity *prev = scope_insert_entity(c->context.scope, uvar);
if (prev != NULL) { if (prev != nullptr) {
error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); error(e->token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string));
break; break;
} }
@@ -729,7 +729,7 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod
check_scope_usage(c, c->context.scope); check_scope_usage(c, c->context.scope);
if (decl->parent != NULL) { if (decl->parent != nullptr) {
// NOTE(bill): Add the dependencies from the procedure literal (lambda) // NOTE(bill): Add the dependencies from the procedure literal (lambda)
for_array(i, decl->deps.entries) { for_array(i, decl->deps.entries) {
HashKey key = decl->deps.entries[i].key; HashKey key = decl->deps.entries[i].key;
src/check_expr.cpp
+274 -241
View File
File diff suppressed because it is too large Load Diff
src/check_stmt.cpp
+81 -81
View File
@@ -75,7 +75,7 @@ bool check_has_break(AstNode *stmt, bool implicit) {
case AstNode_IfStmt: case AstNode_IfStmt:
if (check_has_break(stmt->IfStmt.body, implicit) || if (check_has_break(stmt->IfStmt.body, implicit) ||
(stmt->IfStmt.else_stmt != NULL && check_has_break(stmt->IfStmt.else_stmt, implicit))) { (stmt->IfStmt.else_stmt != nullptr && check_has_break(stmt->IfStmt.else_stmt, implicit))) {
return true; return true;
} }
break; break;
@@ -107,7 +107,7 @@ bool check_is_terminating(AstNode *node) {
case_end; case_end;
case_ast_node(is, IfStmt, node); case_ast_node(is, IfStmt, node);
if (is->else_stmt != NULL) { if (is->else_stmt != nullptr) {
if (check_is_terminating(is->body) && if (check_is_terminating(is->body) &&
check_is_terminating(is->else_stmt)) { check_is_terminating(is->else_stmt)) {
return true; return true;
@@ -116,7 +116,7 @@ bool check_is_terminating(AstNode *node) {
case_end; case_end;
case_ast_node(ws, WhenStmt, node); case_ast_node(ws, WhenStmt, node);
if (ws->else_stmt != NULL) { if (ws->else_stmt != nullptr) {
if (check_is_terminating(ws->body) && if (check_is_terminating(ws->body) &&
check_is_terminating(ws->else_stmt)) { check_is_terminating(ws->else_stmt)) {
return true; return true;
@@ -125,7 +125,7 @@ bool check_is_terminating(AstNode *node) {
case_end; case_end;
case_ast_node(fs, ForStmt, node); case_ast_node(fs, ForStmt, node);
if (fs->cond == NULL && !check_has_break(fs->body, true)) { if (fs->cond == nullptr && !check_has_break(fs->body, true)) {
return check_is_terminating(fs->body); return check_is_terminating(fs->body);
} }
case_end; case_end;
@@ -180,7 +180,7 @@ bool check_is_terminating(AstNode *node) {
Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) { Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
if (rhs->mode == Addressing_Invalid || if (rhs->mode == Addressing_Invalid ||
(rhs->type == t_invalid && rhs->mode != Addressing_Overload)) { (rhs->type == t_invalid && rhs->mode != Addressing_Overload)) {
return NULL; return nullptr;
} }
AstNode *node = unparen_expr(lhs_node); AstNode *node = unparen_expr(lhs_node);
@@ -188,15 +188,15 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
// NOTE(bill): Ignore assignments to `_` // NOTE(bill): Ignore assignments to `_`
if (node->kind == AstNode_Ident && if (node->kind == AstNode_Ident &&
node->Ident.token.string == "_") { node->Ident.token.string == "_") {
add_entity_definition(&c->info, node, NULL); add_entity_definition(&c->info, node, nullptr);
check_assignment(c, rhs, NULL, str_lit("assignment to `_` identifier")); check_assignment(c, rhs, nullptr, str_lit("assignment to `_` identifier"));
if (rhs->mode == Addressing_Invalid) { if (rhs->mode == Addressing_Invalid) {
return NULL; return nullptr;
} }
return rhs->type; return rhs->type;
} }
Entity *e = NULL; Entity *e = nullptr;
bool used = false; bool used = false;
Operand lhs = {Addressing_Invalid}; Operand lhs = {Addressing_Invalid};
@@ -204,13 +204,13 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
check_expr(c, &lhs, lhs_node); check_expr(c, &lhs, lhs_node);
if (lhs.mode == Addressing_Invalid || if (lhs.mode == Addressing_Invalid ||
lhs.type == t_invalid) { lhs.type == t_invalid) {
return NULL; return nullptr;
} }
if (rhs->mode == Addressing_Overload) { if (rhs->mode == Addressing_Overload) {
isize overload_count = rhs->overload_count; isize overload_count = rhs->overload_count;
Entity **procs = rhs->overload_entities; Entity **procs = rhs->overload_entities;
GB_ASSERT(procs != NULL && overload_count > 0); GB_ASSERT(procs != nullptr && overload_count > 0);
// NOTE(bill): These should be done // NOTE(bill): These should be done
for (isize i = 0; i < overload_count; i++) { for (isize i = 0; i < overload_count; i++) {
@@ -228,32 +228,32 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
} }
} }
if (e != NULL) { if (e != nullptr) {
// HACK TODO(bill): Should the entities be freed as it's technically a leak // HACK TODO(bill): Should the entities be freed as it's technically a leak
rhs->mode = Addressing_Value; rhs->mode = Addressing_Value;
rhs->type = e->type; rhs->type = e->type;
rhs->overload_count = 0; rhs->overload_count = 0;
rhs->overload_entities = NULL; rhs->overload_entities = nullptr;
} }
} else { } else {
if (node->kind == AstNode_Ident) { if (node->kind == AstNode_Ident) {
ast_node(i, Ident, node); ast_node(i, Ident, node);
e = scope_lookup_entity(c->context.scope, i->token.string); e = scope_lookup_entity(c->context.scope, i->token.string);
if (e != NULL && e->kind == Entity_Variable) { if (e != nullptr && e->kind == Entity_Variable) {
used = (e->flags & EntityFlag_Used) != 0; // TODO(bill): Make backup just in case used = (e->flags & EntityFlag_Used) != 0; // TODO(bill): Make backup just in case
} }
} }
} }
if (e != NULL && used) { if (e != nullptr && used) {
e->flags |= EntityFlag_Used; e->flags |= EntityFlag_Used;
} }
Type *assignment_type = lhs.type; Type *assignment_type = lhs.type;
switch (lhs.mode) { switch (lhs.mode) {
case Addressing_Invalid: case Addressing_Invalid:
return NULL; return nullptr;
case Addressing_Variable: { case Addressing_Variable: {
if (is_type_bit_field_value(lhs.type)) { if (is_type_bit_field_value(lhs.type)) {
@@ -286,7 +286,7 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
error(rhs->expr, "Cannot assign `%s` to bit field `%s`", rhs_expr, lhs_expr); error(rhs->expr, "Cannot assign `%s` to bit field `%s`", rhs_expr, lhs_expr);
gb_string_free(rhs_expr); gb_string_free(rhs_expr);
gb_string_free(lhs_expr); gb_string_free(lhs_expr);
return NULL; return nullptr;
} }
break; break;
} }
@@ -302,7 +302,7 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
gbString str = expr_to_string(lhs.expr); gbString str = expr_to_string(lhs.expr);
error(lhs.expr, "Cannot assign to the value of a map `%s`", str); error(lhs.expr, "Cannot assign to the value of a map `%s`", str);
gb_string_free(str); gb_string_free(str);
return NULL; return nullptr;
} }
} }
} }
@@ -318,7 +318,7 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
gbString str = expr_to_string(lhs.expr); gbString str = expr_to_string(lhs.expr);
error(lhs.expr, "Cannot assign to record field `%s` in map", str); error(lhs.expr, "Cannot assign to record field `%s` in map", str);
gb_string_free(str); gb_string_free(str);
return NULL; return nullptr;
} }
} }
@@ -334,7 +334,7 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
check_assignment(c, rhs, assignment_type, str_lit("assignment")); check_assignment(c, rhs, assignment_type, str_lit("assignment"));
if (rhs->mode == Addressing_Invalid) { if (rhs->mode == Addressing_Invalid) {
return NULL; return nullptr;
} }
return rhs->type; return rhs->type;
@@ -397,7 +397,7 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) {
error(ws->cond, "Non-constant boolean `when` condition"); error(ws->cond, "Non-constant boolean `when` condition");
return; return;
} }
if (ws->body == NULL || ws->body->kind != AstNode_BlockStmt) { if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) {
error(ws->cond, "Invalid body for `when` statement"); error(ws->cond, "Invalid body for `when` statement");
return; return;
} }
@@ -420,7 +420,7 @@ void check_when_stmt(Checker *c, AstNodeWhenStmt *ws, u32 flags) {
} }
void check_label(Checker *c, AstNode *label) { void check_label(Checker *c, AstNode *label) {
if (label == NULL) { if (label == nullptr) {
return; return;
} }
ast_node(l, Label, label); ast_node(l, Label, label);
@@ -439,7 +439,7 @@ void check_label(Checker *c, AstNode *label) {
error(l->name, "A label is only allowed within a procedure"); error(l->name, "A label is only allowed within a procedure");
return; return;
} }
GB_ASSERT(c->context.decl != NULL); GB_ASSERT(c->context.decl != nullptr);
bool ok = true; bool ok = true;
for_array(i, c->context.decl->labels) { for_array(i, c->context.decl->labels) {
@@ -463,7 +463,7 @@ void check_label(Checker *c, AstNode *label) {
// Returns `true` for `continue`, `false` for `return` // Returns `true` for `continue`, `false` for `return`
bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bool is_selector, Entity *e) { bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bool is_selector, Entity *e) {
if (e == NULL) { if (e == nullptr) {
error(us->token, "`using` applied to an unknown entity"); error(us->token, "`using` applied to an unknown entity");
return true; return true;
} }
@@ -479,7 +479,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo
Entity *f = t->Record.variants[i]; Entity *f = t->Record.variants[i];
// gb_printf_err("%s\n", type_to_string(f->type)); // gb_printf_err("%s\n", type_to_string(f->type));
Entity *found = scope_insert_entity(c->context.scope, f); Entity *found = scope_insert_entity(c->context.scope, f);
if (found != NULL) { if (found != nullptr) {
gbString expr_str = expr_to_string(expr); gbString expr_str = expr_to_string(expr);
error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string)); error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string));
gb_string_free(expr_str); gb_string_free(expr_str);
@@ -491,7 +491,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo
for (isize i = 0; i < t->Record.field_count; i++) { for (isize i = 0; i < t->Record.field_count; i++) {
Entity *f = t->Record.fields[i]; Entity *f = t->Record.fields[i];
Entity *found = scope_insert_entity(c->context.scope, f); Entity *found = scope_insert_entity(c->context.scope, f);
if (found != NULL) { if (found != nullptr) {
gbString expr_str = expr_to_string(expr); gbString expr_str = expr_to_string(expr);
error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string)); error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string));
gb_string_free(expr_str); gb_string_free(expr_str);
@@ -510,7 +510,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo
for_array(i, scope->elements.entries) { for_array(i, scope->elements.entries) {
Entity *decl = scope->elements.entries[i].value; Entity *decl = scope->elements.entries[i].value;
Entity *found = scope_insert_entity(c->context.scope, decl); Entity *found = scope_insert_entity(c->context.scope, decl);
if (found != NULL) { if (found != nullptr) {
gbString expr_str = expr_to_string(expr); gbString expr_str = expr_to_string(expr);
error(us->token, error(us->token,
"Namespace collision while `using` `%s` of: %.*s\n" "Namespace collision while `using` `%s` of: %.*s\n"
@@ -539,7 +539,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo
uvar->using_expr = expr; uvar->using_expr = expr;
// } // }
Entity *prev = scope_insert_entity(c->context.scope, uvar); Entity *prev = scope_insert_entity(c->context.scope, uvar);
if (prev != NULL) { if (prev != nullptr) {
gbString expr_str = expr_to_string(expr); gbString expr_str = expr_to_string(expr);
error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(prev->token.string)); error(us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(prev->token.string));
gb_string_free(expr_str); gb_string_free(expr_str);
@@ -590,7 +590,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
case_ast_node(es, ExprStmt, node) case_ast_node(es, ExprStmt, node)
Operand operand = {Addressing_Invalid}; Operand operand = {Addressing_Invalid};
ExprKind kind = check_expr_base(c, &operand, es->expr, NULL); ExprKind kind = check_expr_base(c, &operand, es->expr, nullptr);
switch (operand.mode) { switch (operand.mode) {
case Addressing_Type: { case Addressing_Type: {
gbString str = type_to_string(operand.type); gbString str = type_to_string(operand.type);
@@ -747,7 +747,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
case_ast_node(is, IfStmt, node); case_ast_node(is, IfStmt, node);
check_open_scope(c, node); check_open_scope(c, node);
if (is->init != NULL) { if (is->init != nullptr) {
check_stmt(c, is->init, 0); check_stmt(c, is->init, 0);
} }
@@ -759,7 +759,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
check_stmt(c, is->body, mod_flags); check_stmt(c, is->body, mod_flags);
if (is->else_stmt != NULL) { if (is->else_stmt != nullptr) {
switch (is->else_stmt->kind) { switch (is->else_stmt->kind) {
case AstNode_IfStmt: case AstNode_IfStmt:
case AstNode_BlockStmt: case AstNode_BlockStmt:
@@ -931,17 +931,17 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
check_open_scope(c, node); check_open_scope(c, node);
check_label(c, fs->label); // TODO(bill): What should the label's "scope" be? check_label(c, fs->label); // TODO(bill): What should the label's "scope" be?
if (fs->init != NULL) { if (fs->init != nullptr) {
check_stmt(c, fs->init, 0); check_stmt(c, fs->init, 0);
} }
if (fs->cond != NULL) { if (fs->cond != nullptr) {
Operand o = {Addressing_Invalid}; Operand o = {Addressing_Invalid};
check_expr(c, &o, fs->cond); check_expr(c, &o, fs->cond);
if (o.mode != Addressing_Invalid && !is_type_boolean(o.type)) { if (o.mode != Addressing_Invalid && !is_type_boolean(o.type)) {
error(fs->cond, "Non-boolean condition in `for` statement"); error(fs->cond, "Non-boolean condition in `for` statement");
} }
} }
if (fs->post != NULL) { if (fs->post != nullptr) {
check_stmt(c, fs->post, 0); check_stmt(c, fs->post, 0);
if (fs->post->kind != AstNode_AssignStmt && if (fs->post->kind != AstNode_AssignStmt &&
@@ -960,8 +960,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
check_open_scope(c, node); check_open_scope(c, node);
check_label(c, rs->label); check_label(c, rs->label);
Type *val = NULL; Type *val = nullptr;
Type *idx = NULL; Type *idx = nullptr;
Entity *entities[2] = {}; Entity *entities[2] = {};
isize entity_count = 0; isize entity_count = 0;
@@ -1105,7 +1105,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
} }
} }
if (val == NULL) { if (val == nullptr) {
gbString s = expr_to_string(operand.expr); gbString s = expr_to_string(operand.expr);
gbString t = type_to_string(operand.type); gbString t = type_to_string(operand.type);
error(operand.expr, "Cannot iterate over `%s` of type `%s`", s, t); error(operand.expr, "Cannot iterate over `%s` of type `%s`", s, t);
@@ -1119,22 +1119,22 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
Type * rhs[2] = {val, idx}; Type * rhs[2] = {val, idx};
for (isize i = 0; i < 2; i++) { for (isize i = 0; i < 2; i++) {
if (lhs[i] == NULL) { if (lhs[i] == nullptr) {
continue; continue;
} }
AstNode *name = lhs[i]; AstNode *name = lhs[i];
Type * type = rhs[i]; Type * type = rhs[i];
Entity *entity = NULL; Entity *entity = nullptr;
if (name->kind == AstNode_Ident) { if (name->kind == AstNode_Ident) {
Token token = name->Ident.token; Token token = name->Ident.token;
String str = token.string; String str = token.string;
Entity *found = NULL; Entity *found = nullptr;
if (str != "_") { if (str != "_") {
found = current_scope_lookup_entity(c->context.scope, str); found = current_scope_lookup_entity(c->context.scope, str);
} }
if (found == NULL) { if (found == nullptr) {
entity = make_entity_variable(c->allocator, c->context.scope, token, type, true); entity = make_entity_variable(c->allocator, c->context.scope, token, type, true);
add_entity_definition(&c->info, name, entity); add_entity_definition(&c->info, name, entity);
} else { } else {
@@ -1149,13 +1149,13 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
error(name, "A variable declaration must be an identifier"); error(name, "A variable declaration must be an identifier");
} }
if (entity == NULL) { if (entity == nullptr) {
entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name)); entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name));
} }
entities[entity_count++] = entity; entities[entity_count++] = entity;
if (type == NULL) { if (type == nullptr) {
entity->type = t_invalid; entity->type = t_invalid;
entity->flags |= EntityFlag_Used; entity->flags |= EntityFlag_Used;
} }
@@ -1177,12 +1177,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
check_open_scope(c, node); check_open_scope(c, node);
check_label(c, ms->label); // TODO(bill): What should the label's "scope" be? check_label(c, ms->label); // TODO(bill): What should the label's "scope" be?
if (ms->init != NULL) { if (ms->init != nullptr) {
check_stmt(c, ms->init, 0); check_stmt(c, ms->init, 0);
} }
if (ms->tag != NULL) { if (ms->tag != nullptr) {
check_expr(c, &x, ms->tag); check_expr(c, &x, ms->tag);
check_assignment(c, &x, NULL, str_lit("match expression")); check_assignment(c, &x, nullptr, str_lit("match expression"));
} else { } else {
x.mode = Addressing_Constant; x.mode = Addressing_Constant;
x.type = t_bool; x.type = t_bool;
@@ -1202,11 +1202,11 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
// NOTE(bill): Check for multiple defaults // NOTE(bill): Check for multiple defaults
AstNode *first_default = NULL; AstNode *first_default = nullptr;
ast_node(bs, BlockStmt, ms->body); ast_node(bs, BlockStmt, ms->body);
for_array(i, bs->stmts) { for_array(i, bs->stmts) {
AstNode *stmt = bs->stmts[i]; AstNode *stmt = bs->stmts[i];
AstNode *default_stmt = NULL; AstNode *default_stmt = nullptr;
if (stmt->kind == AstNode_CaseClause) { if (stmt->kind == AstNode_CaseClause) {
ast_node(cc, CaseClause, stmt); ast_node(cc, CaseClause, stmt);
if (cc->list.count == 0) { if (cc->list.count == 0) {
@@ -1216,8 +1216,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
error(stmt, "Invalid AST - expected case clause"); error(stmt, "Invalid AST - expected case clause");
} }
if (default_stmt != NULL) { if (default_stmt != nullptr) {
if (first_default != NULL) { if (first_default != nullptr) {
TokenPos pos = ast_node_token(first_default).pos; TokenPos pos = ast_node_token(first_default).pos;
error(stmt, error(stmt,
"multiple `default` clauses\n" "multiple `default` clauses\n"
@@ -1323,7 +1323,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
if (y.value.kind != ExactValue_Invalid) { if (y.value.kind != ExactValue_Invalid) {
HashKey key = hash_exact_value(y.value); HashKey key = hash_exact_value(y.value);
TypeAndToken *found = map_get(&seen, key); TypeAndToken *found = map_get(&seen, key);
if (found != NULL) { if (found != nullptr) {
gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
isize count = multi_map_count(&seen, key); isize count = multi_map_count(&seen, key);
TypeAndToken *taps = gb_alloc_array(c->tmp_allocator, TypeAndToken, count); TypeAndToken *taps = gb_alloc_array(c->tmp_allocator, TypeAndToken, count);
@@ -1401,7 +1401,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
AstNode *rhs = as->rhs[0]; AstNode *rhs = as->rhs[0];
check_expr(c, &x, rhs); check_expr(c, &x, rhs);
check_assignment(c, &x, NULL, str_lit("type match expression")); check_assignment(c, &x, nullptr, str_lit("type match expression"));
match_type_kind = check_valid_type_match_type(x.type); match_type_kind = check_valid_type_match_type(x.type);
if (check_valid_type_match_type(x.type) == MatchType_Invalid) { if (check_valid_type_match_type(x.type) == MatchType_Invalid) {
gbString str = type_to_string(x.type); gbString str = type_to_string(x.type);
@@ -1413,11 +1413,11 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
bool is_ptr = is_type_pointer(x.type); bool is_ptr = is_type_pointer(x.type);
// NOTE(bill): Check for multiple defaults // NOTE(bill): Check for multiple defaults
AstNode *first_default = NULL; AstNode *first_default = nullptr;
ast_node(bs, BlockStmt, ms->body); ast_node(bs, BlockStmt, ms->body);
for_array(i, bs->stmts) { for_array(i, bs->stmts) {
AstNode *stmt = bs->stmts[i]; AstNode *stmt = bs->stmts[i];
AstNode *default_stmt = NULL; AstNode *default_stmt = nullptr;
if (stmt->kind == AstNode_CaseClause) { if (stmt->kind == AstNode_CaseClause) {
ast_node(cc, CaseClause, stmt); ast_node(cc, CaseClause, stmt);
if (cc->list.count == 0) { if (cc->list.count == 0) {
@@ -1427,8 +1427,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
error(stmt, "Invalid AST - expected case clause"); error(stmt, "Invalid AST - expected case clause");
} }
if (default_stmt != NULL) { if (default_stmt != nullptr) {
if (first_default != NULL) { if (first_default != nullptr) {
TokenPos pos = ast_node_token(first_default).pos; TokenPos pos = ast_node_token(first_default).pos;
error(stmt, error(stmt,
"Multiple `default` clauses\n" "Multiple `default` clauses\n"
@@ -1460,10 +1460,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
// TODO(bill): Make robust // TODO(bill): Make robust
Type *bt = base_type(type_deref(x.type)); Type *bt = base_type(type_deref(x.type));
Type *case_type = NULL; Type *case_type = nullptr;
for_array(type_index, cc->list) { for_array(type_index, cc->list) {
AstNode *type_expr = cc->list[type_index]; AstNode *type_expr = cc->list[type_index];
if (type_expr != NULL) { // Otherwise it's a default expression if (type_expr != nullptr) { // Otherwise it's a default expression
Operand y = {}; Operand y = {};
check_expr_or_type(c, &y, type_expr); check_expr_or_type(c, &y, type_expr);
@@ -1510,14 +1510,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
if (is_ptr && if (is_ptr &&
!is_type_any(type_deref(x.type)) && !is_type_any(type_deref(x.type)) &&
cc->list.count == 1 && cc->list.count == 1 &&
case_type != NULL) { case_type != nullptr) {
case_type = make_type_pointer(c->allocator, case_type); case_type = make_type_pointer(c->allocator, case_type);
} }
if (cc->list.count > 1) { if (cc->list.count > 1) {
case_type = NULL; case_type = nullptr;
} }
if (case_type == NULL) { if (case_type == nullptr) {
case_type = x.type; case_type = x.type;
} }
add_type_info_type(c, case_type); add_type_info_type(c, case_type);
@@ -1574,7 +1574,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
break; break;
} }
if (bs->label != NULL) { if (bs->label != nullptr) {
if (bs->label->kind != AstNode_Ident) { if (bs->label->kind != AstNode_Ident) {
error(bs->label, "A branch statement's label name must be an identifier"); error(bs->label, "A branch statement's label name must be an identifier");
return; return;
@@ -1582,8 +1582,8 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
AstNode *ident = bs->label; AstNode *ident = bs->label;
String name = ident->Ident.token.string; String name = ident->Ident.token.string;
Operand o = {}; Operand o = {};
Entity *e = check_ident(c, &o, ident, NULL, NULL, false); Entity *e = check_ident(c, &o, ident, nullptr, nullptr, false);
if (e == NULL) { if (e == nullptr) {
error(ident, "Undeclared label name: %.*s", LIT(name)); error(ident, "Undeclared label name: %.*s", LIT(name));
return; return;
} }
@@ -1603,15 +1603,15 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
} }
for_array(i, us->list) { for_array(i, us->list) {
AstNode *expr = unparen_expr(us->list[0]); AstNode *expr = unparen_expr(us->list[0]);
Entity *e = NULL; Entity *e = nullptr;
bool is_selector = false; bool is_selector = false;
if (expr->kind == AstNode_Ident) { if (expr->kind == AstNode_Ident) {
Operand o = {}; Operand o = {};
e = check_ident(c, &o, expr, NULL, NULL, true); e = check_ident(c, &o, expr, nullptr, nullptr, true);
} else if (expr->kind == AstNode_SelectorExpr) { } else if (expr->kind == AstNode_SelectorExpr) {
Operand o = {}; Operand o = {};
e = check_selector(c, &o, expr, NULL); e = check_selector(c, &o, expr, nullptr);
is_selector = true; is_selector = true;
} else if (expr->kind == AstNode_Implicit) { } else if (expr->kind == AstNode_Implicit) {
error(us->token, "`using` applied to an implicit value"); error(us->token, "`using` applied to an implicit value");
@@ -1675,23 +1675,23 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
for_array(i, vd->names) { for_array(i, vd->names) {
AstNode *name = vd->names[i]; AstNode *name = vd->names[i];
Entity *entity = NULL; Entity *entity = nullptr;
if (name->kind != AstNode_Ident) { if (name->kind != AstNode_Ident) {
error(name, "A variable declaration must be an identifier"); error(name, "A variable declaration must be an identifier");
} else { } else {
Token token = name->Ident.token; Token token = name->Ident.token;
String str = token.string; String str = token.string;
Entity *found = NULL; Entity *found = nullptr;
// NOTE(bill): Ignore assignments to `_` // NOTE(bill): Ignore assignments to `_`
if (str != "_") { if (str != "_") {
found = current_scope_lookup_entity(c->context.scope, str); found = current_scope_lookup_entity(c->context.scope, str);
} }
if (found == NULL) { if (found == nullptr) {
entity = make_entity_variable(c->allocator, c->context.scope, token, NULL, false); entity = make_entity_variable(c->allocator, c->context.scope, token, nullptr, false);
entity->identifier = name; entity->identifier = name;
AstNode *fl = c->context.curr_foreign_library; AstNode *fl = c->context.curr_foreign_library;
if (fl != NULL) { if (fl != nullptr) {
GB_ASSERT(fl->kind == AstNode_Ident); GB_ASSERT(fl->kind == AstNode_Ident);
entity->Variable.is_foreign = true; entity->Variable.is_foreign = true;
entity->Variable.foreign_library_ident = fl; entity->Variable.foreign_library_ident = fl;
@@ -1705,17 +1705,17 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
entity = found; entity = found;
} }
} }
if (entity == NULL) { if (entity == nullptr) {
entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name)); entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name));
} }
entity->parent_proc_decl = c->context.curr_proc_decl; entity->parent_proc_decl = c->context.curr_proc_decl;
entities[entity_count++] = entity; entities[entity_count++] = entity;
} }
Type *init_type = NULL; Type *init_type = nullptr;
if (vd->type) { if (vd->type) {
init_type = check_type(c, vd->type, NULL); init_type = check_type(c, vd->type, nullptr);
if (init_type == NULL) { if (init_type == nullptr) {
init_type = t_invalid; init_type = t_invalid;
} else if (is_type_polymorphic(init_type)) { } else if (is_type_polymorphic(init_type)) {
error(vd->type, "Invalid use of a polymorphic type in variable declaration"); error(vd->type, "Invalid use of a polymorphic type in variable declaration");
@@ -1725,14 +1725,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
for (isize i = 0; i < entity_count; i++) { for (isize i = 0; i < entity_count; i++) {
Entity *e = entities[i]; Entity *e = entities[i];
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
if (e->flags & EntityFlag_Visited) { if (e->flags & EntityFlag_Visited) {
e->type = t_invalid; e->type = t_invalid;
continue; continue;
} }
e->flags |= EntityFlag_Visited; e->flags |= EntityFlag_Visited;
if (e->type == NULL) { if (e->type == nullptr) {
e->type = init_type; e->type = init_type;
} }
} }
@@ -1772,14 +1772,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
if ((vd->flags & VarDeclFlag_using) != 0) { if ((vd->flags & VarDeclFlag_using) != 0) {
Token token = ast_node_token(node); Token token = ast_node_token(node);
if (vd->type != NULL && entity_count > 1) { if (vd->type != nullptr && entity_count > 1) {
error(token, "`using` can only be applied to one variable of the same type"); error(token, "`using` can only be applied to one variable of the same type");
// TODO(bill): Should a `continue` happen here? // TODO(bill): Should a `continue` happen here?
} }
for (isize entity_index = 0; entity_index < entity_count; entity_index++) { for (isize entity_index = 0; entity_index < entity_count; entity_index++) {
Entity *e = entities[entity_index]; Entity *e = entities[entity_index];
if (e == NULL) { if (e == nullptr) {
continue; continue;
} }
if (e->kind != Entity_Variable) { if (e->kind != Entity_Variable) {
@@ -1797,7 +1797,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type);
uvar->Variable.is_immutable = is_immutable; uvar->Variable.is_immutable = is_immutable;
Entity *prev = scope_insert_entity(c->context.scope, uvar); Entity *prev = scope_insert_entity(c->context.scope, uvar);
if (prev != NULL) { if (prev != nullptr) {
error(token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); error(token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string));
return; return;
} }
src/checker.cpp
+103 -103
View File
@@ -236,13 +236,13 @@ struct Scope {
bool has_been_imported; // This is only applicable to file scopes bool has_been_imported; // This is only applicable to file scopes
AstFile * file; AstFile * file;
}; };
gb_global Scope *universal_scope = NULL; gb_global Scope *universal_scope = nullptr;
void scope_reset(Scope *scope) { void scope_reset(Scope *scope) {
if (scope == NULL) return; if (scope == nullptr) return;
scope->first_child = NULL; scope->first_child = nullptr;
scope->last_child = NULL; scope->last_child = nullptr;
map_clear (&scope->elements); map_clear (&scope->elements);
map_clear (&scope->implicit); map_clear (&scope->implicit);
array_clear(&scope->shared); array_clear(&scope->shared);
@@ -373,13 +373,13 @@ void destroy_declaration_info(DeclInfo *d) {
} }
bool decl_info_has_init(DeclInfo *d) { bool decl_info_has_init(DeclInfo *d) {
if (d->init_expr != NULL) { if (d->init_expr != nullptr) {
return true; return true;
} }
if (d->proc_lit != NULL) { if (d->proc_lit != nullptr) {
switch (d->proc_lit->kind) { switch (d->proc_lit->kind) {
case_ast_node(pl, ProcLit, d->proc_lit); case_ast_node(pl, ProcLit, d->proc_lit);
if (pl->body != NULL) { if (pl->body != nullptr) {
return true; return true;
} }
case_end; case_end;
@@ -401,7 +401,7 @@ Scope *make_scope(Scope *parent, gbAllocator allocator) {
array_init(&s->shared, heap_allocator()); array_init(&s->shared, heap_allocator());
array_init(&s->imported, heap_allocator()); array_init(&s->imported, heap_allocator());
if (parent != NULL && parent != universal_scope) { if (parent != nullptr && parent != universal_scope) {
DLIST_APPEND(parent->first_child, parent->last_child, s); DLIST_APPEND(parent->first_child, parent->last_child, s);
} }
return s; return s;
@@ -419,7 +419,7 @@ void destroy_scope(Scope *scope) {
} }
} }
for (Scope *child = scope->first_child; child != NULL; child = child->next) { for (Scope *child = scope->first_child; child != nullptr; child = child->next) {
destroy_scope(child); destroy_scope(child);
} }
@@ -433,8 +433,8 @@ void destroy_scope(Scope *scope) {
void add_scope(Checker *c, AstNode *node, Scope *scope) { void add_scope(Checker *c, AstNode *node, Scope *scope) {
GB_ASSERT(node != NULL); GB_ASSERT(node != nullptr);
GB_ASSERT(scope != NULL); GB_ASSERT(scope != nullptr);
scope->node = node; scope->node = node;
map_set(&c->info.scopes, hash_node(node), scope); map_set(&c->info.scopes, hash_node(node), scope);
} }
@@ -484,14 +484,14 @@ Entity *current_scope_lookup_entity(Scope *s, String name) {
return e; return e;
} }
} }
return NULL; return nullptr;
} }
void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entity **entity_) { void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entity **entity_) {
bool gone_thru_proc = false; bool gone_thru_proc = false;
bool gone_thru_file = false; bool gone_thru_file = false;
HashKey key = hash_string(name); HashKey key = hash_string(name);
for (Scope *s = scope; s != NULL; s = s->parent) { for (Scope *s = scope; s != nullptr; s = s->parent) {
Entity **found = map_get(&s->elements, key); Entity **found = map_get(&s->elements, key);
if (found) { if (found) {
Entity *e = *found; Entity *e = *found;
@@ -550,13 +550,13 @@ void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entit
} }
if (entity_) *entity_ = NULL; if (entity_) *entity_ = nullptr;
if (scope_) *scope_ = NULL; if (scope_) *scope_ = nullptr;
} }
Entity *scope_lookup_entity(Scope *s, String name) { Entity *scope_lookup_entity(Scope *s, String name) {
Entity *entity = NULL; Entity *entity = nullptr;
scope_lookup_parent_entity(s, name, NULL, &entity); scope_lookup_parent_entity(s, name, nullptr, &entity);
return entity; return entity;
} }
@@ -569,7 +569,7 @@ Entity *scope_insert_entity(Scope *s, Entity *entity) {
#if 1 #if 1
// IMPORTANT NOTE(bill): Procedure overloading code // IMPORTANT NOTE(bill): Procedure overloading code
Entity *prev = NULL; Entity *prev = nullptr;
if (found) { if (found) {
prev = *found; prev = *found;
if (prev->kind != Entity_Procedure || if (prev->kind != Entity_Procedure ||
@@ -578,7 +578,7 @@ Entity *scope_insert_entity(Scope *s, Entity *entity) {
} }
} }
if (prev != NULL && entity->kind == Entity_Procedure) { if (prev != nullptr && entity->kind == Entity_Procedure) {
// if (s->is_global) return prev; // if (s->is_global) return prev;
multi_map_insert(&s->elements, key, entity); multi_map_insert(&s->elements, key, entity);
@@ -591,10 +591,10 @@ Entity *scope_insert_entity(Scope *s, Entity *entity) {
} }
map_set(&s->elements, key, entity); map_set(&s->elements, key, entity);
#endif #endif
if (entity->scope == NULL) { if (entity->scope == nullptr) {
entity->scope = s; entity->scope = s;
} }
return NULL; return nullptr;
} }
@@ -608,10 +608,10 @@ void add_dependency(DeclInfo *d, Entity *e) {
} }
void add_declaration_dependency(Checker *c, Entity *e) { void add_declaration_dependency(Checker *c, Entity *e) {
if (e == NULL) { if (e == nullptr) {
return; return;
} }
if (c->context.decl != NULL) { if (c->context.decl != nullptr) {
DeclInfo **found = map_get(&c->info.entities, hash_entity(e)); DeclInfo **found = map_get(&c->info.entities, hash_entity(e));
if (found) { if (found) {
add_dependency(c->context.decl, e); add_dependency(c->context.decl, e);
@@ -632,7 +632,7 @@ Entity *add_global_entity(Entity *entity) {
} }
void add_global_constant(gbAllocator a, String name, Type *type, ExactValue value) { void add_global_constant(gbAllocator a, String name, Type *type, ExactValue value) {
Entity *entity = alloc_entity(a, Entity_Constant, NULL, make_token_ident(name), type); Entity *entity = alloc_entity(a, Entity_Constant, nullptr, make_token_ident(name), type);
entity->Constant.value = value; entity->Constant.value = value;
add_global_entity(entity); add_global_entity(entity);
} }
@@ -650,15 +650,15 @@ void init_universal_scope(void) {
BuildContext *bc = &build_context; BuildContext *bc = &build_context;
// NOTE(bill): No need to free these // NOTE(bill): No need to free these
gbAllocator a = heap_allocator(); gbAllocator a = heap_allocator();
universal_scope = make_scope(NULL, a); universal_scope = make_scope(nullptr, a);
// Types // Types
for (isize i = 0; i < gb_count_of(basic_types); i++) { for (isize i = 0; i < gb_count_of(basic_types); i++) {
add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_types[i].Basic.name), &basic_types[i])); add_global_entity(make_entity_type_name(a, nullptr, make_token_ident(basic_types[i].Basic.name), &basic_types[i]));
} }
#if 1 #if 1
// for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) { // for (isize i = 0; i < gb_count_of(basic_type_aliases); i++) {
// add_global_entity(make_entity_type_name(a, NULL, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i])); // add_global_entity(make_entity_type_name(a, nullptr, make_token_ident(basic_type_aliases[i].Basic.name), &basic_type_aliases[i]));
// } // }
#else #else
{ {
@@ -689,7 +689,7 @@ void init_universal_scope(void) {
BuiltinProcId id = cast(BuiltinProcId)i; BuiltinProcId id = cast(BuiltinProcId)i;
String name = builtin_procs[i].name; String name = builtin_procs[i].name;
if (name != "") { if (name != "") {
Entity *entity = alloc_entity(a, Entity_Builtin, NULL, make_token_ident(name), t_invalid); Entity *entity = alloc_entity(a, Entity_Builtin, nullptr, make_token_ident(name), t_invalid);
entity->Builtin.id = id; entity->Builtin.id = id;
add_global_entity(entity); add_global_entity(entity);
} }
@@ -813,7 +813,7 @@ Entity *entity_of_ident(CheckerInfo *i, AstNode *identifier) {
return *found; return *found;
} }
} }
return NULL; return nullptr;
} }
TypeAndValue type_and_value_of_expr(CheckerInfo *i, AstNode *expr) { TypeAndValue type_and_value_of_expr(CheckerInfo *i, AstNode *expr) {
@@ -835,30 +835,30 @@ Type *type_of_expr(CheckerInfo *i, AstNode *expr) {
} }
} }
return NULL; return nullptr;
} }
Entity *implicit_entity_of_node(CheckerInfo *i, AstNode *clause) { Entity *implicit_entity_of_node(CheckerInfo *i, AstNode *clause) {
Entity **found = map_get(&i->implicits, hash_node(clause)); Entity **found = map_get(&i->implicits, hash_node(clause));
if (found != NULL) { if (found != nullptr) {
return *found; return *found;
} }
return NULL; return nullptr;
} }
bool is_entity_implicitly_imported(Entity *import_name, Entity *e) { bool is_entity_implicitly_imported(Entity *import_name, Entity *e) {
GB_ASSERT(import_name->kind == Entity_ImportName); GB_ASSERT(import_name->kind == Entity_ImportName);
return map_get(&import_name->ImportName.scope->implicit, hash_entity(e)) != NULL; return map_get(&import_name->ImportName.scope->implicit, hash_entity(e)) != nullptr;
} }
DeclInfo *decl_info_of_entity(CheckerInfo *i, Entity *e) { DeclInfo *decl_info_of_entity(CheckerInfo *i, Entity *e) {
if (e != NULL) { if (e != nullptr) {
DeclInfo **found = map_get(&i->entities, hash_entity(e)); DeclInfo **found = map_get(&i->entities, hash_entity(e));
if (found != NULL) { if (found != nullptr) {
return *found; return *found;
} }
} }
return NULL; return nullptr;
} }
DeclInfo *decl_info_of_ident(CheckerInfo *i, AstNode *ident) { DeclInfo *decl_info_of_ident(CheckerInfo *i, AstNode *ident) {
@@ -867,17 +867,17 @@ DeclInfo *decl_info_of_ident(CheckerInfo *i, AstNode *ident) {
AstFile *ast_file_of_filename(CheckerInfo *i, String filename) { AstFile *ast_file_of_filename(CheckerInfo *i, String filename) {
AstFile **found = map_get(&i->files, hash_string(filename)); AstFile **found = map_get(&i->files, hash_string(filename));
if (found != NULL) { if (found != nullptr) {
return *found; return *found;
} }
return NULL; return nullptr;
} }
Scope *scope_of_node(CheckerInfo *i, AstNode *node) { Scope *scope_of_node(CheckerInfo *i, AstNode *node) {
Scope **found = map_get(&i->scopes, hash_node(node)); Scope **found = map_get(&i->scopes, hash_node(node));
if (found) { if (found) {
return *found; return *found;
} }
return NULL; return nullptr;
} }
ExprInfo *check_get_expr_info(CheckerInfo *i, AstNode *expr) { ExprInfo *check_get_expr_info(CheckerInfo *i, AstNode *expr) {
return map_get(&i->untyped, hash_node(expr)); return map_get(&i->untyped, hash_node(expr));
@@ -927,7 +927,7 @@ void add_untyped(CheckerInfo *i, AstNode *expression, bool lhs, AddressingMode m
} }
void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value) { void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode, Type *type, ExactValue value) {
if (expression == NULL) { if (expression == nullptr) {
return; return;
} }
if (mode == Addressing_Invalid) { if (mode == Addressing_Invalid) {
@@ -954,7 +954,7 @@ void add_type_and_value(CheckerInfo *i, AstNode *expression, AddressingMode mode
} }
void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) { void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity) {
GB_ASSERT(identifier != NULL); GB_ASSERT(identifier != nullptr);
if (identifier->kind == AstNode_Ident) { if (identifier->kind == AstNode_Ident) {
if (identifier->Ident.token.string == "_") { if (identifier->Ident.token.string == "_") {
return; return;
@@ -967,7 +967,7 @@ void add_entity_definition(CheckerInfo *i, AstNode *identifier, Entity *entity)
} }
bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) { bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) {
if (scope == NULL) { if (scope == nullptr) {
return false; return false;
} }
String name = entity->token.string; String name = entity->token.string;
@@ -976,7 +976,7 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) {
if (ie) { if (ie) {
TokenPos pos = ie->token.pos; TokenPos pos = ie->token.pos;
Entity *up = ie->using_parent; Entity *up = ie->using_parent;
if (up != NULL) { if (up != nullptr) {
if (token_pos_eq(pos, up->token.pos)) { if (token_pos_eq(pos, up->token.pos)) {
// NOTE(bill): Error should have been handled already // NOTE(bill): Error should have been handled already
return false; return false;
@@ -1001,14 +1001,14 @@ bool add_entity(Checker *c, Scope *scope, AstNode *identifier, Entity *entity) {
} }
} }
} }
if (identifier != NULL) { if (identifier != nullptr) {
add_entity_definition(&c->info, identifier, entity); add_entity_definition(&c->info, identifier, entity);
} }
return true; return true;
} }
void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) { void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) {
GB_ASSERT(identifier != NULL); GB_ASSERT(identifier != nullptr);
if (identifier->kind != AstNode_Ident) { if (identifier->kind != AstNode_Ident) {
return; return;
} }
@@ -1020,17 +1020,17 @@ void add_entity_use(Checker *c, AstNode *identifier, Entity *entity) {
void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d) { void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d) {
GB_ASSERT(identifier->kind == AstNode_Ident); GB_ASSERT(identifier->kind == AstNode_Ident);
GB_ASSERT(e != NULL && d != NULL); GB_ASSERT(e != nullptr && d != nullptr);
GB_ASSERT(identifier->Ident.token.string == e->token.string); GB_ASSERT(identifier->Ident.token.string == e->token.string);
if (e->scope != NULL) add_entity(c, e->scope, identifier, e); if (e->scope != nullptr) add_entity(c, e->scope, identifier, e);
add_entity_definition(&c->info, identifier, e); add_entity_definition(&c->info, identifier, e);
map_set(&c->info.entities, hash_entity(e), d); map_set(&c->info.entities, hash_entity(e), d);
} }
void add_implicit_entity(Checker *c, AstNode *node, Entity *e) { void add_implicit_entity(Checker *c, AstNode *node, Entity *e) {
GB_ASSERT(node != NULL); GB_ASSERT(node != nullptr);
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
map_set(&c->info.implicits, hash_node(node), e); map_set(&c->info.implicits, hash_node(node), e);
} }
@@ -1039,7 +1039,7 @@ void add_implicit_entity(Checker *c, AstNode *node, Entity *e) {
void add_type_info_type(Checker *c, Type *t) { void add_type_info_type(Checker *c, Type *t) {
if (t == NULL) { if (t == nullptr) {
return; return;
} }
t = default_type(t); t = default_type(t);
@@ -1050,7 +1050,7 @@ void add_type_info_type(Checker *c, Type *t) {
return; // Could be nil return; // Could be nil
} }
if (map_get(&c->info.type_info_map, hash_type(t)) != NULL) { if (map_get(&c->info.type_info_map, hash_type(t)) != nullptr) {
// Types have already been added // Types have already been added
return; return;
} }
@@ -1181,7 +1181,7 @@ void add_type_info_type(Checker *c, Type *t) {
} }
void check_procedure_later(Checker *c, ProcedureInfo info) { void check_procedure_later(Checker *c, ProcedureInfo info) {
if (info.decl != NULL) { if (info.decl != nullptr) {
map_set(&c->procs, hash_decl_info(info.decl), info); map_set(&c->procs, hash_decl_info(info.decl), info);
} }
} }
@@ -1210,11 +1210,11 @@ Type *const curr_procedure_type(Checker *c) {
if (count > 0) { if (count > 0) {
return c->proc_stack[count-1]; return c->proc_stack[count-1];
} }
return NULL; return nullptr;
} }
void add_curr_ast_file(Checker *c, AstFile *file) { void add_curr_ast_file(Checker *c, AstFile *file) {
if (file != NULL) { if (file != nullptr) {
TokenPos zero_pos = {}; TokenPos zero_pos = {};
global_error_collector.prev = zero_pos; global_error_collector.prev = zero_pos;
c->curr_ast_file = file; c->curr_ast_file = file;
@@ -1226,25 +1226,25 @@ void add_curr_ast_file(Checker *c, AstFile *file) {
void add_dependency_to_map(Map<Entity *> *map, CheckerInfo *info, Entity *entity) { void add_dependency_to_map(Map<Entity *> *map, CheckerInfo *info, Entity *entity) {
if (entity == NULL) { if (entity == nullptr) {
return; return;
} }
if (entity->type != NULL && if (entity->type != nullptr &&
is_type_polymorphic(entity->type)) { is_type_polymorphic(entity->type)) {
DeclInfo *decl = decl_info_of_entity(info, entity); DeclInfo *decl = decl_info_of_entity(info, entity);
if (decl->gen_proc_type == NULL) { if (decl->gen_proc_type == nullptr) {
return; return;
} }
} }
if (map_get(map, hash_entity(entity)) != NULL) { if (map_get(map, hash_entity(entity)) != nullptr) {
return; return;
} }
map_set(map, hash_entity(entity), entity); map_set(map, hash_entity(entity), entity);
DeclInfo *decl = decl_info_of_entity(info, entity); DeclInfo *decl = decl_info_of_entity(info, entity);
if (decl == NULL) { if (decl == nullptr) {
return; return;
} }
@@ -1282,7 +1282,7 @@ Map<Entity *> generate_minimum_dependency_map(CheckerInfo *info, Entity *start)
} }
bool is_entity_in_dependency_map(Map<Entity *> *map, Entity *e) { bool is_entity_in_dependency_map(Map<Entity *> *map, Entity *e) {
return map_get(map, hash_entity(e)) != NULL; return map_get(map, hash_entity(e)) != nullptr;
} }
@@ -1290,7 +1290,7 @@ bool is_entity_in_dependency_map(Map<Entity *> *map, Entity *e) {
Entity *find_core_entity(Checker *c, String name) { Entity *find_core_entity(Checker *c, String name) {
Entity *e = current_scope_lookup_entity(c->global_scope, name); Entity *e = current_scope_lookup_entity(c->global_scope, name);
if (e == NULL) { if (e == nullptr) {
compiler_error("Could not find type declaration for `%.*s`\n" compiler_error("Could not find type declaration for `%.*s`\n"
"Is `_preload.odin` missing from the `core` directory relative to odin.exe?", LIT(name)); "Is `_preload.odin` missing from the `core` directory relative to odin.exe?", LIT(name));
// NOTE(bill): This will exit the program as it's cannot continue without it! // NOTE(bill): This will exit the program as it's cannot continue without it!
@@ -1299,7 +1299,7 @@ Entity *find_core_entity(Checker *c, String name) {
} }
void init_preload(Checker *c) { void init_preload(Checker *c) {
if (t_type_info == NULL) { if (t_type_info == nullptr) {
Entity *type_info_entity = find_core_entity(c, str_lit("TypeInfo")); Entity *type_info_entity = find_core_entity(c, str_lit("TypeInfo"));
t_type_info = type_info_entity->type; t_type_info = type_info_entity->type;
@@ -1364,31 +1364,31 @@ void init_preload(Checker *c) {
t_type_info_bit_field_ptr = make_type_pointer(c->allocator, t_type_info_bit_field); t_type_info_bit_field_ptr = make_type_pointer(c->allocator, t_type_info_bit_field);
} }
if (t_allocator == NULL) { if (t_allocator == nullptr) {
Entity *e = find_core_entity(c, str_lit("Allocator")); Entity *e = find_core_entity(c, str_lit("Allocator"));
t_allocator = e->type; t_allocator = e->type;
t_allocator_ptr = make_type_pointer(c->allocator, t_allocator); t_allocator_ptr = make_type_pointer(c->allocator, t_allocator);
} }
if (t_context == NULL) { if (t_context == nullptr) {
Entity *e = find_core_entity(c, str_lit("Context")); Entity *e = find_core_entity(c, str_lit("Context"));
e_context = e; e_context = e;
t_context = e->type; t_context = e->type;
t_context_ptr = make_type_pointer(c->allocator, t_context); t_context_ptr = make_type_pointer(c->allocator, t_context);
} }
if (t_source_code_location == NULL) { if (t_source_code_location == nullptr) {
Entity *e = find_core_entity(c, str_lit("SourceCodeLocation")); Entity *e = find_core_entity(c, str_lit("SourceCodeLocation"));
t_source_code_location = e->type; t_source_code_location = e->type;
t_source_code_location_ptr = make_type_pointer(c->allocator, t_allocator); t_source_code_location_ptr = make_type_pointer(c->allocator, t_allocator);
} }
if (t_map_key == NULL) { if (t_map_key == nullptr) {
Entity *e = find_core_entity(c, str_lit("__MapKey")); Entity *e = find_core_entity(c, str_lit("__MapKey"));
t_map_key = e->type; t_map_key = e->type;
} }
if (t_map_header == NULL) { if (t_map_header == nullptr) {
Entity *e = find_core_entity(c, str_lit("__MapHeader")); Entity *e = find_core_entity(c, str_lit("__MapHeader"));
t_map_header = e->type; t_map_header = e->type;
} }
@@ -1461,7 +1461,7 @@ void check_procedure_overloading(Checker *c, Entity *e) {
TokenPos pos = q->token.pos; TokenPos pos = q->token.pos;
if (q->type == NULL || q->type == t_invalid) { if (q->type == nullptr || q->type == t_invalid) {
continue; continue;
} }
@@ -1526,7 +1526,7 @@ bool check_arity_match(Checker *c, AstNodeValueDecl *vd) {
isize rhs = vd->values.count; isize rhs = vd->values.count;
if (rhs == 0) { if (rhs == 0) {
if (vd->type == NULL) { if (vd->type == nullptr) {
error(vd->names[0], "Missing type or initial expression"); error(vd->names[0], "Missing type or initial expression");
return false; return false;
} }
@@ -1560,7 +1560,7 @@ void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws, bool
if (operand.mode != Addressing_Constant) { if (operand.mode != Addressing_Constant) {
error(ws->cond, "Non-constant condition in `when` statement"); error(ws->cond, "Non-constant condition in `when` statement");
} }
if (ws->body == NULL || ws->body->kind != AstNode_BlockStmt) { if (ws->body == nullptr || ws->body->kind != AstNode_BlockStmt) {
error(ws->cond, "Invalid body for `when` statement"); error(ws->cond, "Invalid body for `when` statement");
} else { } else {
if (operand.value.kind == ExactValue_Bool && if (operand.value.kind == ExactValue_Bool &&
@@ -1582,7 +1582,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 // NOTE(bill): If file_scopes == nullptr, this will act like a local scope
void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_scope) { void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_scope) {
// NOTE(bill): File scope and local scope are different kinds of scopes // NOTE(bill): File scope and local scope are different kinds of scopes
if (is_file_scope) { if (is_file_scope) {
@@ -1620,7 +1620,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
isize entity_cap = vd->names.count; isize entity_cap = vd->names.count;
isize entity_count = 0; isize entity_count = 0;
Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_cap); Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_cap);
DeclInfo *di = NULL; DeclInfo *di = nullptr;
if (vd->values.count > 0) { if (vd->values.count > 0) {
di = make_declaration_info(heap_allocator(), c->context.scope, c->context.decl); di = make_declaration_info(heap_allocator(), c->context.scope, c->context.decl);
di->entities = entities; di->entities = entities;
@@ -1636,7 +1636,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
for_array(i, vd->names) { for_array(i, vd->names) {
AstNode *name = vd->names[i]; AstNode *name = vd->names[i];
AstNode *value = NULL; AstNode *value = nullptr;
if (i < vd->values.count) { if (i < vd->values.count) {
value = vd->values[i]; value = vd->values[i];
} }
@@ -1644,7 +1644,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); error(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind]));
continue; continue;
} }
Entity *e = make_entity_variable(c->allocator, c->context.scope, name->Ident.token, NULL, false); Entity *e = make_entity_variable(c->allocator, c->context.scope, name->Ident.token, nullptr, false);
e->Variable.is_thread_local = (vd->flags & VarDeclFlag_thread_local) != 0; e->Variable.is_thread_local = (vd->flags & VarDeclFlag_thread_local) != 0;
e->identifier = name; e->identifier = name;
@@ -1654,7 +1654,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
} }
AstNode *fl = c->context.curr_foreign_library; AstNode *fl = c->context.curr_foreign_library;
if (fl != NULL) { if (fl != nullptr) {
GB_ASSERT(fl->kind == AstNode_Ident); GB_ASSERT(fl->kind == AstNode_Ident);
e->Variable.is_foreign = true; e->Variable.is_foreign = true;
e->Variable.foreign_library_ident = fl; e->Variable.foreign_library_ident = fl;
@@ -1663,7 +1663,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
entities[entity_count++] = e; entities[entity_count++] = e;
DeclInfo *d = di; DeclInfo *d = di;
if (d == NULL) { if (d == nullptr) {
AstNode *init_expr = value; AstNode *init_expr = value;
d = make_declaration_info(heap_allocator(), e->scope, c->context.decl); d = make_declaration_info(heap_allocator(), e->scope, c->context.decl);
d->type_expr = vd->type; d->type_expr = vd->type;
@@ -1673,7 +1673,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
add_entity_and_decl_info(c, name, e, d); add_entity_and_decl_info(c, name, e, d);
} }
if (di != NULL) { if (di != nullptr) {
di->entity_count = entity_count; di->entity_count = entity_count;
} }
@@ -1687,26 +1687,26 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
} }
AstNode *init = unparen_expr(vd->values[i]); AstNode *init = unparen_expr(vd->values[i]);
if (init == NULL) { if (init == nullptr) {
error(name, "Expected a value for this constant value declaration"); error(name, "Expected a value for this constant value declaration");
continue; continue;
} }
AstNode *fl = c->context.curr_foreign_library; AstNode *fl = c->context.curr_foreign_library;
DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl);
Entity *e = NULL; Entity *e = nullptr;
if (is_ast_node_type(init)) { if (is_ast_node_type(init)) {
e = make_entity_type_name(c->allocator, d->scope, name->Ident.token, NULL); e = make_entity_type_name(c->allocator, d->scope, name->Ident.token, nullptr);
if (vd->type != NULL) { if (vd->type != nullptr) {
error(name, "A type declaration cannot have an type parameter"); error(name, "A type declaration cannot have an type parameter");
} }
d->type_expr = init; d->type_expr = init;
d->init_expr = init; d->init_expr = init;
} else if (init->kind == AstNode_ProcLit) { } else if (init->kind == AstNode_ProcLit) {
ast_node(pl, ProcLit, init); ast_node(pl, ProcLit, init);
e = make_entity_procedure(c->allocator, d->scope, name->Ident.token, NULL, pl->tags); e = make_entity_procedure(c->allocator, d->scope, name->Ident.token, nullptr, pl->tags);
if (fl != NULL) { if (fl != nullptr) {
GB_ASSERT(fl->kind == AstNode_Ident); GB_ASSERT(fl->kind == AstNode_Ident);
e->Procedure.foreign_library_ident = fl; e->Procedure.foreign_library_ident = fl;
pl->tags |= ProcTag_foreign; pl->tags |= ProcTag_foreign;
@@ -1714,13 +1714,13 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
d->proc_lit = init; d->proc_lit = init;
d->type_expr = pl->type; d->type_expr = pl->type;
} else { } else {
e = make_entity_constant(c->allocator, d->scope, name->Ident.token, NULL, empty_exact_value); e = make_entity_constant(c->allocator, d->scope, name->Ident.token, nullptr, empty_exact_value);
d->type_expr = vd->type; d->type_expr = vd->type;
d->init_expr = init; d->init_expr = init;
} }
e->identifier = name; e->identifier = name;
if (fl != NULL && e->kind != Entity_Procedure) { if (fl != nullptr && e->kind != Entity_Procedure) {
AstNodeKind kind = init->kind; AstNodeKind kind = init->kind;
error(name, "Only procedures and variables are allowed to be in a foreign block, got %.*s", LIT(ast_node_strings[kind])); error(name, "Only procedures and variables are allowed to be in a foreign block, got %.*s", LIT(ast_node_strings[kind]));
if (kind == AstNode_ProcType) { if (kind == AstNode_ProcType) {
@@ -1772,7 +1772,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
continue; continue;
} }
if (fl->cond != NULL) { if (fl->cond != nullptr) {
Operand operand = {Addressing_Invalid}; Operand operand = {Addressing_Invalid};
check_expr(c, &operand, fl->cond); check_expr(c, &operand, fl->cond);
if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) {
@@ -1796,7 +1796,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
AstNode *foreign_library = fb->foreign_library; AstNode *foreign_library = fb->foreign_library;
if (foreign_library->kind != AstNode_Ident) { if (foreign_library->kind != AstNode_Ident) {
error(foreign_library, "foreign library name must be an identifier"); error(foreign_library, "foreign library name must be an identifier");
foreign_library = NULL; foreign_library = nullptr;
} }
CheckerContext prev_context = c->context; CheckerContext prev_context = c->context;
@@ -1814,11 +1814,11 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
// DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); // DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl);
// Entity *e = NULL; // Entity *e = nullptr;
// e = make_entity_procedure(c->allocator, d->scope, name->Ident, NULL, pd->tags); // e = make_entity_procedure(c->allocator, d->scope, name->Ident, nullptr, pd->tags);
// AstNode *fl = c->context.curr_foreign_library; // AstNode *fl = c->context.curr_foreign_library;
// if (fl != NULL) { // if (fl != nullptr) {
// GB_ASSERT(fl->kind == AstNode_Ident); // GB_ASSERT(fl->kind == AstNode_Ident);
// e->Procedure.foreign_library_ident = fl; // e->Procedure.foreign_library_ident = fl;
// pd->tags |= ProcTag_foreign; // pd->tags |= ProcTag_foreign;
@@ -1853,7 +1853,7 @@ void check_collect_entities(Checker *c, Array<AstNode *> nodes, bool is_file_sco
void check_all_global_entities(Checker *c) { void check_all_global_entities(Checker *c) {
Scope *prev_file = NULL; Scope *prev_file = nullptr;
for_array(i, c->info.entities.entries) { for_array(i, c->info.entities.entries) {
auto *entry = &c->info.entities.entries[i]; auto *entry = &c->info.entities.entries[i];
@@ -1886,7 +1886,7 @@ void check_all_global_entities(Checker *c) {
CheckerContext prev_context = c->context; CheckerContext prev_context = c->context;
c->context.decl = d; c->context.decl = d;
c->context.scope = d->scope; c->context.scope = d->scope;
check_entity_decl(c, e, d, NULL); check_entity_decl(c, e, d, nullptr);
c->context = prev_context; c->context = prev_context;
@@ -2009,7 +2009,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
HashKey key = hash_string(id->fullpath); HashKey key = hash_string(id->fullpath);
Scope **found = map_get(file_scopes, key); Scope **found = map_get(file_scopes, key);
if (found == NULL) { if (found == nullptr) {
for_array(scope_index, file_scopes->entries) { for_array(scope_index, file_scopes->entries) {
Scope *scope = file_scopes->entries[scope_index].value; Scope *scope = file_scopes->entries[scope_index].value;
gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath)); gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath));
@@ -2082,7 +2082,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
HashKey key = hash_string(id->fullpath); HashKey key = hash_string(id->fullpath);
Scope **found = map_get(file_scopes, key); Scope **found = map_get(file_scopes, key);
if (found == NULL) { if (found == nullptr) {
for_array(scope_index, file_scopes->entries) { for_array(scope_index, file_scopes->entries) {
Scope *scope = file_scopes->entries[scope_index].value; Scope *scope = file_scopes->entries[scope_index].value;
gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath)); gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath));
@@ -2097,7 +2097,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
continue; continue;
} }
if (id->cond != NULL) { if (id->cond != nullptr) {
Operand operand = {Addressing_Invalid}; Operand operand = {Addressing_Invalid};
check_expr(c, &operand, id->cond); check_expr(c, &operand, id->cond);
if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) {
@@ -2163,7 +2163,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
scope); scope);
add_entity(c, parent_scope, NULL, e); add_entity(c, parent_scope, nullptr, e);
} }
} }
} }
@@ -2190,7 +2190,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
file_str = import_file; file_str = import_file;
} }
if (fl->cond != NULL) { if (fl->cond != nullptr) {
Operand operand = {Addressing_Invalid}; Operand operand = {Addressing_Invalid};
check_expr(c, &operand, fl->cond); check_expr(c, &operand, fl->cond);
if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) { if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) {
@@ -2212,7 +2212,7 @@ void check_import_entities(Checker *c, Map<Scope *> *file_scopes) {
fl->library_name.string = library_name; fl->library_name.string = library_name;
Entity *e = make_entity_library_name(c->allocator, parent_scope, fl->library_name, t_invalid, Entity *e = make_entity_library_name(c->allocator, parent_scope, fl->library_name, t_invalid,
file_str, library_name); file_str, library_name);
add_entity(c, parent_scope, NULL, e); add_entity(c, parent_scope, nullptr, e);
} }
} }
} }
@@ -2228,7 +2228,7 @@ void check_parsed_files(Checker *c) {
// Map full filepaths to Scopes // Map full filepaths to Scopes
for_array(i, c->parser->files) { for_array(i, c->parser->files) {
AstFile *f = &c->parser->files[i]; AstFile *f = &c->parser->files[i];
Scope *scope = NULL; Scope *scope = nullptr;
scope = make_scope(c->global_scope, c->allocator); scope = make_scope(c->global_scope, c->allocator);
scope->is_global = f->is_global_scope; scope->is_global = f->is_global_scope;
scope->is_file = true; scope->is_file = true;
@@ -2270,7 +2270,7 @@ void check_parsed_files(Checker *c) {
// NOTE(bill): Nested procedures bodies will be added to this "queue" // NOTE(bill): Nested procedures bodies will be added to this "queue"
for_array(i, c->procs.entries) { for_array(i, c->procs.entries) {
ProcedureInfo *pi = &c->procs.entries[i].value; ProcedureInfo *pi = &c->procs.entries[i].value;
if (pi->type == NULL) { if (pi->type == nullptr) {
continue; continue;
} }
CheckerContext prev_context = c->context; CheckerContext prev_context = c->context;
@@ -2305,7 +2305,7 @@ void check_parsed_files(Checker *c) {
HashKey key = entry->key; HashKey key = entry->key;
AstNode *expr = cast(AstNode *)key.ptr; AstNode *expr = cast(AstNode *)key.ptr;
ExprInfo *info = &entry->value; ExprInfo *info = &entry->value;
if (info != NULL && expr != NULL) { if (info != nullptr && expr != nullptr) {
if (is_type_typed(info->type)) { if (is_type_typed(info->type)) {
compiler_error("%s (type %s) is typed!", expr_to_string(expr), type_to_string(info->type)); compiler_error("%s (type %s) is typed!", expr_to_string(expr), type_to_string(info->type));
} }
@@ -2341,7 +2341,7 @@ void check_parsed_files(Checker *c) {
for_array(i, c->info.definitions.entries) { for_array(i, c->info.definitions.entries) {
Entity *e = c->info.definitions.entries[i].value; Entity *e = c->info.definitions.entries[i].value;
if (e->kind == Entity_TypeName) { if (e->kind == Entity_TypeName) {
if (e->type != NULL) { if (e->type != nullptr) {
// i64 size = type_size_of(c->sizes, c->allocator, e->type); // i64 size = type_size_of(c->sizes, c->allocator, e->type);
i64 align = type_align_of(c->allocator, e->type); i64 align = type_align_of(c->allocator, e->type);
if (align > 0) { if (align > 0) {
@@ -2358,7 +2358,7 @@ void check_parsed_files(Checker *c) {
Scope *s = file_scopes.entries[i].value; Scope *s = file_scopes.entries[i].value;
if (s->is_init) { if (s->is_init) {
Entity *e = current_scope_lookup_entity(s, str_lit("main")); Entity *e = current_scope_lookup_entity(s, str_lit("main"));
if (e == NULL) { if (e == nullptr) {
Token token = {}; Token token = {};
if (s->file->tokens.count > 0) { if (s->file->tokens.count > 0) {
token = s->file->tokens[0]; token = s->file->tokens[0];
src/common.cpp
+13 -13
View File
@@ -93,9 +93,9 @@ void pool_init(Pool *pool,
} }
void pool_free_all(Pool *p) { void pool_free_all(Pool *p) {
if (p->current_memblock != NULL) { if (p->current_memblock != nullptr) {
array_add(&p->unused_memblock, p->current_memblock); array_add(&p->unused_memblock, p->current_memblock);
p->current_memblock = NULL; p->current_memblock = nullptr;
} }
for_array(i, p->used_memblock) { for_array(i, p->used_memblock) {
@@ -118,19 +118,19 @@ void pool_destroy(Pool *p) {
} }
void pool_cycle_new_block(Pool *p) { void pool_cycle_new_block(Pool *p) {
GB_ASSERT_MSG(p->block_allocator.proc != NULL, GB_ASSERT_MSG(p->block_allocator.proc != nullptr,
"You must call pool_init on a Pool before using it!"); "You must call pool_init on a Pool before using it!");
if (p->current_memblock != NULL) { if (p->current_memblock != nullptr) {
array_add(&p->used_memblock, p->current_memblock); array_add(&p->used_memblock, p->current_memblock);
} }
u8 *new_block = NULL; u8 *new_block = nullptr;
if (p->unused_memblock.count > 0) { if (p->unused_memblock.count > 0) {
new_block = array_pop(&p->unused_memblock); new_block = array_pop(&p->unused_memblock);
} else { } else {
GB_ASSERT(p->block_allocator.proc != NULL); GB_ASSERT(p->block_allocator.proc != nullptr);
new_block = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, p->alignment); new_block = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, p->alignment);
} }
@@ -146,9 +146,9 @@ void *pool_get(Pool *p,
isize extra = alignment - (size & alignment); isize extra = alignment - (size & alignment);
size += extra; size += extra;
if (size >= p->out_of_band_size) { if (size >= p->out_of_band_size) {
GB_ASSERT(p->block_allocator.proc != NULL); GB_ASSERT(p->block_allocator.proc != nullptr);
u8 *memory = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, alignment); u8 *memory = cast(u8 *)gb_alloc_align(p->block_allocator, p->memblock_size, alignment);
if (memory != NULL) { if (memory != nullptr) {
array_add(&p->out_of_band_allocations, memory); array_add(&p->out_of_band_allocations, memory);
} }
return memory; return memory;
@@ -156,8 +156,8 @@ void *pool_get(Pool *p,
if (p->bytes_left < size) { if (p->bytes_left < size) {
pool_cycle_new_block(p); pool_cycle_new_block(p);
if (p->current_memblock != NULL) { if (p->current_memblock != nullptr) {
return NULL; return nullptr;
} }
} }
@@ -172,7 +172,7 @@ gbAllocator pool_allocator(Pool *pool);
GB_ALLOCATOR_PROC(pool_allocator_procedure) { GB_ALLOCATOR_PROC(pool_allocator_procedure) {
Pool *p = cast(Pool *)allocator_data; Pool *p = cast(Pool *)allocator_data;
void *ptr = NULL; void *ptr = nullptr;
switch (type) { switch (type) {
case gbAllocation_Alloc: case gbAllocation_Alloc:
@@ -296,7 +296,7 @@ f64 gb_sqrt(f64 x) {
} while (0) } while (0)
#define DLIST_APPEND(root_element, curr_element, next_element) do { \ #define DLIST_APPEND(root_element, curr_element, next_element) do { \
if ((root_element) == NULL) { \ if ((root_element) == nullptr) { \
(root_element) = (curr_element) = (next_element); \ (root_element) = (curr_element) = (next_element); \
} else { \ } else { \
DLIST_SET(curr_element, next_element); \ DLIST_SET(curr_element, next_element); \
@@ -362,7 +362,7 @@ wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
i++; i++;
} }
_argv[j] = '\0'; _argv[j] = '\0';
argv[argc] = NULL; argv[argc] = nullptr;
if (_argc) *_argc = argc; if (_argc) *_argc = argc;
return argv; return argv;
src/docs.cpp
+2 -2
View File
@@ -10,7 +10,7 @@ String alloc_comment_group_string(gbAllocator a, CommentGroup g) {
len += 1; // for \n len += 1; // for \n
} }
if (len == 0) { if (len == 0) {
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
u8 *text = gb_alloc_array(a, u8, len+1); u8 *text = gb_alloc_array(a, u8, len+1);
@@ -70,7 +70,7 @@ void print_proc_decl(AstNodeProcDecl *pd) {
gbString params = expr_to_string(proc_type->params); gbString params = expr_to_string(proc_type->params);
defer (gb_string_free(params)); defer (gb_string_free(params));
gb_printf("proc %.*s(%s)", LIT(name), params); gb_printf("proc %.*s(%s)", LIT(name), params);
if (proc_type->results != NULL) { if (proc_type->results != nullptr) {
ast_node(fl, FieldList, proc_type->results); ast_node(fl, FieldList, proc_type->results);
isize count = fl->list.count; isize count = fl->list.count;
if (count > 0) { if (count > 0) {
src/entity.cpp
+7 -7
View File
@@ -71,8 +71,8 @@ struct Entity {
Token token; Token token;
Scope * scope; Scope * scope;
Type * type; Type * type;
AstNode * identifier; // Can be NULL AstNode * identifier; // Can be nullptr
DeclInfo * parent_proc_decl; // NULL if in file/global scope DeclInfo * parent_proc_decl; // nullptr if in file/global scope
// TODO(bill): Cleanup how `using` works for entities // TODO(bill): Cleanup how `using` works for entities
Entity * using_parent; Entity * using_parent;
@@ -131,7 +131,7 @@ struct Entity {
}; };
}; };
gb_global Entity *e_context = NULL; gb_global Entity *e_context = nullptr;
bool is_entity_kind_exported(EntityKind kind) { bool is_entity_kind_exported(EntityKind kind) {
switch (kind) { switch (kind) {
@@ -146,7 +146,7 @@ bool is_entity_kind_exported(EntityKind kind) {
bool is_entity_exported(Entity *e) { bool is_entity_exported(Entity *e) {
// TODO(bill): Determine the actual exportation rules for imports of entities // TODO(bill): Determine the actual exportation rules for imports of entities
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
if (!is_entity_kind_exported(e->kind)) { if (!is_entity_kind_exported(e->kind)) {
return false; return false;
} }
@@ -177,7 +177,7 @@ Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *typ
} }
Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) { Entity *make_entity_using_variable(gbAllocator a, Entity *parent, Token token, Type *type) {
GB_ASSERT(parent != NULL); GB_ASSERT(parent != nullptr);
token.pos = parent->token.pos; token.pos = parent->token.pos;
Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type); Entity *entity = alloc_entity(a, Entity_Variable, parent->scope, token, type);
entity->using_parent = parent; entity->using_parent = parent;
@@ -265,7 +265,7 @@ Entity *make_entity_library_name(gbAllocator a, Scope *scope, Token token, Type
Entity *make_entity_nil(gbAllocator a, String name, Type *type) { Entity *make_entity_nil(gbAllocator a, String name, Type *type) {
Token token = make_token_ident(name); Token token = make_token_ident(name);
Entity *entity = alloc_entity(a, Entity_Nil, NULL, token, type); Entity *entity = alloc_entity(a, Entity_Nil, nullptr, token, type);
return entity; return entity;
} }
@@ -280,6 +280,6 @@ Entity *make_entity_label(gbAllocator a, Scope *scope, Token token, Type *type,
Entity *make_entity_dummy_variable(gbAllocator a, Scope *scope, Token token) { Entity *make_entity_dummy_variable(gbAllocator a, Scope *scope, Token token) {
token.string = str_lit("_"); token.string = str_lit("_");
return make_entity_variable(a, scope, token, NULL, false); return make_entity_variable(a, scope, token, nullptr, false);
} }
src/integer128.cpp
+4 -4
View File
@@ -520,7 +520,7 @@ u128 u128_quo(u128 a, u128 b) {
} }
u128 res = {0}; u128 res = {0};
u128_divide(a, b, &res, NULL); u128_divide(a, b, &res, nullptr);
return res; return res;
} }
u128 u128_mod(u128 a, u128 b) { u128 u128_mod(u128 a, u128 b) {
@@ -528,7 +528,7 @@ u128 u128_mod(u128 a, u128 b) {
return u128_from_u64(a.lo%b.lo); return u128_from_u64(a.lo%b.lo);
} }
u128 res = {0}; u128 res = {0};
u128_divide(a, b, NULL, &res); u128_divide(a, b, nullptr, &res);
return res; return res;
} }
@@ -716,11 +716,11 @@ void i128_divide(i128 a, i128 b, i128 *quo, i128 *rem) {
i128 i128_quo(i128 a, i128 b) { i128 i128_quo(i128 a, i128 b) {
i128 res = {0}; i128 res = {0};
i128_divide(a, b, &res, NULL); i128_divide(a, b, &res, nullptr);
return res; return res;
} }
i128 i128_mod(i128 a, i128 b) { i128 i128_mod(i128 a, i128 b) {
i128 res = {0}; i128 res = {0};
i128_divide(a, b, NULL, &res); i128_divide(a, b, nullptr, &res);
return res; return res;
} }
src/ir.cpp
+368 -368
View File
File diff suppressed because it is too large Load Diff
src/ir_opt.cpp
+12 -12
View File
@@ -39,7 +39,7 @@ void ir_opt_add_operands(Array<irValue *> *ops, irInstr *i) {
array_add(ops, i->If.cond); array_add(ops, i->If.cond);
break; break;
case irInstr_Return: case irInstr_Return:
if (i->Return.value != NULL) { if (i->Return.value != nullptr) {
array_add(ops, i->Return.value); array_add(ops, i->Return.value);
} }
break; break;
@@ -168,7 +168,7 @@ void ir_remove_dead_blocks(irProcedure *proc) {
isize j = 0; isize j = 0;
for_array(i, proc->blocks) { for_array(i, proc->blocks) {
irBlock *b = proc->blocks[i]; irBlock *b = proc->blocks[i];
if (b == NULL) { if (b == nullptr) {
continue; continue;
} }
// NOTE(bill): Swap order // NOTE(bill): Swap order
@@ -210,7 +210,7 @@ void ir_remove_unreachable_blocks(irProcedure *proc) {
} }
// NOTE(bill): Mark as empty but don't actually free it // NOTE(bill): Mark as empty but don't actually free it
// As it's been allocated with an arena // As it's been allocated with an arena
proc->blocks[i] = NULL; proc->blocks[i] = nullptr;
} }
} }
ir_remove_dead_blocks(proc); ir_remove_dead_blocks(proc);
@@ -245,7 +245,7 @@ bool ir_opt_block_fusion(irProcedure *proc, irBlock *a) {
ir_opt_block_replace_pred(b->succs[i], b, a); ir_opt_block_replace_pred(b->succs[i], b, a);
} }
proc->blocks[b->index] = NULL; proc->blocks[b->index] = nullptr;
return true; return true;
} }
@@ -258,7 +258,7 @@ void ir_opt_blocks(irProcedure *proc) {
changed = false; changed = false;
for_array(i, proc->blocks) { for_array(i, proc->blocks) {
irBlock *b = proc->blocks[i]; irBlock *b = proc->blocks[i];
if (b == NULL) { if (b == nullptr) {
continue; continue;
} }
GB_ASSERT_MSG(b->index == i, "%d, %td", b->index, i); GB_ASSERT_MSG(b->index == i, "%d, %td", b->index, i);
@@ -286,11 +286,11 @@ void ir_opt_build_referrers(irProcedure *proc) {
ir_opt_add_operands(&ops, &instr->Instr); ir_opt_add_operands(&ops, &instr->Instr);
for_array(k, ops) { for_array(k, ops) {
irValue *op = ops[k]; irValue *op = ops[k];
if (op == NULL) { if (op == nullptr) {
continue; continue;
} }
Array<irValue *> *refs = ir_value_referrers(op); Array<irValue *> *refs = ir_value_referrers(op);
if (refs != NULL) { if (refs != nullptr) {
array_add(refs, instr); array_add(refs, instr);
} }
} }
@@ -325,10 +325,10 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
preorder[i] = p; preorder[i] = p;
p->dom.pre = i++; p->dom.pre = i++;
lt->sdom[p->index] = p; lt->sdom[p->index] = p;
ir_lt_link(lt, NULL, p); ir_lt_link(lt, nullptr, p);
for_array(index, p->succs) { for_array(index, p->succs) {
irBlock *q = p->succs[index]; irBlock *q = p->succs[index];
if (lt->sdom[q->index] == NULL) { if (lt->sdom[q->index] == nullptr) {
lt->parent[q->index] = p; lt->parent[q->index] = p;
i = ir_lt_depth_first_search(lt, q, i, preorder); i = ir_lt_depth_first_search(lt, q, i, preorder);
} }
@@ -339,7 +339,7 @@ i32 ir_lt_depth_first_search(irLTState *lt, irBlock *p, i32 i, irBlock **preorde
irBlock *ir_lt_eval(irLTState *lt, irBlock *v) { irBlock *ir_lt_eval(irLTState *lt, irBlock *v) {
irBlock *u = v; irBlock *u = v;
for (; for (;
lt->ancestor[v->index] != NULL; lt->ancestor[v->index] != nullptr;
v = lt->ancestor[v->index]) { v = lt->ancestor[v->index]) {
if (lt->sdom[v->index]->dom.pre < lt->sdom[u->index]->dom.pre) { if (lt->sdom[v->index]->dom.pre < lt->sdom[u->index]->dom.pre) {
u = v; u = v;
@@ -432,7 +432,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
for (isize i = 1; i < n; i++) { for (isize i = 1; i < n; i++) {
irBlock *w = preorder[i]; irBlock *w = preorder[i];
if (w == root) { if (w == root) {
w->dom.idom = NULL; w->dom.idom = nullptr;
} else { } else {
// Weird tree relationships here! // Weird tree relationships here!
@@ -441,7 +441,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
} }
// Calculate children relation as inverse of idom // Calculate children relation as inverse of idom
if (w->dom.idom->dom.children.data == NULL) { if (w->dom.idom->dom.children.data == nullptr) {
// TODO(bill): Is this good enough for memory allocations? // TODO(bill): Is this good enough for memory allocations?
array_init(&w->dom.idom->dom.children, heap_allocator()); array_init(&w->dom.idom->dom.children, heap_allocator());
} }
src/ir_print.cpp
+26 -30
View File
@@ -5,8 +5,8 @@ struct irFileBuffer {
}; };
void ir_file_buffer_init(irFileBuffer *f, gbFile *output) { void ir_file_buffer_init(irFileBuffer *f, gbFile *output) {
isize size = 8*gb_virtual_memory_page_size(NULL); isize size = 8*gb_virtual_memory_page_size(nullptr);
f->vm = gb_vm_alloc(NULL, size); f->vm = gb_vm_alloc(nullptr, size);
f->offset = 0; f->offset = 0;
f->output = output; f->output = output;
} }
@@ -268,10 +268,6 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
ir_fprintf(f, "]}"); ir_fprintf(f, "]}");
return; return;
} }
/* ir_fprintf(f, "<%lld x ", t->Vector.count);
ir_print_type(f, m, t->Vector.elem);
ir_fprintf(f, ">");
return; */
case Type_Slice: case Type_Slice:
ir_fprintf(f, "{"); ir_fprintf(f, "{");
ir_print_type(f, m, t->Slice.elem); ir_print_type(f, m, t->Slice.elem);
@@ -345,7 +341,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
case Type_Named: case Type_Named:
if (is_type_struct(t) || is_type_union(t)) { if (is_type_struct(t) || is_type_union(t)) {
String *name = map_get(&m->entity_names, hash_pointer(t->Named.type_name)); String *name = map_get(&m->entity_names, hash_pointer(t->Named.type_name));
GB_ASSERT_MSG(name != NULL, "%.*s", LIT(t->Named.name)); GB_ASSERT_MSG(name != nullptr, "%.*s", LIT(t->Named.name));
ir_print_encoded_local(f, *name); ir_print_encoded_local(f, *name);
} else { } else {
ir_print_type(f, m, base_type(t)); ir_print_type(f, m, base_type(t));
@@ -376,7 +372,7 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
} return; } return;
case Type_Map: { case Type_Map: {
GB_ASSERT(t->Map.generated_struct_type != NULL); GB_ASSERT(t->Map.generated_struct_type != nullptr);
ir_print_type(f, m, t->Map.generated_struct_type); ir_print_type(f, m, t->Map.generated_struct_type);
} break; } break;
@@ -660,7 +656,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *
} }
void ir_print_block_name(irFileBuffer *f, irBlock *b) { void ir_print_block_name(irFileBuffer *f, irBlock *b) {
if (b != NULL) { if (b != nullptr) {
ir_print_escape_string(f, b->label, false, false); ir_print_escape_string(f, b->label, false, false);
ir_fprintf(f, "-%td", b->index); ir_fprintf(f, "-%td", b->index);
} else { } else {
@@ -669,7 +665,7 @@ void ir_print_block_name(irFileBuffer *f, irBlock *b) {
} }
bool ir_print_is_proc_global(irModule *m, irProcedure *proc) { bool ir_print_is_proc_global(irModule *m, irProcedure *proc) {
if (proc->entity != NULL && if (proc->entity != nullptr &&
proc->entity->kind == Entity_Procedure) { proc->entity->kind == Entity_Procedure) {
if (m->entry_point_entity == proc->entity) { if (m->entry_point_entity == proc->entity) {
// gb_printf("%.*s\n", LIT(proc->entity->token.string)); // gb_printf("%.*s\n", LIT(proc->entity->token.string));
@@ -684,8 +680,8 @@ bool ir_print_is_proc_global(irModule *m, irProcedure *proc) {
} }
void ir_print_value(irFileBuffer *f, irModule *m, irValue *value, Type *type_hint) { void ir_print_value(irFileBuffer *f, irModule *m, irValue *value, Type *type_hint) {
if (value == NULL) { if (value == nullptr) {
ir_fprintf(f, "!!!NULL_VALUE"); ir_fprintf(f, "!!!nullptr_VALUE");
return; return;
} }
switch (value->kind) { switch (value->kind) {
@@ -697,7 +693,7 @@ void ir_print_value(irFileBuffer *f, irModule *m, irValue *value, Type *type_hin
case irValue_ConstantSlice: { case irValue_ConstantSlice: {
irValueConstantSlice *cs = &value->ConstantSlice; irValueConstantSlice *cs = &value->ConstantSlice;
if (cs->backing_array == NULL || cs->count == 0) { if (cs->backing_array == nullptr || cs->count == 0) {
ir_fprintf(f, "zeroinitializer"); ir_fprintf(f, "zeroinitializer");
} else { } else {
Type *at = base_type(type_deref(ir_type(cs->backing_array))); Type *at = base_type(type_deref(ir_type(cs->backing_array)));
@@ -735,7 +731,7 @@ void ir_print_value(irFileBuffer *f, irModule *m, irValue *value, Type *type_hin
Entity *e = value->Global.entity; Entity *e = value->Global.entity;
Scope *scope = e->scope; Scope *scope = e->scope;
bool in_global_scope = false; bool in_global_scope = false;
if (scope != NULL) { if (scope != nullptr) {
// TODO(bill): Fix this rule. What should it be? // TODO(bill): Fix this rule. What should it be?
in_global_scope = scope->is_global || scope->is_init; in_global_scope = scope->is_global || scope->is_init;
} }
@@ -925,8 +921,8 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
} }
irValue *edge = instr->Phi.edges[i]; irValue *edge = instr->Phi.edges[i];
irBlock *block = NULL; irBlock *block = nullptr;
if (instr->parent != NULL && if (instr->parent != nullptr &&
i < instr->parent->preds.count) { i < instr->parent->preds.count) {
block = instr->parent->preds[i]; block = instr->parent->preds[i];
} }
@@ -1024,7 +1020,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
case irInstr_Return: { case irInstr_Return: {
irInstrReturn *ret = &instr->Return; irInstrReturn *ret = &instr->Return;
ir_fprintf(f, "ret "); ir_fprintf(f, "ret ");
if (ret->value == NULL) { if (ret->value == nullptr) {
ir_fprintf(f, "void"); ir_fprintf(f, "void");
} else { } else {
Type *t = ir_type(ret->value); Type *t = ir_type(ret->value);
@@ -1269,7 +1265,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
ir_fprintf(f, "("); ir_fprintf(f, "(");
if (proc_type->Proc.return_by_pointer) { if (proc_type->Proc.return_by_pointer) {
GB_ASSERT(call->return_ptr != NULL); GB_ASSERT(call->return_ptr != nullptr);
ir_print_type(f, m, proc_type->Proc.results); ir_print_type(f, m, proc_type->Proc.results);
ir_fprintf(f, "* "); ir_fprintf(f, "* ");
ir_print_value(f, m, call->return_ptr, ir_type(call->return_ptr)); ir_print_value(f, m, call->return_ptr, ir_type(call->return_ptr));
@@ -1286,7 +1282,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
isize i = 0; isize i = 0;
for (; i < params->variable_count-1; i++) { for (; i < params->variable_count-1; i++) {
Entity *e = params->variables[i]; Entity *e = params->variables[i];
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
if (e->kind != Entity_Variable) continue; if (e->kind != Entity_Variable) continue;
if (param_index > 0) ir_fprintf(f, ", "); if (param_index > 0) ir_fprintf(f, ", ");
@@ -1316,7 +1312,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
isize param_count = params->variable_count; isize param_count = params->variable_count;
for (isize i = 0; i < param_count; i++) { for (isize i = 0; i < param_count; i++) {
Entity *e = params->variables[i]; Entity *e = params->variables[i];
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
if (e->kind != Entity_Variable) continue; if (e->kind != Entity_Variable) continue;
if (param_index > 0) ir_fprintf(f, ", "); if (param_index > 0) ir_fprintf(f, ", ");
@@ -1523,7 +1519,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) { void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
if (proc->body == NULL) { if (proc->body == nullptr) {
ir_fprintf(f, "declare "); ir_fprintf(f, "declare ");
// if (proc->tags & ProcTag_dll_import) { // if (proc->tags & ProcTag_dll_import) {
// ir_fprintf(f, "dllimport "); // ir_fprintf(f, "dllimport ");
@@ -1584,7 +1580,7 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
if (e->flags&EntityFlag_NoAlias) { if (e->flags&EntityFlag_NoAlias) {
ir_fprintf(f, " noalias"); ir_fprintf(f, " noalias");
} }
if (proc->body != NULL) { if (proc->body != nullptr) {
if (e->token.string != "" && if (e->token.string != "" &&
e->token.string != "_") { e->token.string != "_") {
ir_fprintf(f, " "); ir_fprintf(f, " ");
@@ -1615,10 +1611,10 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
} }
if (proc->entity != NULL) { if (proc->entity != nullptr) {
if (proc->body != NULL) { if (proc->body != nullptr) {
irDebugInfo **di_ = map_get(&proc->module->debug_info, hash_pointer(proc->entity)); irDebugInfo **di_ = map_get(&proc->module->debug_info, hash_pointer(proc->entity));
if (di_ != NULL) { if (di_ != nullptr) {
irDebugInfo *di = *di_; irDebugInfo *di = *di_;
GB_ASSERT(di->kind == irDebugInfo_Proc); GB_ASSERT(di->kind == irDebugInfo_Proc);
// ir_fprintf(f, "!dbg !%d ", di->id); // ir_fprintf(f, "!dbg !%d ", di->id);
@@ -1627,7 +1623,7 @@ void ir_print_proc(irFileBuffer *f, irModule *m, irProcedure *proc) {
} }
if (proc->body != NULL) { if (proc->body != nullptr) {
// ir_fprintf(f, "nounwind uwtable {\n"); // ir_fprintf(f, "nounwind uwtable {\n");
ir_fprintf(f, "{\n"); ir_fprintf(f, "{\n");
@@ -1716,7 +1712,7 @@ void print_llvm_ir(irGen *ir) {
continue; continue;
} }
if (v->Proc.body == NULL) { if (v->Proc.body == nullptr) {
ir_print_proc(f, m, &v->Proc); ir_print_proc(f, m, &v->Proc);
} }
} }
@@ -1728,7 +1724,7 @@ void print_llvm_ir(irGen *ir) {
continue; continue;
} }
if (v->Proc.body != NULL) { if (v->Proc.body != nullptr) {
ir_print_proc(f, m, &v->Proc); ir_print_proc(f, m, &v->Proc);
} }
} }
@@ -1742,7 +1738,7 @@ void print_llvm_ir(irGen *ir) {
irValueGlobal *g = &v->Global; irValueGlobal *g = &v->Global;
Scope *scope = g->entity->scope; Scope *scope = g->entity->scope;
bool in_global_scope = false; bool in_global_scope = false;
if (scope != NULL) { if (scope != nullptr) {
// TODO(bill): Fix this rule. What should it be? // TODO(bill): Fix this rule. What should it be?
in_global_scope = scope->is_global || scope->is_init; in_global_scope = scope->is_global || scope->is_init;
// in_global_scope = value->Global.name_is_not_mangled; // in_global_scope = value->Global.name_is_not_mangled;
@@ -1773,7 +1769,7 @@ void print_llvm_ir(irGen *ir) {
ir_print_type(f, m, g->entity->type); ir_print_type(f, m, g->entity->type);
ir_fprintf(f, " "); ir_fprintf(f, " ");
if (!g->is_foreign) { if (!g->is_foreign) {
if (g->value != NULL) { if (g->value != nullptr) {
ir_print_value(f, m, g->value, g->entity->type); ir_print_value(f, m, g->value, g->entity->type);
} else { } else {
ir_fprintf(f, "zeroinitializer"); ir_fprintf(f, "zeroinitializer");
src/main.cpp
+2 -2
View File
@@ -41,8 +41,8 @@ i32 system_exec_command_line_app(char *name, bool is_silent, char *fmt, ...) {
cmd = string_to_string16(string_buffer_allocator, make_string(cast(u8 *)cmd_line, cmd_len-1)); cmd = string_to_string16(string_buffer_allocator, make_string(cast(u8 *)cmd_line, cmd_len-1));
if (CreateProcessW(NULL, cmd.text, if (CreateProcessW(nullptr, cmd.text,
NULL, NULL, true, 0, NULL, NULL, nullptr, nullptr, true, 0, nullptr, nullptr,
&start_info, &pi)) { &start_info, &pi)) {
WaitForSingleObject(pi.hProcess, INFINITE); WaitForSingleObject(pi.hProcess, INFINITE);
GetExitCodeProcess(pi.hProcess, cast(DWORD *)&exit_code); GetExitCodeProcess(pi.hProcess, cast(DWORD *)&exit_code);
src/map.cpp
+6 -6
View File
@@ -234,7 +234,7 @@ gb_inline T *map_get(Map<T> *h, HashKey key) {
if (index >= 0) { if (index >= 0) {
return &h->entries[index].value; return &h->entries[index].value;
} }
return NULL; return nullptr;
} }
template <typename T> template <typename T>
@@ -303,7 +303,7 @@ template <typename T>
MapEntry<T> *multi_map_find_first(Map<T> *h, HashKey key) { MapEntry<T> *multi_map_find_first(Map<T> *h, HashKey key) {
isize i = map__find(h, key).entry_index; isize i = map__find(h, key).entry_index;
if (i < 0) { if (i < 0) {
return NULL; return nullptr;
} }
return &h->entries[i]; return &h->entries[i];
} }
@@ -317,14 +317,14 @@ MapEntry<T> *multi_map_find_next(Map<T> *h, MapEntry<T> *e) {
} }
i = h->entries[i].next; i = h->entries[i].next;
} }
return NULL; return nullptr;
} }
template <typename T> template <typename T>
isize multi_map_count(Map<T> *h, HashKey key) { isize multi_map_count(Map<T> *h, HashKey key) {
isize count = 0; isize count = 0;
MapEntry<T> *e = multi_map_find_first(h, key); MapEntry<T> *e = multi_map_find_first(h, key);
while (e != NULL) { while (e != nullptr) {
count++; count++;
e = multi_map_find_next(h, e); e = multi_map_find_next(h, e);
} }
@@ -335,7 +335,7 @@ template <typename T>
void multi_map_get_all(Map<T> *h, HashKey key, T *items) { void multi_map_get_all(Map<T> *h, HashKey key, T *items) {
isize i = 0; isize i = 0;
MapEntry<T> *e = multi_map_find_first(h, key); MapEntry<T> *e = multi_map_find_first(h, key);
while (e != NULL) { while (e != nullptr) {
items[i++] = e->value; items[i++] = e->value;
e = multi_map_find_next(h, e); e = multi_map_find_next(h, e);
} }
@@ -374,7 +374,7 @@ void multi_map_remove(Map<T> *h, HashKey key, MapEntry<T> *e) {
template <typename T> template <typename T>
void multi_map_remove_all(Map<T> *h, HashKey key) { void multi_map_remove_all(Map<T> *h, HashKey key) {
while (map_get(h, key) != NULL) { while (map_get(h, key) != nullptr) {
map_remove(h, key); map_remove(h, key);
} }
} }
src/parser.cpp
+133 -133
View File
@@ -519,7 +519,7 @@ Token ast_node_token(AstNode *node) {
case AstNode_BasicDirective: return node->BasicDirective.token; case AstNode_BasicDirective: return node->BasicDirective.token;
case AstNode_ProcLit: return ast_node_token(node->ProcLit.type); case AstNode_ProcLit: return ast_node_token(node->ProcLit.type);
case AstNode_CompoundLit: case AstNode_CompoundLit:
if (node->CompoundLit.type != NULL) { if (node->CompoundLit.type != nullptr) {
return ast_node_token(node->CompoundLit.type); return ast_node_token(node->CompoundLit.type);
} }
return node->CompoundLit.open; return node->CompoundLit.open;
@@ -534,7 +534,7 @@ Token ast_node_token(AstNode *node) {
case AstNode_CallExpr: return ast_node_token(node->CallExpr.proc); case AstNode_CallExpr: return ast_node_token(node->CallExpr.proc);
case AstNode_MacroCallExpr: return ast_node_token(node->MacroCallExpr.macro); case AstNode_MacroCallExpr: return ast_node_token(node->MacroCallExpr.macro);
case AstNode_SelectorExpr: case AstNode_SelectorExpr:
if (node->SelectorExpr.selector != NULL) { if (node->SelectorExpr.selector != nullptr) {
return ast_node_token(node->SelectorExpr.selector); return ast_node_token(node->SelectorExpr.selector);
} }
return node->SelectorExpr.token; return node->SelectorExpr.token;
@@ -622,8 +622,8 @@ Array<AstNode *> clone_ast_node_array(gbAllocator a, Array<AstNode *> array) {
} }
AstNode *clone_ast_node(gbAllocator a, AstNode *node) { AstNode *clone_ast_node(gbAllocator a, AstNode *node) {
if (node == NULL) { if (node == nullptr) {
return NULL; return nullptr;
} }
AstNode *n = gb_alloc_item(a, AstNode); AstNode *n = gb_alloc_item(a, AstNode);
gb_memmove(n, node, gb_size_of(AstNode)); gb_memmove(n, node, gb_size_of(AstNode));
@@ -891,7 +891,7 @@ AstNode *clone_ast_node(gbAllocator a, AstNode *node) {
void error(AstNode *node, char *fmt, ...) { void error(AstNode *node, char *fmt, ...) {
Token token = {}; Token token = {};
if (node != NULL) { if (node != nullptr) {
token = ast_node_token(node); token = ast_node_token(node);
} }
va_list va; va_list va;
@@ -978,11 +978,11 @@ AstNode *ast_unary_expr(AstFile *f, Token op, AstNode *expr) {
AstNode *ast_binary_expr(AstFile *f, Token op, AstNode *left, AstNode *right) { AstNode *ast_binary_expr(AstFile *f, Token op, AstNode *left, AstNode *right) {
AstNode *result = make_ast_node(f, AstNode_BinaryExpr); AstNode *result = make_ast_node(f, AstNode_BinaryExpr);
if (left == NULL) { if (left == nullptr) {
syntax_error(op, "No lhs expression for binary expression `%.*s`", LIT(op.string)); syntax_error(op, "No lhs expression for binary expression `%.*s`", LIT(op.string));
left = ast_bad_expr(f, op, op); left = ast_bad_expr(f, op, op);
} }
if (right == NULL) { if (right == nullptr) {
syntax_error(op, "No rhs expression for binary expression `%.*s`", LIT(op.string)); syntax_error(op, "No rhs expression for binary expression `%.*s`", LIT(op.string));
right = ast_bad_expr(f, op, op); right = ast_bad_expr(f, op, op);
} }
@@ -1802,7 +1802,7 @@ Token expect_closing(AstFile *f, TokenKind kind, String context) {
} }
bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
if (s == NULL) { if (s == nullptr) {
return false; return false;
} }
@@ -1828,7 +1828,7 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
case AstNode_BitFieldType: case AstNode_BitFieldType:
return true; return true;
case AstNode_ProcLit: case AstNode_ProcLit:
return s->ProcLit.body != NULL; return s->ProcLit.body != nullptr;
case AstNode_ValueDecl: case AstNode_ValueDecl:
if (s->ValueDecl.is_mutable) { if (s->ValueDecl.is_mutable) {
@@ -1875,7 +1875,7 @@ void expect_semicolon(AstFile *f, AstNode *s) {
return; return;
} }
if (s != NULL) { if (s != nullptr) {
if (prev_token.pos.line != f->curr_token.pos.line) { if (prev_token.pos.line != f->curr_token.pos.line) {
if (is_semicolon_optional_for_node(f, s)) { if (is_semicolon_optional_for_node(f, s)) {
return; return;
@@ -1940,8 +1940,8 @@ AstNode *parse_tag_expr(AstFile *f, AstNode *expression) {
AstNode *unparen_expr(AstNode *node) { AstNode *unparen_expr(AstNode *node) {
for (;;) { for (;;) {
if (node == NULL) { if (node == nullptr) {
return NULL; return nullptr;
} }
if (node->kind != AstNode_ParenExpr) { if (node->kind != AstNode_ParenExpr) {
return node; return node;
@@ -1989,7 +1989,7 @@ AstNode *parse_literal_value(AstFile *f, AstNode *type) {
AstNode *parse_value(AstFile *f) { AstNode *parse_value(AstFile *f) {
if (f->curr_token.kind == Token_OpenBrace) { if (f->curr_token.kind == Token_OpenBrace) {
return parse_literal_value(f, NULL); return parse_literal_value(f, nullptr);
} }
AstNode *value = parse_expr(f, false); AstNode *value = parse_expr(f, false);
@@ -2056,13 +2056,13 @@ bool is_foreign_name_valid(String name) {
void parse_proc_tags(AstFile *f, u64 *tags, String *link_name, ProcCallingConvention *calling_convention) { void parse_proc_tags(AstFile *f, u64 *tags, String *link_name, ProcCallingConvention *calling_convention) {
// TODO(bill): Add this to procedure literals too // TODO(bill): Add this to procedure literals too
GB_ASSERT(tags != NULL); GB_ASSERT(tags != nullptr);
GB_ASSERT(link_name != NULL); GB_ASSERT(link_name != nullptr);
ProcCallingConvention cc = ProcCC_Invalid; ProcCallingConvention cc = ProcCC_Invalid;
while (f->curr_token.kind == Token_Hash) { while (f->curr_token.kind == Token_Hash) {
AstNode *tag_expr = parse_tag_expr(f, NULL); AstNode *tag_expr = parse_tag_expr(f, nullptr);
ast_node(te, TagExpr, tag_expr); ast_node(te, TagExpr, tag_expr);
String tag_name = te->name.string; String tag_name = te->name.string;
@@ -2165,8 +2165,8 @@ AstNode * parse_type (AstFile *f);
AstNode * parse_call_expr (AstFile *f, AstNode *operand); AstNode * parse_call_expr (AstFile *f, AstNode *operand);
AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) { AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) {
if (statement == NULL) { if (statement == nullptr) {
return NULL; return nullptr;
} }
if (statement->kind == AstNode_ExprStmt) { if (statement->kind == AstNode_ExprStmt) {
@@ -2184,7 +2184,7 @@ AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) {
AstNode *parse_operand(AstFile *f, bool lhs) { AstNode *parse_operand(AstFile *f, bool lhs) {
AstNode *operand = NULL; // Operand AstNode *operand = nullptr; // Operand
switch (f->curr_token.kind) { switch (f->curr_token.kind) {
case Token_Ident: case Token_Ident:
return parse_ident(f); return parse_ident(f);
@@ -2285,13 +2285,13 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
u64 tags = type->ProcType.tags; u64 tags = type->ProcType.tags;
if (allow_token(f, Token_Undef)) { if (allow_token(f, Token_Undef)) {
return ast_proc_lit(f, type, NULL, tags, link_name); return ast_proc_lit(f, type, nullptr, tags, link_name);
} else if (f->curr_token.kind == Token_OpenBrace) { } else if (f->curr_token.kind == Token_OpenBrace) {
if ((tags & ProcTag_foreign) != 0) { if ((tags & ProcTag_foreign) != 0) {
syntax_error(token, "A procedure tagged as `#foreign` cannot have a body"); syntax_error(token, "A procedure tagged as `#foreign` cannot have a body");
} }
AstNode *curr_proc = f->curr_proc; AstNode *curr_proc = f->curr_proc;
AstNode *body = NULL; AstNode *body = nullptr;
f->curr_proc = type; f->curr_proc = type;
body = parse_body(f); body = parse_body(f);
f->curr_proc = curr_proc; f->curr_proc = curr_proc;
@@ -2302,7 +2302,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
syntax_error(token, "A procedure tagged as `#foreign` cannot have a body"); syntax_error(token, "A procedure tagged as `#foreign` cannot have a body");
} }
AstNode *curr_proc = f->curr_proc; AstNode *curr_proc = f->curr_proc;
AstNode *body = NULL; AstNode *body = nullptr;
f->curr_proc = type; f->curr_proc = type;
body = parse_stmt(f); body = parse_stmt(f);
if (body->kind == AstNode_BlockStmt) { if (body->kind == AstNode_BlockStmt) {
@@ -2320,7 +2320,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
} }
if ((tags & ProcTag_foreign) != 0) { if ((tags & ProcTag_foreign) != 0) {
return ast_proc_lit(f, type, NULL, tags, link_name); return ast_proc_lit(f, type, nullptr, tags, link_name);
} }
if (tags != 0) { if (tags != 0) {
// syntax_error(token, "A procedure type cannot have tags"); // syntax_error(token, "A procedure type cannot have tags");
@@ -2331,7 +2331,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
default: { default: {
AstNode *type = parse_type_or_ident(f); AstNode *type = parse_type_or_ident(f);
if (type != NULL) { if (type != nullptr) {
// TODO(bill): Is this correct??? // TODO(bill): Is this correct???
// NOTE(bill): Sanity check as identifiers should be handled already // NOTE(bill): Sanity check as identifiers should be handled already
TokenPos pos = ast_node_token(type).pos; TokenPos pos = ast_node_token(type).pos;
@@ -2342,7 +2342,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
} }
} }
return NULL; return nullptr;
} }
bool is_literal_type(AstNode *node) { bool is_literal_type(AstNode *node) {
@@ -2446,7 +2446,7 @@ AstNode *parse_macro_call_expr(AstFile *f, AstNode *operand) {
} }
AstNode *parse_atom_expr(AstFile *f, AstNode *operand, bool lhs) { AstNode *parse_atom_expr(AstFile *f, AstNode *operand, bool lhs) {
if (operand == NULL) { if (operand == nullptr) {
Token begin = f->curr_token; Token begin = f->curr_token;
syntax_error(begin, "Expected an operand"); syntax_error(begin, "Expected an operand");
fix_advance_to_next_stmt(f); fix_advance_to_next_stmt(f);
@@ -2484,7 +2484,7 @@ AstNode *parse_atom_expr(AstFile *f, AstNode *operand, bool lhs) {
syntax_error(f->curr_token, "Expected a selector"); syntax_error(f->curr_token, "Expected a selector");
next_token(f); next_token(f);
operand = ast_bad_expr(f, ast_node_token(operand), f->curr_token); operand = ast_bad_expr(f, ast_node_token(operand), f->curr_token);
// operand = ast_selector_expr(f, f->curr_token, operand, NULL); // operand = ast_selector_expr(f, f->curr_token, operand, nullptr);
break; break;
} }
} break; } break;
@@ -2532,11 +2532,11 @@ AstNode *parse_atom_expr(AstFile *f, AstNode *operand, bool lhs) {
if (ellipsis_count == 2) { if (ellipsis_count == 2) {
index3 = true; index3 = true;
// 2nd and 3rd index must be present // 2nd and 3rd index must be present
if (indices[1] == NULL) { if (indices[1] == nullptr) {
error(ellipses[0], "2nd index required in 3-index slice expression"); error(ellipses[0], "2nd index required in 3-index slice expression");
indices[1] = ast_bad_expr(f, ellipses[0], ellipses[1]); indices[1] = ast_bad_expr(f, ellipses[0], ellipses[1]);
} }
if (indices[2] == NULL) { if (indices[2] == nullptr) {
error(ellipses[1], "3rd index required in 3-index slice expression"); error(ellipses[1], "3rd index required in 3-index slice expression");
indices[2] = ast_bad_expr(f, ellipses[1], close); indices[2] = ast_bad_expr(f, ellipses[1], close);
} }
@@ -2591,7 +2591,7 @@ AstNode *parse_unary_expr(AstFile *f, bool lhs) {
} }
bool is_ast_node_a_range(AstNode *expr) { bool is_ast_node_a_range(AstNode *expr) {
if (expr == NULL) { if (expr == nullptr) {
return false; return false;
} }
if (expr->kind != AstNode_BinaryExpr) { if (expr->kind != AstNode_BinaryExpr) {
@@ -2667,7 +2667,7 @@ AstNode *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) {
expr = ast_ternary_expr(f, cond, x, y); expr = ast_ternary_expr(f, cond, x, y);
} else { } else {
AstNode *right = parse_binary_expr(f, false, prec+1); AstNode *right = parse_binary_expr(f, false, prec+1);
if (right == NULL) { if (right == nullptr) {
syntax_error(op, "Expected expression on the right-hand side of the binary operator"); syntax_error(op, "Expected expression on the right-hand side of the binary operator");
} }
expr = ast_binary_expr(f, op, expr, right); expr = ast_binary_expr(f, op, expr, right);
@@ -2725,7 +2725,7 @@ Array<AstNode *> parse_ident_list(AstFile *f) {
AstNode *parse_type_attempt(AstFile *f) { AstNode *parse_type_attempt(AstFile *f) {
AstNode *type = parse_type_or_ident(f); AstNode *type = parse_type_or_ident(f);
if (type != NULL) { if (type != nullptr) {
// TODO(bill): Handle? // TODO(bill): Handle?
} }
return type; return type;
@@ -2733,7 +2733,7 @@ AstNode *parse_type_attempt(AstFile *f) {
AstNode *parse_type(AstFile *f) { AstNode *parse_type(AstFile *f) {
AstNode *type = parse_type_attempt(f); AstNode *type = parse_type_attempt(f);
if (type == NULL) { if (type == nullptr) {
Token token = f->curr_token; Token token = f->curr_token;
syntax_error(token, "Expected a type"); syntax_error(token, "Expected a type");
next_token(f); next_token(f);
@@ -2765,7 +2765,7 @@ AstNode *parse_gen_decl(AstFile *f, Token token, ParseSpecFunc *func) {
if (require_semicolon_after_paren || if (require_semicolon_after_paren ||
f->curr_token.pos.line == close.pos.line || f->curr_token.pos.line == close.pos.line ||
open.pos.line == close.pos.line) { open.pos.line == close.pos.line) {
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
} }
} else { } else {
specs = make_ast_node_array(f, 1); specs = make_ast_node_array(f, 1);
@@ -2781,9 +2781,9 @@ AstNode *parse_gen_decl(AstFile *f, Token token, ParseSpecFunc *func) {
} }
PARSE_SPEC_FUNC(parse_import_spec) { PARSE_SPEC_FUNC(parse_import_spec) {
AstNode *spec = NULL; AstNode *spec = nullptr;
if (token.kind == Token_import) { if (token.kind == Token_import) {
AstNode *cond = NULL; AstNode *cond = nullptr;
Token import_name = {}; Token import_name = {};
switch (f->curr_token.kind) { switch (f->curr_token.kind) {
@@ -2810,15 +2810,15 @@ PARSE_SPEC_FUNC(parse_import_spec) {
cond = parse_expr(f, false); cond = parse_expr(f, false);
} }
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
if (f->curr_proc != NULL) { if (f->curr_proc != nullptr) {
syntax_error(import_name, "You cannot use `import` within a procedure. This must be done at the file scope"); syntax_error(import_name, "You cannot use `import` within a procedure. This must be done at the file scope");
spec = ast_bad_decl(f, import_name, file_path); spec = ast_bad_decl(f, import_name, file_path);
} else { } else {
spec = ast_import_spec(f, true, file_path, import_name, cond, docs, f->line_comment); spec = ast_import_spec(f, true, file_path, import_name, cond, docs, f->line_comment);
} }
} else { } else {
AstNode *cond = NULL; AstNode *cond = nullptr;
Token file_path = expect_token_after(f, Token_String, "import_load"); Token file_path = expect_token_after(f, Token_String, "import_load");
Token import_name = file_path; Token import_name = file_path;
import_name.string = str_lit("."); import_name.string = str_lit(".");
@@ -2827,8 +2827,8 @@ PARSE_SPEC_FUNC(parse_import_spec) {
cond = parse_expr(f, false); cond = parse_expr(f, false);
} }
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
if (f->curr_proc != NULL) { if (f->curr_proc != nullptr) {
syntax_error(import_name, "You cannot use `import_load` within a procedure. This must be done at the file scope"); syntax_error(import_name, "You cannot use `import_load` within a procedure. This must be done at the file scope");
spec = ast_bad_decl(f, import_name, file_path); spec = ast_bad_decl(f, import_name, file_path);
} else { } else {
@@ -2839,9 +2839,9 @@ PARSE_SPEC_FUNC(parse_import_spec) {
} }
PARSE_SPEC_FUNC(parse_foreign_library_spec) { PARSE_SPEC_FUNC(parse_foreign_library_spec) {
AstNode *spec = NULL; AstNode *spec = nullptr;
if (token.kind == Token_foreign_system_library) { if (token.kind == Token_foreign_system_library) {
AstNode *cond = NULL; AstNode *cond = nullptr;
Token lib_name = {}; Token lib_name = {};
switch (f->curr_token.kind) { switch (f->curr_token.kind) {
@@ -2863,16 +2863,16 @@ PARSE_SPEC_FUNC(parse_foreign_library_spec) {
cond = parse_expr(f, false); cond = parse_expr(f, false);
} }
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
spec = ast_foreign_library_spec(f, file_path, lib_name, cond, true, docs, f->line_comment); spec = ast_foreign_library_spec(f, file_path, lib_name, cond, true, docs, f->line_comment);
} else { } else {
syntax_error(lib_name, "You cannot use foreign_system_library within a procedure. This must be done at the file scope"); syntax_error(lib_name, "You cannot use foreign_system_library within a procedure. This must be done at the file scope");
spec = ast_bad_decl(f, lib_name, file_path); spec = ast_bad_decl(f, lib_name, file_path);
} }
} else { } else {
AstNode *cond = NULL; AstNode *cond = nullptr;
Token lib_name = {}; Token lib_name = {};
switch (f->curr_token.kind) { switch (f->curr_token.kind) {
@@ -2894,9 +2894,9 @@ PARSE_SPEC_FUNC(parse_foreign_library_spec) {
cond = parse_expr(f, false); cond = parse_expr(f, false);
} }
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
spec = ast_foreign_library_spec(f, file_path, lib_name, cond, false, docs, f->line_comment); spec = ast_foreign_library_spec(f, file_path, lib_name, cond, false, docs, f->line_comment);
} else { } else {
syntax_error(lib_name, "You cannot use foreign_library within a procedure. This must be done at the file scope"); syntax_error(lib_name, "You cannot use foreign_library within a procedure. This must be done at the file scope");
@@ -2928,7 +2928,7 @@ void parse_foreign_block_decl(AstFile *f, Array<AstNode *> *decls) {
} }
AstNode *parse_decl(AstFile *f) { AstNode *parse_decl(AstFile *f) {
ParseSpecFunc *func = NULL; ParseSpecFunc *func = nullptr;
switch (f->curr_token.kind) { switch (f->curr_token.kind) {
case Token_import: case Token_import:
case Token_import_load: case Token_import_load:
@@ -2984,7 +2984,7 @@ AstNode *parse_decl(AstFile *f) {
AstNode *parse_value_decl(AstFile *f, Array<AstNode *> names, CommentGroup docs) { AstNode *parse_value_decl(AstFile *f, Array<AstNode *> names, CommentGroup docs) {
bool is_mutable = true; bool is_mutable = true;
AstNode *type = NULL; AstNode *type = nullptr;
Array<AstNode *> values = {}; Array<AstNode *> values = {};
Token colon = expect_token_after(f, Token_Colon, "identifier list"); Token colon = expect_token_after(f, Token_Colon, "identifier list");
@@ -3006,23 +3006,23 @@ AstNode *parse_value_decl(AstFile *f, Array<AstNode *> names, CommentGroup docs)
if (is_mutable) { if (is_mutable) {
if (type == NULL && values.count == 0) { if (type == nullptr && values.count == 0) {
syntax_error(f->curr_token, "Missing variable type or initialization"); syntax_error(f->curr_token, "Missing variable type or initialization");
return ast_bad_decl(f, f->curr_token, f->curr_token); return ast_bad_decl(f, f->curr_token, f->curr_token);
} }
} else { } else {
if (type == NULL && values.count == 0 && names.count > 0) { if (type == nullptr && values.count == 0 && names.count > 0) {
syntax_error(f->curr_token, "Missing constant value"); syntax_error(f->curr_token, "Missing constant value");
return ast_bad_decl(f, f->curr_token, f->curr_token); return ast_bad_decl(f, f->curr_token, f->curr_token);
} }
} }
if (values.data == NULL) { if (values.data == nullptr) {
values = make_ast_node_array(f); values = make_ast_node_array(f);
} }
if (f->expr_level >= 0) { if (f->expr_level >= 0) {
AstNode *end = NULL; AstNode *end = nullptr;
if (!is_mutable && values.count > 0) { if (!is_mutable && values.count > 0) {
end = values[values.count-1]; end = values[values.count-1];
} }
@@ -3055,7 +3055,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) {
case Token_CmpAndEq: case Token_CmpAndEq:
case Token_CmpOrEq: case Token_CmpOrEq:
{ {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a simple statement in the file scope"); syntax_error(f->curr_token, "You cannot use a simple statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
@@ -3131,7 +3131,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) {
AstNode *parse_block_stmt(AstFile *f, b32 is_when) { AstNode *parse_block_stmt(AstFile *f, b32 is_when) {
if (!is_when && f->curr_proc == NULL) { if (!is_when && f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a block statement in the file scope"); syntax_error(f->curr_token, "You cannot use a block statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
@@ -3143,7 +3143,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
AstNode *parse_results(AstFile *f) { AstNode *parse_results(AstFile *f) {
if (!allow_token(f, Token_ArrowRight)) { if (!allow_token(f, Token_ArrowRight)) {
return NULL; return nullptr;
} }
if (f->curr_token.kind != Token_OpenParen) { if (f->curr_token.kind != Token_OpenParen) {
@@ -3152,23 +3152,23 @@ AstNode *parse_results(AstFile *f) {
Array<AstNode *> empty_names = {}; Array<AstNode *> empty_names = {};
Array<AstNode *> list = make_ast_node_array(f, 1); Array<AstNode *> list = make_ast_node_array(f, 1);
AstNode *type = parse_type(f); AstNode *type = parse_type(f);
array_add(&list, ast_field(f, empty_names, type, NULL, 0, empty_group, empty_group)); array_add(&list, ast_field(f, empty_names, type, nullptr, 0, empty_group, empty_group));
return ast_field_list(f, begin_token, list); return ast_field_list(f, begin_token, list);
} }
AstNode *list = NULL; AstNode *list = nullptr;
expect_token(f, Token_OpenParen); expect_token(f, Token_OpenParen);
list = parse_field_list(f, NULL, 0, Token_CloseParen, true); list = parse_field_list(f, nullptr, 0, Token_CloseParen, true);
expect_token_after(f, Token_CloseParen, "parameter list"); expect_token_after(f, Token_CloseParen, "parameter list");
return list; return list;
} }
AstNode *parse_proc_type(AstFile *f, Token proc_token, String *link_name_) { AstNode *parse_proc_type(AstFile *f, Token proc_token, String *link_name_) {
AstNode *params = NULL; AstNode *params = nullptr;
AstNode *results = NULL; AstNode *results = nullptr;
expect_token(f, Token_OpenParen); expect_token(f, Token_OpenParen);
params = parse_field_list(f, NULL, FieldFlag_Signature, Token_CloseParen, true); params = parse_field_list(f, nullptr, FieldFlag_Signature, Token_CloseParen, true);
expect_token_after(f, Token_CloseParen, "parameter list"); expect_token_after(f, Token_CloseParen, "parameter list");
results = parse_results(f); results = parse_results(f);
@@ -3188,7 +3188,7 @@ AstNode *parse_proc_type(AstFile *f, Token proc_token, String *link_name_) {
is_generic = true; is_generic = true;
break; break;
} }
if (f->type != NULL && if (f->type != nullptr &&
f->type->kind == AstNode_TypeType) { f->type->kind == AstNode_TypeType) {
is_generic = true; is_generic = true;
break; break;
@@ -3204,20 +3204,20 @@ AstNode *parse_var_type(AstFile *f, bool allow_ellipsis, bool allow_type_token)
Token tok = f->curr_token; Token tok = f->curr_token;
next_token(f); next_token(f);
AstNode *type = parse_type_or_ident(f); AstNode *type = parse_type_or_ident(f);
if (type == NULL) { if (type == nullptr) {
error(tok, "variadic field missing type after `...`"); error(tok, "variadic field missing type after `...`");
type = ast_bad_expr(f, tok, f->curr_token); type = ast_bad_expr(f, tok, f->curr_token);
} }
return ast_ellipsis(f, tok, type); return ast_ellipsis(f, tok, type);
} }
AstNode *type = NULL; AstNode *type = nullptr;
if (allow_type_token && if (allow_type_token &&
f->curr_token.kind == Token_type) { f->curr_token.kind == Token_type) {
type = ast_type_type(f, expect_token(f, Token_type)); type = ast_type_type(f, expect_token(f, Token_type));
} else { } else {
type = parse_type_attempt(f); type = parse_type_attempt(f);
} }
if (type == NULL) { if (type == nullptr) {
Token tok = f->curr_token; Token tok = f->curr_token;
error(tok, "Expected a type"); error(tok, "Expected a type");
type = ast_bad_expr(f, tok, f->curr_token); type = ast_bad_expr(f, tok, f->curr_token);
@@ -3408,8 +3408,8 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags); set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags);
total_name_count += names.count; total_name_count += names.count;
AstNode *type = NULL; AstNode *type = nullptr;
AstNode *default_value = NULL; AstNode *default_value = nullptr;
expect_token_after(f, Token_Colon, "field list"); expect_token_after(f, Token_Colon, "field list");
if (f->curr_token.kind != Token_Eq) { if (f->curr_token.kind != Token_Eq) {
@@ -3423,7 +3423,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
} }
} }
if (default_value != NULL && names.count > 1) { if (default_value != nullptr && names.count > 1) {
syntax_error(f->curr_token, "Default parameters can only be applied to single values"); syntax_error(f->curr_token, "Default parameters can only be applied to single values");
} }
@@ -3445,8 +3445,8 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags); set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags);
total_name_count += names.count; total_name_count += names.count;
AstNode *type = NULL; AstNode *type = nullptr;
AstNode *default_value = NULL; AstNode *default_value = nullptr;
expect_token_after(f, Token_Colon, "field list"); expect_token_after(f, Token_Colon, "field list");
if (f->curr_token.kind != Token_Eq) { if (f->curr_token.kind != Token_Eq) {
type = parse_var_type(f, allow_ellipsis, allow_default_parameters); type = parse_var_type(f, allow_ellipsis, allow_default_parameters);
@@ -3459,7 +3459,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
} }
} }
if (default_value != NULL && names.count > 1) { if (default_value != nullptr && names.count > 1) {
syntax_error(f->curr_token, "Default parameters can only be applied to single values"); syntax_error(f->curr_token, "Default parameters can only be applied to single values");
} }
@@ -3486,7 +3486,7 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
names[0] = ast_ident(f, token); names[0] = ast_ident(f, token);
u32 flags = check_field_prefixes(f, list.count, allowed_flags, list[i].flags); u32 flags = check_field_prefixes(f, list.count, allowed_flags, list[i].flags);
AstNode *param = ast_field(f, names, list[i].node, NULL, flags, docs, f->line_comment); AstNode *param = ast_field(f, names, list[i].node, nullptr, flags, docs, f->line_comment);
array_add(&params, param); array_add(&params, param);
} }
@@ -3556,11 +3556,11 @@ AstNode *parse_type_or_ident(AstFile *f) {
case Token_OpenBracket: { case Token_OpenBracket: {
Token token = expect_token(f, Token_OpenBracket); Token token = expect_token(f, Token_OpenBracket);
AstNode *count_expr = NULL; AstNode *count_expr = nullptr;
bool is_vector = false; bool is_vector = false;
if (f->curr_token.kind == Token_Ellipsis) { if (f->curr_token.kind == Token_Ellipsis) {
count_expr = ast_unary_expr(f, expect_token(f, Token_Ellipsis), NULL); count_expr = ast_unary_expr(f, expect_token(f, Token_Ellipsis), nullptr);
} else if (f->curr_token.kind == Token_vector) { } else if (f->curr_token.kind == Token_vector) {
next_token(f); next_token(f);
if (f->curr_token.kind != Token_CloseBracket) { if (f->curr_token.kind != Token_CloseBracket) {
@@ -3589,9 +3589,9 @@ AstNode *parse_type_or_ident(AstFile *f) {
case Token_map: { case Token_map: {
Token token = expect_token(f, Token_map); Token token = expect_token(f, Token_map);
AstNode *count = NULL; AstNode *count = nullptr;
AstNode *key = NULL; AstNode *key = nullptr;
AstNode *value = NULL; AstNode *value = nullptr;
Token open = expect_token_after(f, Token_OpenBracket, "map"); Token open = expect_token_after(f, Token_OpenBracket, "map");
key = parse_expr(f, true); key = parse_expr(f, true);
@@ -3609,7 +3609,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
Token token = expect_token(f, Token_struct); Token token = expect_token(f, Token_struct);
bool is_packed = false; bool is_packed = false;
bool is_ordered = false; bool is_ordered = false;
AstNode *align = NULL; AstNode *align = nullptr;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
f->expr_level = -1; f->expr_level = -1;
@@ -3648,7 +3648,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
Token close = expect_token(f, Token_CloseBrace); Token close = expect_token(f, Token_CloseBrace);
Array<AstNode *> decls = {}; Array<AstNode *> decls = {};
if (fields != NULL) { if (fields != nullptr) {
GB_ASSERT(fields->kind == AstNode_FieldList); GB_ASSERT(fields->kind == AstNode_FieldList);
decls = fields->FieldList.list; decls = fields->FieldList.list;
} }
@@ -3676,7 +3676,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
total_decl_name_count += names.count; total_decl_name_count += names.count;
expect_token_after(f, Token_Colon, "field list"); expect_token_after(f, Token_Colon, "field list");
AstNode *type = parse_var_type(f, false, false); AstNode *type = parse_var_type(f, false, false);
array_add(&decls, ast_field(f, names, type, NULL, set_flags, docs, f->line_comment)); array_add(&decls, ast_field(f, names, type, nullptr, set_flags, docs, f->line_comment));
} else { } else {
Array<AstNode *> names = parse_ident_list(f); Array<AstNode *> names = parse_ident_list(f);
if (names.count == 0) { if (names.count == 0) {
@@ -3687,7 +3687,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
total_decl_name_count += names.count; total_decl_name_count += names.count;
expect_token_after(f, Token_Colon, "field list"); expect_token_after(f, Token_Colon, "field list");
AstNode *type = parse_var_type(f, false, false); AstNode *type = parse_var_type(f, false, false);
array_add(&decls, ast_field(f, names, type, NULL, set_flags, docs, f->line_comment)); array_add(&decls, ast_field(f, names, type, nullptr, set_flags, docs, f->line_comment));
} else { } else {
AstNode *name = names[0]; AstNode *name = names[0];
Token open = expect_token(f, Token_OpenBrace); Token open = expect_token(f, Token_OpenBrace);
@@ -3718,7 +3718,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
Token close = expect_token(f, Token_CloseBrace); Token close = expect_token(f, Token_CloseBrace);
Array<AstNode *> decls = {}; Array<AstNode *> decls = {};
if (fields != NULL) { if (fields != nullptr) {
GB_ASSERT(fields->kind == AstNode_FieldList); GB_ASSERT(fields->kind == AstNode_FieldList);
decls = fields->FieldList.list; decls = fields->FieldList.list;
} }
@@ -3728,7 +3728,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
case Token_enum: { case Token_enum: {
Token token = expect_token(f, Token_enum); Token token = expect_token(f, Token_enum);
AstNode *base_type = NULL; AstNode *base_type = nullptr;
if (f->curr_token.kind != Token_OpenBrace) { if (f->curr_token.kind != Token_OpenBrace) {
base_type = parse_type(f); base_type = parse_type(f);
} }
@@ -3743,7 +3743,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
case Token_bit_field: { case Token_bit_field: {
Token token = expect_token(f, Token_bit_field); Token token = expect_token(f, Token_bit_field);
Array<AstNode *> fields = make_ast_node_array(f); Array<AstNode *> fields = make_ast_node_array(f);
AstNode *align = NULL; AstNode *align = nullptr;
Token open, close; Token open, close;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
@@ -3787,7 +3787,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
case Token_proc: { case Token_proc: {
Token token = f->curr_token; next_token(f); Token token = f->curr_token; next_token(f);
AstNode *pt = parse_proc_type(f, token, NULL); AstNode *pt = parse_proc_type(f, token, nullptr);
if (pt->ProcType.tags != 0) { if (pt->ProcType.tags != 0) {
syntax_error(token, "A procedure type cannot have tags"); syntax_error(token, "A procedure type cannot have tags");
} }
@@ -3802,7 +3802,7 @@ AstNode *parse_type_or_ident(AstFile *f) {
} break; } break;
} }
return NULL; return nullptr;
} }
@@ -3822,16 +3822,16 @@ AstNode *parse_body(AstFile *f) {
} }
AstNode *parse_if_stmt(AstFile *f) { AstNode *parse_if_stmt(AstFile *f) {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use an if statement in the file scope"); syntax_error(f->curr_token, "You cannot use an if statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
Token token = expect_token(f, Token_if); Token token = expect_token(f, Token_if);
AstNode *init = NULL; AstNode *init = nullptr;
AstNode *cond = NULL; AstNode *cond = nullptr;
AstNode *body = NULL; AstNode *body = nullptr;
AstNode *else_stmt = NULL; AstNode *else_stmt = nullptr;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
f->expr_level = -1; f->expr_level = -1;
@@ -3844,13 +3844,13 @@ AstNode *parse_if_stmt(AstFile *f) {
cond = parse_expr(f, false); cond = parse_expr(f, false);
} else { } else {
cond = convert_stmt_to_expr(f, init, str_lit("boolean expression")); cond = convert_stmt_to_expr(f, init, str_lit("boolean expression"));
init = NULL; init = nullptr;
} }
} }
f->expr_level = prev_level; f->expr_level = prev_level;
if (cond == NULL) { if (cond == nullptr) {
syntax_error(f->curr_token, "Expected condition for if statement"); syntax_error(f->curr_token, "Expected condition for if statement");
} }
@@ -3890,9 +3890,9 @@ AstNode *parse_if_stmt(AstFile *f) {
AstNode *parse_when_stmt(AstFile *f) { AstNode *parse_when_stmt(AstFile *f) {
Token token = expect_token(f, Token_when); Token token = expect_token(f, Token_when);
AstNode *cond = NULL; AstNode *cond = nullptr;
AstNode *body = NULL; AstNode *body = nullptr;
AstNode *else_stmt = NULL; AstNode *else_stmt = nullptr;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
f->expr_level = -1; f->expr_level = -1;
@@ -3901,7 +3901,7 @@ AstNode *parse_when_stmt(AstFile *f) {
f->expr_level = prev_level; f->expr_level = prev_level;
if (cond == NULL) { if (cond == nullptr) {
syntax_error(f->curr_token, "Expected condition for when statement"); syntax_error(f->curr_token, "Expected condition for when statement");
} }
@@ -3941,7 +3941,7 @@ AstNode *parse_when_stmt(AstFile *f) {
AstNode *parse_return_stmt(AstFile *f) { AstNode *parse_return_stmt(AstFile *f) {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a return statement in the file scope"); syntax_error(f->curr_token, "You cannot use a return statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
@@ -3969,7 +3969,7 @@ AstNode *parse_return_stmt(AstFile *f) {
next_token(f); next_token(f);
} }
AstNode *end = NULL; AstNode *end = nullptr;
if (results.count > 0) { if (results.count > 0) {
end = results[results.count-1]; end = results[results.count-1];
} }
@@ -3979,7 +3979,7 @@ AstNode *parse_return_stmt(AstFile *f) {
// AstNode *parse_give_stmt(AstFile *f) { // AstNode *parse_give_stmt(AstFile *f) {
// if (f->curr_proc == NULL) { // if (f->curr_proc == nullptr) {
// syntax_error(f->curr_token, "You cannot use a give statement in the file scope"); // syntax_error(f->curr_token, "You cannot use a give statement in the file scope");
// return ast_bad_stmt(f, f->curr_token, f->curr_token); // return ast_bad_stmt(f, f->curr_token, f->curr_token);
// } // }
@@ -4001,17 +4001,17 @@ AstNode *parse_return_stmt(AstFile *f) {
// } // }
AstNode *parse_for_stmt(AstFile *f) { AstNode *parse_for_stmt(AstFile *f) {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a for statement in the file scope"); syntax_error(f->curr_token, "You cannot use a for statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
Token token = expect_token(f, Token_for); Token token = expect_token(f, Token_for);
AstNode *init = NULL; AstNode *init = nullptr;
AstNode *cond = NULL; AstNode *cond = nullptr;
AstNode *post = NULL; AstNode *post = nullptr;
AstNode *body = NULL; AstNode *body = nullptr;
bool is_range = false; bool is_range = false;
if (f->curr_token.kind != Token_OpenBrace && if (f->curr_token.kind != Token_OpenBrace &&
@@ -4028,7 +4028,7 @@ AstNode *parse_for_stmt(AstFile *f) {
if (!is_range && f->curr_token.kind == Token_Semicolon) { if (!is_range && f->curr_token.kind == Token_Semicolon) {
next_token(f); next_token(f);
init = cond; init = cond;
cond = NULL; cond = nullptr;
if (f->curr_token.kind != Token_Semicolon) { if (f->curr_token.kind != Token_Semicolon) {
cond = parse_simple_stmt(f, StmtAllowFlag_None); cond = parse_simple_stmt(f, StmtAllowFlag_None);
} }
@@ -4054,8 +4054,8 @@ AstNode *parse_for_stmt(AstFile *f) {
if (is_range) { if (is_range) {
GB_ASSERT(cond->kind == AstNode_AssignStmt); GB_ASSERT(cond->kind == AstNode_AssignStmt);
Token in_token = cond->AssignStmt.op; Token in_token = cond->AssignStmt.op;
AstNode *value = NULL; AstNode *value = nullptr;
AstNode *index = NULL; AstNode *index = nullptr;
switch (cond->AssignStmt.lhs.count) { switch (cond->AssignStmt.lhs.count) {
case 1: case 1:
value = cond->AssignStmt.lhs[0]; value = cond->AssignStmt.lhs[0];
@@ -4069,7 +4069,7 @@ AstNode *parse_for_stmt(AstFile *f) {
return ast_bad_stmt(f, token, f->curr_token); return ast_bad_stmt(f, token, f->curr_token);
} }
AstNode *rhs = NULL; AstNode *rhs = nullptr;
if (cond->AssignStmt.rhs.count > 0) { if (cond->AssignStmt.rhs.count > 0) {
rhs = cond->AssignStmt.rhs[0]; rhs = cond->AssignStmt.rhs[0];
} }
@@ -4099,15 +4099,15 @@ AstNode *parse_case_clause(AstFile *f, bool is_type) {
AstNode *parse_match_stmt(AstFile *f) { AstNode *parse_match_stmt(AstFile *f) {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a match statement in the file scope"); syntax_error(f->curr_token, "You cannot use a match statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
Token token = expect_token(f, Token_match); Token token = expect_token(f, Token_match);
AstNode *init = NULL; AstNode *init = nullptr;
AstNode *tag = NULL; AstNode *tag = nullptr;
AstNode *body = NULL; AstNode *body = nullptr;
Token open, close; Token open, close;
bool is_type_match = false; bool is_type_match = false;
Array<AstNode *> list = make_ast_node_array(f); Array<AstNode *> list = make_ast_node_array(f);
@@ -4122,7 +4122,7 @@ AstNode *parse_match_stmt(AstFile *f) {
} else { } else {
if (allow_token(f, Token_Semicolon)) { if (allow_token(f, Token_Semicolon)) {
init = tag; init = tag;
tag = NULL; tag = nullptr;
if (f->curr_token.kind != Token_OpenBrace) { if (f->curr_token.kind != Token_OpenBrace) {
tag = parse_simple_stmt(f, StmtAllowFlag_None); tag = parse_simple_stmt(f, StmtAllowFlag_None);
} }
@@ -4149,7 +4149,7 @@ AstNode *parse_match_stmt(AstFile *f) {
} }
AstNode *parse_defer_stmt(AstFile *f) { AstNode *parse_defer_stmt(AstFile *f) {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(f->curr_token, "You cannot use a defer statement in the file scope"); syntax_error(f->curr_token, "You cannot use a defer statement in the file scope");
return ast_bad_stmt(f, f->curr_token, f->curr_token); return ast_bad_stmt(f, f->curr_token, f->curr_token);
} }
@@ -4178,9 +4178,9 @@ AstNode *parse_asm_stmt(AstFile *f) {
Token open, close, code_string; Token open, close, code_string;
open = expect_token(f, Token_OpenBrace); open = expect_token(f, Token_OpenBrace);
code_string = expect_token(f, Token_String); code_string = expect_token(f, Token_String);
AstNode *output_list = NULL; AstNode *output_list = nullptr;
AstNode *input_list = NULL; AstNode *input_list = nullptr;
AstNode *clobber_list = NULL; AstNode *clobber_list = nullptr;
isize output_count = 0; isize output_count = 0;
isize input_count = 0; isize input_count = 0;
isize clobber_count = 0; isize clobber_count = 0;
@@ -4201,7 +4201,7 @@ AstNode *parse_asm_stmt(AstFile *f) {
AstNode *parse_stmt(AstFile *f) { AstNode *parse_stmt(AstFile *f) {
AstNode *s = NULL; AstNode *s = nullptr;
Token token = f->curr_token; Token token = f->curr_token;
switch (token.kind) { switch (token.kind) {
// Operands // Operands
@@ -4250,7 +4250,7 @@ AstNode *parse_stmt(AstFile *f) {
case Token_break: case Token_break:
case Token_continue: case Token_continue:
case Token_fallthrough: { case Token_fallthrough: {
AstNode *label = NULL; AstNode *label = nullptr;
next_token(f); next_token(f);
if (token.kind != Token_fallthrough && if (token.kind != Token_fallthrough &&
f->curr_token.kind == Token_Ident) { f->curr_token.kind == Token_Ident) {
@@ -4264,11 +4264,11 @@ AstNode *parse_stmt(AstFile *f) {
case Token_using: { case Token_using: {
CommentGroup docs = f->lead_comment; CommentGroup docs = f->lead_comment;
Token token = expect_token(f, Token_using); Token token = expect_token(f, Token_using);
AstNode *decl = NULL; AstNode *decl = nullptr;
Array<AstNode *> list = parse_lhs_expr_list(f); Array<AstNode *> list = parse_lhs_expr_list(f);
if (list.count == 0) { if (list.count == 0) {
syntax_error(token, "Illegal use of `using` statement"); syntax_error(token, "Illegal use of `using` statement");
expect_semicolon(f, NULL); expect_semicolon(f, nullptr);
return ast_bad_stmt(f, token, f->curr_token); return ast_bad_stmt(f, token, f->curr_token);
} }
@@ -4278,12 +4278,12 @@ AstNode *parse_stmt(AstFile *f) {
} }
decl = parse_value_decl(f, list, docs); decl = parse_value_decl(f, list, docs);
if (decl != NULL && decl->kind == AstNode_ValueDecl) { if (decl != nullptr && decl->kind == AstNode_ValueDecl) {
if (!decl->ValueDecl.is_mutable) { if (!decl->ValueDecl.is_mutable) {
syntax_error(token, "`using` may only be applied to variable declarations"); syntax_error(token, "`using` may only be applied to variable declarations");
return decl; return decl;
} }
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
syntax_error(token, "`using` is not allowed at the file scope"); syntax_error(token, "`using` is not allowed at the file scope");
} else { } else {
decl->ValueDecl.flags |= VarDeclFlag_using; decl->ValueDecl.flags |= VarDeclFlag_using;
@@ -4297,7 +4297,7 @@ AstNode *parse_stmt(AstFile *f) {
case Token_push_allocator: { case Token_push_allocator: {
next_token(f); next_token(f);
AstNode *body = NULL; AstNode *body = nullptr;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
f->expr_level = -1; f->expr_level = -1;
AstNode *expr = parse_expr(f, false); AstNode *expr = parse_expr(f, false);
@@ -4317,7 +4317,7 @@ AstNode *parse_stmt(AstFile *f) {
case Token_push_context: { case Token_push_context: {
next_token(f); next_token(f);
AstNode *body = NULL; AstNode *body = nullptr;
isize prev_level = f->expr_level; isize prev_level = f->expr_level;
f->expr_level = -1; f->expr_level = -1;
AstNode *expr = parse_expr(f, false); AstNode *expr = parse_expr(f, false);
@@ -4336,13 +4336,13 @@ AstNode *parse_stmt(AstFile *f) {
} break; } break;
case Token_Hash: { case Token_Hash: {
AstNode *s = NULL; AstNode *s = nullptr;
Token hash_token = expect_token(f, Token_Hash); Token hash_token = expect_token(f, Token_Hash);
Token name = expect_token(f, Token_Ident); Token name = expect_token(f, Token_Ident);
String tag = name.string; String tag = name.string;
if (tag == "shared_global_scope") { if (tag == "shared_global_scope") {
if (f->curr_proc == NULL) { if (f->curr_proc == nullptr) {
f->is_global_scope = true; f->is_global_scope = true;
s = ast_empty_stmt(f, f->curr_token); s = ast_empty_stmt(f, f->curr_token);
} else { } else {
@@ -4358,7 +4358,7 @@ AstNode *parse_stmt(AstFile *f) {
if (!s->ValueDecl.is_mutable) { if (!s->ValueDecl.is_mutable) {
syntax_error(token, "`thread_local` may only be applied to variable declarations"); syntax_error(token, "`thread_local` may only be applied to variable declarations");
} }
if (f->curr_proc != NULL) { if (f->curr_proc != nullptr) {
syntax_error(token, "`thread_local` is only allowed at the file scope"); syntax_error(token, "`thread_local` is only allowed at the file scope");
} else { } else {
s->ValueDecl.flags |= VarDeclFlag_thread_local; s->ValueDecl.flags |= VarDeclFlag_thread_local;
@@ -4422,7 +4422,7 @@ Array<AstNode *> parse_stmt_list(AstFile *f) {
if (stmt && stmt->kind != AstNode_EmptyStmt) { if (stmt && stmt->kind != AstNode_EmptyStmt) {
array_add(&list, stmt); array_add(&list, stmt);
if (stmt->kind == AstNode_ExprStmt && if (stmt->kind == AstNode_ExprStmt &&
stmt->ExprStmt.expr != NULL && stmt->ExprStmt.expr != nullptr &&
stmt->ExprStmt.expr->kind == AstNode_ProcLit) { stmt->ExprStmt.expr->kind == AstNode_ProcLit) {
syntax_error(stmt, "Procedure literal evaluated but not used"); syntax_error(stmt, "Procedure literal evaluated but not used");
} }
@@ -4465,7 +4465,7 @@ ParseFileError init_ast_file(AstFile *f, String fullpath) {
gb_arena_init_from_allocator(&f->arena, heap_allocator(), arena_size); gb_arena_init_from_allocator(&f->arena, heap_allocator(), arena_size);
array_init(&f->comments, heap_allocator()); array_init(&f->comments, heap_allocator());
f->curr_proc = NULL; f->curr_proc = nullptr;
return ParseFile_None; return ParseFile_None;
} }
src/printer.cpp
+1 -1
View File
@@ -6,7 +6,7 @@ gb_inline void print_indent(isize indent) {
} }
void print_ast(AstNode *node, isize indent) { void print_ast(AstNode *node, isize indent) {
if (node == NULL) if (node == nullptr)
return; return;
switch (node->kind) { switch (node->kind) {
src/ssa.cpp
+93 -93
View File
@@ -206,7 +206,7 @@ ssaBlock *ssa_new_block(ssaProc *p, ssaBlockKind kind, char *name) {
b->kind = kind; b->kind = kind;
b->proc = p; b->proc = p;
p->scope_level = p->scope_level; p->scope_level = p->scope_level;
if (name != NULL || name[0] != 0) { if (name != nullptr || name[0] != 0) {
b->name = make_string_c(name); b->name = make_string_c(name);
} }
@@ -218,34 +218,34 @@ ssaBlock *ssa_new_block(ssaProc *p, ssaBlockKind kind, char *name) {
} }
void ssa_clear_block(ssaProc *p, ssaBlock *b) { void ssa_clear_block(ssaProc *p, ssaBlock *b) {
GB_ASSERT(b->proc != NULL); GB_ASSERT(b->proc != nullptr);
array_clear(&b->values); array_clear(&b->values);
array_clear(&b->preds); array_clear(&b->preds);
array_clear(&b->succs); array_clear(&b->succs);
b->proc = NULL; b->proc = nullptr;
b->kind = ssaBlock_Plain; b->kind = ssaBlock_Plain;
} }
void ssa_start_block(ssaProc *p, ssaBlock *b) { void ssa_start_block(ssaProc *p, ssaBlock *b) {
GB_ASSERT(p->curr_block == NULL); GB_ASSERT(p->curr_block == nullptr);
p->curr_block = b; p->curr_block = b;
} }
ssaBlock *ssa_end_block(ssaProc *p) { ssaBlock *ssa_end_block(ssaProc *p) {
ssaBlock *b = p->curr_block; ssaBlock *b = p->curr_block;
if (b == NULL) { if (b == nullptr) {
return NULL; return nullptr;
} }
p->curr_block = NULL; p->curr_block = nullptr;
return b; return b;
} }
void ssa_add_edge_to(ssaBlock *b, ssaBlock *c) { void ssa_add_edge_to(ssaBlock *b, ssaBlock *c) {
if (b == NULL) { if (b == nullptr) {
return; return;
} }
GB_ASSERT(c != NULL); GB_ASSERT(c != nullptr);
isize i = b->succs.count; isize i = b->succs.count;
isize j = b->preds.count; isize j = b->preds.count;
ssaEdge s = {c, j}; ssaEdge s = {c, j};
@@ -255,11 +255,11 @@ void ssa_add_edge_to(ssaBlock *b, ssaBlock *c) {
} }
void ssa_set_control(ssaBlock *b, ssaValue *v) { void ssa_set_control(ssaBlock *b, ssaValue *v) {
if (b->control != NULL) { if (b->control != nullptr) {
b->control->uses--; b->control->uses--;
} }
b->control = v; b->control = v;
if (v != NULL) { if (v != nullptr) {
v->uses++; v->uses++;
} }
} }
@@ -295,7 +295,7 @@ void ssa_add_arg(ssaValueArgs *va, ssaValue *arg) {
ssaValue *ssa_new_value(ssaProc *p, ssaOp op, Type *t, ssaBlock *b) { ssaValue *ssa_new_value(ssaProc *p, ssaOp op, Type *t, ssaBlock *b) {
GB_ASSERT(b != NULL); GB_ASSERT(b != nullptr);
ssaValue *v = gb_alloc_item(p->allocator, ssaValue); ssaValue *v = gb_alloc_item(p->allocator, ssaValue);
v->id = p->value_id++; v->id = p->value_id++;
v->op = op; v->op = op;
@@ -388,7 +388,7 @@ ssaValue *ssa_const_int(ssaProc *p, Type *t, i64 c) {
case 64: return ssa_const_i64(p, t, cast(i64)c); case 64: return ssa_const_i64(p, t, cast(i64)c);
} }
GB_PANIC("Unknown int size"); GB_PANIC("Unknown int size");
return NULL; return nullptr;
} }
@@ -416,8 +416,8 @@ void ssa_reset(ssaValue *v, ssaOp op) {
} }
ssaValue *ssa_get_last_value(ssaBlock *b) { ssaValue *ssa_get_last_value(ssaBlock *b) {
if (b == NULL) { if (b == nullptr) {
return NULL; return nullptr;
} }
isize len = b->values.count; isize len = b->values.count;
if (len <= 0) { if (len <= 0) {
@@ -428,7 +428,7 @@ ssaValue *ssa_get_last_value(ssaBlock *b) {
} }
void ssa_emit_comment(ssaProc *p, String s) { void ssa_emit_comment(ssaProc *p, String s) {
// ssa_new_value0v(p, ssaOp_Comment, NULL, exact_value_string(s)); // ssa_new_value0v(p, ssaOp_Comment, nullptr, exact_value_string(s));
} }
void ssa_build_defer_stmt(ssaProc *p, ssaDefer d) { void ssa_build_defer_stmt(ssaProc *p, ssaDefer d) {
@@ -463,7 +463,7 @@ void ssa_emit_defer_stmts(ssaProc *p, ssaDeferExitKind kind, ssaBlock *b) {
} else if (kind == ssaDeferExit_Return) { } else if (kind == ssaDeferExit_Return) {
ssa_build_defer_stmt(p, d); ssa_build_defer_stmt(p, d);
} else if (kind == ssaDeferExit_Branch) { } else if (kind == ssaDeferExit_Branch) {
GB_ASSERT(b != NULL); GB_ASSERT(b != nullptr);
i32 lower_limit = b->scope_level+1; i32 lower_limit = b->scope_level+1;
if (lower_limit < d.scope_level) { if (lower_limit < d.scope_level) {
ssa_build_defer_stmt(p, d); ssa_build_defer_stmt(p, d);
@@ -542,7 +542,7 @@ bool ssa_is_blank_ident(AstNode *node) {
ssaAddr ssa_addr(ssaValue *v) { ssaAddr ssa_addr(ssaValue *v) {
if (v != NULL) { if (v != nullptr) {
GB_ASSERT(is_type_pointer(v->type)); GB_ASSERT(is_type_pointer(v->type));
} }
ssaAddr addr = {0}; ssaAddr addr = {0};
@@ -551,13 +551,13 @@ ssaAddr ssa_addr(ssaValue *v) {
} }
Type *ssa_addr_type(ssaAddr addr) { Type *ssa_addr_type(ssaAddr addr) {
if (addr.addr == NULL) { if (addr.addr == nullptr) {
return NULL; return nullptr;
} }
if (addr.kind == ssaAddr_Map) { if (addr.kind == ssaAddr_Map) {
GB_PANIC("TODO: ssa_addr_type"); GB_PANIC("TODO: ssa_addr_type");
return NULL; return nullptr;
} }
Type *t = addr.addr->type; Type *t = addr.addr->type;
@@ -603,18 +603,18 @@ ssaAddr ssa_add_local_for_ident(ssaProc *p, AstNode *name) {
return ssa_add_local(p, e, name); return ssa_add_local(p, e, name);
} }
return ssa_addr(NULL); return ssa_addr(nullptr);
} }
ssaAddr ssa_add_local_generated(ssaProc *p, Type *t) { ssaAddr ssa_add_local_generated(ssaProc *p, Type *t) {
GB_ASSERT(t != NULL); GB_ASSERT(t != nullptr);
Scope *scope = NULL; Scope *scope = nullptr;
if (p->curr_block) { if (p->curr_block) {
// scope = p->curr_block->scope; // scope = p->curr_block->scope;
} }
Entity *e = make_entity_variable(p->allocator, scope, empty_token, t, false); Entity *e = make_entity_variable(p->allocator, scope, empty_token, t, false);
return ssa_add_local(p, e, NULL); return ssa_add_local(p, e, nullptr);
} }
@@ -667,7 +667,7 @@ bool can_ssa_type(Type *t) {
} }
void ssa_addr_store(ssaProc *p, ssaAddr addr, ssaValue *value) { void ssa_addr_store(ssaProc *p, ssaAddr addr, ssaValue *value) {
if (addr.addr == NULL) { if (addr.addr == nullptr) {
return; return;
} }
if (addr.kind == ssaAddr_Map) { if (addr.kind == ssaAddr_Map) {
@@ -679,13 +679,13 @@ void ssa_addr_store(ssaProc *p, ssaAddr addr, ssaValue *value) {
} }
ssaValue *ssa_addr_load(ssaProc *p, ssaAddr addr) { ssaValue *ssa_addr_load(ssaProc *p, ssaAddr addr) {
if (addr.addr == NULL) { if (addr.addr == nullptr) {
return NULL; return nullptr;
} }
if (addr.kind == ssaAddr_Map) { if (addr.kind == ssaAddr_Map) {
GB_PANIC("here\n"); GB_PANIC("here\n");
return NULL; return nullptr;
} }
Type *t = addr.addr->type; Type *t = addr.addr->type;
@@ -702,23 +702,23 @@ ssaValue *ssa_get_using_variable(ssaProc *p, Entity *e) {
String name = e->token.string; String name = e->token.string;
Entity *parent = e->using_parent; Entity *parent = e->using_parent;
Selection sel = lookup_field(p->allocator, parent->type, name, false); Selection sel = lookup_field(p->allocator, parent->type, name, false);
GB_ASSERT(sel.entity != NULL); GB_ASSERT(sel.entity != nullptr);
ssaValue **pv = map_get(&p->module->values, hash_pointer(parent)); ssaValue **pv = map_get(&p->module->values, hash_pointer(parent));
ssaValue *v = NULL; ssaValue *v = nullptr;
if (pv != NULL) { if (pv != nullptr) {
v = *pv; v = *pv;
} else { } else {
v = ssa_build_addr(p, e->using_expr).addr; v = ssa_build_addr(p, e->using_expr).addr;
} }
GB_ASSERT(v != NULL); GB_ASSERT(v != nullptr);
GB_ASSERT(type_deref(v->type) == parent->type); GB_ASSERT(type_deref(v->type) == parent->type);
return ssa_emit_deep_field_ptr_index(p, v, sel); return ssa_emit_deep_field_ptr_index(p, v, sel);
} }
ssaAddr ssa_build_addr_from_entity(ssaProc *p, Entity *e, AstNode *expr) { ssaAddr ssa_build_addr_from_entity(ssaProc *p, Entity *e, AstNode *expr) {
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
ssaValue *v = NULL; ssaValue *v = nullptr;
ssaValue **found = map_get(&p->module->values, hash_pointer(e)); ssaValue **found = map_get(&p->module->values, hash_pointer(e));
if (found) { if (found) {
v = *found; v = *found;
@@ -727,7 +727,7 @@ ssaAddr ssa_build_addr_from_entity(ssaProc *p, Entity *e, AstNode *expr) {
v = ssa_get_using_variable(p, e); v = ssa_get_using_variable(p, e);
} }
if (v == NULL) { if (v == nullptr) {
GB_PANIC("Unknown value: %.*s, entity: %p %.*s\n", LIT(e->token.string), e, LIT(entity_strings[e->kind])); GB_PANIC("Unknown value: %.*s, entity: %p %.*s\n", LIT(e->token.string), e, LIT(entity_strings[e->kind]));
} }
@@ -773,11 +773,11 @@ ssaValue *ssa_emit_conv(ssaProc *p, ssaValue *v, Type *t) {
GB_PANIC("Invalid type conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t)); GB_PANIC("Invalid type conversion: `%s` to `%s`", type_to_string(src_type), type_to_string(t));
return NULL; return nullptr;
} }
// NOTE(bill): Returns NULL if not possible // NOTE(bill): Returns nullptr if not possible
ssaValue *ssa_address_from_load_or_generate_local(ssaProc *p, ssaValue *v) { ssaValue *ssa_address_from_load_or_generate_local(ssaProc *p, ssaValue *v) {
if (v->op == ssaOp_Load) { if (v->op == ssaOp_Load) {
return v->args[0]; return v->args[0];
@@ -789,11 +789,11 @@ ssaValue *ssa_address_from_load_or_generate_local(ssaProc *p, ssaValue *v) {
ssaValue *ssa_emit_array_index(ssaProc *p, ssaValue *v, ssaValue *index) { ssaValue *ssa_emit_array_index(ssaProc *p, ssaValue *v, ssaValue *index) {
GB_ASSERT(v != NULL); GB_ASSERT(v != nullptr);
GB_ASSERT(is_type_pointer(v->type)); GB_ASSERT(is_type_pointer(v->type));
Type *t = base_type(type_deref(v->type)); Type *t = base_type(type_deref(v->type));
GB_ASSERT_MSG(is_type_array(t) || is_type_vector(t), "%s", type_to_string(t)); GB_ASSERT_MSG(is_type_array(t) || is_type_vector(t), "%s", type_to_string(t));
Type *elem_ptr = NULL; Type *elem_ptr = nullptr;
if (is_type_array(t)) { if (is_type_array(t)) {
elem_ptr = make_type_pointer(p->allocator, t->Array.elem); elem_ptr = make_type_pointer(p->allocator, t->Array.elem);
} else if (is_type_vector(t)) { } else if (is_type_vector(t)) {
@@ -806,7 +806,7 @@ ssaValue *ssa_emit_array_index(ssaProc *p, ssaValue *v, ssaValue *index) {
ssaValue *ssa_emit_ptr_index(ssaProc *p, ssaValue *s, i64 index) { ssaValue *ssa_emit_ptr_index(ssaProc *p, ssaValue *s, i64 index) {
gbAllocator a = p->allocator; gbAllocator a = p->allocator;
Type *t = base_type(type_deref(s->type)); Type *t = base_type(type_deref(s->type));
Type *result_type = NULL; Type *result_type = nullptr;
if (is_type_struct(t)) { if (is_type_struct(t)) {
GB_ASSERT(t->Record.field_count > 0); GB_ASSERT(t->Record.field_count > 0);
@@ -854,7 +854,7 @@ ssaValue *ssa_emit_ptr_index(ssaProc *p, ssaValue *s, i64 index) {
GB_PANIC("TODO(bill): ssa_emit_ptr_index type: %s, %d", type_to_string(s->type), index); GB_PANIC("TODO(bill): ssa_emit_ptr_index type: %s, %d", type_to_string(s->type), index);
} }
GB_ASSERT(result_type != NULL); GB_ASSERT(result_type != nullptr);
return ssa_new_value1i(p, ssaOp_PtrIndex, result_type, index, s); return ssa_new_value1i(p, ssaOp_PtrIndex, result_type, index, s);
} }
@@ -869,7 +869,7 @@ ssaValue *ssa_emit_value_index(ssaProc *p, ssaValue *s, i64 index) {
gbAllocator a = p->allocator; gbAllocator a = p->allocator;
Type *t = base_type(s->type); Type *t = base_type(s->type);
Type *result_type = NULL; Type *result_type = nullptr;
if (is_type_struct(t)) { if (is_type_struct(t)) {
GB_ASSERT(t->Record.field_count > 0); GB_ASSERT(t->Record.field_count > 0);
@@ -917,7 +917,7 @@ ssaValue *ssa_emit_value_index(ssaProc *p, ssaValue *s, i64 index) {
GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(s->type), index); GB_PANIC("TODO(bill): struct_ev type: %s, %d", type_to_string(s->type), index);
} }
GB_ASSERT(result_type != NULL); GB_ASSERT(result_type != nullptr);
return ssa_new_value1i(p, ssaOp_ValueIndex, result_type, index, s); return ssa_new_value1i(p, ssaOp_ValueIndex, result_type, index, s);
} }
@@ -1054,7 +1054,7 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
if (tav.mode == Addressing_Invalid) { if (tav.mode == Addressing_Invalid) {
// NOTE(bill): Imports // NOTE(bill): Imports
Entity *imp = entity_of_ident(p->module->info, se->expr); Entity *imp = entity_of_ident(p->module->info, se->expr);
if (imp != NULL) { if (imp != nullptr) {
GB_ASSERT(imp->kind == Entity_ImportName); GB_ASSERT(imp->kind == Entity_ImportName);
} }
return ssa_build_addr(p, se->selector); return ssa_build_addr(p, se->selector);
@@ -1072,7 +1072,7 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
// if (name == "names") { // if (name == "names") {
// ssaValue *ti_ptr = ir_type_info(p, type); // ssaValue *ti_ptr = ir_type_info(p, type);
// ssaValue *names_ptr = NULL; // ssaValue *names_ptr = nullptr;
// if (is_type_enum(type)) { // if (is_type_enum(type)) {
// ssaValue *enum_info = ssa_emit_conv(p, ti_ptr, t_type_info_enum_ptr); // ssaValue *enum_info = ssa_emit_conv(p, ti_ptr, t_type_info_enum_ptr);
@@ -1089,7 +1089,7 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
} }
Selection sel = lookup_field(p->allocator, type, selector, false); Selection sel = lookup_field(p->allocator, type, selector, false);
GB_ASSERT(sel.entity != NULL); GB_ASSERT(sel.entity != nullptr);
ssaValue *a = ssa_build_addr(p, se->expr).addr; ssaValue *a = ssa_build_addr(p, se->expr).addr;
a = ssa_emit_deep_field_ptr_index(p, a, sel); a = ssa_emit_deep_field_ptr_index(p, a, sel);
@@ -1101,7 +1101,7 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
i64 index = i128_to_i64(val.value_integer); i64 index = i128_to_i64(val.value_integer);
Selection sel = lookup_field_from_index(p->allocator, type, index); Selection sel = lookup_field_from_index(p->allocator, type, index);
GB_ASSERT(sel.entity != NULL); GB_ASSERT(sel.entity != nullptr);
ssaValue *a = ssa_build_addr(p, se->expr).addr; ssaValue *a = ssa_build_addr(p, se->expr).addr;
a = ssa_emit_deep_field_ptr_index(p, a, sel); a = ssa_emit_deep_field_ptr_index(p, a, sel);
@@ -1156,7 +1156,7 @@ ssaAddr ssa_build_addr(ssaProc *p, AstNode *expr) {
LIT(token_pos.file), token_pos.line, token_pos.column); LIT(token_pos.file), token_pos.line, token_pos.column);
return ssa_addr(NULL); return ssa_addr(nullptr);
} }
@@ -1382,7 +1382,7 @@ ssaOp ssa_determine_op(TokenKind op, Type *t) {
ssaValue *ssa_emit_comp(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y) { ssaValue *ssa_emit_comp(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y) {
GB_ASSERT(x != NULL && y != NULL); GB_ASSERT(x != nullptr && y != nullptr);
Type *a = core_type(x->type); Type *a = core_type(x->type);
Type *b = core_type(y->type); Type *b = core_type(y->type);
if (are_types_identical(a, b)) { if (are_types_identical(a, b)) {
@@ -1486,7 +1486,7 @@ ssaValue *ssa_emit_unary_arith(ssaProc *p, TokenKind op, ssaValue *x, Type *type
GB_PANIC("unknown type for -x"); GB_PANIC("unknown type for -x");
} break; } break;
} }
return NULL; return nullptr;
} }
ssaValue *ssa_emit_arith(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y, Type *type) { ssaValue *ssa_emit_arith(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y, Type *type) {
if (is_type_vector(x->type)) { if (is_type_vector(x->type)) {
@@ -1537,11 +1537,11 @@ ssaValue *ssa_emit_arith(ssaProc *p, TokenKind op, ssaValue *x, ssaValue *y, Typ
case Token_Or: case Token_Or:
case Token_Xor: case Token_Xor:
case Token_AndNot: case Token_AndNot:
GB_ASSERT(x != NULL && y != NULL); GB_ASSERT(x != nullptr && y != nullptr);
return ssa_new_value2(p, ssa_determine_op(op, x->type), type, x, y); return ssa_new_value2(p, ssa_determine_op(op, x->type), type, x, y);
} }
return NULL; return nullptr;
} }
@@ -1589,7 +1589,7 @@ ssaValue *ssa_emit_logical_binary_expr(ssaProc *p, AstNode *expr) {
ssaBlock *rhs = ssa_new_block(p, ssaBlock_Plain, "logical.cmp.rhs"); ssaBlock *rhs = ssa_new_block(p, ssaBlock_Plain, "logical.cmp.rhs");
ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "logical.cmp.done"); ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "logical.cmp.done");
GB_ASSERT(p->curr_block != NULL); GB_ASSERT(p->curr_block != nullptr);
Type *type = default_type(type_of_expr(p->module->info, expr)); Type *type = default_type(type_of_expr(p->module->info, expr));
@@ -1689,10 +1689,10 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
GB_PANIC("TODO(bill): ssa_build_expr Entity_Builtin `%.*s`\n" GB_PANIC("TODO(bill): ssa_build_expr Entity_Builtin `%.*s`\n"
"\t at %.*s(%td:%td)", LIT(builtin_procs[e->Builtin.id].name), "\t at %.*s(%td:%td)", LIT(builtin_procs[e->Builtin.id].name),
LIT(token.pos.file), token.pos.line, token.pos.column); LIT(token.pos.file), token.pos.line, token.pos.column);
return NULL; return nullptr;
} else if (e->kind == Entity_Nil) { } else if (e->kind == Entity_Nil) {
GB_PANIC("TODO(bill): nil"); GB_PANIC("TODO(bill): nil");
return NULL; return nullptr;
} }
ssaValue **found = map_get(&p->module->values, hash_pointer(e)); ssaValue **found = map_get(&p->module->values, hash_pointer(e));
@@ -1737,7 +1737,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
case Token_Shl: case Token_Shl:
case Token_Shr: { case Token_Shr: {
GB_PANIC("TODO: shifts"); GB_PANIC("TODO: shifts");
return NULL; return nullptr;
} }
case Token_CmpEq: case Token_CmpEq:
@@ -1772,29 +1772,29 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
case_ast_node(te, TernaryExpr, expr); case_ast_node(te, TernaryExpr, expr);
ssa_emit_comment(p, str_lit("TernaryExpr")); ssa_emit_comment(p, str_lit("TernaryExpr"));
ssaValue *yes = NULL; ssaValue *yes = nullptr;
ssaValue *no = NULL; ssaValue *no = nullptr;
GB_ASSERT(te->y != NULL); GB_ASSERT(te->y != nullptr);
ssaBlock *then = ssa_new_block(p, ssaBlock_Plain, "if.then"); ssaBlock *then = ssa_new_block(p, ssaBlock_Plain, "if.then");
ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "if.done"); // NOTE(bill): Append later ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "if.done"); // NOTE(bill): Append later
ssaBlock *else_ = ssa_new_block(p, ssaBlock_Plain, "if.else"); ssaBlock *else_ = ssa_new_block(p, ssaBlock_Plain, "if.else");
ssaBlock *v = NULL; ssaBlock *v = nullptr;
ssa_build_cond(p, te->cond, then, else_); ssa_build_cond(p, te->cond, then, else_);
ssa_start_block(p, then); ssa_start_block(p, then);
// ssa_open_scope(p); // ssa_open_scope(p);
yes = ssa_build_expr(p, te->x); yes = ssa_build_expr(p, te->x);
// ssa_close_scope(p, ssaDeferExit_Default, NULL); // ssa_close_scope(p, ssaDeferExit_Default, nullptr);
ssa_emit_jump(p, done); ssa_emit_jump(p, done);
ssa_start_block(p, else_); ssa_start_block(p, else_);
// ssa_open_scope(p); // ssa_open_scope(p);
no = ssa_build_expr(p, te->y); no = ssa_build_expr(p, te->y);
// ssa_close_scope(p, ssaDeferExit_Default, NULL); // ssa_close_scope(p, ssaDeferExit_Default, nullptr);
ssa_emit_jump(p, done); ssa_emit_jump(p, done);
ssa_start_block(p, done); ssa_start_block(p, done);
@@ -1815,7 +1815,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
Type *type = type_of_expr(proc->module->info, expr); Type *type = type_of_expr(proc->module->info, expr);
irValue *value = ir_value_procedure(proc->module->allocator, irValue *value = ir_value_procedure(proc->module->allocator,
proc->module, NULL, type, pl->type, pl->body, name); proc->module, nullptr, type, pl->type, pl->body, name);
value->Proc.tags = pl->tags; value->Proc.tags = pl->tags;
value->Proc.parent = proc; value->Proc.parent = proc;
@@ -1854,7 +1854,7 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
GB_PANIC("Unexpected expression: %.*s", LIT(ast_node_strings[expr->kind])); GB_PANIC("Unexpected expression: %.*s", LIT(ast_node_strings[expr->kind]));
return NULL; return nullptr;
} }
@@ -1927,7 +1927,7 @@ void ssa_build_stmt(ssaProc *p, AstNode *node) {
p->module->stmt_state_flags = prev_stmt_state_flags; p->module->stmt_state_flags = prev_stmt_state_flags;
} }
void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
if (p->curr_block == NULL) { if (p->curr_block == nullptr) {
ssaBlock *dead_block = ssa_new_block(p, ssaBlock_Plain, ""); ssaBlock *dead_block = ssa_new_block(p, ssaBlock_Plain, "");
ssa_start_block(p, dead_block); ssa_start_block(p, dead_block);
} }
@@ -1939,7 +1939,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
case_ast_node(bs, BlockStmt, node); case_ast_node(bs, BlockStmt, node);
ssa_open_scope(p); ssa_open_scope(p);
ssa_build_stmt_list(p, bs->stmts); ssa_build_stmt_list(p, bs->stmts);
ssa_close_scope(p, ssaDeferExit_Default, NULL); ssa_close_scope(p, ssaDeferExit_Default, nullptr);
case_end; case_end;
case_ast_node(us, UsingStmt, node); case_ast_node(us, UsingStmt, node);
@@ -2064,7 +2064,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
case_ast_node(is, IfStmt, node); case_ast_node(is, IfStmt, node);
ssa_emit_comment(p, str_lit("IfStmt")); ssa_emit_comment(p, str_lit("IfStmt"));
if (is->init != NULL) { if (is->init != nullptr) {
ssaBlock *init = ssa_new_block(p, ssaBlock_Plain, "if.init"); ssaBlock *init = ssa_new_block(p, ssaBlock_Plain, "if.init");
ssa_emit_jump(p, init); ssa_emit_jump(p, init);
ssa_start_block(p, init); ssa_start_block(p, init);
@@ -2073,26 +2073,26 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
ssaBlock *then = ssa_new_block(p, ssaBlock_Plain, "if.then"); ssaBlock *then = ssa_new_block(p, ssaBlock_Plain, "if.then");
ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "if.done"); ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "if.done");
ssaBlock *else_ = done; ssaBlock *else_ = done;
if (is->else_stmt != NULL) { if (is->else_stmt != nullptr) {
else_ = ssa_new_block(p, ssaBlock_Plain, "if.else"); else_ = ssa_new_block(p, ssaBlock_Plain, "if.else");
} }
ssaBlock *b = NULL; ssaBlock *b = nullptr;
ssa_build_cond(p, is->cond, then, else_); ssa_build_cond(p, is->cond, then, else_);
ssa_start_block(p, then); ssa_start_block(p, then);
ssa_open_scope(p); ssa_open_scope(p);
ssa_build_stmt(p, is->body); ssa_build_stmt(p, is->body);
ssa_close_scope(p, ssaDeferExit_Default, NULL); ssa_close_scope(p, ssaDeferExit_Default, nullptr);
ssa_emit_jump(p, done); ssa_emit_jump(p, done);
if (is->else_stmt != NULL) { if (is->else_stmt != nullptr) {
ssa_start_block(p, else_); ssa_start_block(p, else_);
ssa_open_scope(p); ssa_open_scope(p);
ssa_build_stmt(p, is->else_stmt); ssa_build_stmt(p, is->else_stmt);
ssa_close_scope(p, ssaDeferExit_Default, NULL); ssa_close_scope(p, ssaDeferExit_Default, nullptr);
ssa_emit_jump(p, done); ssa_emit_jump(p, done);
} }
@@ -2103,7 +2103,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
case_ast_node(fs, ForStmt, node); case_ast_node(fs, ForStmt, node);
ssa_emit_comment(p, str_lit("ForStmt")); ssa_emit_comment(p, str_lit("ForStmt"));
if (fs->init != NULL) { if (fs->init != nullptr) {
ssaBlock *init = ssa_new_block(p, ssaBlock_Plain, "for.init"); ssaBlock *init = ssa_new_block(p, ssaBlock_Plain, "for.init");
ssa_emit_jump(p, init); ssa_emit_jump(p, init);
ssa_start_block(p, init); ssa_start_block(p, init);
@@ -2113,11 +2113,11 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
ssaBlock *body = ssa_new_block(p, ssaBlock_Plain, "for.body"); ssaBlock *body = ssa_new_block(p, ssaBlock_Plain, "for.body");
ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "for.done"); ssaBlock *done = ssa_new_block(p, ssaBlock_Plain, "for.done");
ssaBlock *loop = body; ssaBlock *loop = body;
if (fs->cond != NULL) { if (fs->cond != nullptr) {
loop = ssa_new_block(p, ssaBlock_Plain, "for.loop"); loop = ssa_new_block(p, ssaBlock_Plain, "for.loop");
} }
ssaBlock *post = loop; ssaBlock *post = loop;
if (fs->post != NULL) { if (fs->post != nullptr) {
post = ssa_new_block(p, ssaBlock_Plain, "for.post"); post = ssa_new_block(p, ssaBlock_Plain, "for.post");
} }
@@ -2129,15 +2129,15 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
ssa_start_block(p, body); ssa_start_block(p, body);
} }
ssa_push_target_list(p, done, post, NULL); ssa_push_target_list(p, done, post, nullptr);
ssa_open_scope(p); ssa_open_scope(p);
ssa_build_stmt(p, fs->body); ssa_build_stmt(p, fs->body);
ssa_close_scope(p, ssaDeferExit_Default, NULL); ssa_close_scope(p, ssaDeferExit_Default, nullptr);
ssa_pop_target_list(p); ssa_pop_target_list(p);
ssa_emit_jump(p, post); ssa_emit_jump(p, post);
if (fs->post != NULL) { if (fs->post != nullptr) {
ssa_start_block(p, post); ssa_start_block(p, post);
ssa_build_stmt(p, fs->post); ssa_build_stmt(p, fs->post);
ssa_emit_jump(p, post); ssa_emit_jump(p, post);
@@ -2159,25 +2159,25 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
case_end; case_end;
case_ast_node(bs, BranchStmt, node); case_ast_node(bs, BranchStmt, node);
ssaBlock *b = NULL; ssaBlock *b = nullptr;
switch (bs->token.kind) { switch (bs->token.kind) {
case Token_break: case Token_break:
for (ssaTargetList *t = p->target_list; t != NULL && b == NULL; t = t->prev) { for (ssaTargetList *t = p->target_list; t != nullptr && b == nullptr; t = t->prev) {
b = t->break_; b = t->break_;
} }
break; break;
case Token_continue: case Token_continue:
for (ssaTargetList *t = p->target_list; t != NULL && b == NULL; t = t->prev) { for (ssaTargetList *t = p->target_list; t != nullptr && b == nullptr; t = t->prev) {
b = t->continue_; b = t->continue_;
} }
break; break;
case Token_fallthrough: case Token_fallthrough:
for (ssaTargetList *t = p->target_list; t != NULL && b == NULL; t = t->prev) { for (ssaTargetList *t = p->target_list; t != nullptr && b == nullptr; t = t->prev) {
b = t->fallthrough_; b = t->fallthrough_;
} }
break; break;
} }
if (b != NULL) { if (b != nullptr) {
ssa_emit_defer_stmts(p, ssaDeferExit_Branch, b); ssa_emit_defer_stmts(p, ssaDeferExit_Branch, b);
} }
switch (bs->token.kind) { switch (bs->token.kind) {
@@ -2198,7 +2198,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
} }
void ssa_print_value(gbFile *f, ssaValue *v) { void ssa_print_value(gbFile *f, ssaValue *v) {
if (v == NULL) { if (v == nullptr) {
gb_fprintf(f, "nil"); gb_fprintf(f, "nil");
} }
gb_fprintf(f, "v%d", v->id); gb_fprintf(f, "v%d", v->id);
@@ -2249,7 +2249,7 @@ void ssa_print_reg_value(gbFile *f, ssaValue *v) {
gb_fprintf(f, " "); gb_fprintf(f, " ");
gb_fprintf(f, "v%d = %.*s", v->id, LIT(ssa_op_strings[v->op])); gb_fprintf(f, "v%d = %.*s", v->id, LIT(ssa_op_strings[v->op]));
if (v->type != NULL) { if (v->type != nullptr) {
gbString type_str = type_to_string(default_type(v->type)); gbString type_str = type_to_string(default_type(v->type));
gb_fprintf(f, " %s", type_str); gb_fprintf(f, " %s", type_str);
gb_string_free(type_str); gb_string_free(type_str);
@@ -2313,7 +2313,7 @@ void ssa_print_proc(gbFile *f, ssaProc *p) {
bool skip = false; bool skip = false;
for_array(k, v->args) { for_array(k, v->args) {
ssaValue *w = v->args[k]; ssaValue *w = v->args[k];
if (w != NULL && w->block == b && !printed[w->id]) { if (w != nullptr && w->block == b && !printed[w->id]) {
skip = true; skip = true;
break; break;
} }
@@ -2377,13 +2377,13 @@ void ssa_build_proc(ssaModule *m, ssaProc *p) {
p->module = m; p->module = m;
m->proc = p; m->proc = p;
if (p->decl_info->proc_lit == NULL || if (p->decl_info->proc_lit == nullptr ||
p->decl_info->proc_lit->kind != AstNode_ProcLit) { p->decl_info->proc_lit->kind != AstNode_ProcLit) {
return; return;
} }
ast_node(pl, ProcLit, p->decl_info->proc_lit); ast_node(pl, ProcLit, p->decl_info->proc_lit);
if (pl->body == NULL) { if (pl->body == nullptr) {
return; return;
} }
p->entry = ssa_new_block(p, ssaBlock_Entry, "entry"); p->entry = ssa_new_block(p, ssaBlock_Entry, "entry");
@@ -2392,7 +2392,7 @@ void ssa_build_proc(ssaModule *m, ssaProc *p) {
ssa_build_stmt(p, pl->body); ssa_build_stmt(p, pl->body);
if (p->entity->type->Proc.result_count == 0) { if (p->entity->type->Proc.result_count == 0) {
ssa_emit_defer_stmts(p, ssaDeferExit_Return, NULL); ssa_emit_defer_stmts(p, ssaDeferExit_Return, nullptr);
} }
p->exit = ssa_new_block(p, ssaBlock_Exit, "exit"); p->exit = ssa_new_block(p, ssaBlock_Exit, "exit");
@@ -2429,7 +2429,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) {
} }
isize global_variable_max_count = 0; isize global_variable_max_count = 0;
Entity *entry_point = NULL; Entity *entry_point = nullptr;
bool has_dll_main = false; bool has_dll_main = false;
bool has_win_main = false; bool has_win_main = false;
@@ -2470,7 +2470,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) {
continue; continue;
} }
if (map_get(&m.min_dep_map, hash_pointer(e)) == NULL) { if (map_get(&m.min_dep_map, hash_pointer(e)) == nullptr) {
// NOTE(bill): Nothing depends upon it so doesn't need to be built // NOTE(bill): Nothing depends upon it so doesn't need to be built
continue; continue;
} }
@@ -2515,7 +2515,7 @@ bool ssa_generate(Parser *parser, CheckerInfo *info) {
// ssa_module_add_value(m, e, p); // ssa_module_add_value(m, e, p);
// HashKey hash_name = hash_string(name); // HashKey hash_name = hash_string(name);
// if (map_get(&m.members, hash_name) == NULL) { // if (map_get(&m.members, hash_name) == nullptr) {
// map_set(&m.members, hash_name, p); // map_set(&m.members, hash_name, p);
// } // }
} break; } break;
src/string.cpp
+11 -11
View File
@@ -65,7 +65,7 @@ gb_inline String16 make_string16(wchar_t *text, isize len) {
} }
isize string16_len(wchar_t *s) { isize string16_len(wchar_t *s) {
if (s == NULL) { if (s == nullptr) {
return 0; return 0;
} }
wchar_t *p = s; wchar_t *p = s;
@@ -256,7 +256,7 @@ String filename_from_path(String s) {
s.text += j+1; s.text += j+1;
s.len = i-j-1; s.len = i-j-1;
} }
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
@@ -271,7 +271,7 @@ String filename_from_path(String s) {
return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, multibyte_input, input_length, output, output_size); return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, multibyte_input, input_length, output, output_size);
} }
int convert_widechar_to_multibyte(wchar_t *widechar_input, int input_length, char *output, int output_size) { int convert_widechar_to_multibyte(wchar_t *widechar_input, int input_length, char *output, int output_size) {
return WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, widechar_input, input_length, output, output_size, NULL, NULL); return WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, widechar_input, input_length, output, output_size, nullptr, nullptr);
} }
#elif defined(GB_SYSTEM_UNIX) || defined(GB_SYSTEM_OSX) #elif defined(GB_SYSTEM_UNIX) || defined(GB_SYSTEM_OSX)
@@ -305,12 +305,12 @@ String16 string_to_string16(gbAllocator a, String s) {
wchar_t *text; wchar_t *text;
if (s.len < 1) { if (s.len < 1) {
return make_string16(NULL, 0); return make_string16(nullptr, 0);
} }
len = convert_multibyte_to_widechar(cast(char *)s.text, s.len, NULL, 0); len = convert_multibyte_to_widechar(cast(char *)s.text, s.len, nullptr, 0);
if (len == 0) { if (len == 0) {
return make_string16(NULL, 0); return make_string16(nullptr, 0);
} }
text = gb_alloc_array(a, wchar_t, len+1); text = gb_alloc_array(a, wchar_t, len+1);
@@ -318,7 +318,7 @@ String16 string_to_string16(gbAllocator a, String s) {
len1 = convert_multibyte_to_widechar(cast(char *)s.text, s.len, text, len); len1 = convert_multibyte_to_widechar(cast(char *)s.text, s.len, text, len);
if (len1 == 0) { if (len1 == 0) {
gb_free(a, text); gb_free(a, text);
return make_string16(NULL, 0); return make_string16(nullptr, 0);
} }
text[len] = 0; text[len] = 0;
@@ -331,12 +331,12 @@ String string16_to_string(gbAllocator a, String16 s) {
u8 *text; u8 *text;
if (s.len < 1) { if (s.len < 1) {
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
len = convert_widechar_to_multibyte(s.text, s.len, NULL, 0); len = convert_widechar_to_multibyte(s.text, s.len, nullptr, 0);
if (len == 0) { if (len == 0) {
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
len += 1; // NOTE(bill): It needs an extra 1 for some reason len += 1; // NOTE(bill): It needs an extra 1 for some reason
@@ -345,7 +345,7 @@ String string16_to_string(gbAllocator a, String16 s) {
len1 = convert_widechar_to_multibyte(s.text, s.len, cast(char *)text, len); len1 = convert_widechar_to_multibyte(s.text, s.len, cast(char *)text, len);
if (len1 == 0) { if (len1 == 0) {
gb_free(a, text); gb_free(a, text);
return make_string(NULL, 0); return make_string(nullptr, 0);
} }
text[len] = 0; text[len] = 0;
src/tokenizer.cpp
+2 -2
View File
@@ -433,7 +433,7 @@ TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) {
// TODO(bill): Memory map rather than copy contents // TODO(bill): Memory map rather than copy contents
gbFileContents fc = gb_file_read_contents(heap_allocator(), true, c_str); gbFileContents fc = gb_file_read_contents(heap_allocator(), true, c_str);
gb_zero_item(t); gb_zero_item(t);
if (fc.data != NULL) { if (fc.data != nullptr) {
t->start = cast(u8 *)fc.data; t->start = cast(u8 *)fc.data;
t->line = t->read_curr = t->curr = t->start; t->line = t->read_curr = t->curr = t->start;
t->end = t->start + fc.size; t->end = t->start + fc.size;
@@ -468,7 +468,7 @@ TokenizerInitError init_tokenizer(Tokenizer *t, String fullpath) {
} }
gb_inline void destroy_tokenizer(Tokenizer *t) { gb_inline void destroy_tokenizer(Tokenizer *t) {
if (t->start != NULL) { if (t->start != nullptr) {
gb_free(heap_allocator(), t->start); gb_free(heap_allocator(), t->start);
} }
for_array(i, t->allocated_strings) { for_array(i, t->allocated_strings) {
src/types.cpp
+113 -113
View File
@@ -221,7 +221,7 @@ void selection_add_index(Selection *s, isize index) {
// IMPORTANT NOTE(bill): this requires a stretchy buffer/dynamic array so it requires some form // IMPORTANT NOTE(bill): this requires a stretchy buffer/dynamic array so it requires some form
// of heap allocation // of heap allocation
// TODO(bill): Find a way to use a backing buffer for initial use as the general case is probably .count<3 // TODO(bill): Find a way to use a backing buffer for initial use as the general case is probably .count<3
if (s->index.data == NULL) { if (s->index.data == nullptr) {
array_init(&s->index, heap_allocator()); array_init(&s->index, heap_allocator());
} }
array_add(&s->index, cast(i32)index); array_add(&s->index, cast(i32)index);
@@ -317,80 +317,80 @@ gb_global Type *t_untyped_nil = &basic_types[Basic_UntypedNil];
gb_global Type *t_untyped_undef = &basic_types[Basic_UntypedUndef]; gb_global Type *t_untyped_undef = &basic_types[Basic_UntypedUndef];
gb_global Type *t_u8_ptr = NULL; gb_global Type *t_u8_ptr = nullptr;
gb_global Type *t_int_ptr = NULL; gb_global Type *t_int_ptr = nullptr;
gb_global Type *t_i64_ptr = NULL; gb_global Type *t_i64_ptr = nullptr;
gb_global Type *t_i128_ptr = NULL; gb_global Type *t_i128_ptr = nullptr;
gb_global Type *t_f64_ptr = NULL; gb_global Type *t_f64_ptr = nullptr;
gb_global Type *t_u8_slice = NULL; gb_global Type *t_u8_slice = nullptr;
gb_global Type *t_string_slice = NULL; gb_global Type *t_string_slice = nullptr;
// Type generated for the "preload" file // Type generated for the "preload" file
gb_global Type *t_type_info = NULL; gb_global Type *t_type_info = nullptr;
gb_global Type *t_type_info_record = NULL; gb_global Type *t_type_info_record = nullptr;
gb_global Type *t_type_info_enum_value = NULL; gb_global Type *t_type_info_enum_value = nullptr;
gb_global Type *t_type_info_ptr = NULL; gb_global Type *t_type_info_ptr = nullptr;
gb_global Type *t_type_info_record_ptr = NULL; gb_global Type *t_type_info_record_ptr = nullptr;
gb_global Type *t_type_info_enum_value_ptr = NULL; gb_global Type *t_type_info_enum_value_ptr = nullptr;
gb_global Type *t_type_info_named = NULL; gb_global Type *t_type_info_named = nullptr;
gb_global Type *t_type_info_integer = NULL; gb_global Type *t_type_info_integer = nullptr;
gb_global Type *t_type_info_rune = NULL; gb_global Type *t_type_info_rune = nullptr;
gb_global Type *t_type_info_float = NULL; gb_global Type *t_type_info_float = nullptr;
gb_global Type *t_type_info_complex = NULL; gb_global Type *t_type_info_complex = nullptr;
gb_global Type *t_type_info_any = NULL; gb_global Type *t_type_info_any = nullptr;
gb_global Type *t_type_info_string = NULL; gb_global Type *t_type_info_string = nullptr;
gb_global Type *t_type_info_boolean = NULL; gb_global Type *t_type_info_boolean = nullptr;
gb_global Type *t_type_info_pointer = NULL; gb_global Type *t_type_info_pointer = nullptr;
gb_global Type *t_type_info_atomic = NULL; gb_global Type *t_type_info_atomic = nullptr;
gb_global Type *t_type_info_procedure = NULL; gb_global Type *t_type_info_procedure = nullptr;
gb_global Type *t_type_info_array = NULL; gb_global Type *t_type_info_array = nullptr;
gb_global Type *t_type_info_dynamic_array = NULL; gb_global Type *t_type_info_dynamic_array = nullptr;
gb_global Type *t_type_info_slice = NULL; gb_global Type *t_type_info_slice = nullptr;
gb_global Type *t_type_info_vector = NULL; gb_global Type *t_type_info_vector = nullptr;
gb_global Type *t_type_info_tuple = NULL; gb_global Type *t_type_info_tuple = nullptr;
gb_global Type *t_type_info_struct = NULL; gb_global Type *t_type_info_struct = nullptr;
gb_global Type *t_type_info_raw_union = NULL; gb_global Type *t_type_info_raw_union = nullptr;
gb_global Type *t_type_info_union = NULL; gb_global Type *t_type_info_union = nullptr;
gb_global Type *t_type_info_enum = NULL; gb_global Type *t_type_info_enum = nullptr;
gb_global Type *t_type_info_map = NULL; gb_global Type *t_type_info_map = nullptr;
gb_global Type *t_type_info_bit_field = NULL; gb_global Type *t_type_info_bit_field = nullptr;
gb_global Type *t_type_info_named_ptr = NULL; gb_global Type *t_type_info_named_ptr = nullptr;
gb_global Type *t_type_info_integer_ptr = NULL; gb_global Type *t_type_info_integer_ptr = nullptr;
gb_global Type *t_type_info_rune_ptr = NULL; gb_global Type *t_type_info_rune_ptr = nullptr;
gb_global Type *t_type_info_float_ptr = NULL; gb_global Type *t_type_info_float_ptr = nullptr;
gb_global Type *t_type_info_complex_ptr = NULL; gb_global Type *t_type_info_complex_ptr = nullptr;
gb_global Type *t_type_info_quaternion_ptr = NULL; gb_global Type *t_type_info_quaternion_ptr = nullptr;
gb_global Type *t_type_info_any_ptr = NULL; gb_global Type *t_type_info_any_ptr = nullptr;
gb_global Type *t_type_info_string_ptr = NULL; gb_global Type *t_type_info_string_ptr = nullptr;
gb_global Type *t_type_info_boolean_ptr = NULL; gb_global Type *t_type_info_boolean_ptr = nullptr;
gb_global Type *t_type_info_pointer_ptr = NULL; gb_global Type *t_type_info_pointer_ptr = nullptr;
gb_global Type *t_type_info_atomic_ptr = NULL; gb_global Type *t_type_info_atomic_ptr = nullptr;
gb_global Type *t_type_info_procedure_ptr = NULL; gb_global Type *t_type_info_procedure_ptr = nullptr;
gb_global Type *t_type_info_array_ptr = NULL; gb_global Type *t_type_info_array_ptr = nullptr;
gb_global Type *t_type_info_dynamic_array_ptr = NULL; gb_global Type *t_type_info_dynamic_array_ptr = nullptr;
gb_global Type *t_type_info_slice_ptr = NULL; gb_global Type *t_type_info_slice_ptr = nullptr;
gb_global Type *t_type_info_vector_ptr = NULL; gb_global Type *t_type_info_vector_ptr = nullptr;
gb_global Type *t_type_info_tuple_ptr = NULL; gb_global Type *t_type_info_tuple_ptr = nullptr;
gb_global Type *t_type_info_struct_ptr = NULL; gb_global Type *t_type_info_struct_ptr = nullptr;
gb_global Type *t_type_info_raw_union_ptr = NULL; gb_global Type *t_type_info_raw_union_ptr = nullptr;
gb_global Type *t_type_info_union_ptr = NULL; gb_global Type *t_type_info_union_ptr = nullptr;
gb_global Type *t_type_info_enum_ptr = NULL; gb_global Type *t_type_info_enum_ptr = nullptr;
gb_global Type *t_type_info_map_ptr = NULL; gb_global Type *t_type_info_map_ptr = nullptr;
gb_global Type *t_type_info_bit_field_ptr = NULL; gb_global Type *t_type_info_bit_field_ptr = nullptr;
gb_global Type *t_allocator = NULL; gb_global Type *t_allocator = nullptr;
gb_global Type *t_allocator_ptr = NULL; gb_global Type *t_allocator_ptr = nullptr;
gb_global Type *t_context = NULL; gb_global Type *t_context = nullptr;
gb_global Type *t_context_ptr = NULL; gb_global Type *t_context_ptr = nullptr;
gb_global Type *t_source_code_location = NULL; gb_global Type *t_source_code_location = nullptr;
gb_global Type *t_source_code_location_ptr = NULL; gb_global Type *t_source_code_location_ptr = nullptr;
gb_global Type *t_map_key = NULL; gb_global Type *t_map_key = nullptr;
gb_global Type *t_map_header = NULL; gb_global Type *t_map_header = nullptr;
@@ -405,7 +405,7 @@ gbString type_to_string(Type *type);
Type *base_type(Type *t) { Type *base_type(Type *t) {
for (;;) { for (;;) {
if (t == NULL) { if (t == nullptr) {
break; break;
} }
if (t->kind != Type_Named) { if (t->kind != Type_Named) {
@@ -421,7 +421,7 @@ Type *base_type(Type *t) {
Type *base_enum_type(Type *t) { Type *base_enum_type(Type *t) {
Type *bt = base_type(t); Type *bt = base_type(t);
if (bt != NULL && if (bt != nullptr &&
bt->kind == Type_Record && bt->kind == Type_Record &&
bt->Record.kind == TypeRecord_Enum) { bt->Record.kind == TypeRecord_Enum) {
return bt->Record.enum_base_type; return bt->Record.enum_base_type;
@@ -431,7 +431,7 @@ Type *base_enum_type(Type *t) {
Type *core_type(Type *t) { Type *core_type(Type *t) {
for (;;) { for (;;) {
if (t == NULL) { if (t == nullptr) {
break; break;
} }
@@ -572,7 +572,7 @@ Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_coun
if (param_count == 0) { if (param_count == 0) {
GB_PANIC("variadic procedure must have at least one parameter"); GB_PANIC("variadic procedure must have at least one parameter");
} }
GB_ASSERT(params != NULL && params->kind == Type_Tuple); GB_ASSERT(params != nullptr && params->kind == Type_Tuple);
Entity *e = params->Tuple.variables[param_count-1]; Entity *e = params->Tuple.variables[param_count-1];
if (base_type(e->type)->kind != Type_Slice) { if (base_type(e->type)->kind != Type_Slice) {
// NOTE(bill): For custom calling convention // NOTE(bill): For custom calling convention
@@ -594,7 +594,7 @@ bool is_type_valid_for_keys(Type *t);
Type *make_type_map(gbAllocator a, i64 count, Type *key, Type *value) { Type *make_type_map(gbAllocator a, i64 count, Type *key, Type *value) {
Type *t = alloc_type(a, Type_Map); Type *t = alloc_type(a, Type_Map);
if (key != NULL) { if (key != nullptr) {
GB_ASSERT(is_type_valid_for_keys(key)); GB_ASSERT(is_type_valid_for_keys(key));
} }
t->Map.count = count; t->Map.count = count;
@@ -620,11 +620,11 @@ Type *make_type_bit_field(gbAllocator a) {
Type *type_deref(Type *t) { Type *type_deref(Type *t) {
if (t != NULL) { if (t != nullptr) {
Type *bt = base_type(t); Type *bt = base_type(t);
if (bt == NULL) if (bt == nullptr)
return NULL; return nullptr;
if (bt != NULL && bt->kind == Type_Pointer) if (bt != nullptr && bt->kind == Type_Pointer)
return bt->Pointer.elem; return bt->Pointer.elem;
} }
return t; return t;
@@ -641,7 +641,7 @@ bool is_type_named_alias(Type *t) {
return false; return false;
} }
Entity *e = t->Named.type_name; Entity *e = t->Named.type_name;
if (e == NULL) { if (e == nullptr) {
return false; return false;
} }
if (e->kind != Entity_TypeName) { if (e->kind != Entity_TypeName) {
@@ -698,7 +698,7 @@ bool is_type_string(Type *t) {
} }
bool is_type_typed(Type *t) { bool is_type_typed(Type *t) {
t = base_type(t); t = base_type(t);
if (t == NULL) { if (t == nullptr) {
return false; return false;
} }
if (t->kind == Type_Basic) { if (t->kind == Type_Basic) {
@@ -865,7 +865,7 @@ bool is_type_union(Type *t) {
bool is_type_variant(Type *t) { bool is_type_variant(Type *t) {
t = base_type(t); t = base_type(t);
if (t->kind == Type_Record) { if (t->kind == Type_Record) {
return t->Record.kind == TypeRecord_Struct && t->Record.variant_parent != NULL; return t->Record.kind == TypeRecord_Struct && t->Record.variant_parent != nullptr;
} }
return false; return false;
} }
@@ -990,7 +990,7 @@ bool is_type_polymorphic(Type *t) {
case Type_Record: case Type_Record:
if (t->Record.kind == TypeRecord_Enum) { if (t->Record.kind == TypeRecord_Enum) {
if (t->Record.enum_base_type != NULL) { if (t->Record.enum_base_type != nullptr) {
return is_type_polymorphic(t->Record.enum_base_type); return is_type_polymorphic(t->Record.enum_base_type);
} }
return false; return false;
@@ -1090,8 +1090,8 @@ bool are_types_identical(Type *x, Type *y) {
return true; return true;
} }
if ((x == NULL && y != NULL) || if ((x == nullptr && y != nullptr) ||
(x != NULL && y == NULL)) { (x != nullptr && y == nullptr)) {
return false; return false;
} }
@@ -1160,7 +1160,7 @@ bool are_types_identical(Type *x, Type *y) {
return false; return false;
} }
} }
// NOTE(bill): zeroth variant is NULL // NOTE(bill): zeroth variant is nullptr
for (isize i = 1; i < x->Record.variant_count; i++) { for (isize i = 1; i < x->Record.variant_count; i++) {
if (!are_types_identical(x->Record.variants[i]->type, y->Record.variants[i]->type)) { if (!are_types_identical(x->Record.variants[i]->type, y->Record.variants[i]->type)) {
return false; return false;
@@ -1230,7 +1230,7 @@ bool are_types_identical(Type *x, Type *y) {
} }
Type *default_bit_field_value_type(Type *type) { Type *default_bit_field_value_type(Type *type) {
if (type == NULL) { if (type == nullptr) {
return t_invalid; return t_invalid;
} }
Type *t = base_type(type); Type *t = base_type(type);
@@ -1250,7 +1250,7 @@ Type *default_bit_field_value_type(Type *type) {
} }
Type *default_type(Type *type) { Type *default_type(Type *type) {
if (type == NULL) { if (type == nullptr) {
return t_invalid; return t_invalid;
} }
if (type->kind == Type_Basic) { if (type->kind == Type_Basic) {
@@ -1347,9 +1347,9 @@ enum ProcTypeOverloadKind {
}; };
ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) { ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) {
if (x == NULL && y == NULL) return ProcOverload_NotProcedure; if (x == nullptr && y == nullptr) return ProcOverload_NotProcedure;
if (x == NULL && y != NULL) return ProcOverload_NotProcedure; if (x == nullptr && y != nullptr) return ProcOverload_NotProcedure;
if (x != NULL && y == NULL) return ProcOverload_NotProcedure; if (x != nullptr && y == nullptr) return ProcOverload_NotProcedure;
if (!is_type_proc(x)) return ProcOverload_NotProcedure; if (!is_type_proc(x)) return ProcOverload_NotProcedure;
if (!is_type_proc(y)) return ProcOverload_NotProcedure; if (!is_type_proc(y)) return ProcOverload_NotProcedure;
@@ -1398,7 +1398,7 @@ ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) {
} }
} }
if (px.params != NULL && py.params != NULL) { if (px.params != nullptr && py.params != nullptr) {
Entity *ex = px.params->Tuple.variables[0]; Entity *ex = px.params->Tuple.variables[0];
Entity *ey = py.params->Tuple.variables[0]; Entity *ey = py.params->Tuple.variables[0];
bool ok = are_types_identical(ex->type, ey->type); bool ok = are_types_identical(ex->type, ey->type);
@@ -1474,11 +1474,11 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
} }
gb_global Entity *entity__any_data = NULL; gb_global Entity *entity__any_data = nullptr;
gb_global Entity *entity__any_type_info = NULL; gb_global Entity *entity__any_type_info = nullptr;
Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_name, bool is_type, Selection sel) { Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_name, bool is_type, Selection sel) {
GB_ASSERT(type_ != NULL); GB_ASSERT(type_ != nullptr);
if (field_name == "_") { if (field_name == "_") {
return empty_selection; return empty_selection;
@@ -1498,11 +1498,11 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
// `Raw_Any` type? // `Raw_Any` type?
String data_str = str_lit("data"); String data_str = str_lit("data");
String type_info_str = str_lit("type_info"); String type_info_str = str_lit("type_info");
if (entity__any_data == NULL) { if (entity__any_data == nullptr) {
entity__any_data = make_entity_field(a, NULL, make_token_ident(data_str), t_rawptr, false, 0); entity__any_data = make_entity_field(a, nullptr, make_token_ident(data_str), t_rawptr, false, 0);
} }
if (entity__any_type_info == NULL) { if (entity__any_type_info == nullptr) {
entity__any_type_info = make_entity_field(a, NULL, make_token_ident(type_info_str), t_type_info_ptr, false, 1); entity__any_type_info = make_entity_field(a, nullptr, make_token_ident(type_info_str), t_type_info_ptr, false, 1);
} }
if (field_name == data_str) { if (field_name == data_str) {
@@ -1527,7 +1527,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
case (_length): \ case (_length): \
if (field_name == _name) { \ if (field_name == _name) { \
selection_add_index(&sel, (_length)-1); \ selection_add_index(&sel, (_length)-1); \
sel.entity = make_entity_vector_elem(a, NULL, make_token_ident(str_lit(_name)), type->Vector.elem, (_length)-1); \ sel.entity = make_entity_vector_elem(a, nullptr, make_token_ident(str_lit(_name)), type->Vector.elem, (_length)-1); \
return sel; \ return sel; \
} \ } \
/*fallthrough*/ /*fallthrough*/
@@ -1545,7 +1545,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
if (is_type) { if (is_type) {
if (type->kind == Type_Record) { if (type->kind == Type_Record) {
if (type->Record.names != NULL && if (type->Record.names != nullptr &&
field_name == "names") { field_name == "names") {
sel.entity = type->Record.names; sel.entity = type->Record.names;
return sel; return sel;
@@ -1566,7 +1566,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
} }
} else if (is_type_enum(type)) { } else if (is_type_enum(type)) {
// NOTE(bill): These may not have been added yet, so check in case // NOTE(bill): These may not have been added yet, so check in case
if (type->Record.enum_count != NULL) { if (type->Record.enum_count != nullptr) {
if (field_name == "count") { if (field_name == "count") {
sel.entity = type->Record.enum_count; sel.entity = type->Record.enum_count;
return sel; return sel;
@@ -1612,7 +1612,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
sel = lookup_field_with_selection(a, f->type, field_name, is_type, sel); sel = lookup_field_with_selection(a, f->type, field_name, is_type, sel);
if (sel.entity != NULL) { if (sel.entity != nullptr) {
if (is_type_pointer(f->type)) { if (is_type_pointer(f->type)) {
sel.indirect = true; sel.indirect = true;
} }
@@ -1624,7 +1624,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
if (type->Record.kind == TypeRecord_Union) { if (type->Record.kind == TypeRecord_Union) {
if (field_name == "__tag") { if (field_name == "__tag") {
Entity *e = type->Record.union__tag; Entity *e = type->Record.union__tag;
GB_ASSERT(e != NULL); GB_ASSERT(e != nullptr);
selection_add_index(&sel, -1); // HACK(bill): Leaky memory selection_add_index(&sel, -1); // HACK(bill): Leaky memory
sel.entity = e; sel.entity = e;
return sel; return sel;
@@ -1666,11 +1666,11 @@ void type_path_free(TypePath *tp) {
} }
void type_path_print_illegal_cycle(TypePath *tp, isize start_index) { void type_path_print_illegal_cycle(TypePath *tp, isize start_index) {
GB_ASSERT(tp != NULL); GB_ASSERT(tp != nullptr);
GB_ASSERT(start_index < tp->path.count); GB_ASSERT(start_index < tp->path.count);
Type *t = tp->path[start_index]; Type *t = tp->path[start_index];
GB_ASSERT(t != NULL); GB_ASSERT(t != nullptr);
GB_ASSERT_MSG(is_type_named(t), "%s", type_to_string(t)); GB_ASSERT_MSG(is_type_named(t), "%s", type_to_string(t));
Entity *e = t->Named.type_name; Entity *e = t->Named.type_name;
@@ -1689,7 +1689,7 @@ void type_path_print_illegal_cycle(TypePath *tp, isize start_index) {
} }
TypePath *type_path_push(TypePath *tp, Type *t) { TypePath *type_path_push(TypePath *tp, Type *t) {
GB_ASSERT(tp != NULL); GB_ASSERT(tp != nullptr);
for (isize i = 0; i < tp->path.count; i++) { for (isize i = 0; i < tp->path.count; i++) {
if (tp->path[i] == t) { if (tp->path[i] == t) {
@@ -1704,7 +1704,7 @@ TypePath *type_path_push(TypePath *tp, Type *t) {
} }
void type_path_pop(TypePath *tp) { void type_path_pop(TypePath *tp) {
if (tp != NULL && tp->path.count > 0) { if (tp != nullptr && tp->path.count > 0) {
array_pop(&tp->path); array_pop(&tp->path);
} }
} }
@@ -1726,7 +1726,7 @@ i64 align_formula(i64 size, i64 align) {
} }
i64 type_size_of(gbAllocator allocator, Type *t) { i64 type_size_of(gbAllocator allocator, Type *t) {
if (t == NULL) { if (t == nullptr) {
return 0; return 0;
} }
i64 size; i64 size;
@@ -1738,7 +1738,7 @@ i64 type_size_of(gbAllocator allocator, Type *t) {
} }
i64 type_align_of(gbAllocator allocator, Type *t) { i64 type_align_of(gbAllocator allocator, Type *t) {
if (t == NULL) { if (t == nullptr) {
return 1; return 1;
} }
i64 align; i64 align;
@@ -2086,7 +2086,7 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
if (path->failure) { if (path->failure) {
return FAILURE_SIZE; return FAILURE_SIZE;
} }
if (t->Record.are_offsets_being_processed && t->Record.offsets == NULL) { if (t->Record.are_offsets_being_processed && t->Record.offsets == nullptr) {
type_path_print_illegal_cycle(path, path->path.count-1); type_path_print_illegal_cycle(path, path->path.count-1);
return FAILURE_SIZE; return FAILURE_SIZE;
} }
@@ -2268,7 +2268,7 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s
} }
gbString write_type_to_string(gbString str, Type *type) { gbString write_type_to_string(gbString str, Type *type) {
if (type == NULL) { if (type == nullptr) {
return gb_string_appendc(str, "<no type>"); return gb_string_appendc(str, "<no type>");
} }
@@ -2395,7 +2395,7 @@ gbString write_type_to_string(gbString str, Type *type) {
case TypeRecord_Enum: case TypeRecord_Enum:
str = gb_string_appendc(str, "enum"); str = gb_string_appendc(str, "enum");
if (type->Record.enum_base_type != NULL) { if (type->Record.enum_base_type != nullptr) {
str = gb_string_appendc(str, " "); str = gb_string_appendc(str, " ");
str = write_type_to_string(str, type->Record.enum_base_type); str = write_type_to_string(str, type->Record.enum_base_type);
} }
@@ -2425,7 +2425,7 @@ gbString write_type_to_string(gbString str, Type *type) {
} break; } break;
case Type_Named: case Type_Named:
if (type->Named.type_name != NULL) { if (type->Named.type_name != nullptr) {
str = gb_string_append_length(str, type->Named.name.text, type->Named.name.len); str = gb_string_append_length(str, type->Named.name.text, type->Named.name.len);
} else { } else {
// NOTE(bill): Just in case // NOTE(bill): Just in case
@@ -2437,7 +2437,7 @@ gbString write_type_to_string(gbString str, Type *type) {
if (type->Tuple.variable_count > 0) { if (type->Tuple.variable_count > 0) {
for (isize i = 0; i < type->Tuple.variable_count; i++) { for (isize i = 0; i < type->Tuple.variable_count; i++) {
Entity *var = type->Tuple.variables[i]; Entity *var = type->Tuple.variables[i];
if (var != NULL) { if (var != nullptr) {
if (i > 0) { if (i > 0) {
str = gb_string_appendc(str, ", "); str = gb_string_appendc(str, ", ");
} }
@@ -2503,7 +2503,7 @@ gbString write_type_to_string(gbString str, Type *type) {
for (isize i = 0; i < type->BitField.field_count; i++) { for (isize i = 0; i < type->BitField.field_count; i++) {
Entity *f = type->BitField.fields[i]; Entity *f = type->BitField.fields[i];
GB_ASSERT(f->kind == Entity_Variable); GB_ASSERT(f->kind == Entity_Variable);
GB_ASSERT(f->type != NULL && f->type->kind == Type_BitFieldValue); GB_ASSERT(f->type != nullptr && f->type->kind == Type_BitFieldValue);
str = gb_string_appendc(str, "{"); str = gb_string_appendc(str, "{");
if (i > 0) { if (i > 0) {
str = gb_string_appendc(str, ", "); str = gb_string_appendc(str, ", ");