Nearly finished Jai-like declarations

core/atomic.odin

@@ -5,36 +5,36 @@ 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.ReadWriteBarrier(); }
-proc sfence      () { win32.WriteBarrier(); }
-proc lfence      () { win32.ReadBarrier(); }
+yield_thread :: proc() { win32._mm_pause(); }
+mfence       :: proc() { win32.ReadWriteBarrier(); }
+sfence       :: proc() { win32.WriteBarrier(); }
+lfence       :: proc() { win32.ReadBarrier(); }
 
 
-proc load32(a ^i32) -> i32 {
+load32 :: proc(a ^i32) -> i32 {
 	return a^;
 }
-proc store32(a ^i32, value i32) {
+store32 :: proc(a ^i32, value i32) {
 	a^ = value;
 }
-proc compare_exchange32(a ^i32, expected, desired i32) -> i32 {
+compare_exchange32 :: proc(a ^i32, expected, desired i32) -> i32 {
 	return win32.InterlockedCompareExchange(a, desired, expected);
 }
-proc exchanged32(a ^i32, desired i32) -> i32 {
+exchanged32 :: proc(a ^i32, desired i32) -> i32 {
 	return win32.InterlockedExchange(a, desired);
 }
-proc fetch_add32(a ^i32, operand i32) -> i32 {
+fetch_add32 :: proc(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedExchangeAdd(a, operand);
 
 }
-proc fetch_and32(a ^i32, operand i32) -> i32 {
+fetch_and32 :: proc(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedAnd(a, operand);
 
 }
-proc fetch_or32(a ^i32, operand i32) -> i32 {
+fetch_or32 :: proc(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedOr(a, operand);
 }
-proc spin_lock32(a ^i32, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
+spin_lock32 :: proc(a ^i32, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange32(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -45,11 +45,11 @@ proc spin_lock32(a ^i32, time_out int) -> bool { // NOTE(bill) time_out = -1 as
 	}
 	return old_value == 0;
 }
-proc spin_unlock32(a ^i32) {
+spin_unlock32 :: proc(a ^i32) {
 	store32(a, 0);
 	mfence();
 }
-proc try_acquire_lock32(a ^i32) -> bool {
+try_acquire_lock32 :: proc(a ^i32) -> bool {
 	yield_thread();
 	old_value := compare_exchange32(a, 1, 0);
 	mfence();
@@ -57,28 +57,28 @@ proc try_acquire_lock32(a ^i32) -> bool {
 }
 
 
-proc load64(a ^i64) -> i64 {
+load64 :: proc(a ^i64) -> i64 {
 	return a^;
 }
-proc store64(a ^i64, value i64) {
+store64 :: proc(a ^i64, value i64) {
 	a^ = value;
 }
-proc compare_exchange64(a ^i64, expected, desired i64) -> i64 {
+compare_exchange64 :: proc(a ^i64, expected, desired i64) -> i64 {
 	return win32.InterlockedCompareExchange64(a, desired, expected);
 }
-proc exchanged64(a ^i64, desired i64) -> i64 {
+exchanged64 :: proc(a ^i64, desired i64) -> i64 {
 	return win32.InterlockedExchange64(a, desired);
 }
-proc fetch_add64(a ^i64, operand i64) -> i64 {
+fetch_add64 :: proc(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedExchangeAdd64(a, operand);
 }
-proc fetch_and64(a ^i64, operand i64) -> i64 {
+fetch_and64 :: proc(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedAnd64(a, operand);
 }
-proc fetch_or64(a ^i64, operand i64) -> i64 {
+fetch_or64 :: proc(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedOr64(a, operand);
 }
-proc spin_lock64(a ^i64, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
+spin_lock64 :: proc(a ^i64, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange64(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -89,11 +89,11 @@ proc spin_lock64(a ^i64, time_out int) -> bool { // NOTE(bill) time_out = -1 as
 	}
 	return old_value == 0;
 }
-proc spin_unlock64(a ^i64) {
+spin_unlock64 :: proc(a ^i64) {
 	store64(a, 0);
 	mfence();
 }
-proc try_acquire_lock64(a ^i64) -> bool {
+try_acquire_lock64 :: proc(a ^i64) -> bool {
 	yield_thread();
 	old_value := compare_exchange64(a, 1, 0);
 	mfence();