vmod: bring back support for direct vmod -> real mod mapping

This brings back the functionality that was removed in
b9c87eb710. Though it is not used in
xkeyboard-config, from our current perspective it can be quite useful to
be able to set the mappings directly, thus sidestepping the ugly and
legacy-ridden modifier_map statement.

Here's an example of how to get rid of modifier_map statements (though
that would break core-X11 applications, since they must have the
mappings through keysyms):
    virtual_modifiers NumLock = Mod2;
    virtual_modifiers Alt = Mod1;
    // Would be nice to map these to Alt, but that would be
    // incompatible with xkbcomp and somewhat complicated
    virtual_modifiers LAlt = Mod1;
    virtual_modifiers RAlt = Mod1;
    virtual_modifiers LevelThree = Mod5;
    virtual_modifiers RControl = Control;
    virtual_modifiers LControl = Control;
    virtual_modifiers Super = Mod4;
    virtual_modifiers Meta = Mod1;
    virtual_modifiers Hyper = Mod4;
    virtual_modifiers AltGr = Mod5;
    virtual_modifiers LShift = Shift;
    virtual_modifiers RShift = Shift;

Signed-off-by: Ran Benita <ran234@gmail.com>

src/xkbcomp/compat.c

@@ -768,7 +768,7 @@ HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
             ok = HandleGlobalVar(info, (VarDef *) stmt);
             break;
         case STMT_VMOD:
-            ok = HandleVModDef(info->keymap, (VModDef *) stmt);
+            ok = HandleVModDef(info->keymap, (VModDef *) stmt, merge);
             break;
         default:
             log_err(info->keymap->ctx,

src/xkbcomp/symbols.c

@@ -1203,7 +1203,7 @@ HandleSymbolsFile(SymbolsInfo *info, XkbFile *file, enum merge_mode merge)
             ok = HandleGlobalVar(info, (VarDef *) stmt);
             break;
         case STMT_VMOD:
-            ok = HandleVModDef(info->keymap, (VModDef *) stmt);
+            ok = HandleVModDef(info->keymap, (VModDef *) stmt, merge);
             break;
         case STMT_MODMAP:
             ok = HandleModMapDef(info, (ModMapDef *) stmt);

src/xkbcomp/types.c

@@ -639,7 +639,7 @@ HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge)
             ok = true;
             break;
         case STMT_VMOD:
-            ok = HandleVModDef(info->keymap, (VModDef *) stmt);
+            ok = HandleVModDef(info->keymap, (VModDef *) stmt, merge);
             break;
         default:
             log_err(info->keymap->ctx,

src/xkbcomp/vmod.c

@@ -30,28 +30,65 @@
 #include "vmod.h"
 
 bool
-HandleVModDef(struct xkb_keymap *keymap, VModDef *stmt)
+HandleVModDef(struct xkb_keymap *keymap, VModDef *stmt,
+              enum merge_mode merge)
 {
     xkb_mod_index_t i;
-    const struct xkb_mod *mod;
+    struct xkb_mod *mod;
+    xkb_mod_mask_t mapping;
     struct xkb_mod new;
 
-    if (stmt->value)
+    merge = (merge == MERGE_DEFAULT ? stmt->merge : merge);
+
+    if (stmt->value) {
+        /*
+         * This is a statement such as 'virtualModifiers NumLock = Mod1';
+         * it sets the vmod-to-real-mod[s] mapping directly instead of going
+         * through modifier_map or some such.
+         */
+        if (!ExprResolveModMask(keymap, stmt->value, MOD_REAL, &mapping)) {
             log_err(keymap->ctx,
-                "Support for setting a value in a virtual_modifiers statement has been removed; "
+                    "Declaration of %s ignored\n",
-                "Value ignored\n");
+                    xkb_atom_text(keymap->ctx, stmt->name));
+            return false;
+        }
+    }
+    else {
+        mapping = 0;
+    }
 
     darray_enumerate(i, mod, keymap->mods) {
         if (mod->name == stmt->name) {
-            if (mod->type == MOD_VIRT)
+            if (mod->type != MOD_VIRT) {
-                return true;
-
                 log_err(keymap->ctx,
                         "Can't add a virtual modifier named \"%s\"; "
                         "there is already a non-virtual modifier with this name! Ignored\n",
                         xkb_atom_text(keymap->ctx, mod->name));
                 return false;
             }
+
+            if (mod->mapping == mapping)
+                return true;
+
+            if (mod->mapping != 0) {
+                xkb_mod_mask_t use, ignore;
+
+                use = (merge == MERGE_OVERRIDE ? mapping : mod->mapping);
+                ignore = (merge == MERGE_OVERRIDE ? mod->mapping : mapping);
+
+                log_warn(keymap->ctx,
+                         "Virtual modifier %s defined multiple times; "
+                         "Using %s, ignoring %s\n",
+                         xkb_atom_text(keymap->ctx, stmt->name),
+                         ModMaskText(keymap, use),
+                         ModMaskText(keymap, ignore));
+
+                mapping = use;
+            }
+
+            mod->mapping = mapping;
+            return true;
+        }
     }
 
     if (darray_size(keymap->mods) >= XKB_MAX_MODS) {
@@ -62,7 +99,7 @@ HandleVModDef(struct xkb_keymap *keymap, VModDef *stmt)
     }
 
     new.name = stmt->name;
-    new.mapping = 0;
+    new.mapping = mapping;
     new.type = MOD_VIRT;
     darray_append(keymap->mods, new);
     return true;

src/xkbcomp/vmod.h

@@ -28,6 +28,7 @@
 #define XKBCOMP_VMOD_H
 
 bool
-HandleVModDef(struct xkb_keymap *keymap, VModDef *stmt);
+HandleVModDef(struct xkb_keymap *keymap, VModDef *stmt,
+              enum merge_mode merge);
 
 #endif