nomen-lang 0.6.0 → 0.6.1

package/core/System/StringBuilder.nm

@@ -120,6 +120,121 @@ pub struct StringBuilder {
 		}
 	}
 
+	// Read-back: how many bytes the buffer currently holds. (The `len` field
+	// is private; this is the O(1) peek the incremental-builder flow needs —
+	// e.g. recording a mark before appending a section.)
+	pub func length = (self, out int) {
+		return self.len
+	}
+
+	// Whether the buffer's current bytes end with `suffix` (an empty suffix
+	// is always true). Reads the buffer tail in place — no copy of either
+	// side (`view string` avoids materializing the checked suffix).
+	pub func ends_with = (ref self, view string suffix, out bool) {
+		unsafe {
+			var int sl = suffix.length
+			if sl > self.len {
+				return false
+			}
+			var int start = self.len - sl
+			var int i = 0
+			while i < sl; i += 1 {
+				if (self.data as ptr char)[start + i] != (suffix as ptr char)[i] {
+					return false
+				}
+			}
+		}
+		return true
+	}
+
+	// Truncate the buffer to `new_len` bytes (clamped to [0, len]). Capacity
+	// is kept, so a subsequent append reuses the storage without a realloc.
+	pub func truncate = (ref self, int new_len) {
+		var int n = new_len
+		if n < 0 {
+			n = 0
+		}
+		if n > self.len {
+			n = self.len
+		}
+		self.len = n
+	}
+
+	// Drop the last byte (a no-op when the buffer is empty). The common
+	// chomp-the-trailing-separator shape.
+	pub func chomp = (ref self) {
+		if self.len > 0 {
+			self.len = self.len - 1
+		}
+	}
+
+	// Extract the bytes from `mark` to the end as a fresh owned string and
+	// rewind the buffer to `mark` bytes (capacity kept). The mid-render
+	// measure-and-restart shape: record `length()`, append a section, then
+	// `take_since(mark)` to measure it and re-emit decorated. `mark` clamps
+	// to [0, len]; the returned string is always an independent allocation.
+	// (`move out string` — the raw body mallocs the result, so the caller
+	// owns it by signature, like `Console.read_line`.)
+	func take_since = (ref self, int mark, move out string) {
+		```
+		#arch: c
+		int start = mark;
+		if (start < 0) start = 0;
+		if (start > self->len) start = self->len;
+		int n = self->len - start;
+		char* buf = (char*)malloc((size_t)n + 1);
+		if (n > 0) memcpy(buf, (void*)(unsigned long long)(self->data + start), n);
+		buf[n] = 0;
+		self->len = start;
+		// Fat-string ABI: return the (ptr, len) pair — no strlen.
+		return (nomen_string){ buf, n };
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = mark. Clamp start to [0, len]; malloc(n+1),
+		// copy the tail, null-terminate, rewind len. Live values live in a
+		// 32-byte (16-aligned) frame across the calls (x0-x18 are
+		// caller-saved): [sp]=start, [sp+8]=n, [sp+16]=buf.
+		ldr x2, [x19, #16]          // len
+		mov x3, x1                  // start = mark
+		cmp x3, #0
+		b.ge .Lsb_tk_hi
+		mov x3, #0
+		.Lsb_tk_hi:
+		cmp x3, x2
+		b.le .Lsb_tk_ok
+		mov x3, x2                  // start = min(start, len)
+		.Lsb_tk_ok:
+		sub x4, x2, x3              // n = len - start
+		sub sp, sp, #32
+		str x3, [sp, #0]            // start
+		str x4, [sp, #8]            // n
+		add x0, x4, #1
+		// buf = malloc(n + 1) — bare call line: the audit pass rewrites
+		// `bl _malloc` (line-exact) to the counter-wrapped allocator.
+		bl _malloc
+		str x0, [sp, #16]
+		ldr x1, [sp, #8]            // n
+		cbz x1, .Lsb_tk_copied
+		ldr x0, [sp, #16]           // dst = buf
+		ldr x3, [x19, #8]           // data
+		ldr x4, [sp, #0]            // start
+		add x1, x3, x4              // src = data + start
+		ldr x2, [sp, #8]            // n
+		bl _memcpy
+		.Lsb_tk_copied:
+		ldr x0, [sp, #16]           // buf
+		ldr x1, [sp, #8]            // n
+		add x2, x0, x1
+		strb wzr, [x2]              // buf[n] = 0
+		ldr x3, [sp, #0]            // start
+		str x3, [x19, #16]          // len = start
+		ldr x0, [sp, #16]           // return pair: (buf, n)
+		ldr x1, [sp, #8]
+		add sp, sp, #32
+		```
+	}
+
 	// Finalize: null-terminate, return the byte buffer as a string, and
 	// release ownership (sets `data` to 0 so the destructor won't free it).
 	func to_string = (ref self, out string) {

package/core/System/Text/Regex.nm

@@ -469,10 +469,10 @@ func collect_first_bytes = (
 //
 // Handles the shapes the engine's matcher can produce: a leading anchor is
 // zero-width (skipped), a leading group contributes its CONTENT's first bytes
-// (recursively over the group's own top-level alternatives), and a group
-// quantified with '?'/'*' is nullable — what FOLLOWS it can also be first, so
-// the scan continues past it. A wildcard '.' or an empty alternative makes the
-// set indeterminable.
+// (recursively over the group's own top-level alternatives), and ANY leading
+// atom — literal, escaped, class, or group — quantified with '?'/'*' is
+// nullable: what FOLLOWS it can also be first, so the scan continues past it.
+// A wildcard '.' or an empty alternative makes the set indeterminable.
 func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb, out int) {
 	var int i = start
 	while i < end {
@@ -490,9 +490,17 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 					if shorthand_members(e, ref sb) < 0 {
 						return -1
 					}
+				} else {
+					sb.append_char(e)
+				}
+				// A '?'/'*' quantifier makes the atom nullable — the first
+				// byte can also come from whatever follows it.
+				var int cont = nullable_quant_after(pattern, i + 2, end)
+				if cont < 0 {
 					return 0
 				}
-				sb.append_char(e)
+				i = cont
+				continue
 			}
 			return 0
 		}
