nomen-lang 0.0.7 → 0.0.8

package/core/System/Stream/File.nm

@@ -0,0 +1,432 @@
+/**
+ * A file handle for reading and writing, plus static one-shot helpers.
+ *
+ * `File` is a handle opened with a mode string (`"r"`, `"w"`, …) and closed
+ * automatically by its `#destroy` when it goes out of scope. Read methods set
+ * the `eof` flag when the end of the file is reached.
+ *
+ *	var File w = File()
+ *	w.open("notes.txt", "w")
+ *	w.writeLine("hello")
+ *	w.writeLine("world")
+ *	w.close()
+ *
+ *	var File r = File()
+ *	r.open("notes.txt", "r")
+ *	const string first = r.readLine()    // "hello"
+ *	const string rest  = r.readAll()     // read the remaining bytes
+ *
+ * Static one-shot helpers do the open/read/close in one call:
+ *
+ *	File.write_all("out.txt", "payload")
+ *	const string body = File.read_all("out.txt")
+ *	const bool ok     = File.exists("out.txt")
+ *	File.delete("out.txt")
+ **/
+pub struct File {
+	var uint64 handle = 0
+	pub var eof = false
+
+	// Open the file at `path` with a C mode string ("r", "w", "a", …).
+	pub func open = (ref self, string path, string mode) {
+		```
+		#arch: c
+		self->handle = (unsigned long long)fopen(path, mode);
+		```
+		```
+		#arch: aarch64
+		mov x0, x1
+		mov x1, x2
+		bl _fopen
+		str x0, [x19, #8]
+		```
+	}
+
+	// Close the handle. Also performed automatically by #destroy; calling
+	// close explicitly releases the resource early.
+	pub func close = (ref self) {
+		```
+		#arch: c
+		if (self->handle) {
+			fclose((FILE*)(unsigned long long)self->handle);
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lfile_close_end
+		bl _fclose
+		.Lfile_close_end:
+		str xzr, [x19, #8]
+		```
+	}
+
+	// Read every byte from the current position to EOF and return it. Sets
+	// `eof`.
+	pub func readAll = (ref self, out string) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		fseek(f, 0, SEEK_END);
+		long size = ftell(f);
+		fseek(f, 0, SEEK_SET);
+		char *buf = (char*)malloc(size + 1);
+		fread(buf, 1, size, f);
+		buf[size] = 0;
+		self->eof = 1;
+		return buf;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #16
+		ldr x0, [x19, #8]
+		mov x1, #0
+		mov x2, #2
+		bl _fseek
+		ldr x0, [x19, #8]
+		bl _ftell
+		str x0, [sp, #0]
+		ldr x0, [x19, #8]
+		mov x1, #0
+		mov x2, #0
+		bl _fseek
+		ldr x0, [sp, #0]
+		add x0, x0, #1
+		bl _malloc
+		str x0, [sp, #8]
+		ldr x0, [sp, #8]
+		mov x1, #1
+		ldr x2, [sp, #0]
+		ldr x3, [x19, #8]
+		bl _fread
+		ldr x0, [sp, #8]
+		ldr x1, [sp, #0]
+		strb wzr, [x0, x1]
+		mov w1, #1
+		strb w1, [x19, #16]
+		ldr x0, [sp, #8]
+		add sp, sp, #16
+		b .return_File_readAll
+		```
+		return ""
+	}
+
+	// Write a string at the current position.
+	pub func writeAll = (self, string data) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		fputs(data, f);
+		```
+		```
+		#arch: aarch64
+		mov x0, x1
+		ldr x1, [x19, #8]
+		bl _fputs
+		```
+	}
+
+	// Read up to the next '\n' (the newline is not included). Sets `eof`
+	// when the end of the file is reached.
+	pub func readLine = (ref self, out string) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		int cap = 16;
+		int len = 0;
+		char *buf = (char*)malloc(cap);
+		int c = fgetc(f);
+		while (c != EOF && c != '\n') {
+			if (len + 1 >= cap) {
+				cap *= 2;
+				buf = (char*)realloc(buf, cap);
+			}
+			buf[len++] = (char)c;
+			c = fgetc(f);
+		}
+		buf[len] = 0;
+		if (c == EOF) self->eof = 1;
+		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]
+		ldr x0, [x19, #8]
+		bl _fgetc
+		str w0, [sp, #24]
+		.Lfile_readline_loop:
+		ldr w0, [sp, #24]
+		cmp w0, #0
+		blt .Lfile_readline_done
+		cmp w0, #10
+		beq .Lfile_readline_done
+		ldr x0, [sp, #16]
+		add x0, x0, #1
+		ldr x1, [sp, #8]
+		cmp x0, x1
+		ble .Lfile_readline_store
+		ldr x1, [sp, #8]
+		lsl x1, x1, #1
+		str x1, [sp, #8]
+		ldr x0, [sp, #0]
+		bl _realloc
+		str x0, [sp, #0]
+		.Lfile_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]
+		ldr x0, [x19, #8]
+		bl _fgetc
+		str w0, [sp, #24]
+		b .Lfile_readline_loop
+		.Lfile_readline_done:
+		ldr x0, [sp, #0]
+		ldr x1, [sp, #16]
+		strb wzr, [x0, x1]
+		ldr w0, [sp, #24]
+		cmp w0, #0
+		bge .Lfile_readline_ret
+		mov w1, #1
+		strb w1, [x19, #16]
+		.Lfile_readline_ret:
+		ldr x0, [sp, #0]
+		add sp, sp, #32
+		b .return_File_readLine
+		```
+		return ""
+	}
+
+	// Write a string followed by '\n'.
+	pub func writeLine = (self, string data) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		fputs(data, f);
+		fputc('\n', f);
+		```
+		```
+		#arch: aarch64
+		mov x0, x1
+		ldr x1, [x19, #8]
+		bl _fputs
+		mov w0, #10
+		ldr x1, [x19, #8]
+		bl _fputc
+		```
+	}
+
+	// Read up to `size` bytes from the current position. Sets `eof` if fewer
+	// than `size` bytes remain.
+	pub func readChunk = (ref self, int size, out string) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		char *buf = (char*)malloc(size + 1);
+		long n = fread(buf, 1, size, f);
+		buf[n] = 0;
+		if (n < size) self->eof = 1;
+		return buf;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #16
+		str x1, [sp, #0]
+		ldr x0, [sp, #0]
+		add x0, x0, #1
+		bl _malloc
+		str x0, [sp, #8]
+		ldr x0, [sp, #8]
+		mov x1, #1
+		ldr x2, [sp, #0]
+		ldr x3, [x19, #8]
+		bl _fread
+		ldr x1, [sp, #8]
+		strb wzr, [x1, x0]
+		ldr x2, [sp, #0]
+		cmp x0, x2
+		bge .Lfile_readchunk_ret
+		mov w3, #1
+		strb w3, [x19, #16]
+		.Lfile_readchunk_ret:
+		ldr x0, [sp, #8]
+		add sp, sp, #16
+		b .return_File_readChunk
+		```
+		return ""
+	}
+
+	// Write the first `size` bytes of `data` at the current position.
+	pub func writeChunk = (self, string data, int size) {
+		```
+		#arch: c
+		FILE *f = (FILE*)(unsigned long long)self->handle;
+		fwrite(data, 1, size, f);
+		```
+		```
+		#arch: aarch64
+		mov x0, x1
+		mov x1, #1
+		ldr x3, [x19, #8]
+		bl _fwrite
+		```
+	}
+
+	// (static) Whether a file 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_File_exists
+		```
+		return false
+	}
+
+	// (static) Remove the file at `path`.
+	pub func delete = (string path) {
+		```
+		#arch: c
+		remove(path);
+		```
+		```
+		#arch: aarch64
+		bl _remove
+		```
+	}
+
+	// (static) Read the entire contents of `path` in one open/read/close.
+	// Returns an empty string if the file cannot be opened.
+	pub func read_all = (string path, out string) {
+		```
+		#arch: c
+		FILE *f = fopen(path, "r");
+		if (!f) return strdup("");
+		fseek(f, 0, SEEK_END);
+		long size = ftell(f);
+		fseek(f, 0, SEEK_SET);
+		char *buf = (char*)malloc(size + 1);
+		fread(buf, 1, size, f);
+		buf[size] = 0;
+		fclose(f);
+		return buf;
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #48
+		str x0, [sp, #0]
+		adr x1, .Lfile_read_all_mode
+		bl _fopen
+		str x0, [sp, #8]
+		cbz x0, .Lfile_read_all_empty
+		ldr x0, [sp, #8]
+		mov x1, #0
+		mov x2, #2
+		bl _fseek
+		ldr x0, [sp, #8]
+		bl _ftell
+		str x0, [sp, #16]
+		ldr x0, [sp, #8]
+		mov x1, #0
+		mov x2, #0
+		bl _fseek
+		ldr x0, [sp, #16]
+		add x0, x0, #1
+		bl _malloc
+		str x0, [sp, #24]
+		ldr x0, [sp, #24]
+		mov x1, #1
+		ldr x2, [sp, #16]
+		ldr x3, [sp, #8]
+		bl _fread
+		ldr x0, [sp, #24]
+		ldr x1, [sp, #16]
+		strb wzr, [x0, x1]
+		ldr x0, [sp, #8]
+		bl _fclose
+		ldr x0, [sp, #24]
+		add sp, sp, #48
+		b .return_File_read_all
+		.Lfile_read_all_empty:
+		adr x0, .Lfile_read_all_empty_str
+		bl _strdup
+		add sp, sp, #48
+		b .return_File_read_all
+		.Lfile_read_all_mode: .asciz "r"
+		.Lfile_read_all_empty_str: .asciz ""
+		.p2align 2
+		```
+		return ""
+	}
+
+	// (static) Write `data` to `path` (replacing any existing contents) in
+	// one open/write/close.
+	pub func write_all = (string path, string data) {
+		```
+		#arch: c
+		FILE *f = fopen(path, "w");
+		if (!f) return;
+		fputs(data, f);
+		fclose(f);
+		```
+		```
+		#arch: aarch64
+		sub sp, sp, #32
+		str x0, [sp, #0]
+		str x1, [sp, #8]
+		adr x1, .Lfile_write_all_mode
+		bl _fopen
+		str x0, [sp, #16]
+		cbz x0, .Lfile_write_all_done
+		ldr x0, [sp, #8]
+		ldr x1, [sp, #16]
+		bl _fputs
+		ldr x0, [sp, #16]
+		bl _fclose
+		.Lfile_write_all_done:
+		add sp, sp, #32
+		b .return_File_write_all
+		.Lfile_write_all_mode: .asciz "w"
+		.p2align 2
+		```
+	}
+
+	// Closes the handle if still open (no-op after close). Runs automatically
+	// at scope exit, so an unclosed `File` never leaks.
+	func #destroy = () {
+		```
+		#arch: c
+		if (self->handle) {
+			fclose((FILE*)(unsigned long long)self->handle);
+			self->handle = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		ldr x0, [x19, #8]
+		cbz x0, .Lfile_destroy_end
+		bl _fclose
+		.Lfile_destroy_end:
+		str xzr, [x19, #8]
+		```
+	}
+}