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

Remove unneeded semicolons from the core library

Browse Source
This commit is contained in:
gingerBill
2021-08-31 22:32:53 +01:00
parent 2db6fea665
commit f57201bbd1
19 changed files with 80 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/c/c.odin
View File

@@ -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

8
core/compress/common.odin
View File

@@ -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)
}

2
core/compress/gzip/gzip.odin
View File

@@ -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

2
core/compress/zlib/zlib.odin
View File

@@ -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

2
core/fmt/fmt.odin
View File

@@ -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

12
core/image/png/png.odin
View File

@@ -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,

6
core/math/big/common.odin
View File

@@ -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)

42
core/math/big/helpers.odin
View File

@@ -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)

20
core/math/big/internal.odin
View File

@@ -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

28
core/math/big/private.odin
View File

@@ -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 ========================

10
core/math/big/public.odin
View File

@@ -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
}

2
core/math/big/test.odin
View File

@@ -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

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

@@ -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)

2
core/runtime/core.odin
View File

@@ -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,

2
core/runtime/core_builtin.odin
View File

@@ -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")
}
}

4
core/runtime/internal.odin
View File

@@ -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

4
core/sync/atomic.odin
View File

@@ -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"); }

6
core/sys/windows/types.odin
View File

@@ -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,

2
core/thread/thread.odin
View File

@@ -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,