Strip semicolons in core which were missing

3 files changed, 96 insertions, 96 deletions

diff --git a/core/sync/sync2/primitives_darwin.odin b/core/sync/sync2/primitives_darwin.odin
index af342abf3..309567f75 100644
--- a/core/sync/sync2/primitives_darwin.odin
+++ b/core/sync/sync2/primitives_darwin.odin
@@ -9,13 +9,13 @@ import "core:intrinsics"
 foreign import pthread "System.framework"
 
 _current_thread_id :: proc "contextless" () -> int {
-	tid: u64;
+	tid: u64
 	// NOTE(Oskar): available from OSX 10.6 and iOS 3.2.
 	// For older versions there is `syscall(SYS_thread_selfid)`, but not really
 	// the same thing apparently.
-	foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int ---; }
-	pthread_threadid_np(nil, &tid);
-	return int(tid);
+	foreign pthread { pthread_threadid_np :: proc "c" (rawptr, ^u64) -> c.int --- }
+	pthread_threadid_np(nil, &tid)
+	return int(tid)
 }
 
 foreign {
@@ -26,38 +26,38 @@ foreign {
 }
 
 _atomic_try_wait_slow :: proc(ptr: ^u32, val: u32) {
-	history: uint = 10;
+	history: uint = 10
 	for {
 		// Exponential wait
-		_darwin_usleep(history >> 2);
-		history += history >> 2;
+		_darwin_usleep(history >> 2)
+		history += history >> 2
 		if history > (1 << 10) {
-			history = 1 << 10;
+			history = 1 << 10
 		}
 
 		if atomic_load(ptr) != val {
-			break;
+			break
 		}
 	}
 }
 
 _atomic_wait :: proc(ptr: ^u32, val: u32) {
 	if intrinsics.expect(atomic_load(ptr) != val, true) {
-		return;
+		return
 	}
 	for i in 0..<16 {
 		if atomic_load(ptr) != val {
-			return;
+			return
 		}
 		if i < 12 {
-			intrinsics.cpu_relax();
+			intrinsics.cpu_relax()
 		} else {
-			_darwin_sched_yield();
+			_darwin_sched_yield()
 		}
 	}
 
 	for val == atomic_load(ptr) {
-		_atomic_try_wait_slow(ptr, val);
+		_atomic_try_wait_slow(ptr, val)
 	}
 }
 
@@ -73,7 +73,7 @@ _mutex_unlock :: proc(m: ^Mutex) {
 }
 
 _mutex_try_lock :: proc(m: ^Mutex) -> bool {
-	return false;
+	return false
 }
 
 _RW_Mutex :: struct {
@@ -86,7 +86,7 @@ _rw_mutex_unlock :: proc(rw: ^RW_Mutex) {
 }
 
 _rw_mutex_try_lock :: proc(rw: ^RW_Mutex) -> bool {
-	return false;
+	return false
 }
 
 _rw_mutex_shared_lock :: proc(rw: ^RW_Mutex) {
@@ -96,7 +96,7 @@ _rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) {
 }
 
 _rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool {
-	return false;
+	return false
 }
 
 
@@ -110,7 +110,7 @@ _recursive_mutex_unlock :: proc(m: ^Recursive_Mutex) {
 }
 
 _recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
-	return false;
+	return false
 }
 
 
@@ -123,7 +123,7 @@ _cond_wait :: proc(c: ^Cond, m: ^Mutex) {
 }
 
 _cond_wait_with_timeout :: proc(c: ^Cond, m: ^Mutex, timeout: time.Duration) -> bool {
-	return false;
+	return false
 }
 
 _cond_signal :: proc(c: ^Cond) {
diff --git a/core/sync/sync2/primitives_linux.odin b/core/sync/sync2/primitives_linux.odin
index 0a5da0880..2fafaed7a 100644
--- a/core/sync/sync2/primitives_linux.odin
+++ b/core/sync/sync2/primitives_linux.odin
@@ -10,6 +10,6 @@ _current_thread_id :: proc "contextless" () -> int {
 		syscall :: proc(number: i32, #c_vararg args: ..any) -> i32 ---
 	}
 
-	SYS_GETTID :: 186;
-	return int(syscall(SYS_GETTID));
+	SYS_GETTID :: 186
+	return int(syscall(SYS_GETTID))
 }
diff --git a/core/sync/sync2/primitives_pthreads.odin b/core/sync/sync2/primitives_pthreads.odin
index 98270b739..97c453810 100644
--- a/core/sync/sync2/primitives_pthreads.odin
+++ b/core/sync/sync2/primitives_pthreads.odin
@@ -18,30 +18,30 @@ _Mutex :: struct {
 }
 
 _mutex_lock :: proc(m: ^Mutex) {
-	err := unix.pthread_mutex_lock(&m.impl.pthread_mutex);
-	assert(err == 0);
+	err := unix.pthread_mutex_lock(&m.impl.pthread_mutex)
+	assert(err == 0)
 }
 
 _mutex_unlock :: proc(m: ^Mutex) {
-	err := unix.pthread_mutex_unlock(&m.impl.pthread_mutex);
-	assert(err == 0);
+	err := unix.pthread_mutex_unlock(&m.impl.pthread_mutex)
+	assert(err == 0)
 }
 
 _mutex_try_lock :: proc(m: ^Mutex) -> bool {
-	err := unix.pthread_mutex_trylock(&m.impl.pthread_mutex);
-	return err == 0;
+	err := unix.pthread_mutex_trylock(&m.impl.pthread_mutex)
+	return err == 0
 }
 
 
 
-RW_Mutex_State :: distinct uint;
-RW_Mutex_State_Half_Width :: size_of(RW_Mutex_State)*8/2;
-RW_Mutex_State_Is_Writing :: RW_Mutex_State(1);
-RW_Mutex_State_Writer     :: RW_Mutex_State(1)<<1;
-RW_Mutex_State_Reader     :: RW_Mutex_State(1)<<RW_Mutex_State_Half_Width;
+RW_Mutex_State :: distinct uint
+RW_Mutex_State_Half_Width :: size_of(RW_Mutex_State)*8/2
+RW_Mutex_State_Is_Writing :: RW_Mutex_State(1)
+RW_Mutex_State_Writer     :: RW_Mutex_State(1)<<1
+RW_Mutex_State_Reader     :: RW_Mutex_State(1)<<RW_Mutex_State_Half_Width
 
-RW_Mutex_State_Writer_Mask :: RW_Mutex_State(1<<(RW_Mutex_State_Half_Width-1) - 1) << 1;
-RW_Mutex_State_Reader_Mask :: RW_Mutex_State(1<<(RW_Mutex_State_Half_Width-1) - 1) << RW_Mutex_State_Half_Width;
+RW_Mutex_State_Writer_Mask :: RW_Mutex_State(1<<(RW_Mutex_State_Half_Width-1) - 1) << 1
+RW_Mutex_State_Reader_Mask :: RW_Mutex_State(1<<(RW_Mutex_State_Half_Width-1) - 1) << RW_Mutex_State_Half_Width
 
 
 _RW_Mutex :: struct {
@@ -53,72 +53,72 @@ _RW_Mutex :: struct {
 }
 
 _rw_mutex_lock :: proc(rw: ^RW_Mutex) {
-	_ = atomic_add(&rw.impl.state, RW_Mutex_State_Writer);
-	mutex_lock(&rw.impl.mutex);
+	_ = atomic_add(&rw.impl.state, RW_Mutex_State_Writer)
+	mutex_lock(&rw.impl.mutex)
 
-	state := atomic_or(&rw.impl.state, RW_Mutex_State_Writer);
+	state := atomic_or(&rw.impl.state, RW_Mutex_State_Writer)
 	if state & RW_Mutex_State_Reader_Mask != 0 {
-		sema_wait(&rw.impl.sema);
+		sema_wait(&rw.impl.sema)
 	}
 }
 
 _rw_mutex_unlock :: proc(rw: ^RW_Mutex) {
-	_ = atomic_and(&rw.impl.state, ~RW_Mutex_State_Is_Writing);
-	mutex_unlock(&rw.impl.mutex);
+	_ = atomic_and(&rw.impl.state, ~RW_Mutex_State_Is_Writing)
+	mutex_unlock(&rw.impl.mutex)
 }
 
 _rw_mutex_try_lock :: proc(rw: ^RW_Mutex) -> bool {
 	if mutex_try_lock(&rw.impl.mutex) {
-		state := atomic_load(&rw.impl.state);
+		state := atomic_load(&rw.impl.state)
 		if state & RW_Mutex_State_Reader_Mask == 0 {
-			_ = atomic_or(&rw.impl.state, RW_Mutex_State_Is_Writing);
-			return true;
+			_ = atomic_or(&rw.impl.state, RW_Mutex_State_Is_Writing)
+			return true
 		}
 
-		mutex_unlock(&rw.impl.mutex);
+		mutex_unlock(&rw.impl.mutex)
 	}
-	return false;
+	return false
 }
 
 _rw_mutex_shared_lock :: proc(rw: ^RW_Mutex) {
-	state := atomic_load(&rw.impl.state);
+	state := atomic_load(&rw.impl.state)
 	for state & (RW_Mutex_State_Is_Writing|RW_Mutex_State_Writer_Mask) == 0 {
-		ok: bool;
-		state, ok = atomic_compare_exchange_weak(&rw.impl.state, state, state + RW_Mutex_State_Reader);
+		ok: bool
+		state, ok = atomic_compare_exchange_weak(&rw.impl.state, state, state + RW_Mutex_State_Reader)
 		if ok {
-			return;
+			return
 		}
 	}
 
-	mutex_lock(&rw.impl.mutex);
-	_ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader);
-	mutex_unlock(&rw.impl.mutex);
+	mutex_lock(&rw.impl.mutex)
+	_ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader)
+	mutex_unlock(&rw.impl.mutex)
 }
 
 _rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) {
-	state := atomic_sub(&rw.impl.state, RW_Mutex_State_Reader);
+	state := atomic_sub(&rw.impl.state, RW_Mutex_State_Reader)
 
 	if (state & RW_Mutex_State_Reader_Mask == RW_Mutex_State_Reader) &&
 	   (state & RW_Mutex_State_Is_Writing != 0) {
-	   	sema_post(&rw.impl.sema);
+	   	sema_post(&rw.impl.sema)
 	}
 }
 
 _rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool {
-	state := atomic_load(&rw.impl.state);
+	state := atomic_load(&rw.impl.state)
 	if state & (RW_Mutex_State_Is_Writing|RW_Mutex_State_Writer_Mask) == 0 {
-		_, ok := atomic_compare_exchange_strong(&rw.impl.state, state, state + RW_Mutex_State_Reader);
+		_, ok := atomic_compare_exchange_strong(&rw.impl.state, state, state + RW_Mutex_State_Reader)
 		if ok {
-			return true;
+			return true
 		}
 	}
 	if mutex_try_lock(&rw.impl.mutex) {
-		_ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader);
-		mutex_unlock(&rw.impl.mutex);
-		return true;
+		_ = atomic_add(&rw.impl.state, RW_Mutex_State_Reader)
+		mutex_unlock(&rw.impl.mutex)
+		return true
 	}
 
