summaryrefslogtreecommitdiff
path: root/test/hxkeys.zig
blob: c94e5900921bca2e396831cff9dd31b1a97e68b1 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
//! helix's key notation as hxdiff's cases spell it (test/hxcases): the
//! next key of `keys` from `i.*`, null at the end; printables verbatim,
//! `<...>` specials and modifiers. The core's harness (hxdiff.zig) and the
//! library's (hxlib.zig) read the cases through it.
const std = @import("std");

pub fn next(comptime Key: type, keys: []const u8, i: *usize) !?Key {
    if (i.* >= keys.len) return null;
    var key: Key = .{ .cp = 0 };
    if (keys[i.*] == '<') {
        const close = std.mem.indexOfScalarPos(u8, keys, i.*, '>') orelse
            return error.UnterminatedKey;
        var name = keys[i.* + 1 .. close];
        i.* = close + 1;
        while (true) {
            if (std.mem.startsWith(u8, name, "C-")) {
                key.ctrl = true;
                name = name[2..];
            } else if (std.mem.startsWith(u8, name, "A-")) {
                key.alt = true;
                name = name[2..];
            } else if (std.mem.startsWith(u8, name, "S-")) {
                key.shift = true;
                name = name[2..];
            } else break;
        }
        if (name.len == 1 or (name.len > 1 and name.len <= 4 and name[0] >= 0x80)) {
            key.cp = std.unicode.utf8Decode(name) catch return error.InvalidKey;
            if (!key.ctrl and !key.alt) key.text = name;
        } else if (std.mem.eql(u8, name, "esc")) {
            key.cp = Key.escape;
        } else if (std.mem.eql(u8, name, "ret")) {
            key.cp = Key.enter;
        } else if (std.mem.eql(u8, name, "tab")) {
            key.cp = Key.tab;
        } else if (std.mem.eql(u8, name, "space")) {
            key.cp = ' ';
            if (!key.ctrl and !key.alt) key.text = " ";
        } else if (std.mem.eql(u8, name, "backspace")) {
            key.cp = Key.backspace;
        } else if (std.mem.eql(u8, name, "del")) {
            key.cp = Key.delete;
        } else if (std.mem.eql(u8, name, "lt")) {
            key.cp = '<';
            if (!key.ctrl and !key.alt) key.text = "<";
        } else if (std.mem.eql(u8, name, "gt")) {
            key.cp = '>';
            if (!key.ctrl and !key.alt) key.text = ">";
        } else if (std.mem.eql(u8, name, "minus")) {
            // helix spells Alt-'-' this way: a bare `-` after a modifier
            // is a parse error in its own macro notation
            key.cp = '-';
            if (!key.ctrl and !key.alt) key.text = "-";
        } else if (std.mem.eql(u8, name, "up")) {
            key.cp = Key.up;
        } else if (std.mem.eql(u8, name, "down")) {
            key.cp = Key.down;
        } else if (std.mem.eql(u8, name, "left")) {
            key.cp = Key.left;
        } else if (std.mem.eql(u8, name, "right")) {
            key.cp = Key.right;
        } else if (std.mem.eql(u8, name, "home")) {
            key.cp = Key.home;
        } else if (std.mem.eql(u8, name, "end")) {
            key.cp = Key.end;
        } else if (std.mem.eql(u8, name, "pageup")) {
            key.cp = Key.page_up;
        } else if (std.mem.eql(u8, name, "pagedown")) {
            key.cp = Key.page_down;
        } else return error.UnknownKey;
    } else {
        const len = std.unicode.utf8ByteSequenceLength(keys[i.*]) catch return error.InvalidKey;
        if (len > keys.len - i.*) return error.InvalidKey;
        const text = keys[i.*..][0..len];
        key.cp = std.unicode.utf8Decode(text) catch return error.InvalidKey;
        key.text = text;
        i.* += len;
    }
    return key;
}