Remove unneeded semicolons from the core library

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)

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)
 

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

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

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
 }

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

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)