-	return false;
+	return false
 }
 
 
@@ -129,42 +129,42 @@ _Recursive_Mutex :: struct {
 }
 
 _recursive_mutex_lock :: proc(m: ^Recursive_Mutex) {
-	tid := _current_thread_id();
+	tid := _current_thread_id()
 	if tid != m.impl.owner {
-		mutex_lock(&m.impl.mutex);
+		mutex_lock(&m.impl.mutex)
 	}
 	// inside the lock
-	m.impl.owner = tid;
-	m.impl.recursion += 1;
+	m.impl.owner = tid
+	m.impl.recursion += 1
 }
 
 _recursive_mutex_unlock :: proc(m: ^Recursive_Mutex) {
-	tid := _current_thread_id();
-	assert(tid == m.impl.owner);
-	m.impl.recursion -= 1;
-	recursion := m.impl.recursion;
+	tid := _current_thread_id()
+	assert(tid == m.impl.owner)
+	m.impl.recursion -= 1
+	recursion := m.impl.recursion
 	if recursion == 0 {
-		m.impl.owner = 0;
+		m.impl.owner = 0
 	}
 	if recursion == 0 {
-		mutex_unlock(&m.impl.mutex);
+		mutex_unlock(&m.impl.mutex)
 	}
 	// outside the lock
 
 }
 
 _recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
