xkb: implement repeatLastKey key behavior

Author: mahkoh

compile-tests/testcases/t04/t049/t0494/expected.xkb

@@ -0,0 +1,58 @@
+xkb_keymap {
+    xkb_keycodes {
+        minimum = 8;
+        maximum = 255;
+
+        indicator 1 = "DUMMY";
+
+        <a> = 1;
+        <b> = 2;
+        <c> = 3;
+        <d> = 4;
+        <e> = 5;
+        <f> = 6;
+    };
+
+    xkb_types {
+        virtual_modifiers Dummy;
+
+        type "ONE_LEVEL" {
+            modifiers = None;
+            level_name[Level1] = "Any";
+            map[None] = Level1;
+        };
+    };
+
+    xkb_compat {
+        interpret VoidSymbol {
+            repeat = false;
+        };
+    };
+
+    xkb_symbols {
+        key.repeat = true;
+
+        key <a> {
+            repeat = false,
+            repeatLastKey
+        };
+        key <b> {
+            repeat = false
+        };
+        key <c> {
+            repeat = false,
+            repeatLastKey
+        };
+        key <d> {
+            repeat = false
+        };
+        key <e> {
+            repeatLastKey
+        };
+        key <f> {
+            repeatLastKey,
+            type[Group1] = "ONE_LEVEL",
+            symbols[Group1] = [ a ]
+        };
+    };
+};

compile-tests/testcases/t04/t049/t0494/input.xkb

@@ -0,0 +1,18 @@
+xkb_keymap {
+    xkb_keycodes {
+        <a> = 1;
+        <b> = 2;
+        <c> = 3;
+        <d> = 4;
+        <e> = 5;
+        <f> = 6;
+    };
+    xkb_symbols {
+        key <a> { repeatLastKey };
+        key <b> { !repeatLastKey };
+        key <c> { repeatLastKey = true };
+        key <d> { repeatLastKey = false };
+        key <e> { repeatLastKey, repeat };
+        key <f> { repeatLastKey, [ a ] };
+    };
+};

compile-tests/testcases/t04/t049/t0495/expected.xkb

@@ -0,0 +1,33 @@
+xkb_keymap {
+    xkb_keycodes {
+        minimum = 8;
+        maximum = 255;
+
+        indicator 1 = "DUMMY";
+
+        <a> = 1;
+        <b> = 2;
+    };
+
+    xkb_types {
+        virtual_modifiers Dummy;
+    };
+
+    xkb_compat {
+        interpret VoidSymbol {
+            repeat = false;
+        };
+    };
+
+    xkb_symbols {
+        key.repeat = true;
+
+        key <a> {
+            repeat = false
+        };
+        key <b> {
+            repeat = false,
+            repeatLastKey
+        };
+    };
+};

compile-tests/testcases/t04/t049/t0495/input.xkb

@@ -0,0 +1,10 @@
+xkb_keymap {
+    xkb_keycodes {
+        <a> = 1;
+        <b> = 2;
+    };
+    xkb_symbols {
+        key <a> { repeatLastKey[0] };
+        key <b> { repeatLastKey    };
+    };
+};

generator/src/xkb.rs

@@ -14,7 +14,7 @@ pub fn main() {
     std::fs::write("kbvm/src/xkb/meaning/generated.rs", output).unwrap();
 }
 
-const STRINGS: [&str; 228] = [
+const STRINGS: [&str; 229] = [
     "accel",
     "accelerate",
     "AccessXFeedback",
@@ -184,6 +184,7 @@ const STRINGS: [&str; 228] = [
     "repeat",
     "repeating",
     "RepeatKeys",
+    "repeatLastKey",
     "repeats",
     "replace",
     "report",

kbvm/release-notes.md

@@ -90,6 +90,9 @@
   <a> <b> <c>: Y
   <a> <b>:     X
   ```
+- Added support for the `repeatLastKey` key behavior. This key behavior repeats
+  the last pressed key that did not have the `repeatLastKey` behavior and did
+  not contain a `SetMods`, `LatchMods`, or `LockMods` action.
 
 # 0.1.4 (2025-04-21)
 

kbvm/src/state_machine.rs

@@ -319,6 +319,16 @@ impl StateEventHandler for Layer1Handler<'_> {
         &mut self.flags
     }
 
+    #[inline]
+    fn mods_pressed_inc(&mut self, mods: ModifierMask) {
+        self.next.mods_pressed_inc(mods);
+    }
+
+    #[inline]
+    fn mods_pressed_dec(&mut self, mods: ModifierMask) {
+        self.next.mods_pressed_dec(mods);
+    }
+
     #[inline]
     fn mods_pressed_load(&self) -> u32 {
         self.next.acc_state.mods_pressed.0

kbvm/src/xkb/format.rs

@@ -670,6 +670,9 @@ impl Format for Keys<'_> {
                                 }
                                 write!(f.f, "radiogroup = {}", g.radio_group.raw())?;
                             }
+                            KeyBehavior::RepeatLastKey => {
+                                f.write("repeatLastKey")?;
+                            }
                         }
                         needs_newline = true;
                     }

kbvm/src/xkb/kccgst/expr.rs

@@ -1910,6 +1910,7 @@ pub(crate) enum SymbolsField {
     Overlay((KeyOverlay, Interned, Keycode)),
     AllowNone(bool, u32),
     RadioGroup(Option<RadioGroup>),
+    RepeatLastKey(bool),
 }
 
 pub(crate) type GroupList<T> = Vec<SmallVec<[Spanned<T>; 1]>>;
@@ -2213,6 +2214,10 @@ pub(crate) fn eval_symbols_field(
             };
             SymbolsField::RadioGroup(group)
         }
+        Meaning::RepeatLastKey => {
+            deny_idx!();
+            SymbolsField::RepeatLastKey(boolean()?)
+        }
         _ => return Err(UnknownKeyField.spanned2(span)),
     };
     Ok(field.spanned2(span))

kbvm/src/xkb/kccgst/resolver.rs

@@ -1514,6 +1514,9 @@ impl SymbolsKey {
                     SymbolsKeyBehavior::RadioGroup(allow_none, rg).spanned2(f.span)
                 });
             }
+            SymbolsField::RepeatLastKey(b) => {
+                self.behavior = Some(SymbolsKeyBehavior::RepeatLastKey(b).spanned2(f.span));
+            }
         }
     }
 }