Remove unneeded semicolons from the core library

1 files changed, 45 insertions, 45 deletions

diff --git a/core/math/big/common.odin b/core/math/big/common.odin
index ce1f7d77f..f23754e89 100644
--- a/core/math/big/common.odin
+++ b/core/math/big/common.odin
@@ -33,15 +33,15 @@ import "core:intrinsics"
 	To allow tests to run we add `-define:MATH_BIG_EXE=false` to hardcode the cutoffs for now.
 */
 when #config(MATH_BIG_EXE, true) {
-	MUL_KARATSUBA_CUTOFF := initialize_constants();
-	SQR_KARATSUBA_CUTOFF := _DEFAULT_SQR_KARATSUBA_CUTOFF;
-	MUL_TOOM_CUTOFF      := _DEFAULT_MUL_TOOM_CUTOFF;
-	SQR_TOOM_CUTOFF      := _DEFAULT_SQR_TOOM_CUTOFF;
+	MUL_KARATSUBA_CUTOFF := initialize_constants()
+	SQR_KARATSUBA_CUTOFF := _DEFAULT_SQR_KARATSUBA_CUTOFF
+	MUL_TOOM_CUTOFF      := _DEFAULT_MUL_TOOM_CUTOFF
+	SQR_TOOM_CUTOFF      := _DEFAULT_SQR_TOOM_CUTOFF
 } else {
-	MUL_KARATSUBA_CUTOFF := _DEFAULT_MUL_KARATSUBA_CUTOFF;
-	SQR_KARATSUBA_CUTOFF := _DEFAULT_SQR_KARATSUBA_CUTOFF;
-	MUL_TOOM_CUTOFF      := _DEFAULT_MUL_TOOM_CUTOFF;
-	SQR_TOOM_CUTOFF      := _DEFAULT_SQR_TOOM_CUTOFF;	
+	MUL_KARATSUBA_CUTOFF := _DEFAULT_MUL_KARATSUBA_CUTOFF
+	SQR_KARATSUBA_CUTOFF := _DEFAULT_SQR_KARATSUBA_CUTOFF
+	MUL_TOOM_CUTOFF      := _DEFAULT_MUL_TOOM_CUTOFF
+	SQR_TOOM_CUTOFF      := _DEFAULT_SQR_TOOM_CUTOFF	
 }
 
 /*
@@ -57,24 +57,24 @@ when #config(MATH_BIG_EXE, true) {
 	debugged where necessary.
 */
 
-_DEFAULT_MUL_KARATSUBA_CUTOFF :: #config(MUL_KARATSUBA_CUTOFF,  80);
-_DEFAULT_SQR_KARATSUBA_CUTOFF :: #config(SQR_KARATSUBA_CUTOFF, 120);
-_DEFAULT_MUL_TOOM_CUTOFF      :: #config(MUL_TOOM_CUTOFF,      350);
-_DEFAULT_SQR_TOOM_CUTOFF      :: #config(SQR_TOOM_CUTOFF,      400);
+_DEFAULT_MUL_KARATSUBA_CUTOFF :: #config(MUL_KARATSUBA_CUTOFF,  80)
+_DEFAULT_SQR_KARATSUBA_CUTOFF :: #config(SQR_KARATSUBA_CUTOFF, 120)
+_DEFAULT_MUL_TOOM_CUTOFF      :: #config(MUL_TOOM_CUTOFF,      350)
+_DEFAULT_SQR_TOOM_CUTOFF      :: #config(SQR_TOOM_CUTOFF,      400)
 
 
-MAX_ITERATIONS_ROOT_N := 500;
+MAX_ITERATIONS_ROOT_N := 500
 
 /*
 	Largest `N` for which we'll compute `N!`
 */
-FACTORIAL_MAX_N       := 1_000_000;
+FACTORIAL_MAX_N       := 1_000_000
 
 /*
 	Cutoff to switch to int_factorial_binary_split, and its max recursion level.
 */
-FACTORIAL_BINARY_SPLIT_CUTOFF         := 6100;
-FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100;
+FACTORIAL_BINARY_SPLIT_CUTOFF         := 6100
+FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100
 
 
 /*
@@ -85,15 +85,15 @@ FACTORIAL_BINARY_SPLIT_MAX_RECURSIONS := 100;
 
 	2) Optimizations thanks to precomputed masks wouldn't work.
 */
-MATH_BIG_FORCE_64_BIT :: #config(MATH_BIG_FORCE_64_BIT, false);
-MATH_BIG_FORCE_32_BIT :: #config(MATH_BIG_FORCE_32_BIT, false);
+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."); };
 