-	tid := _current_thread_id();
+	tid := _current_thread_id()
 	if m.impl.owner == tid {
-		return mutex_try_lock(&m.impl.mutex);
+		return mutex_try_lock(&m.impl.mutex)
 	}
 	if !mutex_try_lock(&m.impl.mutex) {
-		return false;
+		return false
 	}
 	// inside the lock
-	m.impl.owner = tid;
-	m.impl.recursion += 1;
-	return true;
+	m.impl.owner = tid
+	m.impl.recursion += 1
+	return true
 }
 
 
@@ -173,29 +173,29 @@ _Cond :: struct {
 }
 
 _cond_wait :: proc(c: ^Cond, m: ^Mutex) {
-	err := unix.pthread_cond_wait(&c.impl.pthread_cond, &m.impl.pthread_mutex);
-	assert(err == 0);
+	err := unix.pthread_cond_wait(&c.impl.pthread_cond, &m.impl.pthread_mutex)
+	assert(err == 0)
 }
 
 _cond_wait_with_timeout :: proc(c: ^Cond, m: ^Mutex, timeout: time.Duration) -> bool {
-	ns := time.duration_nanoseconds(timeout);
+	ns := time.duration_nanoseconds(timeout)
 	timeout_timespec := &time.TimeSpec{
 		tv_sec  = ns / 1e9,
 		tv_nsec = ns % 1e9,
-	};
-	err := unix.pthread_cond_timedwait(&c.impl.pthread_cond, &m.impl.pthread_mutex, timeout_timespec);
+	}
+	err := unix.pthread_cond_timedwait(&c.impl.pthread_cond, &m.impl.pthread_mutex, timeout_timespec)
 	// TODO(bill):
