nomen-lang 0.0.7 → 0.0.8

package/core/System/ClassBuffer.nm

@@ -0,0 +1,229 @@
+// ClassBuffer<T>: a flat buffer of owned class pointers of type T. The
+// class-ness is compile-time: #destroy calls the monomorphized element destroy
+// (`T_destroy` -> e.g. Animal_destroy) directly, and store_int/replace_int
+// forbid 0 (you can't overwrite a pointer with null and leak it — use move_int
+// to relinquish a slot). T must be a class. Buffer<T> is the value counterpart.
+
+/**
+ * A flat buffer of owned class pointers of type T — the backing store for collections of classes
+ **/
+pub struct ClassBuffer<T> {
+	var uint64 data = 0
+	var cap = 0
+
+	func alloc_int = (ref self, int size, out int: out >= size) {
+		```
+		#arch: c
+		self->cap = size;
+		self->data = (unsigned long long)(long*)calloc(size, sizeof(long));
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		str x1, [x19, #16]
+		mov x0, x1
+		mov x1, #8
+		bl _calloc
+		str x0, [x19, #8]
+		ldr x0, [x19, #16]
+		```
+	}
+
+	func grow_int = (ref self, int needed, out int: out >= needed) {
+		```
+		#arch: c
+		if (self->cap >= needed) return self->cap;
+		int new_cap = self->cap;
+		if (new_cap == 0) new_cap = 4;
+		while (new_cap < needed) new_cap *= 2;
+		self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
+		memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
+		self->cap = new_cap;
+		return self->cap;
+		```
+		```
+		#arch: aarch64
+		ldr x2, [x19, #16]
+		cmp x2, x1
+		b.ge .Lcb_grow_end
+		mov x3, #4
+		cmp x2, #0
+		csel x3, x3, x2, eq
+		cmp x3, x1
+		b.ge .Lcb_grow_got
+		.Lcb_grow_loop:
+		lsl x3, x3, #1
+		cmp x3, x1
+		b.lt .Lcb_grow_loop
+		.Lcb_grow_got:
+		sub sp, sp, #16
+		str x2, [sp, #0]
+		str x3, [sp, #8]
+		ldr x0, [x19, #8]
+		lsl x1, x3, #3
+		bl _realloc
+		str x0, [x19, #8]
+		ldr x2, [sp, #0]
+		ldr x3, [sp, #8]
+		add sp, sp, #16
+		str x3, [x19, #16]
+		add x0, x0, x2, lsl #3
+		mov x1, #0
+		sub x2, x3, x2
+		lsl x2, x2, #3
+		bl _memset
+		.Lcb_grow_end:
+		ldr x0, [x19, #16]
+		```
+	}
+
+	inline func load_int = (self, int i: i >= 0 && i < self.cap, out int) {
+		```
+		#arch: c
+		return ((long*)(unsigned long long)self->data)[i];
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x1, x1, #3
+		add x0, x0, x1
+		ldr x0, [x0]
+		```
+	}
+
+	inline func store_int = (ref self, int i: i >= 0 && i < self.cap, int val: val != 0) {
+		```
+		#arch: c
+		((long*)(unsigned long long)self->data)[i] = val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x0, x0, x3
+		str x2, [x0]
+		```
+	}
+
+	inline func move_int = (ref self, int i: i >= 0 && i < self.cap, out int) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		long val = slots[i];
+		slots[i] = 0;
+		return val;
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x3, x0, x3
+		ldr x0, [x3]
+		str xzr, [x3]
+		```
+	}
+
+	// Store into a slot, freeing the previous value (it is an owned class
+	// pointer): run its destroy then free it before overwriting.
+	func replace_int = (ref self, int i: i >= 0 && i < self.cap, int val: val != 0) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		if (slots[i]) {
+			T_destroy((void*)slots[i]);
+			free((void*)slots[i]);
+		}
+		slots[i] = val;
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		str x22, [sp, #-16]!
+		ldr x0, [x19, #8]
+		lsl x3, x1, #3
+		add x21, x0, x3
+		mov x20, x2
+		ldr x0, [x21]
+		cbz x0, .Lcb_replace_store
+		mov x22, x0
+		bl T_destroy
+		mov x0, x22
+		bl _free
+		.Lcb_replace_store:
+		str x20, [x21]
+		ldr x22, [sp], #16
+		ldp x20, x21, [sp], #16
+		```
+	}
+
+	// A non-owning (ptr, len) slice [start, end) over this buffer's class
+	// pointers, returned as a `view T` (T is a class, so each element is an
+	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors
+	// Buffer.slice; ClassBuffer stores 8-byte slots, so the element width is 8.
+	func slice = (self, int start: start >= 0, int end: end >= start, out view T) {
+		```
+		#arch: c
+		nomen_view _r;
+		_r.ptr = (void*)((long*)(unsigned long long)self->data + start);
+		_r.len = (long)(end - start);
+		return _r;
+		```
+		```
+		#arch: aarch64
+		// x19 = self (ClassBuffer struct ptr), x1 = start, x2 = end.
+		// self->data at [x19, #8]. Return (ptr, len) in x0/x1.
+		ldr x0, [x19, #8]
+		mov x3, #8
+		madd x0, x1, x3, x0
+		sub x1, x2, x1
+		```
+	}
+
+	func #destroy = () {
+		```
+		#arch: c
+		if (self->data) {
+			long *slots = (long*)(unsigned long long)self->data;
+			for (int i = 0; i < self->cap; i++) {
+				if (slots[i]) {
+					T_destroy((void*)slots[i]);
+					free((void*)slots[i]);
+				}
+			}
+			free(slots);
+		}
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lcb_destroy_end
+		stp x20, x21, [sp, #-16]!
+		str x22, [sp, #-16]!
+		mov x20, x0
+		ldr x21, [x19, #16]
+		mov x22, #0
+		.Lcb_destroy_loop:
+		cmp x22, x21
+		b.ge .Lcb_destroy_done
+		ldr x0, [x20, x22, lsl #3]
+		cbz x0, .Lcb_destroy_skip
+		str x0, [sp, #-16]!
+		bl T_destroy
+		ldr x0, [sp], #16
+		bl _free
+		.Lcb_destroy_skip:
+		add x22, x22, #1
+		b .Lcb_destroy_loop
+		.Lcb_destroy_done:
+		ldr x22, [sp], #16
+		ldp x20, x21, [sp], #16
+		.Lcb_destroy_end:
+		ldr x0, [x19, #8]
+		cbz x0, .Lcb_destroy_free_done
+		bl _free
+		.Lcb_destroy_free_done:
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
+		```
+	}
+}

