Remove unneeded semicolons from the core library

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

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

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

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

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
 

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,

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)

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,

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

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

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

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,

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,