-	return err == 0;
+	return err == 0
 }
 
 _cond_signal :: proc(c: ^Cond) {
-	err := unix.pthread_cond_signal(&c.impl.pthread_cond);
-	assert(err == 0);
+	err := unix.pthread_cond_signal(&c.impl.pthread_cond)
+	assert(err == 0)
 }
 
 _cond_broadcast :: proc(c: ^Cond) {
-	err := unix.pthread_cond_broadcast(&c.impl.pthread_cond);
-	assert(err == 0);
+	err := unix.pthread_cond_broadcast(&c.impl.pthread_cond)
+	assert(err == 0)
 }
 
 _Sema :: struct {
@@ -205,25 +205,25 @@ _Sema :: struct {
 }
 
 _sema_wait :: proc(s: ^Sema) {
-	mutex_lock(&s.impl.mutex);
-	defer mutex_unlock(&s.impl.mutex);
+	mutex_lock(&s.impl.mutex)
+	defer mutex_unlock(&s.impl.mutex)
 
 	for s.impl.count == 0 {
-		cond_wait(&s.impl.cond, &s.impl.mutex);
+		cond_wait(&s.impl.cond, &s.impl.mutex)
 	}
 
-	s.impl.count -= 1;
+	s.impl.count -= 1
 	if s.impl.count > 0 {
-		cond_signal(&s.impl.cond);
+		cond_signal(&s.impl.cond)
 	}
 }
 
 _sema_post :: proc(s: ^Sema, count := 1) {
-	mutex_lock(&s.impl.mutex);
-	defer mutex_unlock(&s.impl.mutex);
+	mutex_lock(&s.impl.mutex)
+	defer mutex_unlock(&s.impl.mutex)
 
-	s.impl.count += count;
-	cond_signal(&s.impl.cond);
+	s.impl.count += count
+	cond_signal(&s.impl.cond)
 }