ed

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README
commit af74e3ddff6faa6deeeffdb1a23006e0715757c0
parent d7e69608322c87733dc92ebb3702673ec29815c4
Author: Byron Torres <b@torresjrjr.com>
Date:   Sun, 26 Sep 2021 00:55:59 +0100

Update syntax for Hare case statements

Diffstat:

Maddress.ha | 72++++++++++++++++++++++++++++++++++++++++++++----------------------------


Mbuffer.ha | 30+++++++++++++++++-------------


Med.ha | 32+++++++++++++++++++++-----------


Moperation.ha | 66++++++++++++++++++++++++++++++++++++++++++------------------------


Mparse.ha | 61++++++++++++++++++++++++++++++++++++++-----------------------


Mutil.ha | 23++++++++++++-----------


6 files changed, 174 insertions(+), 110 deletions(-)

diff --git a/address.ha b/address.ha
@@ -9,9 +9,12 @@ fn addr_linenum(buf: *buffer, n: uint) *linenode = {
 
 	for (i < n) {
 		match (ln.value) {
-			tailnode => abort("Invalid range"), // TODO: return error
-			headnode => ln = ln.next,
-			str      => ln = ln.next,
+		case tailnode =>
+			abort("Invalid range"); // TODO: return error
+		case headnode =>
+			ln = ln.next;
+		case str =>
+			ln = ln.next;
 		};
 
 		i += 1;
@@ -25,9 +28,11 @@ fn addr_lastline(buf: *buffer) *linenode = {
 	let ln = buf.tail.prev;
 
 	match (ln.value) {
-		tailnode => abort("Unreachable"),
-		headnode => abort("TODO"), // TODO: ???
-		str => void,
+	case tailnode =>
+		abort("Unreachable");
+	case headnode =>
+		abort("TODO"); // TODO: ???
+	case str => void;
 	};
 
 	return ln;
@@ -45,20 +50,25 @@ fn addr_regex(buf: *buffer, ln: *linenode, re: str, dir: bool) *linenode = {
 
 	for (true) {
 		match (ln.value) {
-			headnode => ln = buf.tail.prev,
-			tailnode => ln = buf.head.next,
-			txt: str => {
-				if (startln == ln) {
-					abort("No match"); // TODO: return error
-				};
-				switch (strings::contains(txt, re)) { // TODO: use real regex
-					false => switch (dir) {
-						true  => ln = ln.next,
-						false => ln = ln.prev,
-					},
-					true => return ln,
-				};
-			},
+		case headnode =>
+			ln = buf.tail.prev;
+		case tailnode =>
+			ln = buf.head.next;
+		case txt: str =>
+			if (startln == ln) {
+				abort("No match"); // TODO: return error
+			};
+			switch (strings::contains(txt, re)) { // TODO: use real regex
+			case false =>
+				switch (dir) {
+				case true  =>
+					ln = ln.next;
+				case false =>
+					ln = ln.prev;
+			};
+			case true =>
+				return ln;
+			};
 		};
 	};
 
@@ -70,14 +80,17 @@ fn addr_mark(buf: *buffer, mark: rune) *linenode = {
 	let ln = buf.head;
 	for (true) {
 		match (ln.value) {
-			headnode => ln = ln.next,
-			tailnode => abort("Invalid address"), // TODO: return error
-			str => if (ln.mark == mark) {
+		case headnode =>
+			ln = ln.next;
+		case tailnode =>
+			abort("Invalid address"); // TODO: return error
+		case str =>
+			if (ln.mark == mark) {
 				return ln;
 			} else {
 				ln = ln.next;
 				continue;
-			},
+			};
 		};
 	};
 
@@ -88,15 +101,18 @@ fn addr_mark(buf: *buffer, mark: rune) *linenode = {
 fn addr_offset(buf: *buffer, ln: *linenode, n: uint) *linenode = {
 	for (n != 0) {
 		match (ln.value) {
-			headnode => abort("Invalid address"), // TODO: return error
-			tailnode => abort("Invalid address"), // TODO: return error
-			str => if (n > 0) {
+		case headnode =>
+			abort("Invalid address"); // TODO: return error
+		case tailnode =>
+			abort("Invalid address"); // TODO: return error
+		case str =>
+			if (n > 0) {
 				ln = ln.next;
 				n -= 1;
 			} else if (n < 0) {
 				ln = ln.prev;
 				n += 1;
-			},
+			};
 		};
 	};
 
diff --git a/buffer.ha b/buffer.ha
@@ -62,9 +62,12 @@ fn buf_read(buf: *buffer, source: *io::stream) size = {
 
 	for (true) {
 		const rawline = match (bufio::scanline(source)) {
-			* => abort(),
-			io::EOF => break,
-			rawline: []u8 => rawline,
+		case rawline: []u8 =>
+			yield rawline;
+		case io::EOF =>
+			break;
+		case =>
+			abort();
 		};
 		// TODO: make sure to free lines later
 		//defer free(rawline);
@@ -95,14 +98,13 @@ fn buf_write(buf: *buffer, dest: *io::stream) size = {
 
 	for (true) {
 		match (ln.value) {
-			headnode => {
-				ln = ln.next;
-			},
-			text: str => {
-				n += fmt::fprintln(dest, text)!;
-				ln = ln.next;
-			},
-			tailnode => break
+		case headnode =>
+			ln = ln.next;
+		case text: str =>
+			n += fmt::fprintln(dest, text)!;
+			ln = ln.next;
+		case tailnode =>
+			break;
 		};
 	};
 	return n;
@@ -160,8 +162,10 @@ fn buf_delete(buf: *buffer, h: *linenode, t: *linenode) void = {
 	};
 
 	buf.cur.node = match (T.value) {
-		tailnode => T.prev,
-		str => T,
+	case tailnode =>
+		yield T.prev;
+	case str =>
+		yield T;
 	};
 	buf.range_a = buf.cur.node;
 	buf.range_b = buf.cur.node;
diff --git a/ed.ha b/ed.ha
@@ -23,8 +23,10 @@ export fn main() void = {
 	for (let i = 0z; i < len(cmd.opts); i += 1) {
 		const opt = cmd.opts[i];
 		switch (opt.0) {
-			'p' => prompt = opt.1,
-			's' => surpress = true,
+		case 'p' =>
+			prompt = opt.1;
+		case 's' =>
+			surpress = true;
 		};
 	};
 
@@ -33,12 +35,17 @@ export fn main() void = {
 	};
 
 	let fname: filename = switch (len(cmd.args) == 1) {
-		false => void,
-		true  => switch (cmd.args[0]) {
-			"-" => fmt::fatal("Invalid filename '-'"),
-			""  => fmt::fatal("Invalid filename ''"),
-			*   => cmd.args[0],
-		},
+	case false =>
+		void;
+	case true =>
+		switch (cmd.args[0]) {
+		case "-" =>
+			fmt::fatal("Invalid filename '-'");
+		case "" =>
+			fmt::fatal("Invalid filename ''");
+		case =>
+			cmd.args[0];
+		};
 	};
 
 	const buf = new_buffer();
@@ -52,9 +59,12 @@ export fn main() void = {
 		fmt::error(prompt)!;
 
 		const rawline = match (bufio::scanline(os::stdin)) {
-			* => abort(),
-			io::EOF => break,
-			rawline: []u8 => rawline,
+		case rawline: []u8 =>
+			yield rawline;
+		case io::EOF =>
+			break;
+		case =>
+			abort();
 		};
 		defer free(rawline);
 
diff --git a/operation.ha b/operation.ha
@@ -6,11 +6,15 @@ use fs;
 fn op_edit(buf: *buffer, args: arg...) void = {
 	const scratch = new_buffer();
 	const n = match (buf.fname) {
-		void => abort("TODO"),
-		fname: str => match (os::open(fname)) {
-			err: fs::error => fmt::fatal("Error {}", fs::strerror(err)),
-			f: io::file => buf_read(scratch, &f),
-		},
+	case void =>
+		abort("TODO");
+	case fname: str =>
+		yield match (os::open(fname)) {
+		case err: fs::error =>
+			fmt::fatal("Error {}", fs::strerror(err));
+		case f: io::file =>
+			yield buf_read(scratch, &f);
+		};
 	};
 
 	if (!(buf.head.next.value is tailnode)) {
@@ -33,14 +37,20 @@ fn op_write(buf: *buffer, args: arg...) void = {
 		fs::flags::CLOEXEC,
 	];
 	const file = match (buf.fname) {
-		void => abort("TODO"),
-		fname: str => match (os::open(fname, flags...)) {
-			fs::error => match (os::create(fname, mode)) {
-				err: fs::error => fmt::fatal("Error {}", fs::strerror(err)),
-				f: io::file => f,
-			},
-			f: io::file => f,
-		},
+	case void =>
+		abort("TODO");
+	case fname: str =>
+		yield match (os::open(fname, flags...)) {
+		case fs::error =>
+			yield match (os::create(fname, mode)) {
+			case err: fs::error =>
+				fmt::fatal("Error {}", fs::strerror(err));
+			case file: io::file =>
+				yield file;
+			};
+		case file: io::file =>
+			yield file;
+		};
 	};
 
 	const n = buf_write(buf, &file);
@@ -54,11 +64,15 @@ fn op_write(buf: *buffer, args: arg...) void = {
 fn op_read(buf: *buffer, args: arg...) void = {
 	const scratch = new_buffer();
 	const n = match (buf.fname) {
-		void => abort("TODO"),
-		fname: str => match (os::open(fname)) {
-			err: fs::error => fmt::fatal("Error {}", fs::strerror(err)),
-			f: io::file => buf_read(scratch, &f),
-		},
+	case void =>
+		abort("TODO");
+	case fname: str =>
+		yield match (os::open(fname)) {
+		case err: fs::error =>
+			fmt::fatal("Error {}", fs::strerror(err));
+		case f: io::file =>
+			yield buf_read(scratch, &f);
+		};
 	};
 
 	buf_insert(buf, scratch);
@@ -85,9 +99,11 @@ fn op_numbered(buf: *buffer, args: arg...) void = {
 
 	for (true) {
 		match (ln.value) {
-			headnode => void,
-			txt: str => fmt::printfln("{}\t{}", n, txt)?,
-			tailnode => break
+		case headnode => void;
+		case txt: str =>
+			fmt::printfln("{}\t{}", n, txt)?;
+		case tailnode =>
+			break;
 		};
 
 		if (ln == b) {
@@ -107,9 +123,11 @@ fn op_print(buf: *buffer, args: arg...) void = {
 
 	for (true) {
 		match (ln.value) {
-			headnode => void,
-			txt: str => fmt::printfln("{}", txt)?,
-			tailnode => break
+		case headnode => void;
+		case txt: str =>
+			fmt::printfln("{}", txt)?;
+		case tailnode =>
+			break;
 		};
 
 		if (ln == b) {
diff --git a/parse.ha b/parse.ha
@@ -55,8 +55,10 @@ fn parse_input(input: str) command = {
 
 	for (true) {
 		let r: rune = match (strings::next(&iter)) {
-			void => break,
-			r: rune => r,
+		case void =>
+			break;
+		case r: rune =>
+			yield r;
 		};
 
 		if (ascii::isblank(r)) {
@@ -89,25 +91,33 @@ fn construct_ops(cmd: command) []op = {
 
 	for (let i = 0z; i < len(cmd.addrs); i += 1) {
 		const addr = cmd.addrs[i];
+
 		switch (addr.addrtype) {
-			addrtype::LINENUM => {
-				append(ops, op {
-					func = &cur_linenum,
-					args = [addr.linenum]
-				});
-			},
+		case addrtype::LINENUM =>
+			append(ops, op {
+				func = &cur_linenum,
+				args = [addr.linenum]
+			});
 		};
 	};
 	
 	let op = switch (cmd.main) {
-		"e" => op { func = &op_edit, },
-		"r" => op { func = &op_read, },
-		"w" => op { func = &op_write, },
-		"d" => op { func = &op_delete, },
-		"n" => op { func = &op_numbered, },
-		"p" => op { func = &op_print, },
-		" p" => op { func = &print_buffer, }, // DEBUG ONLY
-		* => op { func = &print_buffer, }, // TODO
+	case "e" =>
+		yield op { func = &op_edit, };
+	case "r" =>
+		yield op { func = &op_read, };
+	case "w" =>
+		yield op { func = &op_write, };
+	case "d" =>
+		yield op { func = &op_delete, };
+	case "n" =>
+		yield op { func = &op_numbered, };
+	case "p" =>
+		yield op { func = &op_print, };
+	case " p" =>
+		yield op { func = &print_buffer, }; // DEBUG ONLY
+	case =>
+		yield op { func = &print_buffer, }; // TODO
 	};
 	append(ops, op);
 
@@ -121,8 +131,10 @@ fn scan_uint(iter: *strings::iterator) uint = {
 
 	for (true) {
 		const r = match (strings::next(iter)) {
-			void => break,
-			r: rune => r,
+		case void =>
+			break;
+		case r: rune =>
+			yield r;
 		};
 
 		if (ascii::isdigit(r)) {
@@ -134,9 +146,10 @@ fn scan_uint(iter: *strings::iterator) uint = {
 	};
 
 	match (strconv::stou(strings::fromutf8(num))) {
-		(strconv::invalid | strconv::overflow) =>
-			abort("Invalid format string (invalid index)"),
-		u: uint => return u,
+	case (strconv::invalid | strconv::overflow) =>
+		abort("Invalid format string (invalid index)");
+	case u: uint =>
+		return u;
 	};
 };
 
@@ -147,8 +160,10 @@ fn scan_command(iter: *strings::iterator) str = {
 
 	for (true) {
 		const r = match (strings::next(iter)) {
-			void => break,
-			r: rune => r,
+		case void =>
+			break;
+		case r: rune =>
+			yield r;
 		};
 
 		if (ascii::isalpha(r)) {
diff --git a/util.ha b/util.ha
@@ -5,14 +5,13 @@ fn print_buffer(buf: *buffer, args: arg...) void = {
 	let ln = buf.head;
 	for (true) {
 		match (ln.value) {
-			headnode => {
-				ln = ln.next;
-			},
-			s: str => {
-				fmt::println(s)?;
-				ln = ln.next;
-			},
-			tailnode => break
+		case headnode =>
+			ln = ln.next;
+		case s: str =>
+			fmt::println(s)?;
+			ln = ln.next;
+		case tailnode =>
+			break;
 		};
 	};
 };
@@ -23,13 +22,15 @@ fn find_linenum(buf: *buffer, ln: *linenode) size = {
 
 	for (true) {
 		match (x.value) {
-			tailnode => abort("Unreachable"), // TODO: refactor?
-			(str | headnode) => if (x == ln) {
+		case tailnode =>
+			abort("Unreachable"); // TODO: refactor?
+		case (str | headnode) =>
+			if (x == ln) {
 				break;
 			} else {
 				n += 1;
 				x = x.next;
-			},
+			};
 		};
 	};