xkb: add new keysyms

compile-tests/testcases/t04/t048/t0485/expected.xkb

@@ -64,15 +64,15 @@ xkb_keymap {
         };
         key <02> {
             type[Group1] = "TWO_LEVEL",
-            symbols[Group1] = [ 0x01000001, 0x01000001 ]
+            symbols[Group1] = [ U1, U1 ]
         };
         key <03> {
             type[Group1] = "TWO_LEVEL",
             symbols[Group1] = [ Linefeed, 0x0100000a ]
         };
         key <04> {
             type[Group1] = "TWO_LEVEL",
-            symbols[Group1] = [ 0x0100001f, 0x0100001f ]
+            symbols[Group1] = [ U1f, U1f ]
         };
         key <05> {
             type[Group1] = "TWO_LEVEL",
@@ -88,11 +88,11 @@ xkb_keymap {
         };
         key <08> {
             type[Group1] = "TWO_LEVEL",
-            symbols[Group1] = [ 0x01000080, 0x01000080 ]
+            symbols[Group1] = [ U80, U80 ]
         };
         key <09> {
             type[Group1] = "TWO_LEVEL",
-            symbols[Group1] = [ 0x0100009f, 0x0100009f ]
+            symbols[Group1] = [ U9f, U9f ]
         };
         key <10> {
             type[Group1] = "TWO_LEVEL",

generator/src/keysyms.rs

@@ -59,7 +59,7 @@ fn generate_output() -> String {
 #[derive(Debug)]
 struct KeysymInfo {
     keysym: u32,
-    definitive_name: Option<&'static str>,
+    definitive_name: Option<Cow<'static, str>>,
     code_point: Option<u32>,
     lower: Option<u32>,
     upper: Option<u32>,
@@ -221,7 +221,7 @@ fn handle_yaml(output: &mut IndexMap<u32, KeysymInfo>) {
         let Some(info) = output.get_mut(&keysym) else {
             unreachable!("keysym.yaml contains keysym 0x{keysym:x} not present in the header");
         };
-        info.definitive_name = Some(name);
+        info.definitive_name = Some(Cow::Borrowed(name));
         info.code_point = code_point;
         info.lower = lower;
         info.upper = upper;
@@ -232,6 +232,11 @@ fn handle_yaml(output: &mut IndexMap<u32, KeysymInfo>) {
             info.is_upper = c.is_uppercase();
         }
     }
+    for info in output.values_mut() {
+        if info.definitive_name.is_none() && info.names.len() == 1 {
+            info.definitive_name = Some(info.names[0].name.clone());
+        }
+    }
 }
 
 fn validate(output: &IndexMap<u32, KeysymInfo>) {
@@ -312,7 +317,7 @@ fn validate(output: &IndexMap<u32, KeysymInfo>) {
     for v in output.values() {
         let mut have_definitive_name = false;
         for name in &v.names {
-            if name.name == v.definitive_name.unwrap() {
+            if name.name == **v.definitive_name.as_ref().unwrap() {
                 have_definitive_name = true;
             }
             if let Some(alias) = name.alias_for {
@@ -341,7 +346,7 @@ fn assign_indices(output: &mut IndexMap<u32, KeysymInfo>) {
     for ks in output.values_mut() {
         for name in &mut ks.names {
             name.idx = i;
-            if name.name == ks.definitive_name.unwrap() {
+            if name.name == **ks.definitive_name.as_ref().unwrap() {
                 ks.definitive_idx = i;
             }
             i += 1;
@@ -548,6 +553,9 @@ fn generate_datas(output: &IndexMap<u32, KeysymInfo>) -> String {
         if name.idx != v.definitive_idx {
             res.push_str(" | IS_SECONDARY_IDX");
         }
+        if name.deprecated {
+            res.push_str(" | IS_DEPRECATED");
+        }
         res.push_str(",\n");
         res.push_str("    },\n");
     }

kbvm/src/keysym.rs

@@ -88,6 +88,7 @@ const KEYSYM_IS_CHAR: u8 = 1 << 1;
 const IS_LOWER: u8 = 1 << 2;
 const IS_UPPER: u8 = 1 << 3;
 const IS_SECONDARY_IDX: u8 = 1 << 4;
+const IS_DEPRECATED: u8 = 1 << 5;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[repr(Rust, packed)]
@@ -233,18 +234,15 @@ impl Keysym {
         if matches!(c, 0x08..=0x0b | 0x0d | 0x1b) {
             return Self(c | 0xff00);
         }
-        if matches!(c, 0x7f) {
-            return syms::Delete;
-        }
-        if matches!(c, 0xfdd0..=0xfdef) {
+        if matches!(c, 0x0) {
             return syms::NoSymbol;
         }
-        if matches!(c & 0xffff, 0xfffe..=0xffff) {
-            return syms::NoSymbol;
+        if matches!(c, 0x7f) {
+            return syms::Delete;
         }
         let idx = CHAR_TO_BESPOKE_IDX[&char];
         let data = &DATAS[idx as usize];
-        if data.flags & HAS_CHAR != 0 {
+        if data.flags & (HAS_CHAR | IS_DEPRECATED) == HAS_CHAR {
             let sym = Self(data.keysym_or_definitive_idx);
             if data.flags & KEYSYM_IS_CHAR != 0 && sym.0 == char as u32 {
                 return sym;
@@ -622,15 +620,11 @@ fn from_str<const CASE_INSENSITIVE: bool>(s: &[u8]) -> Option<Keysym> {
 }
 
 fn keysym_from_cp(cp: u32) -> Option<Keysym> {
-    let v = match cp {
-        0x000000..=0x00001f => None,
-        0x000020..=0x00007e => Some(cp),
-        0x00007f..=0x00009f => None,
-        0x0000a0..=0x0000ff => Some(cp),
-        0x000100..=0x10ffff => Some(cp | 0x01_00_00_00),
-        0x110000.. => None,
-    };
-    v.map(Keysym)
+    if matches!(cp, 0x000100..=0x10ffff) {
+        Some(Keysym(cp | 0x01_00_00_00))
+    } else {
+        char::from_u32(cp).map(Keysym::from_char)
+    }
 }
 
 impl FromStr for Keysym {

kbvm/src/keysym/tests.rs

@@ -26,15 +26,8 @@ fn from_char() {
         };
         let l = Keysym::from_char(c).0;
         let r = xkb_utf32_to_keysym(c as _);
-        if matches!(c, '─' | '│' | '┌' | '○') {
-            // xkbcommon returns deprecated keysyms for these characters
-            if l == r {
-                panic!("Expected different output for {c:?} but output is 0x{l:x}");
-            }
-        } else {
-            if l != r {
-                panic!("for {c:?}: self=0x{l:x}, xkbcommon=0x{r:x}");
-            }
+        if l != r {
+            panic!("for {c:?}: self=0x{l:x}, xkbcommon=0x{r:x}");
         }
     }
 }