1 files changed, 102 insertions, 0 deletions

diff --git a/src/key.zig b/src/key.zig
new file mode 100644
index 0000000..1a68ebb
--- /dev/null
+++ b/src/key.zig
@@ -0,0 +1,102 @@
+const std = @import("std");
+
+pub const Key = enum(u16) {
+    return_ = 0x0d,
+    escape = 0x1b,
+    space = 0x20,
+    backspace = 0x7f,
+    max_char = 0xff,
+
+    meta_nil = 0x100,
+    meta_max_char = 0x1ff,
+
+    left,
+    right,
+    up,
+    down,
+    delete,
+    home,
+    end,
+    page_up,
+    page_down,
+
+    _,
+
+    pub fn char(ch: u8) Key {
+        return @intToEnum(Key, ch);
+    }
+
+    pub fn ctrl(ch: u8) Key {
+        return @intToEnum(Key, ch & 0x1f);
+    }
+
+    pub fn format(
+        key: Key,
+        comptime fmt: []const u8,
+        options: std.fmt.FormatOptions,
+        writer: anytype,
+    ) @TypeOf(writer).Error!void {
+        comptime if (fmt.len != 0) {
+            @compileError("Key doesn't support {" ++ fmt ++ "} format");
+        };
+
+        return switch (key) {
+            .return_ => std.fmt.formatBuf("<return>", options, writer),
+            .escape => std.fmt.formatBuf("<escape>", options, writer),
+            .space => std.fmt.formatBuf("<space>", options, writer),
+            .backspace => std.fmt.formatBuf("<backspace>", options, writer),
+            .max_char => key.formatGeneric(options, writer),
+
+            .meta_nil, .meta_max_char => key.formatGeneric(options, writer),
+
+            .left => std.fmt.formatBuf("<left>", options, writer),
+            .right => std.fmt.formatBuf("<right>", options, writer),
+            .up => std.fmt.formatBuf("<up>", options, writer),
+            .down => std.fmt.formatBuf("<down>", options, writer),
+            .delete => std.fmt.formatBuf("<delete>", options, writer),
+            .home => std.fmt.formatBuf("<home>", options, writer),
+            .end => std.fmt.formatBuf("<end>", options, writer),
+            .page_up => std.fmt.formatBuf("<page-up>", options, writer),
+            .page_down => std.fmt.formatBuf("<page-down>", options, writer),
+
+            _ => key.formatGeneric(options, writer),
+        };
+    }
+
+    pub fn meta(ch: u8) Key {
+        return @intToEnum(Key, ch + @enumToInt(Key.meta_nil));
+    }
+
+    pub fn metaCtrl(ch: u8) Key {
+        return @intToEnum(Key, (ch & 0x1f) + @enumToInt(Key.meta_nil));
+    }
+
+    fn formatGeneric(
+        key: Key,
+        options: std.fmt.FormatOptions,
+        writer: anytype,
+    ) @TypeOf(writer).Error!void {
+        const key_int = @enumToInt(key);
+        if (key_int < @enumToInt(Key.space)) {
+            const ch = std.ascii.toLower(@intCast(u8, key_int + 0x40));
+            const buf = [_]u8{'C', '-', ch};
+            return std.fmt.formatBuf(&buf, options, writer);
+        } else if (key_int < @enumToInt(Key.meta_nil)) {
+            const buf = [_]u8{@intCast(u8, key_int)};
+            // This should be printed as C-? or <backspace>, it's dealt with in
+            // format()
+            std.debug.assert(buf[0] != '\x7F');
+            return std.fmt.formatBuf(&buf, options, writer);
+        } else if (key_int <= @enumToInt(Key.meta_max_char)) {
+            try std.fmt.formatBuf("M-", options, writer);
+            return Key.format(
+                @intToEnum(Key, key_int - @enumToInt(Key.meta_nil)),
+                "",
+                options,
+                writer,
+            );
+        } else {
+            unreachable;
+        }
+    }
+};