mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-06-07 02:54:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Minimize unneeded casts

Browse Source
This commit is contained in:
gingerBill
2021-03-03 14:31:17 +00:00
parent 75f127af7c
commit b727b6438b
24 changed files with 108 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
core/fmt/fmt.odin
View File

@@ -1169,7 +1169,7 @@ fmt_bit_set :: proc(fi: ^Info, v: any, name: string = "") {
case 128:
x := (^u128)(v.data)^;
if do_byte_swap { x = byte_swap(x); }
bits = u128(x);
bits = x;
case: panic("unknown bit_size size");
}
@@ -1389,7 +1389,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
t := a;
y, mon, d := time.date(t);
h, min, s := time.clock(t);
ns := i64(t._nsec - (t._nsec/1e9 + time.UNIX_TO_ABSOLUTE)*1e9) % 1e9;
ns := (t._nsec - (t._nsec/1e9 + time.UNIX_TO_ABSOLUTE)*1e9) % 1e9;
write_padded_number(fi, i64(y), 4);
io.write_byte(fi.writer, '-');
write_padded_number(fi, i64(mon), 2);
@@ -1403,7 +1403,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
io.write_byte(fi.writer, ':');
write_padded_number(fi, i64(s), 2);
io.write_byte(fi.writer, '.');
write_padded_number(fi, i64(ns), 9);
write_padded_number(fi, (ns), 9);
io.write_string(fi.writer, " +0000 UTC");
return;
}
@@ -1842,7 +1842,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
case u32: tag = i64(i);
case i32: tag = i64(i);
case u64: tag = i64(i);
case i64: tag = i64(i);
case i64: tag = i;
case: panic("Invalid union tag type");
}
assert(tag >= 0);
@@ -2014,7 +2014,7 @@ fmt_arg :: proc(fi: ^Info, arg: any, verb: rune) {
base_arg := arg;
base_arg.id = runtime.typeid_base(base_arg.id);
switch a in base_arg {
case bool: fmt_bool(fi, bool(a), verb);
case bool: fmt_bool(fi, a, verb);
case b8: fmt_bool(fi, bool(a), verb);
case b16: fmt_bool(fi, bool(a), verb);
case b32: fmt_bool(fi, bool(a), verb);
@@ -2045,7 +2045,7 @@ fmt_arg :: proc(fi: ^Info, arg: any, verb: rune) {
case i32: fmt_int(fi, u64(a), true, 32, verb);
case u32: fmt_int(fi, u64(a), false, 32, verb);
case i64: fmt_int(fi, u64(a), true, 64, verb);
case u64: fmt_int(fi, u64(a), false, 64, verb);
case u64: fmt_int(fi, a, false, 64, verb);
case int: fmt_int(fi, u64(a), true, 8*size_of(int), verb);
case uint: fmt_int(fi, u64(a), false, 8*size_of(uint), verb);
case uintptr: fmt_int(fi, u64(a), false, 8*size_of(uintptr), verb);
@@ -2070,7 +2070,7 @@ fmt_arg :: proc(fi: ^Info, arg: any, verb: rune) {
case u64be: fmt_int(fi, u64(a), false, 64, verb);
case i128: fmt_int_128(fi, u128(a), true, 128, verb);
case u128: fmt_int_128(fi, u128(a), false, 128, verb);
case u128: fmt_int_128(fi, a, false, 128, verb);
case i128le: fmt_int_128(fi, u128(a), true, 128, verb);
case u128le: fmt_int_128(fi, u128(a), false, 128, verb);

2
core/io/io.odin
View File

@@ -290,7 +290,7 @@ write_byte :: proc{
};
write_byte_to_byte_writer :: proc(w: Byte_Writer, c: byte) -> Error {
return _write_byte(auto_cast w, c);
return _write_byte(w, c);
}
write_byte_to_writer :: proc(w: Writer, c: byte) -> Error {

2
core/io/util.odin
View File

@@ -4,7 +4,7 @@ import "core:strconv"
write_u64 :: proc(w: Writer, i: u64, base: int = 10) -> (n: int, err: Error) {
buf: [32]byte;
s := strconv.append_bits(buf[:], u64(i), base, false, 64, strconv.digits, nil);
s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil);
return write_string(w, s);
}
write_i64 :: proc(w: Writer, i: i64, base: int = 10) -> (n: int, err: Error) {

8
core/math/bits/bits.odin
View File

@@ -65,13 +65,13 @@ leading_zeros_u64 :: proc(i: u64) -> int {
byte_swap_u16 :: proc(x: u16) -> u16 {
return u16(runtime.bswap_16(u16(x)));
return runtime.bswap_16(x);
}
byte_swap_u32 :: proc(x: u32) -> u32 {
return u32(runtime.bswap_32(u32(x)));
return runtime.bswap_32(x);
}
byte_swap_u64 :: proc(x: u64) -> u64 {
return u64(runtime.bswap_64(u64(x)));
return runtime.bswap_64(x);
}
byte_swap_i16 :: proc(x: i16) -> i16 {
return i16(runtime.bswap_16(u16(x)));
@@ -83,7 +83,7 @@ byte_swap_i64 :: proc(x: i64) -> i64 {
return i64(runtime.bswap_64(u64(x)));
}
byte_swap_u128 :: proc(x: u128) -> u128 {
return u128(runtime.bswap_128(u128(x)));
return runtime.bswap_128(x);
}
byte_swap_i128 :: proc(x: i128) -> i128 {
return i128(runtime.bswap_128(u128(x)));

18
core/mem/allocators.odin
View File

@@ -203,7 +203,7 @@ size := size;
old_ptr := uintptr(old_memory);
if s.prev_allocation == old_memory {
s.curr_offset = int(uintptr(s.prev_allocation) - uintptr(start));
s.curr_offset = int(uintptr(s.prev_allocation) - start);
s.prev_allocation = nil;
return nil;
}
@@ -319,8 +319,8 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
next_addr := curr_addr + uintptr(padding);
header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header));
header.padding = auto_cast padding;
header.prev_offset = auto_cast s.prev_offset;
header.padding = padding;
header.prev_offset = s.prev_offset;
s.curr_offset += size;
@@ -352,12 +352,12 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header));
old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data)));
if old_offset != int(header.prev_offset) {
if old_offset != header.prev_offset {
panic("Out of order stack allocator free");
}
s.curr_offset = int(old_offset);
s.prev_offset = int(header.prev_offset);
s.curr_offset = old_offset;
s.prev_offset = header.prev_offset;
case .Free_All:
@@ -391,7 +391,7 @@ stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
header := (^Stack_Allocation_Header)(curr_addr - size_of(Stack_Allocation_Header));
old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data)));
if old_offset != int(header.prev_offset) {
if old_offset != header.prev_offset {
ptr := raw_alloc(s, size, alignment);
copy(ptr, old_memory, min(old_size, size));
return ptr;
@@ -504,7 +504,7 @@ small_stack_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header));
old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data)));
s.offset = int(old_offset);
s.offset = old_offset;
case .Free_All:
s.offset = 0;
@@ -838,7 +838,7 @@ Tracking_Allocator_Entry :: struct {
}
Tracking_Allocator_Bad_Free_Entry :: struct {
memory: rawptr,
location: runtime.Source_Code_Location,
location: runtime.Source_Code_Location,
}
Tracking_Allocator :: struct {
backing: Allocator,

3
core/mem/mem.odin
View File

@@ -263,8 +263,7 @@ align_formula :: proc(size, align: int) -> int {
}
calc_padding_with_header :: proc(ptr: uintptr, align: uintptr, header_size: int) -> int {
p := uintptr(ptr);
a := uintptr(align);
p, a := ptr, align;
modulo := p & (a-1);
padding := uintptr(0);

6
core/os/file_windows.odin
View File

@@ -27,7 +27,7 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Errn
access |= win32.FILE_GENERIC_WRITE;
}
share_mode := u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
share_mode := win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE;
sa: ^win32.SECURITY_ATTRIBUTES = nil;
sa_inherit := win32.SECURITY_ATTRIBUTES{nLength = size_of(win32.SECURITY_ATTRIBUTES), bInheritHandle = true};
if mode&O_CLOEXEC == 0 {
@@ -48,7 +48,7 @@ open :: proc(path: string, mode: int = O_RDONLY, perm: int = 0) -> (Handle, Errn
create_mode = win32.OPEN_EXISTING;
}
wide_path := win32.utf8_to_wstring(path);
handle := Handle(win32.CreateFileW(auto_cast wide_path, access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL|win32.FILE_FLAG_BACKUP_SEMANTICS, nil));
handle := Handle(win32.CreateFileW(wide_path, access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL|win32.FILE_FLAG_BACKUP_SEMANTICS, nil));
if handle != INVALID_HANDLE {
return handle, ERROR_NONE;
}
@@ -107,7 +107,7 @@ read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
for total_read < length {
remaining := length - total_read;
to_read := win32.DWORD(min(u32(remaining), MAX_RW));
to_read := min(win32.DWORD(remaining), MAX_RW);
e := win32.ReadFile(win32.HANDLE(fd), &data[total_read], to_read, &single_read_length, nil);
if single_read_length <= 0 || !e {

2
core/os/os_windows.odin
View File

@@ -79,7 +79,7 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
data: win32.WIN32_FILE_ATTRIBUTE_DATA;
wide_path := win32.utf8_to_wstring(name);
if !win32.GetFileAttributesExW(auto_cast wide_path, win32.GetFileExInfoStandard, &data) {
if !win32.GetFileAttributesExW(wide_path, win32.GetFileExInfoStandard, &data) {
return 0, Errno(win32.GetLastError());
}

4
core/os/stat_windows.odin
View File

@@ -68,13 +68,13 @@ _stat :: proc(name: string, create_file_attributes: u32, allocator := context.al
lstat :: proc(name: string, allocator := context.allocator) -> (File_Info, Errno) {
attrs := u32(win32.FILE_FLAG_BACKUP_SEMANTICS);
attrs := win32.FILE_FLAG_BACKUP_SEMANTICS;
attrs |= win32.FILE_FLAG_OPEN_REPARSE_POINT;
return _stat(name, attrs, allocator);
}
stat :: proc(name: string, allocator := context.allocator) -> (File_Info, Errno) {
attrs := u32(win32.FILE_FLAG_BACKUP_SEMANTICS);
attrs := win32.FILE_FLAG_BACKUP_SEMANTICS;
return _stat(name, attrs, allocator);
}

84
core/reflect/reflect.odin
View File

@@ -597,7 +597,7 @@ union_variant_typeid :: proc(a: any) -> typeid {
case u32: tag = i64(i);
case i32: tag = i64(i);
case u64: tag = i64(i);
case i64: tag = i64(i);
case i64: tag = i;
case: unimplemented();
}
@@ -633,7 +633,7 @@ get_union_variant_raw_tag :: proc(a: any) -> i64 {
case u32: tag = i64(i);
case i32: tag = i64(i);
case u64: tag = i64(i);
case i64: tag = i64(i);
case i64: tag = i;
case: unimplemented();
}
@@ -664,7 +664,7 @@ set_union_variant_raw_tag :: proc(a: any, tag: i64) {
case u32: i = u32(tag);
case i32: i = i32(tag);
case u64: i = u64(tag);
case i64: i = i64(tag);
case i64: i = tag;
case: unimplemented();
}
@@ -744,7 +744,7 @@ as_bool :: proc(a: any) -> (value: bool, valid: bool) {
case Type_Info_Boolean:
valid = true;
switch v in a {
case bool: value = bool(v);
case bool: value = v;
case b8: value = bool(v);
case b16: value = bool(v);
case b32: value = bool(v);
@@ -783,7 +783,7 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
case i8: value = i64(v);
case i16: value = i64(v);
case i32: value = i64(v);
case i64: value = i64(v);
case i64: value = v;
case i128: value = i64(v);
case int: value = i64(v);
@@ -825,23 +825,23 @@ as_i64 :: proc(a: any) -> (value: i64, valid: bool) {
case Type_Info_Float:
valid = true;
switch v in a {
case f32: value = i64(f32(v));
case f64: value = i64(f64(v));
case f32le: value = i64(f32(v));
case f64le: value = i64(f64(v));
case f32be: value = i64(f32(v));
case f64be: value = i64(f64(v));
case f32: value = i64(v);
case f64: value = i64(v);
case f32le: value = i64(v);
case f64le: value = i64(v);
case f32be: value = i64(v);
case f64be: value = i64(v);
case: valid = false;
}
case Type_Info_Boolean:
valid = true;
switch v in a {
case bool: value = i64(bool(v));
case b8: value = i64(bool(v));
case b16: value = i64(bool(v));
case b32: value = i64(bool(v));
case b64: value = i64(bool(v));
case bool: value = i64(v);
case b8: value = i64(v);
case b16: value = i64(v);
case b32: value = i64(v);
case b64: value = i64(v);
case: valid = false;
}
@@ -897,7 +897,7 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
case u8: value = u64(v);
case u16: value = u64(v);
case u32: value = u64(v);
case u64: value = u64(v);
case u64: value = (v);
case u128: value = u64(v);
case uint: value = u64(v);
case uintptr:value = u64(v);
@@ -932,23 +932,23 @@ as_u64 :: proc(a: any) -> (value: u64, valid: bool) {
case Type_Info_Float:
valid = true;
switch v in a {
case f32: value = u64(f32(v));
case f64: value = u64(f64(v));
case f32le: value = u64(f32(v));
case f64le: value = u64(f64(v));
case f32be: value = u64(f32(v));
case f64be: value = u64(f64(v));
case f32: value = u64(v);
case f64: value = u64(v);
case f32le: value = u64(v);
case f64le: value = u64(v);
case f32be: value = u64(v);
case f64be: value = u64(v);
case: valid = false;
}
case Type_Info_Boolean:
valid = true;
switch v in a {
case bool: value = u64(bool(v));
case b8: value = u64(bool(v));
case b16: value = u64(bool(v));
case b32: value = u64(bool(v));
case b64: value = u64(bool(v));
case bool: value = u64(v);
case b8: value = u64(v);
case b16: value = u64(v);
case b32: value = u64(v);
case b64: value = u64(v);
case: valid = false;
}
@@ -1037,23 +1037,23 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
case Type_Info_Float:
valid = true;
switch v in a {
case f32: value = f64(f32(v));
case f64: value = f64(f64(v));
case f32le: value = f64(f32(v));
case f64le: value = f64(f64(v));
case f32be: value = f64(f32(v));
case f64be: value = f64(f64(v));
case f32: value = f64(v);
case f64: value = (v);
case f32le: value = f64(v);
case f64le: value = f64(v);
case f32be: value = f64(v);
case f64be: value = f64(v);
case: valid = false;
}
case Type_Info_Boolean:
valid = true;
switch v in a {
case bool: value = f64(i32(bool(v)));
case b8: value = f64(i32(bool(v)));
case b16: value = f64(i32(bool(v)));
case b32: value = f64(i32(bool(v)));
case b64: value = f64(i32(bool(v)));
case bool: value = f64(i32(v));
case b8: value = f64(i32(v));
case b16: value = f64(i32(v));
case b32: value = f64(i32(v));
case b64: value = f64(i32(v));
case: valid = false;
}
@@ -1066,7 +1066,7 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
}
case complex128:
if imag(v) == 0 {
value = f64(real(v));
value = real(v);
valid = true;
}
}
@@ -1080,7 +1080,7 @@ as_f64 :: proc(a: any) -> (value: f64, valid: bool) {
}
case quaternion256:
if imag(v) == 0 && jmag(v) == 0 && kmag(v) == 0 {
value = f64(real(v));
value = real(v);
valid = true;
}
}
@@ -1100,7 +1100,7 @@ as_string :: proc(a: any) -> (value: string, valid: bool) {
case Type_Info_String:
valid = true;
switch v in a {
case string: value = string(v);
case string: value = v;
case cstring: value = string(v);
case: valid = false;
}

2
core/runtime/default_allocators.odin
View File

@@ -127,7 +127,7 @@ default_temp_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode
old_ptr := uintptr(old_memory);
if s.prev_allocation == old_memory {
s.curr_offset = int(uintptr(s.prev_allocation) - uintptr(start));
s.curr_offset = int(uintptr(s.prev_allocation) - start);
s.prev_allocation = nil;
return nil;
}

12
core/runtime/dynamic_map_internal.odin
View File

@@ -159,14 +159,14 @@ __get_map_header :: proc "contextless" (m: ^$T/map[$K]$V) -> Map_Header {
header.equal = intrinsics.type_equal_proc(K);
header.entry_size = int(size_of(Entry));
header.entry_align = int(align_of(Entry));
header.entry_size = size_of(Entry);
header.entry_align = align_of(Entry);
header.key_offset = uintptr(offset_of(Entry, key));
header.key_size = int(size_of(K));
header.key_offset = offset_of(Entry, key);
header.key_size = size_of(K);
header.value_offset = uintptr(offset_of(Entry, value));
header.value_size = int(size_of(V));
header.value_offset = offset_of(Entry, value);
header.value_size = size_of(V);
return header;
}

8
core/runtime/error_checks.odin
View File

@@ -203,17 +203,17 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca
bounds_check_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, index, count: int) {
bounds_check_error(file_path, int(line), int(column), index, count);
bounds_check_error(file_path, line, column, index, count);
}
slice_expr_error_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, hi: int, len: int) {
slice_expr_error_hi(file_path, int(line), int(column), hi, len);
slice_expr_error_hi(file_path, line, column, hi, len);
}
slice_expr_error_lo_hi_loc :: #force_inline proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {
slice_expr_error_lo_hi(file_path, int(line), int(column), lo, hi, len);
slice_expr_error_lo_hi(file_path, line, column, lo, hi, len);
}
dynamic_array_expr_error_loc :: #force_inline proc "contextless" (using loc := #caller_location, low, high, max: int) {
dynamic_array_expr_error(file_path, int(line), int(column), low, high, max);
dynamic_array_expr_error(file_path, line, column, low, high, max);
}

4
core/runtime/internal.odin
View File

@@ -195,7 +195,7 @@ memory_compare :: proc "contextless" (a, b: rawptr, n: int) -> int #no_bounds_ch
n := uintptr(n);
SU :: size_of(uintptr);
fast := uintptr(n/SU + 1);
fast := n/SU + 1;
offset := (fast-1)*SU;
curr_block := uintptr(0);
if n < SU {
@@ -232,7 +232,7 @@ memory_compare_zero :: proc "contextless" (a: rawptr, n: int) -> int #no_bounds_
n := uintptr(n);
SU :: size_of(uintptr);
fast := uintptr(n/SU + 1);
fast := n/SU + 1;
offset := (fast-1)*SU;
curr_block := uintptr(0);
if n < SU {

10
core/runtime/internal_windows.odin
View File

@@ -63,8 +63,8 @@ fixdfti :: proc(a: u64) -> i128 {
aRep := a;
aAbs := aRep & absMask;
sign := i128(-1 if aRep & signBit != 0 else 1);
exponent := u64((aAbs >> significandBits) - exponentBias);
significand := u64((aAbs & significandMask) | implicitBit);
exponent := (aAbs >> significandBits) - exponentBias;
significand := (aAbs & significandMask) | implicitBit;
// If exponent is negative, the result is zero.
if exponent < 0 {
@@ -103,7 +103,7 @@ floattidf :: proc(a: i128) -> f64 {
s := a >> (N-1);
a = (a ~ s) - s;
sd: = N - _clz_i128(a); // number of significant digits
e := u32(sd - 1); // exponent
e := u32(sd - 1); // exponent
if sd > DBL_MANT_DIG {
switch sd {
case DBL_MANT_DIG + 1:
@@ -115,8 +115,8 @@ floattidf :: proc(a: i128) -> f64 {
i128(u128(a) & (~u128(0) >> u128(N + DBL_MANT_DIG+2 - sd)) != 0);
};
a |= i128((a & 4) != 0);
a += 1;
a |= i128((a & 4) != 0);
a += 1;
a >>= 2;
if a & (1 << DBL_MANT_DIG) != 0 {

4
core/strconv/integers.odin
View File

@@ -30,7 +30,7 @@ is_integer_negative :: proc(x: u64, is_signed: bool, bit_size: int) -> (u: u64,
case 64:
i := i64(u);
neg = i < 0;
u = u64(abs(i64(i)));
u = u64(abs(i));
case:
panic("is_integer_negative: Unknown integer size");
}
@@ -105,7 +105,7 @@ is_integer_negative_128 :: proc(x: u128, is_signed: bool, bit_size: int) -> (u:
case 128:
i := i128(u);
neg = i < 0;
u = u128(abs(i128(i)));
u = u128(abs(i));
case:
panic("is_integer_negative: Unknown integer size");
}

4
core/strconv/strconv.odin
View File

@@ -231,7 +231,7 @@ parse_u64_maybe_prefixed :: proc(str: string) -> (value: u64, ok: bool) {
break;
}
value *= base;
value += u64(v);
value += v;
i += 1;
}
s = s[i:];
@@ -433,7 +433,7 @@ append_bool :: proc(buf: []byte, b: bool) -> string {
}
append_uint :: proc(buf: []byte, u: u64, base: int) -> string {
return append_bits(buf, u64(u), base, false, 8*size_of(uint), digits, nil);
return append_bits(buf, u, base, false, 8*size_of(uint), digits, nil);
}
append_int :: proc(buf: []byte, i: i64, base: int) -> string {
return append_bits(buf, u64(i), base, true, 8*size_of(int), digits, nil);

2
core/strings/builder.odin
View File

@@ -385,7 +385,7 @@ write_escaped_rune_writer :: proc(w: io.Writer, r: rune, quote: byte, html_safe
write_u64 :: proc(b: ^Builder, i: u64, base: int = 10) -> (n: int) {
buf: [32]byte;
s := strconv.append_bits(buf[:], u64(i), base, false, 64, strconv.digits, nil);
s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil);
return write_string(b, s);
}
write_i64 :: proc(b: ^Builder, i: i64, base: int = 10) -> (n: int) {

2
core/sync/channel_windows.odin
View File

@@ -5,7 +5,7 @@ import win32 "core:sys/windows"
import "core:time"
raw_channel_wait_queue_wait_on :: proc(state: ^uintptr, timeout: time.Duration) {
ms := win32.DWORD(win32.INFINITE);
ms: win32.DWORD = win32.INFINITE;
if max(time.Duration) != SELECT_MAX_TIMEOUT {
ms = win32.DWORD((max(time.duration_nanoseconds(timeout), 0) + 999999)/1000000);
}

2
core/sys/win32/comdlg32.odin
View File

@@ -69,7 +69,7 @@ foreign comdlg32 {
OPEN_TITLE :: "Select file to open";
OPEN_FLAGS :: u32(OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST);
OPEN_FLAGS_MULTI :: u32(OPEN_FLAGS | OFN_ALLOWMULTISELECT | OFN_EXPLORER);
OPEN_FLAGS_MULTI :: OPEN_FLAGS | OFN_ALLOWMULTISELECT | OFN_EXPLORER;
SAVE_TITLE :: "Select file to save";
SAVE_FLAGS :: u32(OFN_OVERWRITEPROMPT | OFN_EXPLORER);

8
core/sys/windows/kernel32.odin
View File

@@ -293,10 +293,10 @@ SECTION_EXTEND_SIZE :: DWORD(0x0010);
SECTION_ALL_ACCESS :: STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE;
SECTION_MAP_EXECUTE_EXPLICIT :: DWORD(0x0020);
FILE_MAP_WRITE :: DWORD(SECTION_MAP_WRITE);
FILE_MAP_READ :: DWORD(SECTION_MAP_READ);
FILE_MAP_ALL_ACCESS :: DWORD(SECTION_ALL_ACCESS);
FILE_MAP_EXECUTE :: DWORD(SECTION_MAP_EXECUTE_EXPLICIT);
FILE_MAP_WRITE :: SECTION_MAP_WRITE;
FILE_MAP_READ :: SECTION_MAP_READ;
FILE_MAP_ALL_ACCESS :: SECTION_ALL_ACCESS;
FILE_MAP_EXECUTE :: SECTION_MAP_EXECUTE_EXPLICIT;
FILE_MAP_COPY :: DWORD(0x00000001);
FILE_MAP_RESERVE :: DWORD(0x80000000);
FILE_MAP_TARGETS_INVALID :: DWORD(0x40000000);

4
core/sys/windows/util.odin
View File

@@ -22,7 +22,7 @@ utf8_to_utf16 :: proc(s: string, allocator := context.temp_allocator) -> []u16 {
text := make([]u16, n+1, allocator);
n1 := MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, cstr, i32(len(s)), raw_data(text), i32(n));
n1 := MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, cstr, i32(len(s)), raw_data(text), n);
if n1 == 0 {
delete(text, allocator);
return nil;
@@ -36,7 +36,7 @@ utf8_to_utf16 :: proc(s: string, allocator := context.temp_allocator) -> []u16 {
}
utf8_to_wstring :: proc(s: string, allocator := context.temp_allocator) -> wstring {
if res := utf8_to_utf16(s, allocator); res != nil {
return wstring(&res[0]);
return &res[0];
}
return nil;
}

10
core/time/time.odin
View File

@@ -174,16 +174,16 @@ time_add :: proc(t: Time, d: Duration) -> Time {
ABSOLUTE_ZERO_YEAR :: i64(-292277022399); // Day is chosen so that 2001-01-01 is Monday in the calculations
ABSOLUTE_TO_INTERNAL :: i64(-9223371966579724800); // i64((ABSOLUTE_ZERO_YEAR - 1) * 365.2425 * SECONDS_PER_DAY);
INTERNAL_TO_ABSOLUTE :: i64(-ABSOLUTE_TO_INTERNAL);
INTERNAL_TO_ABSOLUTE :: -ABSOLUTE_TO_INTERNAL;
UNIX_TO_INTERNAL :: i64((1969*365 + 1969/4 - 1969/100 + 1969/400) * SECONDS_PER_DAY);
INTERNAL_TO_UNIX :: i64(-UNIX_TO_INTERNAL);
INTERNAL_TO_UNIX :: -UNIX_TO_INTERNAL;
WALL_TO_INTERNAL :: i64((1884*365 + 1884/4 - 1884/100 + 1884/400) * SECONDS_PER_DAY);
INTERNAL_TO_WALL :: i64(- WALL_TO_INTERNAL);
INTERNAL_TO_WALL :: -WALL_TO_INTERNAL;
UNIX_TO_ABSOLUTE :: i64(UNIX_TO_INTERNAL + INTERNAL_TO_ABSOLUTE);
ABSOLUTE_TO_UNIX :: i64(-UNIX_TO_ABSOLUTE);
UNIX_TO_ABSOLUTE :: UNIX_TO_INTERNAL + INTERNAL_TO_ABSOLUTE;
ABSOLUTE_TO_UNIX :: -UNIX_TO_ABSOLUTE;
_is_leap_year :: proc(year: int) -> bool {
return year%4 == 0 && (year%100 != 0 || year%400 == 0);

2
core/time/time_windows.odin
View File

@@ -32,6 +32,6 @@ _tick_now :: proc() -> Tick {
now: win32.LARGE_INTEGER;
win32.QueryPerformanceCounter(&now);
_nsec := i64(mul_div_u64(i64(now), 1e9, i64(qpc_frequency)));
_nsec := mul_div_u64(i64(now), 1e9, i64(qpc_frequency));
return Tick{_nsec = _nsec};
}