diff --git a/core/c/c.odin b/core/c/c.odin index 40c273927..3d5b89a08 100644 --- a/core/c/c.odin +++ b/core/c/c.odin @@ -24,7 +24,7 @@ double :: b.f64 complex_float :: b.complex64 complex_double :: b.complex128 -#assert(size_of(b.uintptr) == size_of(b.int)); +#assert(size_of(b.uintptr) == size_of(b.int)) size_t :: b.uint ssize_t :: b.int diff --git a/core/compress/common.odin b/core/compress/common.odin index 2364f1c8d..b245e35b2 100644 --- a/core/compress/common.odin +++ b/core/compress/common.odin @@ -141,7 +141,7 @@ Context_Memory_Input :: struct #packed { size_packed: i64, size_unpacked: i64, } -#assert(size_of(Context_Memory_Input) == 64); +#assert(size_of(Context_Memory_Input) == 64) Context_Stream_Input :: struct #packed { input_data: []u8, @@ -432,7 +432,7 @@ peek_bits_no_refill_lsb :: proc{peek_bits_no_refill_lsb_from_memory, peek_bits_n @(optimization_mode="speed") read_bits_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 { k := #force_inline peek_bits_lsb(z, width) - #force_inline consume_bits_lsb(z, width); + #force_inline consume_bits_lsb(z, width) return k } @@ -448,7 +448,7 @@ read_bits_lsb :: proc{read_bits_lsb_from_memory, read_bits_lsb_from_stream} @(optimization_mode="speed") read_bits_no_refill_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 { k := #force_inline peek_bits_no_refill_lsb(z, width) - #force_inline consume_bits_lsb(z, width); + #force_inline consume_bits_lsb(z, width) return k } @@ -465,7 +465,7 @@ read_bits_no_refill_lsb :: proc{read_bits_no_refill_lsb_from_memory, read_bits_n @(optimization_mode="speed") discard_to_next_byte_lsb_from_memory :: proc(z: ^Context_Memory_Input) { discard := u8(z.num_bits & 7) - #force_inline consume_bits_lsb(z, discard); + #force_inline consume_bits_lsb(z, discard) } diff --git a/core/compress/gzip/gzip.odin b/core/compress/gzip/gzip.odin index 1ef7cc827..e49a12f1c 100644 --- a/core/compress/gzip/gzip.odin +++ b/core/compress/gzip/gzip.odin @@ -33,7 +33,7 @@ Header :: struct #packed { xfl: Compression_Flags, os: OS, } -#assert(size_of(Header) == 10); +#assert(size_of(Header) == 10) Header_Flag :: enum u8 { // Order is important diff --git a/core/compress/zlib/zlib.odin b/core/compress/zlib/zlib.odin index ad9d44d4d..c44dc1a63 100644 --- a/core/compress/zlib/zlib.odin +++ b/core/compress/zlib/zlib.odin @@ -510,7 +510,7 @@ inflate_raw :: proc(z: ^$C, expected_output_size := -1, allocator := context.all */ reserve(&z.output.buf, expected_output_size) resize (&z.output.buf, expected_output_size) - }; + } if len(z.output.buf) != expected_output_size { return .Resize_Failed diff --git a/core/fmt/fmt.odin b/core/fmt/fmt.odin index 4b48ea8ad..8c667390f 100644 --- a/core/fmt/fmt.odin +++ b/core/fmt/fmt.odin @@ -1419,7 +1419,7 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) { io.write_string(fi.writer, info.name) io.write_string(fi.writer, "{}") return - }; + } is_soa := b.soa_kind != .None diff --git a/core/image/png/png.odin b/core/image/png/png.odin index 847dc1943..2550dd5db 100644 --- a/core/image/png/png.odin +++ b/core/image/png/png.odin @@ -109,7 +109,7 @@ IHDR :: struct #packed { interlace_method: Interlace_Method, } IHDR_SIZE :: size_of(IHDR) -#assert (IHDR_SIZE == 13); +#assert (IHDR_SIZE == 13) Color_Value :: enum u8 { Paletted = 0, // 1 << 0 = 1 @@ -162,7 +162,7 @@ tIME :: struct #packed { minute: u8, second: u8, } -#assert(size_of(tIME) == 7); +#assert(size_of(tIME) == 7) CIE_1931_Raw :: struct #packed { x: u32be, @@ -180,7 +180,7 @@ cHRM_Raw :: struct #packed { g: CIE_1931_Raw, b: CIE_1931_Raw, } -#assert(size_of(cHRM_Raw) == 32); +#assert(size_of(cHRM_Raw) == 32) cHRM :: struct #packed { w: CIE_1931, @@ -188,19 +188,19 @@ cHRM :: struct #packed { g: CIE_1931, b: CIE_1931, } -#assert(size_of(cHRM) == 32); +#assert(size_of(cHRM) == 32) gAMA :: struct { gamma_100k: u32be, // Gamma * 100k } -#assert(size_of(gAMA) == 4); +#assert(size_of(gAMA) == 4) pHYs :: struct #packed { ppu_x: u32be, ppu_y: u32be, unit: pHYs_Unit, } -#assert(size_of(pHYs) == 9); +#assert(size_of(pHYs) == 9) pHYs_Unit :: enum u8 { Unknown = 0, diff --git a/core/math/big/common.odin b/core/math/big/common.odin index f23754e89..643e8b49d 100644 --- a/core/math/big/common.odin +++ b/core/math/big/common.odin @@ -87,7 +87,7 @@ FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100 */ MATH_BIG_FORCE_64_BIT :: #config(MATH_BIG_FORCE_64_BIT, false) MATH_BIG_FORCE_32_BIT :: #config(MATH_BIG_FORCE_32_BIT, false) -when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously."); }; +when (MATH_BIG_FORCE_32_BIT && MATH_BIG_FORCE_64_BIT) { #panic("Cannot force 32-bit and 64-bit big backend simultaneously."); } _LOW_MEMORY :: #config(BIGINT_SMALL_MEMORY, false) when _LOW_MEMORY { @@ -172,7 +172,7 @@ Primality_Flags :: bit_set[Primality_Flag; u8] */ _MIN_DIGIT_COUNT :: max(3, ((size_of(u128) + _DIGIT_BITS) - 1) / _DIGIT_BITS) -#assert(_DEFAULT_DIGIT_COUNT >= _MIN_DIGIT_COUNT); +#assert(_DEFAULT_DIGIT_COUNT >= _MIN_DIGIT_COUNT) /* Maximum number of digits. @@ -193,7 +193,7 @@ when MATH_BIG_FORCE_64_BIT || (!MATH_BIG_FORCE_32_BIT && size_of(rawptr) == 8) { DIGIT :: distinct u32 _WORD :: distinct u64 } -#assert(size_of(_WORD) == 2 * size_of(DIGIT)); +#assert(size_of(_WORD) == 2 * size_of(DIGIT)) _DIGIT_TYPE_BITS :: 8 * size_of(DIGIT) _WORD_TYPE_BITS :: 8 * size_of(_WORD) diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin index 5138dd77d..6b01fc241 100644 --- a/core/math/big/helpers.odin +++ b/core/math/big/helpers.odin @@ -27,7 +27,7 @@ int_destroy :: proc(integers: ..^Int) { for a in &integers { assert_if_nil(a) } - #force_inline internal_int_destroy(..integers); + #force_inline internal_int_destroy(..integers) } /* @@ -42,7 +42,7 @@ int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, allocator : Check that `src` is usable and `dest` isn't immutable. */ assert_if_nil(dest) - #force_inline internal_error_if_immutable(dest) or_return; + #force_inline internal_error_if_immutable(dest) or_return return #force_inline internal_int_set_from_integer(dest, src, minimize) } @@ -64,8 +64,8 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca assert_if_nil(dest, src) context.allocator = allocator - #force_inline internal_clear_if_uninitialized(src) or_return; - #force_inline internal_error_if_immutable(dest) or_return; + #force_inline internal_clear_if_uninitialized(src) or_return + #force_inline internal_error_if_immutable(dest) or_return return #force_inline internal_int_copy(dest, src, minimize) } @@ -78,7 +78,7 @@ copy :: proc { int_copy, } */ int_swap :: proc(a, b: ^Int) { assert_if_nil(a, b) - #force_inline internal_swap(a, b); + #force_inline internal_swap(a, b) } swap :: proc { int_swap, } @@ -92,8 +92,8 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) assert_if_nil(dest, src) context.allocator = allocator - #force_inline internal_clear_if_uninitialized(src) or_return; - #force_inline internal_error_if_immutable(dest) or_return; + #force_inline internal_clear_if_uninitialized(src) or_return + #force_inline internal_error_if_immutable(dest) or_return return #force_inline internal_int_abs(dest, src) } @@ -113,8 +113,8 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error) assert_if_nil(dest, src) context.allocator = allocator - #force_inline internal_clear_if_uninitialized(src) or_return; - #force_inline internal_error_if_immutable(dest) or_return; + #force_inline internal_clear_if_uninitialized(src) or_return + #force_inline internal_error_if_immutable(dest) or_return return #force_inline internal_int_neg(dest, src) } @@ -134,7 +134,7 @@ int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.a assert_if_nil(a) context.allocator = allocator - #force_inline internal_clear_if_uninitialized(a) or_return; + #force_inline internal_clear_if_uninitialized(a) or_return return #force_inline internal_int_bitfield_extract(a, offset, count) } @@ -148,7 +148,7 @@ shrink :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) { assert_if_nil(a) context.allocator = allocator - #force_inline internal_clear_if_uninitialized(a) or_return; + #force_inline internal_clear_if_uninitialized(a) or_return return #force_inline internal_shrink(a) } @@ -305,7 +305,7 @@ int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T, Check that `a` is usable. */ assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return return #force_inline internal_int_get(a, T) } get :: proc { int_get, } @@ -315,7 +315,7 @@ int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err Check that `a` is usable. */ assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return return #force_inline internal_int_get_float(a) } @@ -327,7 +327,7 @@ count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err: Check that `a` is usable. */ assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return return #force_inline internal_count_bits(a), nil } @@ -340,7 +340,7 @@ int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, e Check that `a` is usable. */ assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return return #force_inline internal_int_count_lsb(a) } @@ -385,7 +385,7 @@ zero_unused :: proc(dest: ^Int, old_used := -1) { assert_if_nil(dest) if ! #force_inline is_initialized(dest) { return; } - #force_inline internal_zero_unused(dest, old_used); + #force_inline internal_zero_unused(dest, old_used) } clear_if_uninitialized_single :: proc(arg: ^Int, allocator := context.allocator) -> (err: Error) { @@ -398,7 +398,7 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato assert_if_nil(..args) for i in &args { - #force_inline internal_clear_if_uninitialized_single(i, allocator) or_return; + #force_inline internal_clear_if_uninitialized_single(i, allocator) or_return } return err } @@ -425,7 +425,7 @@ int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err integers := integers for a in &integers { - #force_inline internal_clear(a, true, allocator) or_return; + #force_inline internal_clear(a, true, allocator) or_return } return nil } @@ -439,7 +439,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, offset := int(0), allocator := Check that `src` is usable and `dest` isn't immutable. */ assert_if_nil(dest, src) - #force_inline internal_clear_if_uninitialized(src) or_return; + #force_inline internal_clear_if_uninitialized(src) or_return return #force_inline internal_copy_digits(dest, src, digits, offset) } @@ -452,7 +452,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, offset := int(0), allocator := */ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) { assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return for a.used > 0 && a.digit[a.used - 1] == 0 { a.used -= 1 @@ -470,7 +470,7 @@ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) { */ int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) { assert_if_nil(a) - #force_inline internal_clear_if_uninitialized(a, allocator) or_return; + #force_inline internal_clear_if_uninitialized(a, allocator) or_return size_in_bits := internal_count_bits(a) diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin index 033bc11a2..b0e0c1f5d 100644 --- a/core/math/big/internal.odin +++ b/core/math/big/internal.odin @@ -852,7 +852,7 @@ internal_div :: proc { internal_int_div, } Asssumes quotient, numerator and denominator to have been initialized and not to be nil. */ internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) { - #force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return; + #force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return if remainder.used == 0 || denominator.sign == remainder.sign { return nil; } @@ -869,7 +869,7 @@ internal_mod :: proc{ internal_int_mod, internal_int_mod_digit} remainder = (number + addend) % modulus. */ internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) { - #force_inline internal_add(remainder, number, addend, allocator) or_return; + #force_inline internal_add(remainder, number, addend, allocator) or_return return #force_inline internal_mod(remainder, remainder, modulus, allocator) } internal_addmod :: proc { internal_int_addmod, } @@ -878,7 +878,7 @@ internal_addmod :: proc { internal_int_addmod, } remainder = (number - decrease) % modulus. */ internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) { - #force_inline internal_sub(remainder, number, decrease, allocator) or_return; + #force_inline internal_sub(remainder, number, decrease, allocator) or_return return #force_inline internal_mod(remainder, remainder, modulus, allocator) } internal_submod :: proc { internal_int_submod, } @@ -887,7 +887,7 @@ internal_submod :: proc { internal_int_submod, } remainder = (number * multiplicand) % modulus. */ internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) { - #force_inline internal_mul(remainder, number, multiplicand, allocator) or_return; + #force_inline internal_mul(remainder, number, multiplicand, allocator) or_return return #force_inline internal_mod(remainder, remainder, modulus, allocator) } internal_mulmod :: proc { internal_int_mulmod, } @@ -896,7 +896,7 @@ internal_mulmod :: proc { internal_int_mulmod, } remainder = (number * number) % modulus. */ internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) { - #force_inline internal_sqr(remainder, number, allocator) or_return; + #force_inline internal_sqr(remainder, number, allocator) or_return return #force_inline internal_mod(remainder, remainder, modulus, allocator) } internal_sqrmod :: proc { internal_int_sqrmod, } @@ -919,7 +919,7 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator return #force_inline internal_set(res, _factorial_table[n]) } - #force_inline internal_set(res, _factorial_table[i - 1]) or_return; + #force_inline internal_set(res, _factorial_table[i - 1]) or_return for { if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n { return err @@ -1695,7 +1695,7 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al internal_set :: proc { internal_int_set_from_integer, internal_int_copy } internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int, offset := int(0)) -> (err: Error) { - #force_inline internal_error_if_immutable(dest) or_return; + #force_inline internal_error_if_immutable(dest) or_return /* If dest == src, do nothing @@ -2069,7 +2069,7 @@ internal_int_get :: proc(a: ^Int, $T: typeid) -> (res: T, err: Error) where intr res |= T(a.digit[i]) if size_in_bits <= _DIGIT_BITS { break - }; + } } when !intrinsics.type_is_unsigned(T) { @@ -2499,7 +2499,7 @@ internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context /* Resize `quotient` to accomodate extra digits. */ - #force_inline internal_grow(quotient, quotient.used + digits) or_return; + #force_inline internal_grow(quotient, quotient.used + digits) or_return /* Increment the used by the shift amount then copy upwards. @@ -2597,7 +2597,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator : digits += 1 } - #force_inline internal_grow(dest, digits) or_return; + #force_inline internal_grow(dest, digits) or_return for i := 0; i < digits; i += 1 { dest.digit[i] = int_random_digit(r) & _MASK diff --git a/core/math/big/private.odin b/core/math/big/private.odin index 81bae57f0..f0d73a008 100644 --- a/core/math/big/private.odin +++ b/core/math/big/private.odin @@ -816,9 +816,9 @@ _private_int_sqr_karatsuba :: proc(dest, src: ^Int, allocator := context.allocat x0.used = B x1.used = src.used - B - #force_inline internal_copy_digits(x0, src, x0.used); - #force_inline mem.copy_non_overlapping(&x1.digit[0], &src.digit[B], size_of(DIGIT) * x1.used); - #force_inline internal_clamp(x0); + #force_inline internal_copy_digits(x0, src, x0.used) + #force_inline mem.copy_non_overlapping(&x1.digit[0], &src.digit[B], size_of(DIGIT) * x1.used) + #force_inline internal_clamp(x0) /* Now calc the products x0*x0 and x1*x1. @@ -882,9 +882,9 @@ _private_int_sqr_toom :: proc(dest, src: ^Int, allocator := context.allocator) - a1.used = B a2.used = src.used - 2 * B - #force_inline mem.copy_non_overlapping(&a0.digit[0], &src.digit[ 0], size_of(DIGIT) * a0.used); - #force_inline mem.copy_non_overlapping(&a1.digit[0], &src.digit[ B], size_of(DIGIT) * a1.used); - #force_inline mem.copy_non_overlapping(&a2.digit[0], &src.digit[2 * B], size_of(DIGIT) * a2.used); + #force_inline mem.copy_non_overlapping(&a0.digit[0], &src.digit[ 0], size_of(DIGIT) * a0.used) + #force_inline mem.copy_non_overlapping(&a1.digit[0], &src.digit[ B], size_of(DIGIT) * a1.used) + #force_inline mem.copy_non_overlapping(&a2.digit[0], &src.digit[2 * B], size_of(DIGIT) * a2.used) internal_clamp(a0) internal_clamp(a1) @@ -1700,17 +1700,17 @@ _private_int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) - } low = high - #force_inline internal_copy(bracket_low, bracket_high) or_return; + #force_inline internal_copy(bracket_low, bracket_high) or_return high <<= 1 - #force_inline internal_sqr(bracket_high, bracket_high) or_return; + #force_inline internal_sqr(bracket_high, bracket_high) or_return } for (high - low) > 1 { mid := (high + low) >> 1 - #force_inline internal_pow(t, bi_base, mid - low) or_return; + #force_inline internal_pow(t, bi_base, mid - low) or_return - #force_inline internal_mul(bracket_mid, bracket_low, t) or_return; + #force_inline internal_mul(bracket_mid, bracket_low, t) or_return mc := #force_inline internal_cmp(a, bracket_mid) switch mc { @@ -2209,7 +2209,7 @@ _private_int_rem_128 := [?]DIGIT{ 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, } -#assert(128 * size_of(DIGIT) == size_of(_private_int_rem_128)); +#assert(128 * size_of(DIGIT) == size_of(_private_int_rem_128)) _private_int_rem_105 := [?]DIGIT{ 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, @@ -2220,7 +2220,7 @@ _private_int_rem_105 := [?]DIGIT{ 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, } -#assert(105 * size_of(DIGIT) == size_of(_private_int_rem_105)); +#assert(105 * size_of(DIGIT) == size_of(_private_int_rem_105)) _private_prime_table := [?]DIGIT{ 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013, @@ -2259,7 +2259,7 @@ _private_prime_table := [?]DIGIT{ 0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623, 0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653, } -#assert(256 * size_of(DIGIT) == size_of(_private_prime_table)); +#assert(256 * size_of(DIGIT) == size_of(_private_prime_table)) when MATH_BIG_FORCE_64_BIT || (!MATH_BIG_FORCE_32_BIT && size_of(rawptr) == 8) { _factorial_table := [35]_WORD{ @@ -2323,7 +2323,7 @@ when MATH_BIG_FORCE_64_BIT || (!MATH_BIG_FORCE_32_BIT && size_of(rawptr) == 8) { /* f(19): */ 121_645_100_408_832_000, /* f(20): */ 2_432_902_008_176_640_000, } -}; +} /* ========================= End of private tables ======================== diff --git a/core/math/big/public.odin b/core/math/big/public.odin index f3dd096b6..9f82e618b 100644 --- a/core/math/big/public.odin +++ b/core/math/big/public.odin @@ -311,12 +311,12 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) - n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{} defer internal_destroy(n_fac, k_fac, n_minus_k_fac) - #force_inline internal_int_factorial(n_minus_k_fac, n - k) or_return; - #force_inline internal_int_factorial(k_fac, k) or_return; - #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac) or_return; + #force_inline internal_int_factorial(n_minus_k_fac, n - k) or_return + #force_inline internal_int_factorial(k_fac, k) or_return + #force_inline internal_mul(k_fac, k_fac, n_minus_k_fac) or_return - #force_inline internal_int_factorial(n_fac, n) or_return; - #force_inline internal_div(res, n_fac, k_fac) or_return; + #force_inline internal_int_factorial(n_fac, n) or_return + #force_inline internal_div(res, n_fac, k_fac) or_return return } diff --git a/core/math/big/test.odin b/core/math/big/test.odin index 609b8ce10..8a48962cb 100644 --- a/core/math/big/test.odin +++ b/core/math/big/test.odin @@ -147,7 +147,7 @@ PyRes :: struct { if err = atoi(aa, string(a), 16); err != nil { return PyRes{res=":log:atoi(a):", err=err}; } if l, err = #force_inline internal_log(aa, base); err != nil { return PyRes{res=":log:log(a, base):", err=err}; } - #force_inline internal_zero(aa); + #force_inline internal_zero(aa) aa.digit[0] = DIGIT(l) & _MASK aa.digit[1] = DIGIT(l) >> _DIGIT_BITS aa.used = 2 diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin index c65c2fa2b..0d05b356d 100644 --- a/core/math/bits/bits.odin +++ b/core/math/bits/bits.odin @@ -221,7 +221,7 @@ mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { when size_of(uint) == size_of(u32) { a, b := mul_u32(u32(x), u32(y)) } else { - #assert(size_of(uint) == size_of(u64)); + #assert(size_of(uint) == size_of(u64)) a, b := mul_u64(u64(x), u64(y)) } return uint(a), uint(b) @@ -285,7 +285,7 @@ div_uint :: proc(hi, lo, y: uint) -> (quo, rem: uint) { when size_of(uint) == size_of(u32) { a, b := div_u32(u32(hi), u32(lo), u32(y)) } else { - #assert(size_of(uint) == size_of(u64)); + #assert(size_of(uint) == size_of(u64)) a, b := div_u64(u64(hi), u64(lo), u64(y)) } return uint(a), uint(b) diff --git a/core/runtime/core.odin b/core/runtime/core.odin index e49470ebc..fd4d7e93a 100644 --- a/core/runtime/core.odin +++ b/core/runtime/core.odin @@ -234,7 +234,7 @@ Typeid_Kind :: enum u8 { Relative_Pointer, Relative_Slice, } -#assert(len(Typeid_Kind) < 32); +#assert(len(Typeid_Kind) < 32) // Typeid_Bit_Field :: bit_field #align align_of(uintptr) { // index: 8*size_of(uintptr) - 8, diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin index f4973089b..44da894c1 100644 --- a/core/runtime/core_builtin.odin +++ b/core/runtime/core_builtin.odin @@ -580,7 +580,7 @@ card :: proc(s: $S/bit_set[$E; $U]) -> int { } else when size_of(S) == 16 { return int(intrinsics.count_ones(transmute(u128)s)) } else { - #panic("Unhandled card bit_set size"); + #panic("Unhandled card bit_set size") } } diff --git a/core/runtime/internal.odin b/core/runtime/internal.odin index b54e8dc5d..912ca9d84 100644 --- a/core/runtime/internal.odin +++ b/core/runtime/internal.odin @@ -702,7 +702,7 @@ floattidf :: proc(a: i128) -> f64 { case: a = i128(u128(a) >> u128(sd - (DBL_MANT_DIG+2))) | i128(u128(a) & (~u128(0) >> u128(N + DBL_MANT_DIG+2 - sd)) != 0) - }; + } a |= i128((a & 4) != 0) a += 1 @@ -743,7 +743,7 @@ floattidf_unsigned :: proc(a: u128) -> f64 { case: a = u128(u128(a) >> u128(sd - (DBL_MANT_DIG+2))) | u128(u128(a) & (~u128(0) >> u128(N + DBL_MANT_DIG+2 - sd)) != 0) - }; + } a |= u128((a & 4) != 0) a += 1 diff --git a/core/sync/atomic.odin b/core/sync/atomic.odin index dbcb5283f..5996d981f 100644 --- a/core/sync/atomic.odin +++ b/core/sync/atomic.odin @@ -75,7 +75,7 @@ atomic_compare_exchange :: #force_inline proc(dst: ^$T, old, new: T, $success, $ when success == .Sequentially_Consistent { return intrinsics.atomic_cxchg(dst, old, new); } else { #panic("an unknown ordering combination"); } } else when failure == .Acquire_Release { - #panic("there is not such thing as an acquire/release failure ordering"); + #panic("there is not such thing as an acquire/release failure ordering") } else when failure == .Release { when success == .Acquire { return instrinsics.atomic_cxchg_failacq(dst, old, new); } else { #panic("an unknown ordering combination"); } @@ -101,7 +101,7 @@ atomic_compare_exchange_weak :: #force_inline proc(dst: ^$T, old, new: T, $succe when success == .Sequentially_Consistent { return intrinsics.atomic_cxchgweak(dst, old, new); } else { #panic("an unknown ordering combination"); } } else when failure == .Acquire_Release { - #panic("there is not such thing as an acquire/release failure ordering"); + #panic("there is not such thing as an acquire/release failure ordering") } else when failure == .Release { when success == .Acquire { return intrinsics.atomic_cxchgweak_failacq(dst, old, new); } else { #panic("an unknown ordering combination"); } diff --git a/core/sys/windows/types.odin b/core/sys/windows/types.odin index 823535575..c8d219d96 100644 --- a/core/sys/windows/types.odin +++ b/core/sys/windows/types.odin @@ -398,7 +398,7 @@ when size_of(uintptr) == 4 { szSystemStatus: [WSASYS_STATUS_LEN + 1]u8, } } else { - #panic("unknown word size"); + #panic("unknown word size") } WSABUF :: struct { @@ -863,7 +863,7 @@ SID :: struct #packed { IdentifierAuthority: SID_IDENTIFIER_AUTHORITY, SubAuthority: [15]DWORD, // Array of DWORDs } -#assert(size_of(SID) == SECURITY_MAX_SID_SIZE); +#assert(size_of(SID) == SECURITY_MAX_SID_SIZE) SID_IDENTIFIER_AUTHORITY :: struct #packed { Value: [6]u8, @@ -916,7 +916,7 @@ USER_INFO_1 :: struct #packed { flags: USER_INFO_FLAGS, script_path: LPWSTR, } -#assert(size_of(USER_INFO_1) == 50); +#assert(size_of(USER_INFO_1) == 50) LOCALGROUP_MEMBERS_INFO_0 :: struct #packed { sid: ^SID, diff --git a/core/thread/thread.odin b/core/thread/thread.odin index fe3e2ffb7..d4cdf08e3 100644 --- a/core/thread/thread.odin +++ b/core/thread/thread.odin @@ -23,7 +23,7 @@ Thread :: struct { creation_allocator: mem.Allocator, } -#assert(size_of(Thread{}.user_index) == size_of(uintptr)); +#assert(size_of(Thread{}.user_index) == size_of(uintptr)) Thread_Priority :: enum { Normal,