nomen-lang 0.0.7 → 0.0.8

package/core/System/Stream/Http.nm

@@ -0,0 +1,453 @@
+/**
+ * A minimal blocking HTTP/1.1 client.
+ *
+ * Plain `http://` only — no TLS (an `https://` URL cannot be served; use a
+ * TLS proxy or wait for a TLS-capable transport). Construct an instance,
+ * call `get`/`post` (which block until the full response is received), then
+ * read the `status` field for the response's status code. `status` is 0 when
+ * DNS resolution or the connection fails.
+ *
+ * URLs may carry an explicit port (`http://host:8080/path`); the default is
+ * 80 and the default path is `/`. `post` sends `body` with a
+ * `Content-Type: application/x-www-form-urlencoded` header and a matching
+ * `Content-Length`; only the response body (after the blank header/body
+ * separator line) is returned.
+ *
+ *	var Http h = Http()
+ *	var string body = h.get("http://example.com/")
+ *	var int code     = h.status
+ *	var string r     = h.post("http://example.com/submit", "hello=world")
+ **/
+pub struct Http {
+	// HTTP status code from the most recent request (e.g. 200). 0 if DNS or
+	// the connection failed.
+	pub var int status = 0
+
+	// Shared socket round-trip used by get/post. `method` is the request
+	// method string ("GET" / "POST"); a leading 'P' selects POST semantics
+	// (sends `body` and the Content-* headers). Sets self->status and returns
+	// the response body (empty string on failure).
+	func exchange = (ref self, string method, string url, string body, out string) {
+		```
+		#arch: c
+		#scope: file
+		#include <sys/socket.h>
+		#include <netdb.h>
+		#include <unistd.h>
+		#include <string.h>
+		#include <stdlib.h>
+		```
+		```
+		#arch: c
+		const char *scheme = strstr(url, "://");
+		const char *hp = scheme ? scheme + 3 : url;
+		const char *colon = strchr(hp, ':');
+		const char *slash = strchr(hp, '/');
+		char host[256];
+		int port = 80;
+		const char *path = "/";
+
+		if (colon && (!slash || colon < slash)) {
+			int hlen = (int)(colon - hp);
+			if (hlen > 255) hlen = 255;
+			memcpy(host, hp, hlen);
+			host[hlen] = 0;
+			port = atoi(colon + 1);
+		} else {
+			const char *end = slash ? slash : hp + strlen(hp);
+			int hlen = (int)(end - hp);
+			if (hlen > 255) hlen = 255;
+			memcpy(host, hp, hlen);
+			host[hlen] = 0;
+		}
+		if (slash) path = slash;
+
+		struct addrinfo hints, *res;
+		memset(&hints, 0, sizeof(hints));
+		hints.ai_family = AF_INET;
+		hints.ai_socktype = SOCK_STREAM;
+		char portstr[16];
+		snprintf(portstr, sizeof(portstr), "%d", port);
+		if (getaddrinfo(host, portstr, &hints, &res) != 0) {
+			self->status = 0;
+			return strdup("");
+		}
+		int sock = socket(AF_INET, SOCK_STREAM, 0);
+		if (sock < 0) {
+			freeaddrinfo(res);
+			self->status = 0;
+			return strdup("");
+		}
+		if (connect(sock, res->ai_addr, res->ai_addrlen) < 0) {
+			freeaddrinfo(res);
+			close(sock);
+			self->status = 0;
+			return strdup("");
+		}
+		freeaddrinfo(res);
+
+		char req[1600];
+		int off = snprintf(req, sizeof(req),
+			"%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n",
+			method, path, host);
+		if (method[0] == 'P') {
+			int blen = (int)strlen(body);
+			off += snprintf(req + off, sizeof(req) - off,
+				"Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\n\r\n",
+				blen);
+			send(sock, req, off, 0);
+			send(sock, body, blen, 0);
+		} else {
+			off += snprintf(req + off, sizeof(req) - off, "\r\n");
+			send(sock, req, off, 0);
+		}
+
+		int cap = 4096, len = 0;
+		char *buf = (char*)malloc(cap);
+		int n;
+		while ((n = recv(sock, buf + len, cap - len - 1, 0)) > 0) {
+			len += n;
+			if (len + 1 >= cap) {
+				cap *= 2;
+				buf = (char*)realloc(buf, cap);
+			}
+		}
+		buf[len] = 0;
+		close(sock);
+
+		int code = 0;
+		if (len >= 12 && strncmp(buf, "HTTP/", 5) == 0) {
+			code = atoi(buf + 9);
+		}
+		self->status = code;
+
+		char *body_start = strstr(buf, "\r\n\r\n");
+		if (body_start) {
+			char *result = strdup(body_start + 4);
+			free(buf);
+			return result;
+		}
+		return buf;
+		```
+		```
+		#arch: aarch64
+		// x0=self(->x19), x1=method, x2=url, x3=body
+		// macOS arm64 passes variadic args on the caller stack at [sp+0..], so
+		// [sp+0..47] is reserved scratch for snprintf variadic args and the
+		// addrinfo hints live above it. Stack frame (2048 bytes):
+		//   #0   variadic scratch (snprintf args)
+		//   #48  hints (struct addrinfo, 48 bytes)
+		//   #96  res*            #104 sock fd
+		//   #112 port            #120 hp (host start)
+		//   #128 method          #136 url
+		//   #144 body            #152 path
+		//   #160 colon/blen/buf  #168 slash/cap
+		//   #176 hostlen/req_off #184 portstr (16)
+		//   #208 host buffer (256)   #464 request buffer (1584)
+		sub sp, sp, #2048
+		str x1, [sp, #128]
+		str x2, [sp, #136]
+		str x3, [sp, #144]
+		mov x0, #80
+		str x0, [sp, #112]
+		adr x0, .Lhttp_slash
+		str x0, [sp, #152]
+
+		// hp = (strstr(url, "://") ?: url) + 3 when scheme present
+		ldr x0, [sp, #136]
+		adr x1, .Lhttp_scheme
+		bl _strstr
+		cbz x0, .Lhttp_sethp
+		add x0, x0, #3
+		.Lhttp_sethp:
+		str x0, [sp, #120]
+
+		// colon = strchr(hp, ':'); slash = strchr(hp, '/')
+		ldr x0, [sp, #120]
+		mov x1, #0x3A
+		bl _strchr
+		str x0, [sp, #160]
+		ldr x0, [sp, #120]
+		mov x1, #0x2F
+		bl _strchr
+		str x0, [sp, #168]
+
+		// if (colon && (!slash || colon < slash)) -> port branch
+		ldr x0, [sp, #160]
+		cbz x0, .Lhttp_np
+		ldr x1, [sp, #168]
+		cbz x1, .Lhttp_port
+		cmp x0, x1
+		b.lo .Lhttp_port
+		.Lhttp_np:
+		// hostlen = slash ? (slash - hp) : strlen(hp); path = slash
+		ldr x0, [sp, #168]
+		cbz x0, .Lhttp_np_strlen
+		ldr x1, [sp, #120]
+		sub x0, x0, x1
+		str x0, [sp, #176]
+		ldr x0, [sp, #168]
+		str x0, [sp, #152]
+		b .Lhttp_cph
+		.Lhttp_np_strlen:
+		ldr x0, [sp, #120]
+		bl _strlen
+		str x0, [sp, #176]
+		b .Lhttp_cph
+		.Lhttp_port:
+		// hostlen = colon - hp; port = atoi(colon + 1)
+		ldr x0, [sp, #120]
+		ldr x1, [sp, #160]
+		sub x0, x1, x0
+		str x0, [sp, #176]
+		ldr x0, [sp, #160]
+		add x0, x0, #1
+		bl _atoi
+		str x0, [sp, #112]
+		ldr x0, [sp, #168]
+		cbz x0, .Lhttp_cph
+		str x0, [sp, #152]
+
+		// hostlen = min(hostlen, 255); memcpy(hostbuf, hp, hostlen); hostbuf[hostlen]=0
+		.Lhttp_cph:
+		ldr x0, [sp, #176]
+		mov x9, #255
+		cmp x0, x9
+		csel x0, x0, x9, ls
+		str x0, [sp, #176]
+		add x0, sp, #208
+		ldr x1, [sp, #120]
+		ldr x2, [sp, #176]
+		bl _memcpy
+		add x0, sp, #208
+		ldr x1, [sp, #176]
+		strb wzr, [x0, x1]
+
+		// memset(&hints, 0, 48); hints.ai_family=AF_INET(2); hints.ai_socktype=SOCK_STREAM(1)
+		add x0, sp, #48
+		mov x1, xzr
+		mov x2, #48
+		bl _memset
+		mov w0, #2
+		str w0, [sp, #52]
+		mov w0, #1
+		str w0, [sp, #56]
+		// snprintf(portstr, 16, "%ld", port) — variadic arg on stack at [sp+0]
+		ldr x9, [sp, #112]
+		str x9, [sp, #0]
+		add x0, sp, #184
+		mov x1, #16
+		adr x2, .Lhttp_fmt_ld
+		bl _snprintf
+		// getaddrinfo(host, portstr, &hints, &res)
+		add x0, sp, #208
+		add x1, sp, #184
+		add x2, sp, #48
+		add x3, sp, #96
+		bl _getaddrinfo
+		cbnz w0, .Lhttp_fail
+
+		// sock = socket(AF_INET, SOCK_STREAM, 0)
+		mov x0, #2
+		mov x1, #1
+		mov x2, xzr
+		bl _socket
+		cmp w0, #0
+		b.ge .Lhttp_sockok
+		ldr x0, [sp, #96]
+		bl _freeaddrinfo
+		b .Lhttp_fail
+		.Lhttp_sockok:
+		str w0, [sp, #104]
+		// connect(sock, res->ai_addr (off 32), res->ai_addrlen (off 16))
+		ldr x9, [sp, #96]
+		ldr x1, [x9, #32]
+		ldr w2, [x9, #16]
+		ldr w0, [sp, #104]
+		bl _connect
+		cmp w0, #0
+		b.ge .Lhttp_connected
+		ldr x0, [sp, #96]
+		bl _freeaddrinfo
+		ldr w0, [sp, #104]
+		bl _close
+		b .Lhttp_fail
+		.Lhttp_connected:
+		ldr x0, [sp, #96]
+		bl _freeaddrinfo
+
+		// off = snprintf(req, 1584, common_fmt, method, path, host)
+		// variadic args on stack: method@[0], path@[8], host@[16]
+		ldr x9, [sp, #128]
+		str x9, [sp, #0]
+		ldr x9, [sp, #152]
+		str x9, [sp, #8]
+		add x9, sp, #208
+		str x9, [sp, #16]
+		add x0, sp, #464
+		mov x1, #1584
+		adr x2, .Lhttp_reqcommon
+		bl _snprintf
+		sxtw x0, w0
+		str x0, [sp, #176]
+
+		// if method[0] == 'P' (0x50) -> POST
+		ldr x0, [sp, #128]
+		ldrb w0, [x0]
+		cmp w0, #0x50
+		b.ne .Lhttp_getsend
+
+		// POST: blen = strlen(body); append Content-Length; send headers; send body
+		ldr x0, [sp, #144]
+		bl _strlen
+		str x0, [sp, #160]
+		// snprintf(req+off, 1584-off, reqpost, blen) — blen on stack at [sp+0]
+		ldr x9, [sp, #160]
+		str x9, [sp, #0]
+		add x0, sp, #464
+		ldr x1, [sp, #176]
+		add x0, x0, x1
+		mov x1, #1584
+		ldr x2, [sp, #176]
+		sub x1, x1, x2
+		adr x2, .Lhttp_reqpost
+		bl _snprintf
+		sxtw x0, w0
+		ldr x1, [sp, #176]
+		add x1, x1, x0
+		str x1, [sp, #176]
+		ldr w0, [sp, #104]
+		add x1, sp, #464
+		ldr x2, [sp, #176]
+		mov x3, xzr
+		bl _send
+		ldr x0, [sp, #144]
+		bl _strlen
+		mov x2, x0
+		ldr w0, [sp, #104]
+		ldr x1, [sp, #144]
+		mov x3, xzr
+		bl _send
+		b .Lhttp_recv
+
+		.Lhttp_getsend:
+		// GET: append trailing "\r\n" (no variadic) and send
+		add x0, sp, #464
+		ldr x1, [sp, #176]
+		add x0, x0, x1
+		mov x1, #1584
+		ldr x2, [sp, #176]
+		sub x1, x1, x2
+		adr x2, .Lhttp_crlf
+		bl _snprintf
+		sxtw x0, w0
+		ldr x1, [sp, #176]
+		add x1, x1, x0
+		str x1, [sp, #176]
+		ldr w0, [sp, #104]
+		add x1, sp, #464
+		ldr x2, [sp, #176]
+		mov x3, xzr
+		bl _send
+
+		// recv loop: buf = malloc(4096); grow as needed
+		.Lhttp_recv:
+		mov x0, #4096
+		bl _malloc
+		str x0, [sp, #160]
+		mov x0, #4096
+		str x0, [sp, #168]
+		str xzr, [sp, #96]
+		.Lhttp_recvloop:
+		ldr w0, [sp, #104]
+		ldr x1, [sp, #160]
+		ldr x2, [sp, #96]
+		add x1, x1, x2
+		ldr x2, [sp, #168]
+		ldr x3, [sp, #96]
+		sub x2, x2, x3
+		sub x2, x2, #1
+		mov x3, xzr
+		bl _recv
+		cmp x0, #0
+		ble .Lhttp_recvdone
+		ldr x1, [sp, #96]
+		add x1, x1, x0
+		str x1, [sp, #96]
+		add x2, x1, #1
+		ldr x3, [sp, #168]
+		cmp x2, x3
+		blt .Lhttp_recvloop
+		ldr x0, [sp, #168]
+		lsl x0, x0, #1
+		str x0, [sp, #168]
+		mov x1, x0
+		ldr x0, [sp, #160]
+		bl _realloc
+		str x0, [sp, #160]
+		b .Lhttp_recvloop
+
+		.Lhttp_recvdone:
+		// buf[len] = 0; close(sock)
+		ldr x0, [sp, #160]
+		ldr x1, [sp, #96]
+		strb wzr, [x0, x1]
+		ldr w0, [sp, #104]
+		bl _close
+		// self->status = atoi(buf + 9)
+		ldr x0, [sp, #160]
+		add x0, x0, #9
+		bl _atoi
+		sxtw x0, w0
+		str x0, [x19, #8]
+		// body_start = strstr(buf, "\r\n\r\n")
+		ldr x0, [sp, #160]
+		adr x1, .Lhttp_hdrsep
+		bl _strstr
+		cbz x0, .Lhttp_retbuf
+		// result = strdup(body_start + 4); free(buf); return result
+		add x0, x0, #4
+		bl _strdup
+		str x0, [sp, #112]
+		ldr x0, [sp, #160]
+		bl _free
+		ldr x0, [sp, #112]
+		add sp, sp, #2048
+		b .return_Http_exchange
+		.Lhttp_retbuf:
+		ldr x0, [sp, #160]
+		add sp, sp, #2048
+		b .return_Http_exchange
+		.Lhttp_fail:
+		str xzr, [x19, #8]
+		adr x0, .Lhttp_empty
+		bl _strdup
+		add sp, sp, #2048
+		b .return_Http_exchange
+
+		.Lhttp_scheme: .asciz "://"
+		.Lhttp_slash: .asciz "/"
+		.Lhttp_fmt_ld: .asciz "%ld"
+		.Lhttp_crlf: .asciz "\r\n"
+		.Lhttp_hdrsep: .asciz "\r\n\r\n"
+		.Lhttp_empty: .asciz ""
+		.Lhttp_reqcommon: .asciz "%s %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n"
+		.Lhttp_reqpost: .asciz "Content-Type: application/x-www-form-urlencoded\r\nContent-Length: %ld\r\n\r\n"
+		.p2align 2
+		```
+		return ""
+	}
+
+	// Issue a blocking GET request to `url`. Returns the response body and
+	// sets `self.status` to the response's status code (0 on failure).
+	pub func get = (ref self, string url, out string) {
+		return self.exchange("GET", url, "")
+	}
+
+	// Issue a blocking POST request to `url` with `body` as the payload.
+	// Returns the response body and sets `self.status` to the response's
+	// status code (0 on failure).
+	pub func post = (ref self, string url, string body, out string) {
+		return self.exchange("POST", url, body)
+	}
+}