@@ -509,7 +517,12 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 				}
 			}
 			add_class_chars(pattern, i + 1, a_end - 1, ref sb)
-			return 0
+			var int cont = nullable_quant_after(pattern, a_end, end)
+			if cont < 0 {
+				return 0
+			}
+			i = cont
+			continue
 		}
 		if c == '(' {
 			var int a_end = atom_end_pos(pattern, i, end)
@@ -518,27 +531,11 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 			if collect_first_bytes(pattern, i + 1, a_end - 1, ref sb) < 0 {
 				return -1
 			}
-			// A '?'/'*' quantifier makes the group nullable — the first byte
-			// can also come from whatever follows it. A second '?' marks the
-			// quantifier lazy and is skipped either way.
-			var int after = a_end
-			var nullable = 0
-			if after < end {
-				var char q = pattern.at(after)
-				if q == '?' || q == '*' {
-					nullable = 1
-					after += 1
-					if after < end {
-						if pattern.at(after) == '?' {
-							after += 1
-						}
-					}
-				}
-			}
-			if nullable == 0 {
+			var int cont = nullable_quant_after(pattern, a_end, end)
+			if cont < 0 {
 				return 0
 			}
-			i = after
+			i = cont
 			continue
 		}
 		if c == '^' || c == '$' {
@@ -552,9 +549,40 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 			return -1
 		}
 		sb.append_char(c)
-		return 0
+		var int cont = nullable_quant_after(pattern, i + 1, end)
+		if cont < 0 {
+			return 0
+		}
+		i = cont
+		continue
+	}
+	// An empty alternative (nothing left after nullable atoms — or nothing at
+	// all) can match at any position — indeterminable.
+	return -1
+}
+
+// If the atom ending at `after` carries a nullable quantifier ('?' or '*',
+// optionally marked lazy by a second '?'), return the position just past the
+// quantifier; otherwise return -1. Callers keep scanning from the returned
+// position: a nullable leading atom means the alternative's match can also
+// START with whatever follows, so those bytes belong in the first-byte set
+// too. ('+' is NOT nullable — the atom must match once — so it leaves the
+// atom's own bytes as the whole first set.)
+func nullable_quant_after = (string pattern, int after, int end, out int) {
+	var int j = after
+	if j >= end {
+		return -1
+	}
+	var char q = pattern.at(j)
+	if q == '?' || q == '*' {
+		j += 1
+		if j < end {
+			if pattern.at(j) == '?' {
+				j += 1
+			}
+		}
+		return j
 	}
-	// An empty alternative can match at any position — indeterminable.
 	return -1
 }
 

