nomen-lang 0.2.2 → 0.3.0

package/core/System/Text/JsonTree.nm

@@ -36,63 +36,35 @@ pub struct JsonTree {
 		// empty-string literal) into the slot. JsonTree manages node texts
 		// manually (set_text strdup's into the slab; free_text/release frees
 		// them; NULL means "no text"), so the slot must start NULL — free the
-		// strdup'd default and NULL it, or reset() would leak it. idx is x1.
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		free(nodes[idx].text.ptr);
-		nodes[idx].text.ptr = 0;
-		nodes[idx].text.len = 0;
-		```
-		```
-		#arch: aarch64
-		// x19 = self. count is at self+32 and already equals idx+1 here, so
-		// idx = count - 1. nodes.data at self+16, JsonNode size 56 (fat text),
-		// text at +16 (ptr) / +24 (len).
-		ldr x0, [x19, #16]
-		ldr x1, [x19, #32]
-		sub x1, x1, #1
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x1, [x0]
-		str xzr, [x0]
-		str xzr, [x0, #8]
-		cbz x1, .Lalloc_node_text_skip
-		mov x0, x1
-		bl _free
-		.Lalloc_node_text_skip:
-		```
+		// strdup'd default and NULL it, or reset() would leak it. The slab
+		// slot layout: 56-byte JsonNode elements — 7 words — with the text
+		// pair at words 2 and 3 of each element.
+		unsafe {
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			var uint64 old = slots[t]
+			if old != 0 {
+				free(old)
+			}
+			slots[t] = 0
+			slots[t + 1] = 0
+		}
 		return idx
 	}
 
 	// Free a node's strdup'd text pointer (set_text writes a heap pointer via
 	// raw strdup; this mirrors it). idx is x1, following set_text's layout.
 	func free_text = (ref self, int idx) {
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		if (nodes[idx].text.ptr) { free(nodes[idx].text.ptr); nodes[idx].text.ptr = 0; nodes[idx].text.len = 0; }
-		```
-		```
-		#arch: aarch64
-		// x19 = self, x1 = idx. Compute &nodes[idx].text (JsonNode size 56).
-		ldr x0, [x19, #16]
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x2, [x0]
-		cbz x2, .Ljsontree_free_text_skip
-		str x0, [sp, #-16]!
-		mov x0, x2
-		bl _free
-		ldr x0, [sp], #16
-		str xzr, [x0]
-		str xzr, [x0, #8]
-		.Ljsontree_free_text_skip:
-		```
+		unsafe {
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			var uint64 p = slots[t]
+			if p != 0 {
+				free(p)
+				slots[t] = 0
+				slots[t + 1] = 0
+			}
+		}
 	}
 
 	// Free every strdup'd text pointer before reusing the slab, otherwise
@@ -121,36 +93,16 @@ pub struct JsonTree {
 	// emitted behind the _raw_ adapter, so `text` arrives as a thin char*;
 	// aarch64 receives the pair x2 = ptr, x3 = len.)
 	func set_text = (ref self, int idx, string text) {
-		```
-		#arch: c
-		JsonNode *nodes = (JsonNode*)(unsigned long long)self->nodes.data;
-		nodes[idx].text.ptr = strdup(text);
-		nodes[idx].text.len = (long)strlen(text);
-		```
-		```
-		#arch: aarch64
-		// x19 = self, x1 = idx, x2 = text.ptr, x3 = text.len
-		// nodes.data is at self+16 (JsonTree.vt[0] + Buffer.vt[8])
-		// text field is at offset 16 in JsonNode (vt[0] + kind[8]); the fat
-		// field is ptr@+16, len@+24; sizeof(JsonNode) = 56.
-		sub sp, sp, #32
-		str x1, [sp, #0]
-		str x3, [sp, #8]
-		mov x0, x2
-		bl _strdup
-		str x0, [sp, #16]
-		ldr x0, [x19, #16]
-		ldr x1, [sp, #0]
-		mov x3, #56
-		madd x1, x1, x3, xzr
-		add x0, x0, x1
-		add x0, x0, #16
-		ldr x1, [sp, #16]
-		str x1, [x0]
-		ldr x1, [sp, #8]
-		str x1, [x0, #8]
-		add sp, sp, #32
-		```
+		unsafe {
+			var int len = text.length
+			var uint64 buf = malloc(len + 1)
+			memcpy(buf, (text as ptr char) as uint64, len)
+			memset(buf + len, 0, 1)
+			var ptr uint64 slots = self.nodes.data as ptr uint64
+			var int t = idx * 7 + 2
+			slots[t] = buf
+			slots[t + 1] = len
+		}
 	}
 
 	func set_kind = (ref self, int idx, int val) {