package/core/System/Console.nm

@@ -0,0 +1,211 @@
+/**
+ * The standard console — writing text to, and reading input from, the terminal
+ **/
+pub struct Console {
+	pub func write = (string line) {
+		```
+		#arch: c
+		printf("%s", line);
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #16
+		mov x1, x0
+		str x1, [sp]
+		adr x0, .Lfmt_console_s
+		bl _printf
+		add sp, sp, #16
+		b .Lend_Console_write
+		.Lfmt_console_s: .asciz "%s"
+		.p2align 2
+		.Lend_Console_write:
+		```
+	}
+
+	pub func write_line = (string line) {
+		```
+		#arch: c
+		printf("%s\n", line);
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #16
+		mov x1, x0
+		str x1, [sp]
+		adr x0, .Lfmt_console_snl
+		bl _printf
+		add sp, sp, #16
+		b .Lend_Console_write_line
+		.Lfmt_console_snl: .asciz "%s\n"
+		.p2align 2
+		.Lend_Console_write_line:
+		```
+	}
+
+	pub func read_line = (out string) {
+		```
+		#arch: c
+		int cap = 16;
+		int len = 0;
+		char *buf = (char*)malloc(cap);
+		int c = getchar();
+		while (c != EOF && c != '\n') {
+			if (len + 2 > cap) {
+				cap *= 2;
+				buf = (char*)realloc(buf, cap);
+			}
+			buf[len++] = (char)c;
+			c = getchar();
+		}
+		buf[len] = 0;
+		return buf;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #32
+		mov x0, #16
+		bl _malloc
+		str x0, [sp, #0]
+		mov x1, #16
+		str x1, [sp, #8]
+		str xzr, [sp, #16]
+		bl _getchar
+		str w0, [sp, #24]
+		.Lconsole_readline_loop:
+		ldr w0, [sp, #24]
+		cmp w0, #0
+		blt .Lconsole_readline_done
+		cmp w0, #10
+		beq .Lconsole_readline_done
+		ldr x0, [sp, #16]
+		add x0, x0, #1
+		ldr x1, [sp, #8]
+		cmp x0, x1
+		ble .Lconsole_readline_store
+		ldr x1, [sp, #8]
+		lsl x1, x1, #1
+		str x1, [sp, #8]
+		ldr x0, [sp, #0]
+		bl _realloc
+		str x0, [sp, #0]
+		.Lconsole_readline_store:
+		ldr x0, [sp, #0]
+		ldr x1, [sp, #16]
+		ldr w2, [sp, #24]
+		strb w2, [x0, x1]
+		ldr x0, [sp, #16]
+		add x0, x0, #1
+		str x0, [sp, #16]
+		bl _getchar
+		str w0, [sp, #24]
+		b .Lconsole_readline_loop
+		.Lconsole_readline_done:
+		ldr x0, [sp, #0]
+		ldr x1, [sp, #16]
+		strb wzr, [x0, x1]
+		ldr x0, [sp, #0]
+		add sp, sp, #32
+		b .return_Console_read_line
+		```
+		return ""
+	}
+
+	pub func read_char = (out char) {
+		```
+		#arch: c
+		return (char)getchar();
+		```
+		```
+		#arch: aarch64
+		bl _getchar
+		```
+	}
+
+	pub func platform = (out string) {
+		```
+		#arch: c
+		#platform: macos
+		return strdup("macos");
+		```
+		```
+		#arch: c
+		#platform: ios
+		return strdup("ios");
+		```
+		```
+		#arch: c
+		#platform: linux
+		return strdup("linux");
+		```
+		```
+		#arch: c
+		#platform: android
+		return strdup("android");
+		```
+		```
+		#arch: c
+		#platform: windows
+		return strdup("windows");
+		```
+		```
+		#arch: c
+		#platform: web
+		return strdup("web");
+		```
+		```
+		#arch: aarch64
+		#platform: macos
+		adr x0, .Lconsole_plat_macos
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_macos: .asciz "macos"
+		.p2align 2
+		```
+		```
+		#arch: aarch64
+		#platform: ios
+		adr x0, .Lconsole_plat_ios
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_ios: .asciz "ios"
+		.p2align 2
+		```
+		```
+		#arch: aarch64
+		#platform: linux
+		adr x0, .Lconsole_plat_linux
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_linux: .asciz "linux"
+		.p2align 2
+		```
+		```
+		#arch: aarch64
+		#platform: android
+		adr x0, .Lconsole_plat_android
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_android: .asciz "android"
+		.p2align 2
+		```
+		```
+		#arch: aarch64
+		#platform: windows
+		adr x0, .Lconsole_plat_windows
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_windows: .asciz "windows"
+		.p2align 2
+		```
+		```
+		#arch: aarch64
+		#platform: web
+		adr x0, .Lconsole_plat_web
+		bl _strdup
+		b .return_Console_platform
+		.Lconsole_plat_web: .asciz "web"
+		.p2align 2
+		```
+		return ""
+	}
+}

