nomen-lang 0.0.7 → 0.0.8

package/core/System/Math.nm

@@ -0,0 +1,54 @@
+/**
+ * Mathematical helper functions
+ **/
+pub struct Math {
+	pub func power = (int base, int exp, out int) {
+		```
+		#arch: c
+		int result = 1;
+		for (int i = 0; i < exp; i++) {
+			result *= base;
+		}
+		return result;
+		```
+		```
+		#arch: aarch64
+		mov x2, #1
+		mov x3, #0
+		b .Lchk_Math_power
+		.Lloop_Math_power:
+		mul x2, x2, x0
+		add x3, x3, #1
+		.Lchk_Math_power:
+		cmp x3, x1
+		blt .Lloop_Math_power
+		mov x0, x2
+		```
+	}
+
+	inline func sqrt = (float x, out float) {
+		```
+		#arch: c
+		return sqrt(x);
+		```
+		```
+		#arch: aarch64
+		fmov d0, x0
+		fsqrt d0, d0
+		fmov x0, d0
+		```
+	}
+
+	pub func log = (float x, out float) {
+		```
+		#arch: c
+		return log(x);
+		```
+		```
+		#arch: aarch64
+		fmov d0, x0
+		bl _log
+		fmov x0, d0
+		```
+	}
+}

package/core/System/Mutex.nm

@@ -0,0 +1,78 @@
+// Mutex — pthread-backed lock for shared mutable state.
+//
+// Default stance in Nomen is "no shared mutable state" — communicate by moving
+// Sendable values (or via Channel<T>). Mutex exists for when you genuinely
+// need shared mutability. See ASYNC.md.
+
+/**
+ * A pthread-backed mutual-exclusion lock for protecting shared mutable state
+ **/
+pub class Mutex: Sendable {
+	pub var uint64 handle = 0
+
+	pub func #init = (self) {
+		```
+		#arch: c
+		#scope: file
+		#include <pthread.h>
+		```
+		```
+		#arch: c
+		self->handle = (unsigned long long)malloc(sizeof(pthread_mutex_t));
+		pthread_mutex_init((pthread_mutex_t *)self->handle, NULL);
+		```
+		```
+		#arch: aarch64
+		mov x0, #64
+		bl _malloc
+		str x0, [x19, #8]
+		mov x1, #0
+		bl _pthread_mutex_init
+		```
+	}
+
+	pub func lock = (self) {
+		```
+		#arch: c
+		pthread_mutex_lock((pthread_mutex_t *)self->handle);
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		bl _pthread_mutex_lock
+		```
+	}
+
+	pub func unlock = (self) {
+		```
+		#arch: c
+		pthread_mutex_unlock((pthread_mutex_t *)self->handle);
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		bl _pthread_mutex_unlock
+		```
+	}
+
+	pub func #destroy = () {
+		```
+		#arch: c
+		if (self->handle) {
+			pthread_mutex_destroy((pthread_mutex_t *)self->handle);
+			free((void *)self->handle);
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lmutex_destroy_end
+		bl _pthread_mutex_destroy
+		ldr x0, [x19, #8]
+		bl _free
+		str xzr, [x19, #8]
+		.Lmutex_destroy_end:
+		```
+	}
+}

package/core/System/Nursery.nm

@@ -0,0 +1,27 @@
+// Nursery — the capability passed to a function that needs to spawn into its
+// caller's nursery (the Trio escape hatch). See ASYNC.md, "Escape hatch:
+// passing the nursery".
+//
+// An `async` block names its nursery (`async pool { }`), binding a Nursery
+// variable in scope. That variable is passed to helper functions with `ref`
+// and is the receiver of `pool.spawn(fn(args))`. The Nursery wraps the
+// per-invocation tracking state of the `async { }` block — a pointer to the
+// futures array and a pointer to the count slot, both on the async block's
+// stack frame — so it is only valid for the lifetime of its enclosing block
+// (which is exactly the structured-concurrency invariant: the block cannot
+// exit until every spawned task, including those spawned through a passed
+// Nursery, has finished).
+//
+// Config rides on the declaration: `async pool = Nursery(timeout: 2000) { }`.
+//
+// `name.spawn(fn(args))` is special-cased by the compiler (it needs the spawn
+// trampoline machinery), so it is NOT a regular method declared here. The two
+// fields are the full runtime contract.
+
+/**
+ * The capability for spawning into a caller's `async` block; owns and tracks its tasks
+ **/
+pub struct Nursery: Sendable {
+	pub var uint64 futures_ptr = 0
+	pub var uint64 count_ptr = 0
+}