package/dist/index.mjs

@@ -19242,6 +19242,7 @@ function build_function_node$1(node, status) {
 	const old_struct_param_slots = status.function_struct_param_slots;
 	const old_function_param_types = status.function_param_types;
 	const old_function_local_types = status.function_local_types;
+	const old_variable_types = status.variable_types;
 	status.function_param_regs = /* @__PURE__ */ new Map();
 	status.function_param_vars = /* @__PURE__ */ new Set();
 	status.function_array_params = /* @__PURE__ */ new Set();
@@ -19250,6 +19251,7 @@ function build_function_node$1(node, status) {
 	status.function_struct_param_slots = /* @__PURE__ */ new Set();
 	status.function_param_types = /* @__PURE__ */ new Map();
 	status.function_local_types = /* @__PURE__ */ new Map();
+	status.variable_types = /* @__PURE__ */ new Map();
 	const old_variadic_params_aarch64 = status.function_variadic_params;
 	const old_view_params = status.function_view_params;
 	status.function_variadic_params = /* @__PURE__ */ new Set();
@@ -19658,6 +19660,7 @@ function build_function_node$1(node, status) {
 	status.function_struct_param_slots = old_struct_param_slots;
 	status.function_param_types = old_function_param_types;
 	status.function_local_types = old_function_local_types;
+	status.variable_types = old_variable_types;
 	status.function_variadic_params = old_variadic_params_aarch64;
 	status.function_view_params = old_view_params;
 	status.function_return_label = old_return_label;
@@ -35126,6 +35129,8 @@ function build_function_node(node, status) {
 	status.function_view_params = /* @__PURE__ */ new Set();
 	const old_return_type = status.function_return_type;
 	status.function_return_type = node.return_type;
+	const old_variable_types = status.variable_types;
+	status.variable_types = /* @__PURE__ */ new Map();
 	const old_nullable_ret_has = status.nullable_ret_has_param;
 	if (is_nullable_struct_type(node.return_type, status)) status.nullable_ret_has_param = "_ret_has";
 	else status.nullable_ret_has_param = void 0;
@@ -35181,6 +35186,7 @@ function build_function_node(node, status) {
 	status.function_variadic_params = old_variadic_params;
 	status.function_view_params = old_view_params;
 	status.function_return_type = old_return_type;
+	status.variable_types = old_variable_types;
 	status.nullable_ret_has_param = old_nullable_ret_has;
 	status.current_function_name = old_function_name;
 	status.current_function = old_current_function;
@@ -43171,7 +43177,7 @@ function build_access_method(node, access_func, status) {
 		emit_asm(status, `str x0, [sp, #-16]!\n`);
 		emit_asm(status, `str x1, [sp, #-16]!\n`);
 		emit_asm(status, `mov x0, x9\n`);
-		emit_asm(status, `bl _nomen_free_wrap\n`);
+		emit_free(status);
 		emit_asm(status, `ldr x1, [sp], #16\n`);
 		emit_asm(status, `ldr x0, [sp], #16\n`);
 		emit_asm(status, `add sp, sp, #16\n`);
@@ -55547,7 +55553,13 @@ function check_return_node(ret, status) {
 		} else if (!func.is_arrow_body) {
 			add_error(status, `Function returns a value but has no 'out' return type`, ret.start);
 			func.return_type = ret.type;
-		} else func.return_type = ret.type;
+		} else {
+			func.return_type = ret.type;
+			if (!ret.type?.name) {
+				func.return_type = new Type("void");
+				ret.type = new Type("void");
+			}
+		}
 	}
 }
 //#endregion
@@ -58515,7 +58527,24 @@ function resolve_linked_types(source, library, file_path) {
 	}
 	const user_declared_funcs = /* @__PURE__ */ new Set();
 	for (let i = 0; i < tokens.length - 1; i++) if (tokens[i].value === "func" && /^\w+$/.test(tokens[i + 1].value)) user_declared_funcs.add(tokens[i + 1].value);
-	for (const token of tokens) {
+	const import_tokens = /* @__PURE__ */ new Set();
+	for (let i = 0; i < tokens.length; i++) {
+		if (tokens[i].value !== "import") continue;
+		import_tokens.add(i);
+		let j = i + 1;
+		if (j < tokens.length && /^\w+$/.test(tokens[j].value)) {
+			import_tokens.add(j);
+			j += 1;
+			while (j + 1 < tokens.length && tokens[j].value === "::" && /^\w+$/.test(tokens[j + 1].value)) {
+				import_tokens.add(j);
+				import_tokens.add(j + 1);
+				j += 2;
+			}
+		}
+	}
+	for (let i = 0; i < tokens.length; i++) {
+		if (import_tokens.has(i)) continue;
+		const token = tokens[i];
 		if (user_defined.has(token.value)) continue;
 		if (library.types.has(token.value) && !BASE_TYPES.includes(token.value)) needed.add(token.value);
 		else if (library.functions.has(token.value) && !user_declared_funcs.has(token.value)) needed.add(token.value);
@@ -59356,7 +59385,8 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 			audit_obj
 		]);
 	}
-	const ext = arch === "aarch64" ? ".s" : ".c";
+	const platform = default_platform();
+	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const codefile = path.join(buildDir, path.basename(entry_path, ".nm") + ext);
 	const outfile = path.join(buildDir, path.basename(entry_path, ".nm"));
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
@@ -59367,6 +59397,7 @@ function run_test_file(entry_path, lib_path, arch, audit = false, audit_runtime)
 		codefile
 	];
 	if (audit_obj) link_args.push(audit_obj);
+	if (platform === "macos" || platform === "ios") link_args.push("-framework", "CoreGraphics", "-framework", "Foundation", "-framework", "AppKit", "-lobjc");
 	try {
 		execFileSync("clang", link_args, {
 			encoding: "utf8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nomen-lang",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "The CLI for the Nomen programming language.",
   "keywords": [],
   "license": "ISC",

package/src/test.ts

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import build from "../../src/build.ts";
+import build, { default_platform } from "../../src/build.ts";
 import join from "../../src/join.ts";
 import { get_library } from "../../src/lib.ts";
 import parse from "../../src/parse.ts";
@@ -329,7 +329,12 @@ export function run_test_file(
 		audit_obj = path.join(buildDir, "audit_runtime.o");
 		execFileSync("clang", ["-c", runtime_src, "-o", audit_obj]);
 	}
-	const ext = arch === "aarch64" ? ".s" : ".c";
+	const platform = default_platform();
+	// Match the run/build command's emission: ObjC-bearing sources (GUI code
+	// pulled in through the library graph) must land in a `.m` TU on Apple
+	// platforms — the ObjC framework headers are Objective-C, and including
+	// them from a plain `.c` TU fails with `@class NSString` syntax errors.
+	const ext = arch === "aarch64" ? ".s" : platform === "macos" || platform === "ios" ? ".m" : ".c";
 	const codefile = path.join(buildDir, path.basename(entry_path, ".nm") + ext);
 	const outfile = path.join(buildDir, path.basename(entry_path, ".nm"));
 	// The C backend's generated source does `#include "main.h"`, so write the
@@ -337,10 +342,23 @@ export function run_test_file(
 	fs.writeFileSync(path.join(buildDir, "main.h"), buildResult.headers ?? "");
 	fs.writeFileSync(codefile, buildResult.code);
 
-	// Link the harness binary. The harness uses only Console/Time (printf,
-	// clock_gettime), so no platform frameworks are required.
+	// Link the harness binary. Frameworks are passed on Apple platforms for
+	// the same reason as the run/build command: the joined source may reference
+	// ObjC runtime symbols even when the test body doesn't, and unused
+	// frameworks cost nothing at link time.
 	const link_args = ["-o", outfile, codefile];
 	if (audit_obj) link_args.push(audit_obj);
+	if (platform === "macos" || platform === "ios") {
+		link_args.push(
+			"-framework",
+			"CoreGraphics",
+			"-framework",
+			"Foundation",
+			"-framework",
+			"AppKit",
+			"-lobjc",
+		);
+	}
 	try {
 		execFileSync("clang", link_args, {
 			encoding: "utf8",