package/core/System/Controls/Button.nm

@@ -0,0 +1,138 @@
+/**
+ * A push-button control that triggers an action when clicked
+ **/
+pub class Button : Control {
+	var uint64 handle = 0
+
+	pub func #init = (self, Window window, string title) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		id btn = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("NSButton"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 100, 32));
+		((void(*)(id, SEL, unsigned long))objc_msgSend)(
+			btn, sel_registerName("setButtonType:"), 1); // NSPushInButton = 1 (momentary push)
+		((void(*)(id, SEL, id))objc_msgSend)(
+			btn, sel_registerName("setTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title));
+		id contentView = ((id(*)(id, SEL))objc_msgSend)(
+			(id)window->handle, sel_registerName("contentView"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			contentView, sel_registerName("addSubview:"), btn);
+		self->handle = (uint64_t)btn;
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		id btn = ((id(*)(id, SEL, CGRect))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)((id)objc_getClass("UIButton"), sel_registerName("alloc")),
+			sel_registerName("initWithFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)(0, 0, 100, 32));
+		((void(*)(id, SEL, unsigned long, id, id))objc_msgSend)(
+			btn, sel_registerName("setTitle:forState:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title),
+			0); // UIControlStateNormal = 0
+		id parentView = ((id(*)(id, SEL))objc_msgSend)(
+			((id(*)(id, SEL))objc_msgSend)(
+				(id)window->handle, sel_registerName("rootViewController")),
+			sel_registerName("view"));
+		((void(*)(id, SEL, id))objc_msgSend)(
+			parentView, sel_registerName("addSubview:"), btn);
+		self->handle = (uint64_t)btn;
+		```
+	}
+
+	pub func set_frame = (ref self, int x, int y, int width, int height) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, CGRect))objc_msgSend)(
+			(id)self->handle, sel_registerName("setFrame:"),
+			((CGRect(*)(double, double, double, double))CGRectMake)((double)x, (double)y, (double)width, (double)height));
+		```
+	}
+
+	pub func set_title = (self, string title) {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		((void(*)(id, SEL, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setTitle:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title));
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		((void(*)(id, SEL, unsigned long, id, id))objc_msgSend)(
+			(id)self->handle, sel_registerName("setTitle:forState:"),
+			((id(*)(id, SEL, const char*))objc_msgSend)(
+				(id)objc_getClass("NSString"), sel_registerName("stringWithUTF8String:"), title),
+			0); // UIControlStateNormal = 0
+		```
+	}
+
+	// ── Control trait conformance ──
+	// A button sizes to its native intrinsic content size (title + chrome);
+	// `measure` clamps that to the box constraints. The native query goes
+	// through the shared `native_intrinsic` FFI (see Container.nm), which works
+	// on both backends — a per-control raw block couldn't return a `Size` from
+	// the aarch64 companion (struct-name mangling) nor mutate a Nomen local.
+
+	pub func intrinsic_size = (self, out Size) {
+		var [w, h] = native_intrinsic(self.handle)
+		var Size s = Size()
+		s.width = w
+		s.height = h
+		return s
+	}
+
+	pub func measure = (self, BoxConstraints constraints, out Size) {
+		var Size s = self.intrinsic_size()
+		if s.width > constraints.max_width {
+			s.width = constraints.max_width
+		}
+		if s.width < constraints.min_width {
+			s.width = constraints.min_width
+		}
+		if s.height > constraints.max_height {
+			s.height = constraints.max_height
+		}
+		if s.height < constraints.min_height {
+			s.height = constraints.min_height
+		}
+		return s
+	}
+
+	func #destroy = () {
+		```
+		#arch: c, aarch64_use_c
+		#platform: macos
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: c, aarch64_use_c
+		#platform: ios
+		if (self->handle) {
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("removeFromSuperview"));
+			((void(*)(id, SEL))objc_msgSend)((id)self->handle, sel_registerName("release"));
+			self->handle = 0;
+		}
+		```
+	}
+}