package/core/System/Sendable.nm

@@ -0,0 +1,9 @@
+// Marker trait for types whose values are safe to move across task boundaries.
+// See ASYNC.md for the design. Auto-derivable in a follow-up; for now, structs
+// opt in explicitly with `: Sendable`.
+
+/**
+ * A marker trait for values that are safe to move across task boundaries
+ **/
+pub trait Sendable {
+}

package/core/System/Set.nm

@@ -0,0 +1,97 @@
+/**
+ * An ordered set of unique values (`add`/`has`/`get`/`remove`)
+ **/
+pub struct Set<T> {
+	var length = 0
+	var Buffer<T> slots = Buffer<T>()
+	var used = Buffer<int>()
+
+	pub func add = (ref self, mov T value) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			cap = self.slots.alloc_int(8)
+			self.used.alloc(8)
+		}
+		if self.length * 4 >= cap * 3 {
+			self.rehash(cap * 2)
+			cap = self.slots.cap
+		}
+		var int idx = self.find_slot(value, cap)
+		if self.used.load(idx) == 0 {
+			self.used.store(idx, 1)
+			self.slots.store_int(idx, value)
+			self.length += 1
+		}
+	}
+
+	pub func has = (self, T value, out bool) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			return false
+		}
+		var int idx = self.find_slot(value, cap)
+		return self.used.load(idx) != 0
+	}
+
+	pub func get = (self, T key, out T) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			return 0
+		}
+		var int idx = self.find_slot(key, cap)
+		if self.used.load(idx) == 0 {
+			return 0
+		}
+		return self.slots.load_int(idx)
+	}
+
+	pub func remove = (ref self, T value) {
+		var int cap = self.slots.cap
+		if cap == 0 {
+			return
+		}
+		var int idx = self.find_slot(value, cap)
+		if self.used.load(idx) == 0 {
+			return
+		}
+		self.used.store(idx, 0)
+		self.slots.store_int(idx, 0)
+		self.length = self.length - 1
+		self.rehash(cap)
+	}
+
+	func find_slot = (self, T value, int cap, out int: out >= 0 && out < cap) {
+		var int v = value
+		var int idx = v % cap
+		if idx < 0 {
+			idx = idx + cap
+		}
+		while self.used.load(idx) != 0 {
+			if self.slots.load_int(idx) == v {
+				return idx
+			}
+			idx += 1
+			if idx >= cap {
+				idx = 0
+			}
+		}
+		return idx
+	}
+
+	func rehash = (ref self, int new_cap) {
+		var Buffer<T> old_slots = mov self.slots swap Buffer<T>()
+		var Buffer<int> old_used = mov self.used swap Buffer<int>()
+		var int old_cap = old_slots.cap
+
+		self.slots.alloc_int(new_cap)
+		self.used.alloc(new_cap)
+		self.length = 0
+
+		var i = 0
+		while i < old_cap; i += 1 {
+			if old_used.load(i) != 0 {
+				self.add(old_slots.load_int(i))
+			}
+		}
+	}
+}

package/core/System/Stream/Directory.nm

