Initial project import

tools/v/vlib/builtin/closure/closure_nix.c.v

@@ -0,0 +1,108 @@
+module closure
+
+$if !freestanding && !vinix {
+	#include <sys/mman.h>
+	#insert "@VEXEROOT/vlib/builtin/closure/closure_once_nix.h"
+
+	fn C.v_closure_init_once(ClosureInitFn)
+}
+
+struct ClosureMutex {
+	closure_mtx [128]u8
+}
+
+@[inline]
+fn closure_mtx_ptr_platform() voidptr {
+	return unsafe { voidptr(&g_closure.closure_mtx[0]) }
+}
+
+@[inline]
+fn closure_alloc_platform() &u8 {
+	mut p := &u8(unsafe { nil })
+	$if freestanding {
+		// Freestanding environments (no OS) use simple malloc
+		p = unsafe { malloc(g_closure.v_page_size * 2) }
+		if isnil(p) {
+			return unsafe { nil }
+		}
+	} $else {
+		// Main OS environments use mmap to get aligned pages
+		p = unsafe {
+			C.mmap(0, g_closure.v_page_size * 2, C.PROT_READ | C.PROT_WRITE,
+				C.MAP_ANONYMOUS | C.MAP_PRIVATE, -1, 0)
+		}
+		if p == &u8(C.MAP_FAILED) {
+			return unsafe { nil }
+		}
+	}
+	return p
+}
+
+@[inline]
+fn closure_memory_protect_platform(ptr voidptr, size isize, attr MemoryProtectAtrr) {
+	$if freestanding {
+		// No memory protection in freestanding mode
+	} $else {
+		match attr {
+			.read_exec {
+				unsafe { C.mprotect(ptr, size, C.PROT_READ | C.PROT_EXEC) }
+			}
+			.read_write {
+				unsafe { C.mprotect(ptr, size, C.PROT_READ | C.PROT_WRITE) }
+			}
+		}
+	}
+}
+
+@[inline]
+fn get_page_size_platform() int {
+	// Determine system page size
+	mut page_size := 0x4000
+	$if !freestanding {
+		// Query actual page size in OS environments
+		page_size = unsafe { int(C.sysconf(C._SC_PAGESIZE)) }
+	}
+	// Calculate required allocation size
+	page_size = page_size * (((assumed_page_size - 1) / page_size) + 1)
+	return page_size
+}
+
+@[inline]
+fn closure_mtx_lock_init_platform() {
+	$if !freestanding || vinix {
+		C.pthread_mutex_init(closure_mtx_ptr_platform(), 0)
+	}
+}
+
+@[inline]
+fn closure_mtx_lock_platform() {
+	$if !freestanding || vinix {
+		C.pthread_mutex_lock(closure_mtx_ptr_platform())
+	}
+}
+
+@[inline]
+fn closure_mtx_unlock_platform() {
+	$if !freestanding || vinix {
+		C.pthread_mutex_unlock(closure_mtx_ptr_platform())
+	}
+}
+
+@[inline]
+fn closure_current_thread_id_platform() u64 {
+	$if !freestanding {
+		return u64(C.pthread_self())
+	}
+	return u64(0)
+}
+
+@[inline]
+fn closure_init_once_platform() {
+	$if freestanding || vinix {
+		if isnil(g_closure.closure_ptr) {
+			closure_init_body()
+		}
+	} $else {
+		C.v_closure_init_once(closure_init_body)
+	}
+}