1 files changed, 106 insertions, 52 deletions

diff --git a/src/key.zig b/src/key.zig
index 5376017..d508ddf 100644
--- a/src/key.zig
+++ b/src/key.zig
@@ -1,34 +1,27 @@
 const std = @import("std");
 
 pub const Key = enum(u16) {
+    tab = 0x09,
     return_ = 0x0d,
     escape = 0x1b,
     space = 0x20,
     backspace = 0x7f,
     max_char = 0xff,
 
-    meta_nil = 0x100,
-    meta_max_char = 0x1ff,
-
-    left,
-    right,
     up,
     down,
-    home,
+    right,
+    left,
     end,
+    home,
+    insert,
     delete,
     page_up,
     page_down,
 
-    ctrl_left,
-    ctrl_right,
-    ctrl_up,
-    ctrl_down,
-    ctrl_home,
-    ctrl_end,
-    // ctrl_delete,
-    // ctrl_page_up,
-    // ctrl_page_down,
+    mod_shft = 0x1000,
+    mod_meta = 0x2000,
+    mod_ctrl = 0x4000,
 
     _,
 
@@ -36,8 +29,59 @@ pub const Key = enum(u16) {
         return @intToEnum(Key, ch);
     }
 
-    pub fn ctrl(ch: u8) Key {
-        return @intToEnum(Key, ch & 0x1f);
+    pub fn shift(k: anytype) Key {
+        return Key.mod(.mod_shft, Key.ify(k));
+    }
+
+    pub fn meta(k: anytype) Key {
+        return Key.mod(.mod_meta, Key.ify(k));
+    }
+
+    pub fn ctrl(k: anytype) Key {
+        return Key.mod(.mod_ctrl, Key.ify(k));
+    }
+
+    /// Key.ify == Keyify :)
+    fn ify(k: anytype) Key {
+        return switch (@TypeOf(k)) {
+            comptime_int, u8 => Key.char(k),
+            Key => k,
+            else => unreachable,
+        };
+    }
+
+    fn mod(comptime modifier: Key, k: Key) Key {
+        comptime std.debug.assert(
+            modifier == .mod_shft
+            or modifier == .mod_meta
+            or modifier == .mod_ctrl
+        );
+
+        const shft_int = @enumToInt(Key.mod_shft);
+        const meta_int = @enumToInt(Key.mod_meta);
+        const ctrl_int = @enumToInt(Key.mod_ctrl);
+
+        const max_char_int = @enumToInt(Key.max_char);
+
+        const mod_int = @enumToInt(modifier);
+        const k_int = @enumToInt(k);
+        if (k_int & mod_int == mod_int) {
+            return k;
+        }
+
+        const k_origmod = k_int & (shft_int | meta_int | ctrl_int);
+        const k_nomod = k_int & ~k_origmod;
+        if (k_nomod <= max_char_int) {
+            // Appending S- to a character is not smart
+            std.debug.assert(modifier != .mod_shft);
+            return switch (modifier) {
+                .mod_meta => @intToEnum(Key, k_int | meta_int),
+                .mod_ctrl => @intToEnum(Key, k_origmod | (k_nomod & 0x1f)),
+                else => unreachable,
+            };
+        } else {
+            return @intToEnum(Key, k_int | mod_int);
+        }
     }
 
     pub fn format(
@@ -51,70 +95,80 @@ pub const Key = enum(u16) {
         };
 
         return switch (key) {
+            .tab => std.fmt.formatBuf("<tab>", options, writer),
             .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),
-            .home => std.fmt.formatBuf("<home>", options, writer),
+            .right => std.fmt.formatBuf("<right>", options, writer),
+            .left => std.fmt.formatBuf("<left>", options, writer),
             .end => std.fmt.formatBuf("<end>", options, writer),
+            .home => std.fmt.formatBuf("<home>", options, writer),
+            .insert => std.fmt.formatBuf("<insert>", options, writer),
             .delete => std.fmt.formatBuf("<delete>", options, writer),
             .page_up => std.fmt.formatBuf("<page-up>", options, writer),
             .page_down => std.fmt.formatBuf("<page-down>", options, writer),
 
-            .ctrl_left => std.fmt.formatBuf("C-<left>", options, writer),
-            .ctrl_right => std.fmt.formatBuf("C-<right>", options, writer),
-            .ctrl_up => std.fmt.formatBuf("C-<up>", options, writer),
-            .ctrl_down => std.fmt.formatBuf("C-<down>", options, writer),
-            .ctrl_home => std.fmt.formatBuf("C-<home>", options, writer),
-            .ctrl_end => std.fmt.formatBuf("C-<end>", options, writer),
-            // ctrl_delete
-            // ctrl_page_up
-            // ctrl_page_down
-
+            .mod_shft, .mod_meta, .mod_ctrl => key.formatGeneric(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 shft_int = @enumToInt(Key.mod_shft);
+        const meta_int = @enumToInt(Key.mod_meta);
+        const ctrl_int = @enumToInt(Key.mod_ctrl);
+
         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)) {
+        if (key_int & shft_int == shft_int) {
+            try std.fmt.formatBuf("S-", options, writer);
+            return Key.format(
+                @intToEnum(Key, key_int & ~shft_int),
+                "",
+                options,
+                writer,
+            );
+        } else if (key_int & meta_int == meta_int) {
             try std.fmt.formatBuf("M-", options, writer);
             return Key.format(
-                @intToEnum(Key, key_int - @enumToInt(Key.meta_nil)),
+                @intToEnum(Key, key_int & ~meta_int),
+                "",
+                options,
+                writer,
+            );
+        } else if (key_int & ctrl_int == ctrl_int) {
+            try std.fmt.formatBuf("C-", options, writer);
+            return Key.format(
+                @intToEnum(Key, key_int & ~ctrl_int),
                 "",
                 options,
                 writer,
             );
+        } else if (key_int < 0x20) {
+            try std.fmt.formatBuf("C-", options, writer);
+            return Key.format(
+                Key.char(@intCast(u8, key_int + 0x40)),
+                "",
+                options,
+                writer
+            );
+        } else if (key_int < 0x100) {
+            const ch = @intCast(u8, key_int);
+            if (std.ascii.isGraph(ch)) {
+                return writer.writeByte(ch);
+            } else {
+                try writer.writeAll("<\\x");
+                try std.fmt.formatIntValue(ch, "X", options, writer);
+                return writer.writeAll(">");
+            }
         } else {
             unreachable;
         }