:: style procedure declarations; remove old parsing code

core/atomics.odin

@@ -5,35 +5,35 @@ import win32 "sys/windows.odin" when ODIN_OS == "windows";
 _ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
 
 
-proc yield_thread() { win32.mm_pause(); }
-proc mfence      () { win32.read_write_barrier(); }
-proc sfence      () { win32.write_barrier(); }
-proc lfence      () { win32.read_barrier(); }
+yield_thread :: proc() { win32.mm_pause(); }
+mfence       :: proc() { win32.read_write_barrier(); }
+sfence       :: proc() { win32.write_barrier(); }
+lfence       :: proc() { win32.read_barrier(); }
 
 
-proc load(a: ^i32) -> i32 {
+load :: proc(a: ^i32) -> i32 {
 	return a^;
 }
-proc store(a: ^i32, value: i32) {
+store :: proc(a: ^i32, value: i32) {
 	a^ = value;
 }
-proc compare_exchange(a: ^i32, expected, desired: i32) -> i32 {
+compare_exchange :: proc(a: ^i32, expected, desired: i32) -> i32 {
 	return win32.interlocked_compare_exchange(a, desired, expected);
 }
-proc exchanged(a: ^i32, desired: i32) -> i32 {
+exchanged :: proc(a: ^i32, desired: i32) -> i32 {
 	return win32.interlocked_exchange(a, desired);
 }
-proc fetch_add(a: ^i32, operand: i32) -> i32 {
+fetch_add :: proc(a: ^i32, operand: i32) -> i32 {
 	return win32.interlocked_exchange_add(a, operand);
 
 }
-proc fetch_and(a: ^i32, operand: i32) -> i32 {
+fetch_and :: proc(a: ^i32, operand: i32) -> i32 {
 	return win32.interlocked_and(a, operand);
 }
-proc fetch_or(a: ^i32, operand: i32) -> i32 {
+fetch_or :: proc(a: ^i32, operand: i32) -> i32 {
 	return win32.interlocked_or(a, operand);
 }
-proc spin_lock(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
+spin_lock :: proc(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -44,11 +44,11 @@ proc spin_lock(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as
 	}
 	return old_value == 0;
 }
-proc spin_unlock(a: ^i32) {
+spin_unlock :: proc(a: ^i32) {
 	store(a, 0);
 	mfence();
 }
-proc try_acquire_lock(a: ^i32) -> bool {
+try_acquire_lock :: proc(a: ^i32) -> bool {
 	yield_thread();
 	old_value := compare_exchange(a, 1, 0);
 	mfence();
@@ -56,28 +56,28 @@ proc try_acquire_lock(a: ^i32) -> bool {
 }
 
 
-proc load(a: ^i64) -> i64 {
+load :: proc(a: ^i64) -> i64 {
 	return a^;
 }
-proc store(a: ^i64, value: i64) {
+store :: proc(a: ^i64, value: i64) {
 	a^ = value;
 }
-proc compare_exchange(a: ^i64, expected, desired: i64) -> i64 {
+compare_exchange :: proc(a: ^i64, expected, desired: i64) -> i64 {
 	return win32.interlocked_compare_exchange64(a, desired, expected);
 }
-proc exchanged(a: ^i64, desired: i64) -> i64 {
+exchanged :: proc(a: ^i64, desired: i64) -> i64 {
 	return win32.interlocked_exchange64(a, desired);
 }
-proc fetch_add(a: ^i64, operand: i64) -> i64 {
+fetch_add :: proc(a: ^i64, operand: i64) -> i64 {
 	return win32.interlocked_exchange_add64(a, operand);
 }
-proc fetch_and(a: ^i64, operand: i64) -> i64 {
+fetch_and :: proc(a: ^i64, operand: i64) -> i64 {
 	return win32.interlocked_and64(a, operand);
 }
-proc fetch_or(a: ^i64, operand: i64) -> i64 {
+fetch_or :: proc(a: ^i64, operand: i64) -> i64 {
 	return win32.interlocked_or64(a, operand);
 }
-proc spin_lock(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
+spin_lock :: proc(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -88,11 +88,11 @@ proc spin_lock(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as
 	}
 	return old_value == 0;
 }
-proc spin_unlock(a: ^i64) {
+spin_unlock :: proc(a: ^i64) {
 	store(a, 0);
 	mfence();
 }
-proc try_acquire_lock(a: ^i64) -> bool {
+try_acquire_lock :: proc(a: ^i64) -> bool {
 	yield_thread();
 	old_value := compare_exchange(a, 1, 0);
 	mfence();