expr: use new log functions

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

diff --git a/src/xkbcomp/action.c b/src/xkbcomp/action.c
index d648384..4242fc3 100644 (file)
--- a/src/xkbcomp/action.c
+++ b/src/xkbcomp/action.c
@@ -255,7 +255,7 @@ CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value,
             return true;
         }
     }
-    if (!ExprResolveVModMask(value, &rtrn, keymap))
+    if (!ExprResolveVModMask(keymap, value, &rtrn))
         return ReportMismatch(keymap, action, F_Modifiers, "modifier mask");
     *mods_rtrn = rtrn.uval;
     *flags_inout &= ~XkbSA_UseModMapMods;

diff --git a/src/xkbcomp/compat.c b/src/xkbcomp/compat.c
index 90f660a..3209871 100644 (file)
--- a/src/xkbcomp/compat.c
+++ b/src/xkbcomp/compat.c
@@ -757,7 +757,7 @@ SetIndicatorMapField(CompatInfo *info, LEDInfo *led,
         if (arrayNdx != NULL)
             return ReportIndicatorNotArray(info, led, field);
 
-        if (!ExprResolveVModMask(value, &rtrn, keymap))
+        if (!ExprResolveVModMask(keymap, value, &rtrn))
             return ReportIndicatorBadType(info, led, field, "modifier mask");
 
         led->real_mods = rtrn.uval & 0xff;
@@ -968,7 +968,7 @@ HandleGroupCompatDef(CompatInfo *info, GroupCompatDef *def,
     }
     tmp.file_id = info->file_id;
     tmp.merge = merge;
-    if (!ExprResolveVModMask(def->def, &val, info->keymap)) {
+    if (!ExprResolveVModMask(info->keymap, def->def, &val)) {
         log_err(info->keymap->ctx,
                 "Expected a modifier mask in group compatibility definition; "
                 "Ignoring illegal compatibility map for group %u\n",

diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c
index d22ffc2..e0fc5b2 100644 (file)
--- a/src/xkbcomp/expr.c
+++ b/src/xkbcomp/expr.c
@@ -26,14 +26,10 @@
 
 #include "expr.h"
 
-/***====================================================================***/
-
 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
                                 xkb_atom_t field, unsigned type,
                                 ExprResult *val_rtrn);
 
-/***====================================================================***/
-
 const char *
 exprOpText(unsigned type)
 {
@@ -153,7 +149,7 @@ ExprResolveLhs(struct xkb_keymap *keymap, ExprDef *expr,
         *index_rtrn = expr->value.array.entry;
         return true;
     }
-    WSGO("Unexpected operator %d in ResolveLhs\n", expr->op);
+    log_wsgo(keymap->ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
     return false;
 }
 
@@ -231,9 +227,9 @@ ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,
     switch (expr->op) {
     case ExprValue:
         if (expr->type != TypeBoolean) {
-            ERROR
-                ("Found constant of type %s where boolean was expected\n",
-                exprTypeText(expr->type));
+            log_err(ctx,
+                    "Found constant of type %s where boolean was expected\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->ival = expr->value.ival;
@@ -255,14 +251,14 @@ ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,
                 return true;
             }
         }
-        ERROR("Identifier \"%s\" of type int is unknown\n",
-              xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+                xkb_atom_text(ctx, expr->value.str));
         return false;
 
     case ExprFieldRef:
-        ERROR("Default \"%s.%s\" of type boolean is unknown\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case OpInvert:
@@ -289,15 +285,16 @@ ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,
     case OpNegate:
         if (bogus == NULL)
             bogus = "Negation";
-        ERROR("%s of boolean values not permitted\n", bogus);
+        log_err(ctx, "%s of boolean values not permitted\n", bogus);
         break;
 
     case OpUnaryPlus:
-        ERROR("Unary \"+\" operator not permitted for boolean values\n");
+        log_err(ctx,
+                "Unary \"+\" operator not permitted for boolean values\n");
         break;
 
     default:
-        WSGO("Unknown operator %d in ResolveBoolean\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
         break;
     }
     return false;
@@ -322,8 +319,8 @@ ExprResolveFloat(struct xkb_context *ctx, ExprDef *expr,
             }
         }
         if (expr->type != TypeInt) {
-            ERROR("Found constant of type %s, expected a number\n",
-                  exprTypeText(expr->type));
+            log_err(ctx, "Found constant of type %s, expected a number\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->ival = expr->value.ival;
@@ -332,14 +329,14 @@ ExprResolveFloat(struct xkb_context *ctx, ExprDef *expr,
         return true;
 
     case ExprIdent:
-        ERROR("Numeric identifier \"%s\" unknown\n",
-              xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Numeric identifier \"%s\" unknown\n",
+                xkb_atom_text(ctx, expr->value.str));
         return ok;
 
     case ExprFieldRef:
-        ERROR("Numeric default \"%s.%s\" unknown\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Numeric default \"%s.%s\" unknown\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case OpAdd:
@@ -372,11 +369,11 @@ ExprResolveFloat(struct xkb_context *ctx, ExprDef *expr,
         return false;
 
     case OpAssign:
-        WSGO("Assignment operator not implemented yet\n");
+        log_wsgo(ctx, "Assignment operator not implemented yet\n");
         break;
 
     case OpNot:
-        ERROR("The ! operator cannot be applied to a number\n");
+        log_err(ctx, "The ! operator cannot be applied to a number\n");
         return false;
 
     case OpInvert:
@@ -396,7 +393,7 @@ ExprResolveFloat(struct xkb_context *ctx, ExprDef *expr,
         return ExprResolveFloat(ctx, left, val_rtrn);
 
     default:
-        WSGO("Unknown operator %d in ResolveFloat\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveFloat\n", expr->op);
         break;
     }
     return false;
@@ -412,9 +409,9 @@ ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr,
     switch (expr->op) {
     case ExprValue:
         if (expr->type != TypeInt) {
-            ERROR
-                ("Found constant of type %s where an int was expected\n",
-                exprTypeText(expr->type));
+            log_err(ctx,
+                    "Found constant of type %s where an int was expected\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->uval = expr->value.uval;
@@ -459,7 +456,7 @@ ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr,
         return ExprResolveKeyCode(ctx, left, val_rtrn);
 
     default:
-        WSGO("Unknown operator %d in ResolveKeyCode\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
         break;
     }
     return false;
@@ -506,9 +503,9 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
                 }
         }
         if (expr->type != TypeInt) {
-            ERROR
-                ("Found constant of type %s where an int was expected\n",
-                exprTypeText(expr->type));
+            log_err(ctx,
+                    "Found constant of type %s where an int was expected\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->ival = expr->value.ival;
@@ -519,14 +516,14 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
             ok = lookup(ctx, lookupPriv, expr->value.str,
                         TypeInt, val_rtrn);
         if (!ok)
-            ERROR("Identifier \"%s\" of type int is unknown\n",
-                  xkb_atom_text(ctx, expr->value.str));
+            log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+                    xkb_atom_text(ctx, expr->value.str));
         return ok;
 
     case ExprFieldRef:
-        ERROR("Default \"%s.%s\" of type int is unknown\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case OpAdd:
@@ -558,11 +555,11 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
         return false;
 
     case OpAssign:
-        WSGO("Assignment operator not implemented yet\n");
+        log_wsgo(ctx, "Assignment operator not implemented yet\n");
         break;
 
     case OpNot:
-        ERROR("The ! operator cannot be applied to an integer\n");
+        log_err(ctx, "The ! operator cannot be applied to an integer\n");
         return false;
 
     case OpInvert:
@@ -584,7 +581,7 @@ ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
                                         lookupPriv);
 
     default:
-        WSGO("Unknown operator %d in ResolveInteger\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
         break;
     }
     return false;
@@ -620,8 +617,8 @@ ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
         return ret;
 
     if (val_rtrn->uval == 0 || val_rtrn->uval > XkbNumKbdGroups) {
-        ERROR("Group index %u is out of range (1..%d)\n",
-              val_rtrn->uval, XkbNumKbdGroups);
+        log_err(ctx, "Group index %u is out of range (1..%d)\n",
+                val_rtrn->uval, XkbNumKbdGroups);
         return false;
     }
 
@@ -651,8 +648,8 @@ ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
         return ret;
 
     if (val_rtrn->ival < 1 || val_rtrn->ival > XkbMaxShiftLevel) {
-        ERROR("Shift level %d is out of range (1..%d)\n", val_rtrn->ival,
-              XkbMaxShiftLevel);
+        log_err(ctx, "Shift level %d is out of range (1..%d)\n",
+                val_rtrn->ival, XkbMaxShiftLevel);
         return false;
     }
 
@@ -689,8 +686,8 @@ ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
     switch (expr->op) {
     case ExprValue:
         if (expr->type != TypeString) {
-            ERROR("Found constant of type %s, expected a string\n",
-                  exprTypeText(expr->type));
+            log_err(ctx, "Found constant of type %s, expected a string\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->str = xkb_atom_strdup(ctx, expr->value.str);
@@ -699,14 +696,14 @@ ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
         return true;
 
     case ExprIdent:
-        ERROR("Identifier \"%s\" of type string not found\n",
-              xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Identifier \"%s\" of type string not found\n",
+                xkb_atom_text(ctx, expr->value.str));
         return false;
 
     case ExprFieldRef:
-        ERROR("Default \"%s.%s\" of type string not found\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Default \"%s.%s\" of type string not found\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case OpAdd:
@@ -748,19 +745,19 @@ ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
     case OpInvert:
         if (bogus == NULL)
             bogus = "Bitwise complement";
-        ERROR("%s of string values not permitted\n", bogus);
+        log_err(ctx, "%s of string values not permitted\n", bogus);
         return false;
 
     case OpNot:
-        ERROR("The ! operator cannot be applied to a string\n");
+        log_err(ctx, "The ! operator cannot be applied to a string\n");
         return false;
 
     case OpUnaryPlus:
-        ERROR("The + operator cannot be applied to a string\n");
+        log_err(ctx, "The + operator cannot be applied to a string\n");
         return false;
 
     default:
-        WSGO("Unknown operator %d in ResolveString\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
         break;
     }
     return false;
@@ -775,22 +772,22 @@ ExprResolveKeyName(struct xkb_context *ctx, ExprDef *expr,
     switch (expr->op) {
     case ExprValue:
         if (expr->type != TypeKeyName) {
-            ERROR("Found constant of type %s, expected a key name\n",
-                  exprTypeText(expr->type));
+            log_err(ctx, "Found constant of type %s, expected a key name\n",
+                    exprTypeText(expr->type));
             return false;
         }
         memcpy(val_rtrn->name, expr->value.keyName, XkbKeyNameLength);
         return true;
 
     case ExprIdent:
-        ERROR("Identifier \"%s\" of type string not found\n",
-              xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Identifier \"%s\" of type string not found\n",
+                xkb_atom_text(ctx, expr->value.str));
         return false;
 
     case ExprFieldRef:
-        ERROR("Default \"%s.%s\" of type key name not found\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case OpAdd:
@@ -814,19 +811,19 @@ ExprResolveKeyName(struct xkb_context *ctx, ExprDef *expr,
     case OpInvert:
         if (bogus == NULL)
             bogus = "Bitwise complement";
-        ERROR("%s of key name values not permitted\n", bogus);
+        log_err(ctx, "%s of key name values not permitted\n", bogus);
         return false;
 
     case OpNot:
-        ERROR("The ! operator cannot be applied to a key name\n");
+        log_err(ctx, "The ! operator cannot be applied to a key name\n");
         return false;
 
     case OpUnaryPlus:
-        ERROR("The + operator cannot be applied to a key name\n");
+        log_err(ctx, "The + operator cannot be applied to a key name\n");
         return false;
 
     default:
-        WSGO("Unknown operator %d in ResolveKeyName\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
         break;
     }
     return false;
@@ -839,24 +836,24 @@ ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr,
                 ExprResult *val_rtrn, const LookupEntry *values)
 {
     if (expr->op != ExprIdent) {
-        ERROR("Found a %s where an enumerated value was expected\n",
-              exprOpText(expr->op));
+        log_err(ctx, "Found a %s where an enumerated value was expected\n",
+                exprOpText(expr->op));
         return false;
     }
     if (!SimpleLookup(ctx, values, expr->value.str, TypeInt, val_rtrn)) {
         int nOut = 0;
-        ERROR("Illegal identifier %s (expected one of: ",
-              xkb_atom_text(ctx, expr->value.str));
+        log_err(ctx, "Illegal identifier %s (expected one of: ",
+                xkb_atom_text(ctx, expr->value.str));
         while (values && values->name)
         {
             if (nOut != 0)
-                INFO(", %s", values->name);
+                log_info(ctx, ", %s", values->name);
             else
-                INFO("%s", values->name);
+                log_info(ctx, "%s", values->name);
             values++;
             nOut++;
         }
-        INFO(")\n");
+        log_info(ctx, ")\n");
         return false;
     }
     return true;
@@ -875,9 +872,9 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
     switch (expr->op) {
     case ExprValue:
         if (expr->type != TypeInt) {
-            ERROR
-                ("Found constant of type %s where a mask was expected\n",
-                exprTypeText(expr->type));
+            log_err(ctx,
+                    "Found constant of type %s where a mask was expected\n",
+                    exprTypeText(expr->type));
             return false;
         }
         val_rtrn->ival = expr->value.ival;
@@ -886,14 +883,14 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
     case ExprIdent:
         ok = lookup(ctx, lookupPriv, expr->value.str, TypeInt, val_rtrn);
         if (!ok)
-            ERROR("Identifier \"%s\" of type int is unknown\n",
-                  xkb_atom_text(ctx, expr->value.str));
+            log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
+                    xkb_atom_text(ctx, expr->value.str));
         return ok;
 
     case ExprFieldRef:
-        ERROR("Default \"%s.%s\" of type int is unknown\n",
-              xkb_atom_text(ctx, expr->value.field.element),
-              xkb_atom_text(ctx, expr->value.field.field));
+        log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
+                xkb_atom_text(ctx, expr->value.field.element),
+                xkb_atom_text(ctx, expr->value.field.field));
         return false;
 
     case ExprArrayRef:
@@ -902,8 +899,9 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
     case ExprActionDecl:
         if (bogus == NULL)
             bogus = "function use";
-        ERROR("Unexpected %s in mask expression\n", bogus);
-        ACTION("Expression ignored\n");
+        log_err(ctx,
+                "Unexpected %s in mask expression; Expression Ignored\n",
+                bogus);
         return false;
 
     case OpAdd:
@@ -925,9 +923,8 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
                 break;
             case OpMultiply:
             case OpDivide:
-                ERROR("Cannot %s masks\n",
-                      expr->op == OpDivide ? "divide" : "multiply");
-                ACTION("Illegal operation ignored\n");
+                log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
+                        (expr->op == OpDivide ? "divide" : "multiply"));
                 return false;
             }
             return true;
@@ -935,7 +932,7 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
         return false;
 
     case OpAssign:
-        WSGO("Assignment operator not implemented yet\n");
+        log_wsgo(ctx, "Assignment operator not implemented yet\n");
         break;
 
     case OpInvert:
@@ -953,13 +950,13 @@ ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
         left = expr->value.child;
         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
                                      lookupPriv)) {
-            ERROR("The %s operator cannot be used with a mask\n",
-                  (expr->op == OpNegate ? "-" : "!"));
+            log_err(ctx, "The %s operator cannot be used with a mask\n",
+                    (expr->op == OpNegate ? "-" : "!"));
         }
         return false;
 
     default:
-        WSGO("Unknown operator %d in ResolveMask\n", expr->op);
+        log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
         break;
     }
     return false;
@@ -980,8 +977,8 @@ ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
 }
 
 int
-ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
-                    struct xkb_keymap *keymap)
+ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+                    ExprResult *val_rtrn)
 {
     return ExprResolveMaskLookup(keymap->ctx, expr, val_rtrn, LookupVModMask,
                                  keymap);

diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h
index 7b48c95..bdaa7c6 100644 (file)
--- a/src/xkbcomp/expr.h
+++ b/src/xkbcomp/expr.h
@@ -69,8 +69,8 @@ ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
                    ExprResult *val_rtrn);
 
 extern int
-ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
-                    struct xkb_keymap *keymap);
+ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
+                    ExprResult *val_rtrn);
 
 extern int
 ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr,

diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c
index c23ed81..371f06e 100644 (file)
--- a/src/xkbcomp/keytypes.c
+++ b/src/xkbcomp/keytypes.c
@@ -535,7 +535,7 @@ SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     if (arrayNdx == NULL)
         return ReportTypeShouldBeArray(info, type, "map entry");
 
-    if (!ExprResolveVModMask(arrayNdx, &rtrn, info->keymap))
+    if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
         return ReportTypeBadType(info, type, "map entry", "modifier mask");
 
     entry.mods.real_mods = rtrn.uval & 0xff;      /* modifiers < 512 */
@@ -576,7 +576,7 @@ SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
     if (arrayNdx == NULL)
         return ReportTypeShouldBeArray(info, type, "preserve entry");
 
-    if (!ExprResolveVModMask(arrayNdx, &rtrn, info->keymap))
+    if (!ExprResolveVModMask(info->keymap, arrayNdx, &rtrn))
         return ReportTypeBadType(info, type, "preserve entry",
                                  "modifier mask");
 
@@ -597,7 +597,7 @@ SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
                 PreserveIndexTxt(info, &new));
     }
 
-    if (!ExprResolveVModMask(value, &rtrn, info->keymap)) {
+    if (!ExprResolveVModMask(info->keymap, value, &rtrn)) {
         log_err(info->keymap->ctx,
                 "Preserve value in a key type is not a modifier mask; "
                 "Ignoring preserve[%s] in type %s\n",
@@ -707,7 +707,7 @@ SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type,
                      "The modifiers field of a key type is not an array; "
                      "Illegal array subscript ignored\n");
         /* get modifier mask for current type */
-        if (!ExprResolveVModMask(value, &tmp, info->keymap)) {
+        if (!ExprResolveVModMask(info->keymap, value, &tmp)) {
             log_err(info->keymap->ctx,
                     "Key type mask field must be a modifier mask; "
                     "Key type definition ignored\n");

diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c
index fe2abfc..f9b75cb 100644 (file)
--- a/src/xkbcomp/symbols.c
+++ b/src/xkbcomp/symbols.c
@@ -1059,7 +1059,7 @@ SetSymbolsField(SymbolsInfo *info, KeyInfo *keyi, char *field,
     else if ((strcasecmp(field, "vmods") == 0) ||
              (strcasecmp(field, "virtualmods") == 0) ||
              (strcasecmp(field, "virtualmodifiers") == 0)) {
-        ok = ExprResolveVModMask(value, &tmp, info->keymap);
+        ok = ExprResolveVModMask(info->keymap, value, &tmp);
         if (ok) {
             keyi->vmodmap = (tmp.uval >> 8);
             keyi->defined |= _Key_VModMap;