package/core/System/String.nm

@@ -0,0 +1,154 @@
+/**
+ * A UTF-8 text string — a heap-owned, length-tracked sequence of bytes
+ **/
+pub struct string: Stringable {
+	pub func to_string = (self, out string) {
+		```
+		#arch: c
+		return strdup(self);
+		```
+		```
+		#arch: aarch64
+		mov x0, x19
+		```
+	}
+
+	pub func at = (self, int index: index >= 0 && index < self.length, out char) {
+		```
+		#arch: c
+		return self[index];
+		```
+		```
+		#arch: aarch64
+		// x19 = self (pointer), x1 = index
+		ldrb w0, [x19, x1]
+		```
+	}
+
+	// A non-owning slice [start, end) into self's buffer. Returns a `view
+	// string` (ptr, len) that borrows from self: it may not outlive self's
+	// scope and is invalidated if self is reassigned. Use .to_string() to
+	// materialize an owned copy.
+	pub func slice = (
+		self,
+		int start: start >= 0 && start <= self.length,
+		int end: end >= start && end <= self.length,
+		out view string
+	) {
+		```
+		#arch: c
+		nomen_view _r;
+		_r.ptr = (void*)(self + start);
+		_r.len = (long)(end - start);
+		return _r;
+		```
+		```
+		#arch: aarch64
+		// view string is (ptr, len), returned in the x0/x1 register pair.
+		// x19 = self (char*), x1 = start, x2 = end (retained through prologue).
+		add x0, x19, x1     // ptr = self + start
+		sub x1, x2, x1      // len = end - start
+		```
+	}
+
+	pub func set = (ref self, int index: index >= 0 && index < self.length, char value) {
+		```
+		#arch: c
+		(*self)[index] = value;
+		```
+		```
+		#arch: aarch64
+		// x19 = self (pointer), x1 = index, w2 = value
+		strb w2, [x19, x1]
+		```
+	}
+
+	pub func #op_eq = (self, string other, out bool) {
+		```
+		#arch: c
+		return strcmp(self, other) == 0;
+		```
+		```
+		#arch: aarch64
+		// x0 = self, x1 = other on entry
+		bl _strcmp
+		cmp x0, #0
+		cset x0, eq
+		```
+	}
+
+	pub func #op_add = (self, string other, out string) {
+		```
+		#arch: c
+		int left_len = strlen(self);
+		int right_len = strlen(other);
+		char* result = malloc(left_len + right_len + 1);
+		strcpy(result, self);
+		strcat(result, other);
+		return result;
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		mov x20, x1
+		bl _strlen
+		mov x21, x0
+		mov x0, x20
+		bl _strlen
+		add x0, x21, x0
+		add x0, x0, #1
+		bl _malloc
+		mov x21, x0
+		mov x1, x19
+		bl _strcpy
+		mov x0, x21
+		mov x1, x20
+		bl _strcat
+		mov x0, x21
+		ldp x20, x21, [sp], #16
+		```
+	}
+
+	pub func #op_mul = (self, int count, out string) {
+		```
+		#arch: c
+		size_t str_len = strlen(self);
+		size_t total = str_len * (size_t)count + 1;
+		char* buf = malloc(total);
+		char* p = buf;
+		for (int i = 0; i < count; i++) {
+			memcpy(p, self, str_len);
+			p += str_len;
+		}
+		*p = 0;
+		return buf;
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		stp x22, xzr, [sp, #-16]!
+		mov x20, x1
+		bl _strlen
+		mov x21, x0
+		mul x0, x0, x20
+		add x0, x0, #1
+		bl _malloc
+		str x0, [x29, #8]
+		mov x22, x0
+		.Lmul_loop:
+		cbz x20, .Lmul_done
+		mov x0, x22
+		mov x1, x19
+		mov x2, x21
+		bl _memcpy
+		add x22, x22, x21
+		sub x20, x20, #1
+		b .Lmul_loop
+		.Lmul_done:
+		strb wzr, [x22]
+		ldr x0, [x29, #8]
+		ldp x22, xzr, [sp], #16
+		ldp x20, x21, [sp], #16
+		```
+	}
+}