mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-04-19 13:00:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Extra type safety; Fix typos

Browse Source
This commit is contained in:
Ginger Bill
2017-07-31 11:36:00 +01:00
parent 8987a6630c
commit 0fae31fb54
17 changed files with 162 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
build.bat
View File

@@ -17,10 +17,13 @@ if %release_mode% EQU 0 ( rem Debug
set compiler_warnings= ^
-W4 -WX ^
-wd4100 -wd4101 -wd4127 -wd4189 ^
-wd4201 -wd4204 -wd4244 ^
-wd4306 ^
-wd4456 -wd4457 -wd4480 ^
-wd4505 -wd4512 -wd4550
-wd4201 ^
-wd4512
rem -wd4100 -wd4101 -wd4127 -wd4189 ^
rem -wd4201 -wd4204 -wd4244 ^
rem -wd4306 ^
rem -wd4456 -wd4457 -wd4480 ^
rem -wd4505 -wd4512 -wd4550
set compiler_includes=
set libs= ^
@@ -38,7 +41,6 @@ if %release_mode% EQU 0 ( rem Debug
set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings%
set linker_settings=%libs% %linker_flags%
del *.pdb > NUL 2> NUL
del *.ilk > NUL 2> NUL

54
core/os_x.odin
View File

@@ -108,13 +108,13 @@ S_ISUID :: 0004000; // Set user id on execution
S_ISGID :: 0002000; // Set group id on execution
S_ISVTX :: 0001000; // Directory restrcted delete
S_ISLNK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; }
S_ISREG :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; }
S_ISDIR :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFDIR; }
S_ISCHR :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFCHR; }
S_ISBLK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; }
S_ISFIFO :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; }
S_ISSOCK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;}
S_ISLNK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFLNK;
S_ISREG :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFREG;
S_ISDIR :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFDIR;
S_ISCHR :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFCHR;
S_ISBLK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFBLK;
S_ISFIFO :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFIFO;
S_ISSOCK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFSOCK;
R_OK :: 4; // Test for read permission
W_OK :: 2; // Test for write permission
@@ -122,28 +122,28 @@ X_OK :: 1; // Test for execute permission
F_OK :: 0; // Test for file existance
foreign libc {
unix_open :: proc(path: ^u8, mode: int) -> Handle #link_name "open" ---;
unix_close :: proc(handle: Handle) #link_name "close" ---;
unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "read" ---;
unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "write" ---;
unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int #link_name "lseek" ---;
unix_gettid :: proc() -> u64 #link_name "gettid" ---;
unix_stat :: proc(path: ^u8, stat: ^Stat) -> int #link_name "stat" ---;
unix_access :: proc(path: ^u8, mask: int) -> int #link_name "access" ---;
unix_open :: proc(path: ^u8, mode: int) -> Handle #link_name "open" ---;
unix_close :: proc(handle: Handle) #link_name "close" ---;
unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "read" ---;
unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "write" ---;
unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int #link_name "lseek" ---;
unix_gettid :: proc() -> u64 #link_name "gettid" ---;
unix_stat :: proc(path: ^u8, stat: ^Stat) -> int #link_name "stat" ---;
unix_access :: proc(path: ^u8, mask: int) -> int #link_name "access" ---;
unix_malloc :: proc(size: int) -> rawptr #link_name "malloc" ---;
unix_free :: proc(ptr: rawptr) #link_name "free" ---;
unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr #link_name "realloc" ---;
unix_getenv :: proc(^u8) -> ^u8 #link_name "getenv" ---;
unix_malloc :: proc(size: int) -> rawptr #link_name "malloc" ---;
unix_free :: proc(ptr: rawptr) #link_name "free" ---;
unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr #link_name "realloc" ---;
unix_getenv :: proc(^u8) -> ^u8 #link_name "getenv" ---;
unix_exit :: proc(status: int) #link_name "exit" ---;
unix_exit :: proc(status: int) #link_name "exit" ---;
}
foreign dl {
unix_dlopen :: proc(filename: ^u8, flags: int) -> rawptr #link_name "dlopen" ---;
unix_dlsym :: proc(handle: rawptr, symbol: ^u8) -> (proc() #cc_c) #link_name "dlsym" ---;
unix_dlclose :: proc(handle: rawptr) -> int #link_name "dlclose" ---;
unix_dlerror :: proc() -> ^u8 #link_name "dlerror" ---;
unix_dlopen :: proc(filename: ^u8, flags: int) -> rawptr #link_name "dlopen" ---;
unix_dlsym :: proc(handle: rawptr, symbol: ^u8) -> (proc() #cc_c) #link_name "dlsym" ---;
unix_dlclose :: proc(handle: rawptr) -> int #link_name "dlclose" ---;
unix_dlerror :: proc() -> ^u8 #link_name "dlerror" ---;
}
// TODO(zangent): Change this to just `open` when Bill fixes overloading.
@@ -187,10 +187,10 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) {
return bytes_read, 0;
}
seek :: proc(fd: Handle, offset: int, whence: int) -> (int, Errno) {
seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
assert(fd != -1);
final_offset := unix_lseek(fd, offset, whence);
final_offset := i64(unix_lseek(fd, offset, whence));
if(final_offset == -1) {
return 0, 1;
}
@@ -201,7 +201,7 @@ file_size :: proc(fd: Handle) -> (i64, Errno) {
prev, _ := seek(fd, 0, SEEK_CUR);
size, err := seek(fd, 0, SEEK_END);
seek(fd, prev, SEEK_SET);
return size, err;
return i64(size), err;
}

4
src/build_settings.cpp
View File

@@ -57,7 +57,7 @@ String odin_root_dir(void) {
len = 0;
for (;;) {
len = GetModuleFileNameW(nullptr, &path_buf[0], path_buf.count);
len = GetModuleFileNameW(nullptr, &path_buf[0], cast(int)path_buf.count);
if (len == 0) {
return make_string(nullptr, 0);
}
@@ -73,7 +73,7 @@ String odin_root_dir(void) {
text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1);
GetModuleFileNameW(nullptr, text, len);
GetModuleFileNameW(nullptr, text, cast(int)len);
path = string16_to_string(heap_allocator(), make_string16(text, len));
for (i = path.len-1; i >= 0; i--) {

30
src/check_expr.cpp
View File

@@ -494,7 +494,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) {
Type *bfv = base_type(operand->type);
i32 bits = bfv->BitFieldValue.bits;
i32 size = next_pow2((bits+7)/8);
i32 dst_size = type_size_of(c->allocator, type);
i32 dst_size = cast(i32)type_size_of(c->allocator, type);
i32 diff = gb_abs(dst_size - size);
// TODO(bill): figure out a decent rule here
return 1;
@@ -1279,7 +1279,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera
gb_sort_array(reordered_fields.data, fields.count, cmp_reorder_struct_fields);
for_array(i, fields) {
reordered_fields[i]->Variable.field_index = i;
reordered_fields[i]->Variable.field_index = cast(i32)i;
}
struct_type->Struct.fields = reordered_fields;
@@ -1564,7 +1564,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod
enum_type->Enum.fields = fields.data;
enum_type->Enum.field_count = fields.count;
enum_type->Enum.field_count = cast(i32)fields.count;
enum_type->Enum.count = make_entity_constant(c->allocator, c->context.scope,
make_token_ident(str_lit("count")), t_int, exact_value_i64(fields.count));
@@ -1622,7 +1622,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As
continue;
}
Type *value_type = make_type_bit_field_value(c->allocator, bits);
Type *value_type = make_type_bit_field_value(c->allocator, cast(i32)bits);
Entity *e = make_entity_variable(c->allocator, bit_field_type->BitField.scope, ident->Ident.token, value_type, false);
e->identifier = ident;
e->flags |= EntityFlag_BitFieldValue;
@@ -1638,16 +1638,16 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As
fields [field_count] = e;
offsets[field_count] = curr_offset;
sizes [field_count] = bits;
sizes [field_count] = cast(i32)bits;
field_count++;
curr_offset += bits;
curr_offset += cast(i32)bits;
}
}
GB_ASSERT(field_count <= bft->fields.count);
bit_field_type->BitField.fields = fields;
bit_field_type->BitField.field_count = field_count;
bit_field_type->BitField.field_count = cast(i32)field_count;
bit_field_type->BitField.sizes = sizes;
bit_field_type->BitField.offsets = offsets;
@@ -2180,7 +2180,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
if (scope != nullptr) {
for_array(i, scope->elements.entries) {
Entity *e = scope->elements.entries[i].value;
if (e->kind == Type_Named) {
if (e->kind == Entity_TypeName) {
Type *t = e->type;
if (t->kind == Type_Generic &&
t->Generic.specialized != nullptr) {
@@ -2523,9 +2523,9 @@ bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array
type->Proc.node = proc_type_node;
type->Proc.scope = c->context.scope;
type->Proc.params = params;
type->Proc.param_count = param_count;
type->Proc.param_count = cast(i32)param_count;
type->Proc.results = results;
type->Proc.result_count = result_count;
type->Proc.result_count = cast(i32)result_count;
type->Proc.variadic = variadic;
type->Proc.calling_convention = pt->calling_convention;
type->Proc.is_polymorphic = pt->generic;
@@ -3341,12 +3341,12 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type
i64 s = 8*type_size_of(c->allocator, type);
u128 umax = U128_NEG_ONE;
if (s < 128) {
umax = u128_sub(u128_shl(U128_ONE, s), U128_ONE);
umax = u128_sub(u128_shl(U128_ONE, cast(u32)s), U128_ONE);
} else {
// IMPORTANT TODO(bill): I NEED A PROPER BIG NUMBER LIBRARY THAT CAN SUPPORT 128 bit floats
s = 128;
}
i128 imax = i128_shl(I128_ONE, s-1ll);
i128 imax = i128_shl(I128_ONE, cast(u32)s-1);
switch (type->Basic.kind) {
case Basic_rune:
@@ -4399,8 +4399,8 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level
defer (gb_temp_arena_memory_end(tmp));
isize count = t->Union.variants.count;
ValidIndexAndScore *valids = gb_alloc_array(c->tmp_allocator, ValidIndexAndScore, count);
i32 valid_count = 0;
i32 first_success_index = -1;
isize valid_count = 0;
isize first_success_index = -1;
for_array(i, t->Union.variants) {
Type *vt = t->Union.variants[i];
i64 score = 0;
@@ -5693,7 +5693,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
gbAllocator a = c->allocator;
Type *tuple = make_type_tuple(a);
i32 variable_count = type->Struct.fields.count;
isize variable_count = type->Struct.fields.count;
array_init_count(&tuple->Tuple.variables, a, variable_count);
// TODO(bill): Should I copy each of the entities or is this good enough?
gb_memcopy_array(tuple->Tuple.variables.data, type->Struct.fields_in_src_order.data, variable_count);

6
src/check_stmt.cpp
View File

@@ -4,7 +4,7 @@ void check_stmt_list(Checker *c, Array<AstNode *> stmts, u32 flags) {
}
if (flags&Stmt_CheckScopeDecls) {
check_scope_decls(c, stmts, 1.2*stmts.count);
check_scope_decls(c, stmts, cast(isize)(1.2*stmts.count));
}
bool ft_ok = (flags & Stmt_FallthroughAllowed) != 0;
@@ -265,9 +265,9 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) {
u128 u = *cast(u128 *)&i;
u128 umax = U128_NEG_ONE;
if (lhs_bits < 128) {
umax = u128_sub(u128_shl(U128_ONE, lhs_bits), U128_ONE);
umax = u128_sub(u128_shl(U128_ONE, cast(u32)lhs_bits), U128_ONE);
}
i128 imax = i128_shl(I128_ONE, lhs_bits-1ll);
i128 imax = i128_shl(I128_ONE, cast(u32)lhs_bits-1);
bool ok = false;
ok = !(u128_lt(u, U128_ZERO) || u128_gt(u, umax));

2
src/checker.cpp
View File

@@ -267,7 +267,7 @@ struct DelayedDecl {
};
struct CheckerFileNode {
i32 id;
isize id;
Array<i32> wheres;
Array<i32> whats;
i32 score; // Higher the score, the better

27
src/common.cpp
View File

@@ -199,7 +199,19 @@ gbAllocator pool_allocator(Pool *pool) {
i32 next_pow2(i32 n) {
if (n <= 0) {
return 0;
}
n--;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n++;
return n;
}
i64 next_pow2(i64 n) {
if (n <= 0) {
return 0;
@@ -215,6 +227,17 @@ i64 next_pow2(i64 n) {
return n;
}
i32 prev_pow2(i32 n) {
if (n <= 0) {
return 0;
}
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return n - (n >> 1);
}
i64 prev_pow2(i64 n) {
if (n <= 0) {
return 0;
@@ -310,7 +333,7 @@ f64 gb_sqrt(f64 x) {
wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
u32 i, j;
u32 len = string16_len(cmd_line);
u32 len = cast(u32)string16_len(cmd_line);
i = ((len+2)/2)*gb_size_of(void *) + gb_size_of(void *);
wchar_t **argv = cast(wchar_t **)GlobalAlloc(GMEM_FIXED, i + (len+2)*gb_size_of(wchar_t));

24
src/exact_value.cpp
View File

@@ -504,19 +504,19 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y)
i128 b = y.value_integer;
i128 c = I128_ZERO;
switch (op) {
case Token_Add: c = a + b; break;
case Token_Sub: c = a - b; break;
case Token_Mul: c = a * b; break;
case Token_Add: c = a + b; break;
case Token_Sub: c = a - b; break;
case Token_Mul: c = a * b; break;
case Token_Quo: return exact_value_float(fmod(i128_to_f64(a), i128_to_f64(b)));
case Token_QuoEq: c = a / b; break; // NOTE(bill): Integer division
case Token_Mod: c = a % b; break;
case Token_ModMod: c = ((a % b) + b) % b; break;
case Token_And: c = a & b; break;
case Token_Or: c = a | b; break;
case Token_Xor: c = a ^ b; break;
case Token_AndNot: c = i128_and_not(a, b); break;
case Token_Shl: c = a << i128_to_u64(b); break;
case Token_Shr: c = a >> i128_to_u64(b); break;
case Token_QuoEq: c = a / b; break; // NOTE(bill): Integer division
case Token_Mod: c = a % b; break;
case Token_ModMod: c = ((a % b) + b) % b; break;
case Token_And: c = a & b; break;
case Token_Or: c = a | b; break;
case Token_Xor: c = a ^ b; break;
case Token_AndNot: c = i128_and_not(a, b); break;
case Token_Shl: c = a << cast(u32)i128_to_u64(b); break;
case Token_Shr: c = a >> cast(u32)i128_to_u64(b); break;
default: goto error;
}

14
src/gb/gb.h
View File

@@ -985,7 +985,7 @@ typedef struct gbThread {
} gbThread;
GB_DEF void gb_thread_init (gbThread *t);
GB_DEF void gb_thread_destory (gbThread *t);
GB_DEF void gb_thread_destroy (gbThread *t);
GB_DEF void gb_thread_start (gbThread *t, gbThreadProc *proc, void *data);
GB_DEF void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void *data, isize stack_size);
GB_DEF void gb_thread_join (gbThread *t);
@@ -4698,7 +4698,7 @@ void gb_thread_init(gbThread *t) {
gb_semaphore_init(&t->semaphore);
}
void gb_thread_destory(gbThread *t) {
void gb_thread_destroy(gbThread *t) {
if (t->is_running) gb_thread_join(t);
gb_semaphore_destroy(&t->semaphore);
}
@@ -7472,13 +7472,13 @@ u64 gb_murmur64_seed(void const *data_, isize len, u64 seed) {
if (w_len_) *w_len_ = w_len;
return NULL;
}
w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, NULL, 0);
w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, NULL, 0);
if (w_len == 0) {
if (w_len_) *w_len_ = w_len;
return NULL;
}
w_text = gb_alloc_array(a, wchar_t, w_len+1);
w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, w_text, w_len);
w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, w_text, cast(int)w_len);
if (w_len1 == 0) {
gb_free(a, w_text);
if (w_len_) *w_len_ = 0;
@@ -8126,17 +8126,17 @@ char *gb_path_get_full_name(gbAllocator a, char const *path) {
return NULL;
}
w_fullpath = gb_alloc_array(gb_heap_allocator(), wchar_t, w_len+1);
GetFullPathNameW(w_path, w_len, w_fullpath, NULL);
GetFullPathNameW(w_path, cast(int)w_len, w_fullpath, NULL);
w_fullpath[w_len] = 0;
gb_free(gb_heap_allocator(), w_path);
new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, NULL, 0, NULL, NULL);
new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, NULL, 0, NULL, NULL);
if (new_len == 0) {
gb_free(gb_heap_allocator(), w_fullpath);
return NULL;
}
new_path = gb_alloc_array(a, char, new_len+1);
new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, new_path, new_len, NULL, NULL);
new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, new_path, cast(int)new_len, NULL, NULL);
if (new_len1 == 0) {
gb_free(gb_heap_allocator(), w_fullpath);
gb_free(a, new_path);

74
src/ir.cpp
View File

@@ -13,7 +13,7 @@ struct irModule {
gbAllocator tmp_allocator;
// bool generate_debug_info;
u32 stmt_state_flags;
u64 stmt_state_flags;
// String source_filename;
String layout;
@@ -442,7 +442,7 @@ irAddr ir_addr_map(irValue *addr, irValue *map_key, Type *map_type, Type *map_re
return v;
}
irAddr ir_addr_bit_field(irValue *addr, isize bit_field_value_index) {
irAddr ir_addr_bit_field(irValue *addr, i32 bit_field_value_index) {
irAddr v = {irAddr_BitField, addr};
v.bit_field_value_index = bit_field_value_index;
return v;
@@ -3435,7 +3435,7 @@ irValue *ir_type_info(irProcedure *proc, Type *type) {
type = default_type(type);
i32 entry_index = type_info_index(info, type);
i32 entry_index = cast(i32)type_info_index(info, type);
// gb_printf_err("%d %s\n", entry_index, type_to_string(type));
@@ -4454,7 +4454,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
Entity *field = t->Struct.fields_in_src_order[src_index];
i32 field_index = field->Variable.field_index;
irValue *f = ir_emit_struct_ev(proc, s, field_index);
irValue *ep = ir_emit_struct_ep(proc, tuple, src_index);
irValue *ep = ir_emit_struct_ep(proc, tuple, cast(i32)src_index);
ir_emit_store(proc, ep, f);
}
return ir_emit_load(proc, tuple);
@@ -4901,7 +4901,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) {
if (at->kind == Type_Tuple) {
for_array(i, at->Tuple.variables) {
Entity *e = at->Tuple.variables[i];
irValue *v = ir_emit_struct_ev(proc, a, i);
irValue *v = ir_emit_struct_ev(proc, a, cast(i32)i);
args[arg_index++] = v;
}
} else {
@@ -5001,7 +5001,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) {
irValue *base_array = ir_add_local_generated(proc, make_type_array(allocator, elem_type, slice_len));
for (isize i = type->param_count-1, j = 0; i < arg_count; i++, j++) {
irValue *addr = ir_emit_array_epi(proc, base_array, j);
irValue *addr = ir_emit_array_epi(proc, base_array, cast(i32)j);
ir_emit_store(proc, addr, args[i]);
}
@@ -5497,7 +5497,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
isize index_count = bt->Vector.count;
irValue *elem_val = ir_build_expr(proc, cl->elems[0]);
for (isize i = 0; i < index_count; i++) {
ir_emit_store(proc, ir_emit_array_epi(proc, v, i), elem_val);
ir_emit_store(proc, ir_emit_array_epi(proc, v, cast(i32)i), elem_val);
}
} else if (cl->elems.count > 0) {
ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr)));
@@ -5510,7 +5510,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
Type *t = ir_type(field_expr);
GB_ASSERT(t->kind != Type_Tuple);
irValue *ev = ir_emit_conv(proc, field_expr, et);
irValue *gep = ir_emit_array_epi(proc, v, i);
irValue *gep = ir_emit_array_epi(proc, v, cast(i32)i);
ir_emit_store(proc, gep, ev);
}
}
@@ -5556,7 +5556,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple);
irValue *fv = ir_emit_conv(proc, field_expr, ft);
irValue *gep = ir_emit_struct_ep(proc, v, index);
irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
ir_emit_store(proc, gep, fv);
}
}
@@ -5585,7 +5585,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
for_array(field_index, cl->elems) {
AstNode *f = cl->elems[field_index];
irValue *value = ir_emit_conv(proc, ir_build_expr(proc, f), elem);
irValue *ep = ir_emit_array_epi(proc, items, field_index);
irValue *ep = ir_emit_array_epi(proc, items, cast(i32)field_index);
ir_emit_store(proc, ep, value);
}
@@ -5633,7 +5633,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
Type *t = ir_type(field_expr);
GB_ASSERT(t->kind != Type_Tuple);
irValue *ev = ir_emit_conv(proc, field_expr, et);
irValue *gep = ir_emit_array_epi(proc, v, i);
irValue *gep = ir_emit_array_epi(proc, v, cast(i32)i);
ir_emit_store(proc, gep, ev);
}
}
@@ -5703,7 +5703,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
Type *ft = field_types[index];
irValue *fv = ir_emit_conv(proc, field_expr, ft);
irValue *gep = ir_emit_struct_ep(proc, v, index);
irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index);
ir_emit_store(proc, gep, fv);
}
}
@@ -5936,11 +5936,11 @@ void ir_build_stmt_list(irProcedure *proc, Array<AstNode *> stmts) {
void ir_build_stmt_internal(irProcedure *proc, AstNode *node);
void ir_build_stmt(irProcedure *proc, AstNode *node) {
u32 prev_stmt_state_flags = proc->module->stmt_state_flags;
u64 prev_stmt_state_flags = proc->module->stmt_state_flags;
if (node->stmt_state_flags != 0) {
u32 in = node->stmt_state_flags;
u32 out = proc->module->stmt_state_flags;
u64 in = node->stmt_state_flags;
u64 out = proc->module->stmt_state_flags;
if (in & StmtStateFlag_bounds_check) {
out |= StmtStateFlag_bounds_check;
@@ -6285,7 +6285,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
if (t->kind == Type_Tuple) {
for_array(i, t->Tuple.variables) {
Entity *e = t->Tuple.variables[i];
irValue *v = ir_emit_struct_ev(proc, init, i);
irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
array_add(&inits, v);
}
} else {
@@ -6350,7 +6350,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
if (t->kind == Type_Tuple) {
for_array(i, t->Tuple.variables) {
Entity *e = t->Tuple.variables[i];
irValue *v = ir_emit_struct_ev(proc, init, i);
irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i);
array_add(&inits, v);
}
} else {
@@ -6445,7 +6445,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
Type *ret_type = proc->type->Proc.results;
v = ir_add_local_generated(proc, ret_type);
for_array(i, results) {
irValue *field = ir_emit_struct_ep(proc, v, i);
irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i);
irValue *res = results[i];
ir_emit_store(proc, field, res);
}
@@ -6481,7 +6481,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
if (t->kind == Type_Tuple) {
for_array(i, t->Tuple.variables) {
Entity *e = t->Tuple.variables[i];
irValue *v = ir_emit_struct_ev(proc, res, i);
irValue *v = ir_emit_struct_ev(proc, res, cast(i32)i);
array_add(&results, v);
total_index++;
}
@@ -6509,7 +6509,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
for_array(i, results) {
Entity *e = tuple->variables[i];
irValue *res = ir_emit_conv(proc, results[i], e->type);
irValue *field = ir_emit_struct_ep(proc, v, i);
irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i);
ir_emit_store(proc, field, res);
}
@@ -7111,7 +7111,7 @@ void ir_number_proc_registers(irProcedure *proc) {
i32 reg_index = 0;
for_array(i, proc->blocks) {
irBlock *b = proc->blocks[i];
b->index = i;
b->index = cast(i32)i;
for_array(j, b->instrs) {
irValue *value = b->instrs[j];
GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name));
@@ -7255,11 +7255,11 @@ void ir_build_proc(irValue *value, irProcedure *parent) {
}
if (proc->body != nullptr) {
u32 prev_stmt_state_flags = proc->module->stmt_state_flags;
u64 prev_stmt_state_flags = proc->module->stmt_state_flags;
if (proc->tags != 0) {
u32 in = proc->tags;
u32 out = proc->module->stmt_state_flags;
u64 in = proc->tags;
u64 out = proc->module->stmt_state_flags;
if (in & ProcTag_bounds_check) {
out |= StmtStateFlag_bounds_check;
out &= ~StmtStateFlag_no_bounds_check;
@@ -7483,22 +7483,22 @@ irValue *ir_get_type_info_ptr(irProcedure *proc, Type *type) {
irValue *ir_type_info_member_types_offset(irProcedure *proc, isize count) {
irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_types, ir_global_type_info_member_types_index);
ir_global_type_info_member_types_index += count;
ir_global_type_info_member_types_index += cast(i32)count;
return offset;
}
irValue *ir_type_info_member_names_offset(irProcedure *proc, isize count) {
irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_names, ir_global_type_info_member_names_index);
ir_global_type_info_member_names_index += count;
ir_global_type_info_member_names_index += cast(i32)count;
return offset;
}
irValue *ir_type_info_member_offsets_offset(irProcedure *proc, isize count) {
irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_offsets, ir_global_type_info_member_offsets_index);
ir_global_type_info_member_offsets_index += count;
ir_global_type_info_member_offsets_index += cast(i32)count;
return offset;
}
irValue *ir_type_info_member_usings_offset(irProcedure *proc, isize count) {
irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_usings, ir_global_type_info_member_usings_index);
ir_global_type_info_member_usings_index += count;
ir_global_type_info_member_usings_index += cast(i32)count;
return offset;
}
@@ -7706,7 +7706,7 @@ void ir_gen_tree(irGen *s) {
for_array(i, m->debug_info.entries) {
auto *entry = &m->debug_info.entries[i];
irDebugInfo *di = entry->value;
di->id = i;
di->id = cast(i32)i;
if (di->kind == irDebugInfo_Proc) {
all_proc_max_count++;
}
@@ -7942,7 +7942,7 @@ void ir_gen_tree(irGen *s) {
isize entry_index = type_info_index(info, t);
irValue *tag = nullptr;
irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, entry_index);
irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, cast(i32)entry_index);
irValue *variant_ptr = ir_emit_struct_ep(proc, ti_ptr, 2);
ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(a, type_size_of(a, t)));
@@ -8134,8 +8134,8 @@ void ir_gen_tree(irGen *s) {
}
for (isize i = 0; i < count; i++) {
irValue *name_ep = ir_emit_array_epi(proc, name_array, i);
irValue *value_ep = ir_emit_array_epi(proc, value_array, i);
irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i);
irValue *value_ep = ir_emit_array_epi(proc, value_array, cast(i32)i);
ExactValue value = fields[i]->Constant.value;
irValue *v = ir_value_constant(a, t->Enum.base_type, value);
@@ -8202,7 +8202,7 @@ void ir_gen_tree(irGen *s) {
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 7), is_custom_align);
}
i32 count = t->Struct.fields.count;
isize count = t->Struct.fields.count;
irValue *memory_types = ir_type_info_member_types_offset (proc, count);
irValue *memory_names = ir_type_info_member_names_offset (proc, count);
@@ -8271,9 +8271,9 @@ void ir_gen_tree(irGen *s) {
Entity *f = fields[i];
GB_ASSERT(f->type != nullptr);
GB_ASSERT(f->type->kind == Type_BitFieldValue);
irValue *name_ep = ir_emit_array_epi(proc, name_array, i);
irValue *bit_ep = ir_emit_array_epi(proc, bit_array, i);
irValue *offset_ep = ir_emit_array_epi(proc, offset_array, i);
irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i);
irValue *bit_ep = ir_emit_array_epi(proc, bit_array, cast(i32)i);
irValue *offset_ep = ir_emit_array_epi(proc, offset_array, cast(i32)i);
ir_emit_store(proc, name_ep, ir_const_string(a, f->token.string));
ir_emit_store(proc, bit_ep, ir_const_u32(a, f->type->BitFieldValue.bits));
@@ -8336,7 +8336,7 @@ void ir_gen_tree(irGen *s) {
for_array(i, m->debug_info.entries) {
auto *entry = &m->debug_info.entries[i];
irDebugInfo *di = entry->value;
di->id = i;
di->id = cast(i32)i;
}

4
src/ir_opt.cpp
View File

@@ -172,7 +172,7 @@ void ir_remove_dead_blocks(irProcedure *proc) {
continue;
}
// NOTE(bill): Swap order
b->index = j;
b->index = cast(i32)j;
proc->blocks[j++] = b;
}
proc->blocks.count = j;
@@ -373,7 +373,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) {
gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena);
isize n = proc->blocks.count;
i32 n = cast(i32)proc->blocks.count;
irBlock **buf = gb_alloc_array(proc->module->tmp_allocator, irBlock *, 5*n);
irLTState lt = {0};

2
src/ir_print.cpp
View File

@@ -686,7 +686,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *
ir_write_string(f, "zeroinitializer");
} else {
if (is_type_struct(type)) {
i32 value_count = type->Struct.fields.count;
i32 value_count = cast(i32)type->Struct.fields.count;
if (type->Struct.is_packed) ir_write_byte(f, '<');
ir_write_byte(f, '{');
if (type->Struct.custom_align > 0) {

2
src/main.cpp
View File

@@ -542,7 +542,7 @@ int main(int arg_count, char **arg_ptr) {
String output_name = ir_gen.output_name;
String output_base = ir_gen.output_base;
int base_name_len = output_base.len;
int base_name_len = cast(int)output_base.len;
build_context.optimization_level = gb_clamp(build_context.optimization_level, 0, 3);

13
src/parser.cpp
View File

@@ -36,7 +36,7 @@ struct ImportedFile {
struct AstFile {
i32 id;
isize id;
gbArena arena;
Tokenizer tokenizer;
Array<Token> tokens;
@@ -1574,7 +1574,7 @@ AstNode *ast_foreign_library_spec(AstFile *f, Token filepath, Token library_name
bool next_token0(AstFile *f) {
Token prev = f->curr_token;
// Token prev = f->curr_token;
if (f->curr_token_index+1 < f->tokens.count) {
f->curr_token = f->tokens[++f->curr_token_index];
return true;
@@ -1675,10 +1675,9 @@ TokenKind look_ahead_token_kind(AstFile *f, isize amount) {
Token expect_token(AstFile *f, TokenKind kind) {
Token prev = f->curr_token;
if (prev.kind != kind) {
String c = token_strings[kind];
String p = token_strings[prev.kind];
syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`",
LIT(token_strings[kind]),
LIT(token_strings[prev.kind]));
syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", LIT(c), LIT(p));
if (prev.kind == Token_EOF) {
gb_exit(1);
}
@@ -5122,7 +5121,7 @@ ParseFileError parse_files(Parser *p, String init_filename) {
} else if (p->curr_import_index < p->imports.count) {
if (t->return_value != 0) {
for_array(i, worker_threads) {
gb_thread_destory(&worker_threads[i]);
gb_thread_destroy(&worker_threads[i]);
}
return cast(ParseFileError)t->return_value;
}
@@ -5137,7 +5136,7 @@ ParseFileError parse_files(Parser *p, String init_filename) {
}
for_array(i, worker_threads) {
gb_thread_destory(&worker_threads[i]);
gb_thread_destroy(&worker_threads[i]);
}
} else {
for_array(i, p->imports) {

12
src/ssa.cpp
View File

@@ -1640,18 +1640,18 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) {
i64 s = 8*type_size_of(p->allocator, t);
switch (s) {
case 8: return ssa_const_i8 (p, tv.type, i128_to_i64(tv.value.value_integer));
case 16: return ssa_const_i16(p, tv.type, i128_to_i64(tv.value.value_integer));
case 32: return ssa_const_i32(p, tv.type, i128_to_i64(tv.value.value_integer));
case 64: return ssa_const_i64(p, tv.type, i128_to_i64(tv.value.value_integer));
case 8: return ssa_const_i8 (p, tv.type, cast (i8)i128_to_i64(tv.value.value_integer));
case 16: return ssa_const_i16(p, tv.type, cast(i16)i128_to_i64(tv.value.value_integer));
case 32: return ssa_const_i32(p, tv.type, cast(i32)i128_to_i64(tv.value.value_integer));
case 64: return ssa_const_i64(p, tv.type, cast(i64)i128_to_i64(tv.value.value_integer));
default: GB_PANIC("Unknown integer size");
}
} else if (is_type_float(t)) {
GB_ASSERT(tv.value.kind == ExactValue_Float);
i64 s = 8*type_size_of(p->allocator, t);
switch (s) {
case 32: return ssa_const_f32(p, tv.type, tv.value.value_float);
case 64: return ssa_const_f64(p, tv.type, tv.value.value_float);
case 32: return ssa_const_f32(p, tv.type, cast(f32)tv.value.value_float);
case 64: return ssa_const_f64(p, tv.type, cast(f64)tv.value.value_float);
default: GB_PANIC("Unknown float size");
}
}

9
src/string.cpp
View File

@@ -196,7 +196,6 @@ gb_inline bool str_has_prefix(String s, String prefix) {
gb_inline isize string_extension_position(String str) {
isize dot_pos = -1;
isize i = str.len;
bool seen_dot = false;
while (i --> 0) {
if (str[i] == GB_PATH_SEPARATOR)
break;
@@ -317,14 +316,14 @@ String16 string_to_string16(gbAllocator a, String s) {
return make_string16(nullptr, 0);
}
len = convert_multibyte_to_widechar(cast(char *)s.text, s.len, nullptr, 0);
len = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, nullptr, 0);
if (len == 0) {
return make_string16(nullptr, 0);
}
text = gb_alloc_array(a, wchar_t, len+1);
len1 = convert_multibyte_to_widechar(cast(char *)s.text, s.len, text, len);
len1 = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, text, cast(int)len);
if (len1 == 0) {
gb_free(a, text);
return make_string16(nullptr, 0);
@@ -343,7 +342,7 @@ String string16_to_string(gbAllocator a, String16 s) {
return make_string(nullptr, 0);
}
len = convert_widechar_to_multibyte(s.text, s.len, nullptr, 0);
len = convert_widechar_to_multibyte(s.text, cast(int)s.len, nullptr, 0);
if (len == 0) {
return make_string(nullptr, 0);
}
@@ -351,7 +350,7 @@ String string16_to_string(gbAllocator a, String16 s) {
text = gb_alloc_array(a, u8, len+1);
len1 = convert_widechar_to_multibyte(s.text, s.len, cast(char *)text, len);
len1 = convert_widechar_to_multibyte(s.text, cast(int)s.len, cast(char *)text, cast(int)len);
if (len1 == 0) {
gb_free(a, text);
return make_string(nullptr, 0);

12
src/types.cpp
View File

@@ -551,9 +551,9 @@ Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_coun
t->Proc.scope = scope;
t->Proc.params = params;
t->Proc.param_count = param_count;
t->Proc.param_count = cast(i32)param_count;
t->Proc.results = results;
t->Proc.result_count = result_count;
t->Proc.result_count = cast(i32)result_count;
t->Proc.variadic = variadic;
t->Proc.calling_convention = calling_convention;
return t;
@@ -1400,7 +1400,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
GB_ASSERT(is_type_struct(type) || is_type_union(type) || is_type_tuple(type));
type = base_type(type);
i64 max_count = 0;
isize max_count = 0;
switch (type->kind) {
case Type_Struct: max_count = type->Struct.fields.count; break;
case Type_Tuple: max_count = type->Tuple.variables.count; break;
@@ -1419,7 +1419,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
if (f->Variable.field_src_index == index) {
Array<i32> sel_array = {0};
array_init_count(&sel_array, a, 1);
sel_array[0] = i;
sel_array[0] = cast(i32)i;
return make_selection(f, sel_array, false);
}
}
@@ -1431,7 +1431,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
if (i == index) {
Array<i32> sel_array = {0};
array_init_count(&sel_array, a, 1);
sel_array[0] = i;
sel_array[0] = cast(i32)i;
return make_selection(f, sel_array, false);
}
}
@@ -2192,7 +2192,7 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s
Type *t = type;
i64 offset = 0;
for_array(i, sel.index) {
isize index = sel.index[i];
i32 index = sel.index[i];
t = base_type(t);
offset += type_offset_of(allocator, t, index);
if (t->kind == Type_Struct && !t->Struct.is_raw_union) {