-_LOW_MEMORY           :: #config(BIGINT_SMALL_MEMORY, false);
+_LOW_MEMORY           :: #config(BIGINT_SMALL_MEMORY, false)
 when _LOW_MEMORY {
-	_DEFAULT_DIGIT_COUNT :: 8;
+	_DEFAULT_DIGIT_COUNT :: 8
 } else {
-	_DEFAULT_DIGIT_COUNT :: 32;
+	_DEFAULT_DIGIT_COUNT :: 32
 }
 
 /*
@@ -103,22 +103,22 @@ when _LOW_MEMORY {
 Sign :: enum u8 {
 	Zero_or_Positive = 0,
 	Negative         = 1,
-};
+}
 
 Int :: struct {
 	used:  int,
 	digit: [dynamic]DIGIT,
 	sign:  Sign,
 	flags: Flags,
-};
+}
 
 Flag :: enum u8 {
 	NaN,
 	Inf,
 	Immutable,
-};
+}
 
-Flags :: bit_set[Flag; u8];
+Flags :: bit_set[Flag; u8]
 
 /*
 	Errors are a strict superset of runtime.Allocation_Error.
@@ -138,7 +138,7 @@ Error :: enum int {
 	Math_Domain_Error       = 9,
 
 	Unimplemented           = 127,
-};
+}
 
 Error_String :: #partial [Error]string{
 	.Out_Of_Memory           = "Out of memory",
@@ -154,14 +154,14 @@ Error_String :: #partial [Error]string{
 	.Math_Domain_Error       = "Math domain error",
 
 	.Unimplemented           = "Unimplemented",
-};
+}
 
 Primality_Flag :: enum u8 {
 	Blum_Blum_Shub = 0,	/* BBS style prime */
 	Safe           = 1,	/* Safe prime (p-1)/2 == prime */
 	Second_MSB_On  = 3,  /* force 2nd MSB to 1 */
-};
-Primality_Flags :: bit_set[Primality_Flag; u8];
+}
+Primality_Flags :: bit_set[Primality_Flag; u8]
 
 /*
 	How do we store the Ints?
@@ -171,7 +171,7 @@ Primality_Flags :: bit_set[Primality_Flag; u8];
 	- Must be large enough such that `init_integer` can store `u128` in the `Int` without growing.
  */
 
-_MIN_DIGIT_COUNT :: max(3, ((size_of(u128) + _DIGIT_BITS) - 1) / _DIGIT_BITS);
+_MIN_DIGIT_COUNT :: max(3, ((size_of(u128) + _DIGIT_BITS) - 1) / _DIGIT_BITS)
 #assert(_DEFAULT_DIGIT_COUNT >= _MIN_DIGIT_COUNT);
 
 /*
@@ -180,36 +180,36 @@ _MIN_DIGIT_COUNT :: max(3, ((size_of(u128) + _DIGIT_BITS) - 1) / _DIGIT_BITS);
  	- Must be small enough such that `_radix_size` for base 2 does not overflow.
 	`_radix_size` needs two additional bytes for zero termination and sign.
 */
-_MAX_BIT_COUNT   :: (max(int) - 2);
-_MAX_DIGIT_COUNT :: _MAX_BIT_COUNT / _DIGIT_BITS;
+_MAX_BIT_COUNT   :: (max(int) - 2)
+_MAX_DIGIT_COUNT :: _MAX_BIT_COUNT / _DIGIT_BITS
 
 when MATH_BIG_FORCE_64_BIT || (!MATH_BIG_FORCE_32_BIT && size_of(rawptr) == 8) {
 	/*
 		We can use u128 as an intermediary.
 	*/
-	DIGIT        :: distinct u64;
-	_WORD        :: distinct u128;
+	DIGIT        :: distinct u64
+	_WORD        :: distinct u128
 } else {
-	DIGIT        :: distinct u32;
-	_WORD        :: distinct u64;
+	DIGIT        :: distinct u32
+	_WORD        :: distinct u64
 }
 #assert(size_of(_WORD) == 2 * size_of(DIGIT));
 
-_DIGIT_TYPE_BITS :: 8 * size_of(DIGIT);
-_WORD_TYPE_BITS  :: 8 * size_of(_WORD);
+_DIGIT_TYPE_BITS :: 8 * size_of(DIGIT)
+_WORD_TYPE_BITS  :: 8 * size_of(_WORD)
 
-_DIGIT_BITS      :: _DIGIT_TYPE_BITS - 4;
-_WORD_BITS       :: 2 * _DIGIT_BITS;
+_DIGIT_BITS      :: _DIGIT_TYPE_BITS - 4
+_WORD_BITS       :: 2 * _DIGIT_BITS
 
-_MASK            :: (DIGIT(1) << DIGIT(_DIGIT_BITS)) - DIGIT(1);
-_DIGIT_MAX       :: _MASK;
-_MAX_COMBA       :: 1 <<  (_WORD_TYPE_BITS - (2 * _DIGIT_BITS))     ;
-_WARRAY          :: 1 << ((_WORD_TYPE_BITS - (2 * _DIGIT_BITS)) + 1);
+_MASK            :: (DIGIT(1) << DIGIT(_DIGIT_BITS)) - DIGIT(1)
+_DIGIT_MAX       :: _MASK
+_MAX_COMBA       :: 1 <<  (_WORD_TYPE_BITS - (2 * _DIGIT_BITS))     
+_WARRAY          :: 1 << ((_WORD_TYPE_BITS - (2 * _DIGIT_BITS)) + 1)
 
 Order :: enum i8 {
 	LSB_First = -1,
 	MSB_First =  1,
-};
+}
 
 Endianness :: enum i8 {
    Little   = -1,