Strip semicolons in core which were missing

core/runtime/default_allocators_general.odin

@@ -8,22 +8,22 @@ when ODIN_DEFAULT_TO_NIL_ALLOCATOR {
 	default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 	                               size, alignment: int,
 	                               old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) {
-		return nil, .None;
+		return nil, .None
 	}
 
 	default_allocator :: proc() -> Allocator {
 		return Allocator{
 			procedure = default_allocator_proc,
 			data = nil,
-		};
+		}
 	}
 } else {
 	// TODO(bill): reimplement these procedures in the os_specific stuff
 	import "core:os"
 
-	default_allocator_proc :: os.heap_allocator_proc;
+	default_allocator_proc :: os.heap_allocator_proc
 
 	default_allocator :: proc() -> Allocator {
-		return os.heap_allocator();
+		return os.heap_allocator()
 	}
 }

core/runtime/internal_linux.odin

@@ -4,86 +4,86 @@ import "core:intrinsics"
 
 @(link_name="__umodti3")
 umodti3 :: proc "c" (a, b: u128) -> u128 {
-	r: u128 = ---;
-	_ = udivmod128(a, b, &r);
-	return r;
+	r: u128 = ---
+	_ = udivmod128(a, b, &r)
+	return r
 }
 
 
 @(link_name="__udivmodti4")
 udivmodti4 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {
-	return udivmod128(a, b, rem);
+	return udivmod128(a, b, rem)
 }
 
 @(link_name="__udivti3")
 udivti3 :: proc "c" (a, b: u128) -> u128 {
-	return udivmodti4(a, b, nil);
+	return udivmodti4(a, b, nil)
 }
 
 
 @(link_name="__modti3")
 modti3 :: proc "c" (a, b: i128) -> i128 {
-	s_a := a >> (128 - 1);
-	s_b := b >> (128 - 1);
-	an := (a ~ s_a) - s_a;
-	bn := (b ~ s_b) - s_b;
+	s_a := a >> (128 - 1)
+	s_b := b >> (128 - 1)
+	an := (a ~ s_a) - s_a
+	bn := (b ~ s_b) - s_b
 
-	r: u128 = ---;
-	_ = udivmod128(transmute(u128)an, transmute(u128)bn, &r);
-	return (transmute(i128)r ~ s_a) - s_a;
+	r: u128 = ---
+	_ = udivmod128(transmute(u128)an, transmute(u128)bn, &r)
+	return (transmute(i128)r ~ s_a) - s_a
 }
 
 
 @(link_name="__divmodti4")
 divmodti4 :: proc "c" (a, b: i128, rem: ^i128) -> i128 {
-	u := udivmod128(transmute(u128)a, transmute(u128)b, cast(^u128)rem);
-	return transmute(i128)u;
+	u := udivmod128(transmute(u128)a, transmute(u128)b, cast(^u128)rem)
+	return transmute(i128)u
 }
 
 @(link_name="__divti3")
 divti3 :: proc "c" (a, b: i128) -> i128 {
-	u := udivmodti4(transmute(u128)a, transmute(u128)b, nil);
-	return transmute(i128)u;
+	u := udivmodti4(transmute(u128)a, transmute(u128)b, nil)
+	return transmute(i128)u
 }
 
 
 @(link_name="__fixdfti")
 fixdfti :: proc(a: u64) -> i128 {
-	significandBits :: 52;
-	typeWidth       :: (size_of(u64)*8);
-	exponentBits    :: (typeWidth - significandBits - 1);
-	maxExponent     :: ((1 << exponentBits) - 1);
-	exponentBias    :: (maxExponent >> 1);
+	significandBits :: 52
+	typeWidth       :: (size_of(u64)*8)
+	exponentBits    :: (typeWidth - significandBits - 1)
+	maxExponent     :: ((1 << exponentBits) - 1)
+	exponentBias    :: (maxExponent >> 1)
 
-	implicitBit     :: (u64(1) << significandBits);
-	significandMask :: (implicitBit - 1);
-	signBit         :: (u64(1) << (significandBits + exponentBits));
-	absMask         :: (signBit - 1);
-	exponentMask    :: (absMask ~ significandMask);
+	implicitBit     :: (u64(1) << significandBits)
+	significandMask :: (implicitBit - 1)
+	signBit         :: (u64(1) << (significandBits + exponentBits))
+	absMask         :: (signBit - 1)
+	exponentMask    :: (absMask ~ significandMask)
 
 	// Break a into sign, exponent, significand
-	aRep := a;
-	aAbs := aRep & absMask;
-	sign := i128(-1 if aRep & signBit != 0 else 1);
-	exponent := u64((aAbs >> significandBits) - exponentBias);
-	significand := u64((aAbs & significandMask) | implicitBit);
+	aRep := a
+	aAbs := aRep & absMask
+	sign := i128(-1 if aRep & signBit != 0 else 1)
+	exponent := u64((aAbs >> significandBits) - exponentBias)
+	significand := u64((aAbs & significandMask) | implicitBit)
 
 	// If exponent is negative, the result is zero.
 	if exponent < 0 {
-		return 0;
+		return 0
 	}
 
 	// If the value is too large for the integer type, saturate.
 	if exponent >= size_of(i128) * 8 {
-		return max(i128) if sign == 1 else min(i128);
+		return max(i128) if sign == 1 else min(i128)
 	}
 
 	// If 0 <= exponent < significandBits, right shift to get the result.
 	// Otherwise, shift left.
 	if exponent < significandBits {
-		return sign * i128(significand >> (significandBits - exponent));
+		return sign * i128(significand >> (significandBits - exponent))
 	} else {
-		return sign * (i128(significand) << (exponent - significandBits));
+		return sign * (i128(significand) << (exponent - significandBits))
 	}
 
 }

core/runtime/os_specific_any.odin

@@ -7,7 +7,7 @@ import "core:os"
 // TODO(bill): reimplement `os.write` so that it does not rely on package os
 // NOTE: Use os_specific_linux.odin, os_specific_darwin.odin, etc
 _os_write :: proc "contextless" (data: []byte) -> (int, _OS_Errno) {
-	context = default_context();
-	n, err := os.write(os.stderr, data);
-	return int(n), _OS_Errno(err);
+	context = default_context()
+	n, err := os.write(os.stderr, data)
+	return int(n), _OS_Errno(err)
 }

core/runtime/procs_unix.odin

@@ -4,15 +4,15 @@ package runtime
 @(link_name="memset")
 memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr {
 	if ptr == nil || len == 0 {
-		return ptr;
+		return ptr
 	}
-	b := byte(val);
+	b := byte(val)
 
-	p_start := uintptr(ptr);
-	p_end := p_start + uintptr(max(len, 0));
+	p_start := uintptr(ptr)
+	p_end := p_start + uintptr(max(len, 0))
 	for p := p_start; p < p_end; p += 1 {
-		(^byte)(p)^ = b;
+		(^byte)(p)^ = b
 	}
 
-	return ptr;
+	return ptr
 }