Initial commit.

remap.c

@@ -0,0 +1,172 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <linux/input.h>
+#include <time.h>
+#include <unistd.h>
+
+/**
+ * Global constants
+ **/
+#define MS_TO_NS 1000000L // 1 millisecond = 1,000,000 Nanoseconds
+const int KEY_STROKE_UP = 0, KEY_STROKE_DOWN = 1, KEY_STROKE_REPEAT = 2;
+const int INPUT_BUFFER_SIZE = 16;
+const long SLEEP_INTERVAL_NS = 20 * MS_TO_NS;
+const int input_event_struct_size = sizeof(struct input_event);
+
+int map_space[KEY_MAX];
+
+// clang-format off
+const struct input_event
+_space_up        = {.type = EV_KEY, .code = KEY_SPACE,    .value = KEY_STROKE_UP},
+_meta_up         = {.type = EV_KEY, .code = KEY_LEFTMETA, .value = KEY_STROKE_UP},
+_space_down      = {.type = EV_KEY, .code = KEY_SPACE,    .value = KEY_STROKE_DOWN},
+_meta_down       = {.type = EV_KEY, .code = KEY_LEFTMETA, .value = KEY_STROKE_DOWN},
+_space_repeat    = {.type = EV_KEY, .code = KEY_SPACE,    .value = KEY_STROKE_REPEAT},
+_meta_repeat     = {.type = EV_KEY, .code = KEY_LEFTMETA, .value = KEY_STROKE_REPEAT},
+_syn             = {.type = EV_SYN, .code = SYN_REPORT,   .value = KEY_STROKE_UP};
+const struct input_event
+*space_up     = &_space_up,
+*meta_up      = &_meta_up,
+*space_down   = &_space_down,
+*meta_down    = &_meta_down,
+*space_repeat = &_space_repeat,
+*meta_repeat  = &_meta_repeat,
+*syn          = &_syn;
+// clang-format on
+
+/*
+static int key_ismod(int code) {
+  switch (code) {
+  default:
+    return 0;
+  case KEY_LEFTSHIFT:
+  case KEY_RIGHTSHIFT:
+  case KEY_LEFTCTRL:
+  case KEY_RIGHTCTRL:
+  case KEY_LEFTALT:
+  case KEY_RIGHTALT:
+  case KEY_LEFTMETA:
+  case KEY_RIGHTMETA:
+    return 1;
+  }
+}
+*/
+void map_space_init() {
+  map_space[KEY_H] = KEY_LEFT;
+  map_space[KEY_J] = KEY_DOWN;
+  map_space[KEY_K] = KEY_UP;
+  map_space[KEY_L] = KEY_RIGHT;
+}
+
+int equal(const struct input_event *first, const struct input_event *second) {
+  return first->type == second->type && first->code == second->code &&
+         first->value == second->value;
+}
+
+int read_event(struct input_event *event) {
+  return fread(event, input_event_struct_size, 1, stdin) == 1;
+}
+
+void write_event(const struct input_event *event) {
+  if (fwrite(event, input_event_struct_size, 1, stdout) != 1)
+    exit(EXIT_FAILURE);
+}
+
+void write_events(const struct input_event *ev1,
+                  const struct input_event *ev2) {
+  const struct input_event buffer[3] = {*ev1, _syn, *ev2};
+  if (fwrite(&buffer, input_event_struct_size, 3, stdout) != 3)
+    exit(EXIT_FAILURE);
+}
+
+int main() {
+  struct input_event *input =
+      (struct input_event *)malloc(input_event_struct_size);
+  struct input_event *input_mapped_down =
+                         (struct input_event *)malloc(input_event_struct_size),
+                     *input_origin_up =
+                         (struct input_event *)malloc(input_event_struct_size),
+                     *input_mapped_up =
+                         (struct input_event *)malloc(input_event_struct_size);
+  *input_mapped_down = *space_down;
+  *input_origin_up = *space_up;
+  *input_mapped_up = *space_up;
+  enum { START, SPACE_HELD, KEY_HELD } state = START;
+  int space_down_not_emitted = 1;
+
+  map_space_init();
+
+  setbuf(stdin, NULL), setbuf(stdout, NULL);
+
+  while (read_event(input)) {
+    if (input->type == EV_MSC && input->code == MSC_SCAN)
+      continue;
+
+    if (input->type != EV_KEY) {
+      write_event(input);
+      continue;
+    }
+
+    switch (state) {
+    case START:
+      if (equal(input, space_down) || equal(input, space_repeat)) {
+        state = SPACE_HELD;
+        space_down_not_emitted = 1;
+      } else {
+        write_event(input);
+      }
+      break;
+    case SPACE_HELD:
+      if (equal(input, space_down) || equal(input, space_repeat))
+        break;
+      if (input->value == KEY_STROKE_DOWN) {
+        if (map_space[input->code] != 0) {
+          // TODO: any mapped key needs to go to a set of HELD keys and
+          // only when last of HELD keys is released, we can go back to SPACE_HELD state
+          // we should also accept new HELD keys while in KEY_HELD state
+          *input_origin_up = *input;
+          input_origin_up->value = KEY_STROKE_UP;
+
+          *input_mapped_down = *input;
+          input_mapped_down->code = map_space[input->code];
+
+          *input_mapped_up = *input_mapped_down;
+          input_mapped_up->value = KEY_STROKE_UP;
+
+          write_event(input_mapped_down);
+          state = KEY_HELD;
+        } else {
+          write_event(input);
+        }
+      } else { // KEY_STROKE_REPEAT or KEY_STROKE_UP
+        if (input->code == KEY_SPACE && space_down_not_emitted) {
+          write_events(space_down, input);
+          space_down_not_emitted = 0;
+        } else {
+          write_event(input);
+        }
+        state = equal(input, space_up) ? START : SPACE_HELD;
+      }
+      break;
+    case KEY_HELD:
+      if (equal(input, space_down) || equal(input, space_repeat))
+        break;
+      if (equal(input, input_mapped_down)) // || equal(input, key_repeat))
+        break;
+
+      if (equal(input, input_origin_up)) {
+        write_event(input_mapped_up);
+        state = SPACE_HELD;
+        // even if it actually wasn't emitted, we don't want to emit it
+        // after we made sure space is supposed to behave as function key
+        space_down_not_emitted = 0;
+      } else {
+        write_event(input);
+      }
+      break;
+    }
+  }
+
+  free(input);
+}