@@ -0,0 +1,176 @@
+/**
+ * Helpers for working with filesystem directories.
+ *
+ * `Directory` is a namespace of static helpers — no instance is constructed.
+ *
+ *	Directory.create("scratch")
+ *	const string names = Directory.list("scratch")
+ *	const bool has     = Directory.exists("scratch")
+ *	Directory.remove("scratch")
+ **/
+pub struct Directory {
+	// (static) Create a directory at `path`.
+	pub func create = (string path) {
+		```
+		#arch: c
+		mkdir(path, 0777);
+		```
+		```
+		#arch: aarch64
+		mov x1, #0x1FF
+		bl _mkdir
+		```
+	}
+
+	// (static) Remove the (empty) directory at `path`.
+	pub func remove = (string path) {
+		```
+		#arch: c
+		rmdir(path);
+		```
+		```
+		#arch: aarch64
+		bl _rmdir
+		```
+	}
+
+	// (static) Whether a directory exists at `path`.
+	pub func exists = (string path, out bool) {
+		```
+		#arch: c
+		struct stat st;
+		return stat(path, &st) == 0 ? 1 : 0;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #160
+		mov x1, sp
+		bl _stat
+		cmp x0, #0
+		cset x0, eq
+		add sp, sp, #160
+		b .return_Directory_exists
+		```
+		return false
+	}
+
+	// Returns the directory's entry names as a single newline-separated
+	// string. The `.` and `..` entries are skipped. Returns an empty string
+	// if the path cannot be opened.
+	//
+	// On macOS/iOS the entry length is read from `dirent.d_namlen`, so this
+	// is currently macOS-specific aarch64 asm (the C backend is portable).
+	pub func list = (string path, out string) {
+		```
+		#arch: c
+		#scope: file
+		#include <dirent.h>
+		```
+		```
+		#arch: c
+		DIR *d = opendir(path);
+		if (!d) return strdup("");
+		int cap = 4096;
+		int len = 0;
+		char *buf = (char*)malloc(cap);
+		struct dirent *e;
+		while ((e = readdir(d)) != NULL) {
+			if (e->d_name[0] == '.' && e->d_name[1] == 0) continue;
+			if (e->d_name[0] == '.' && e->d_name[1] == '.' && e->d_name[2] == 0) continue;
+			int nl = (int)strlen(e->d_name);
+			if (len + nl + 2 > cap) {
+				while (len + nl + 2 > cap) cap *= 2;
+				buf = (char*)realloc(buf, cap);
+			}
+			memcpy(buf + len, e->d_name, nl);
+			len += nl;
+			buf[len++] = '\n';
+		}
+		buf[len] = 0;
+		closedir(d);
+		return buf;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #64
+		str x0, [sp, #0]
+		bl _opendir
+		str x0, [sp, #8]
+		cbz x0, .Ldir_list_empty
+		mov x0, #4096
+		bl _malloc
+		str x0, [sp, #16]
+		str xzr, [sp, #24]
+		mov x0, #4096
+		str x0, [sp, #32]
+		.Ldir_list_loop:
+		ldr x0, [sp, #8]
+		bl _readdir
+		str x0, [sp, #40]
+		cbz x0, .Ldir_list_done
+		ldrb w1, [x0, #21]
+		cmp w1, #46
+		bne .Ldir_list_keep
+		ldrb w1, [x0, #22]
+		cbz w1, .Ldir_list_loop
+		cmp w1, #46
+		bne .Ldir_list_keep
+		ldrb w1, [x0, #23]
+		cbz w1, .Ldir_list_loop
+		.Ldir_list_keep:
+		ldr x0, [sp, #40]
+		ldrh w0, [x0, #18]
+		str x0, [sp, #48]
+		.Ldir_list_grow:
+		ldr x1, [sp, #24]
+		ldr x2, [sp, #48]
+		add x1, x1, x2
+		add x1, x1, #2
+		ldr x2, [sp, #32]
+		cmp x1, x2
+		ble .Ldir_list_grow_ok
+		lsl x2, x2, #1
+		str x2, [sp, #32]
+		ldr x0, [sp, #16]
+		bl _realloc
+		str x0, [sp, #16]
+		b .Ldir_list_grow
+		.Ldir_list_grow_ok:
+		ldr x0, [sp, #16]
+		ldr x1, [sp, #24]
+		add x0, x0, x1
+		ldr x1, [sp, #40]
+		add x1, x1, #21
+		ldr x2, [sp, #48]
+		bl _memcpy
+		ldr x0, [sp, #48]
+		ldr x1, [sp, #24]
+		add x1, x1, x0
+		str x1, [sp, #24]
+		ldr x0, [sp, #16]
+		ldr x1, [sp, #24]
+		mov w2, #10
+		strb w2, [x0, x1]
+		add x1, x1, #1
+		str x1, [sp, #24]
+		b .Ldir_list_loop
+		.Ldir_list_done:
+		ldr x0, [sp, #16]
+		ldr x1, [sp, #24]
+		strb wzr, [x0, x1]
+		ldr x0, [sp, #8]
+		bl _closedir
+		ldr x0, [sp, #16]
+		add sp, sp, #64
+		b .return_Directory_list
+		.Ldir_list_empty:
+		adr x0, .Ldir_list_empty_str
+		bl _strdup
+		add sp, sp, #64
+		b .return_Directory_list
+		.Ldir_list_empty_str: .asciz ""
+		.p2align 2
+		```
+		return ""
+	}
+}