mods: Always use constants from xkbcommon-names.h

Respect the claim that real modifiers names are built-in:
- Add `XKB_MOD_NAME_MOD[1-5]` constants.
- Replace modifiers names with their corresponding constants.

include/xkbcommon/xkbcommon-names.h

@@ -35,6 +35,13 @@
 #define XKB_MOD_NAME_SHIFT      "Shift"
 #define XKB_MOD_NAME_CAPS       "Lock"
 #define XKB_MOD_NAME_CTRL       "Control"
+#define XKB_MOD_NAME_MOD1       "Mod1"
+#define XKB_MOD_NAME_MOD2       "Mod2"
+#define XKB_MOD_NAME_MOD3       "Mod3"
+#define XKB_MOD_NAME_MOD4       "Mod4"
+#define XKB_MOD_NAME_MOD5       "Mod5"
+
+/* Usual virtual modifiers mappings to real modifiers */
 #define XKB_MOD_NAME_ALT        "Mod1"
 #define XKB_MOD_NAME_NUM        "Mod2"
 #define XKB_MOD_NAME_LOGO       "Mod4"

src/keymap-priv.c

@@ -26,21 +26,22 @@
 
 #include "config.h"
 
+#include "xkbcommon/xkbcommon-names.h"
 #include "keymap.h"
 
 static void
 update_builtin_keymap_fields(struct xkb_keymap *keymap)
 {
     /* Predefined (AKA real, core, X11) modifiers. The order is important! */
     static const char *const builtin_mods[] = {
-        [0] = "Shift",
-        [1] = "Lock",
-        [2] = "Control",
-        [3] = "Mod1",
-        [4] = "Mod2",
-        [5] = "Mod3",
-        [6] = "Mod4",
-        [7] = "Mod5"
+        [0] = XKB_MOD_NAME_SHIFT,
+        [1] = XKB_MOD_NAME_CAPS,
+        [2] = XKB_MOD_NAME_CTRL,
+        [3] = XKB_MOD_NAME_MOD1,
+        [4] = XKB_MOD_NAME_MOD2,
+        [5] = XKB_MOD_NAME_MOD3,
+        [6] = XKB_MOD_NAME_MOD4,
+        [7] = XKB_MOD_NAME_MOD5
     };
 
     for (unsigned i = 0; i < ARRAY_SIZE(builtin_mods); i++) {

test/keymap.c

@@ -116,9 +116,9 @@ test_keymap(void)
     assert(mask_count == 1);
     assert(masks_out[0] == 0);
 
-    shift_mask = 1 << xkb_keymap_mod_get_index(keymap, "Shift");
-    lock_mask = 1 << xkb_keymap_mod_get_index(keymap, "Lock");
-    mod2_mask = 1 << xkb_keymap_mod_get_index(keymap, "Mod2");
+    shift_mask = 1 << xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+    lock_mask = 1 << xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+    mod2_mask = 1 << xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_MOD2);
 
     // AC01 level 1 ('A') requires either Shift or Lock modifiers on us-pc104
     mask_count = xkb_keymap_key_get_mods_for_level(keymap, kc, 0, 1, masks_out, 4);

test/modifiers.c

@@ -30,21 +30,62 @@
 #include "test.h"
 #include "keymap.h"
 
+// Standard real modifiers indexes
+#define ShiftIndex   0
+#define LockIndex    1
+#define ControlIndex 2
+#define Mod1Index    3
+#define Mod2Index    4
+#define Mod3Index    5
+#define Mod4Index    6
+#define Mod5Index    7
+
 // Standard real modifier masks
-#define ShiftMask   (1 << 0)
-#define LockMask    (1 << 1)
-#define ControlMask (1 << 2)
-#define Mod1Mask    (1 << 3)
-#define Mod2Mask    (1 << 4)
-#define Mod3Mask    (1 << 5)
-#define Mod4Mask    (1 << 6)
-#define Mod5Mask    (1 << 7)
+#define ShiftMask   (1 << ShiftIndex)
+#define LockMask    (1 << LockIndex)
+#define ControlMask (1 << ControlIndex)
+#define Mod1Mask    (1 << Mod1Index)
+#define Mod2Mask    (1 << Mod2Index)
+#define Mod3Mask    (1 << Mod3Index)
+#define Mod4Mask    (1 << Mod4Index)
+#define Mod5Mask    (1 << Mod5Index)
 #define NoModifier  0
 
+static bool
+test_real_mod(struct xkb_keymap *keymap, const char* name,
+              xkb_mod_index_t idx, xkb_mod_mask_t mapping)
+{
+    return xkb_keymap_mod_get_index(keymap, name) == idx &&
+           (keymap->mods.mods[idx].type == MOD_REAL) &&
+           mapping == (1u << idx);
+}
+
+/* Check that the provided modifier names work */
+static void
+test_modifiers_names(struct xkb_context *context)
+{
+    struct xkb_keymap *keymap;
+
+    keymap = test_compile_rules(context, "evdev", NULL, NULL, NULL, NULL);
+    assert(keymap);
+
+    /* Real modifiers
+     * The indexes and masks are fixed and always valid */
+    assert(test_real_mod(keymap, XKB_MOD_NAME_SHIFT, ShiftIndex, ShiftMask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_CAPS, LockIndex, LockMask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_CTRL, ControlIndex, ControlMask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_MOD1, Mod1Index, Mod1Mask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_MOD2, Mod2Index, Mod2Mask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_MOD3, Mod3Index, Mod3Mask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_MOD4, Mod4Index, Mod4Mask));
+    assert(test_real_mod(keymap, XKB_MOD_NAME_MOD5, Mod5Index, Mod5Mask));
+
+    xkb_keymap_unref(keymap);
+}
+
 static void
-test_modmap_none(void)
+test_modmap_none(struct xkb_context *context)
 {
-    struct xkb_context *context = test_get_context(0);
     struct xkb_keymap *keymap;
     const struct xkb_key *key;
     xkb_keycode_t keycode;
@@ -148,15 +189,20 @@ test_modmap_none(void)
     assert(key->modmap == Mod3Mask);
 
     xkb_keymap_unref(keymap);
-    xkb_context_unref(context);
 }
 
 int
 main(void)
 {
     test_init();
 
-    test_modmap_none();
+    struct xkb_context *context = test_get_context(CONTEXT_NO_FLAG);
+    assert(context);
+
+    test_modmap_none(context);
+    test_modifiers_names(context);
+
+    xkb_context_unref(context);
 
     return 0;
 }

test/state.c

@@ -315,9 +315,9 @@ test_update_mask_mods(struct xkb_keymap *keymap)
     assert(num != XKB_MOD_INVALID);
     alt = xkb_keymap_mod_get_index(keymap, "Alt");
     assert(alt != XKB_MOD_INVALID);
-    mod1 = xkb_keymap_mod_get_index(keymap, "Mod1");
+    mod1 = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_MOD1);
     assert(mod1 != XKB_MOD_INVALID);
-    mod2 = xkb_keymap_mod_get_index(keymap, "Mod2");
+    mod2 = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_MOD2);
     assert(mod2 != XKB_MOD_INVALID);
 
     changed = xkb_state_update_mask(state, 1 << caps, 0, 0, 0, 0, 0);
@@ -395,7 +395,7 @@ test_consume(struct xkb_keymap *keymap)
     assert(caps != XKB_MOD_INVALID);
     ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
     assert(ctrl != XKB_MOD_INVALID);
-    mod5 = xkb_keymap_mod_get_index(keymap, "Mod5");
+    mod5 = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_MOD5);
     assert(mod5 != XKB_MOD_INVALID);
 
     /* Test remove_consumed() */