*
********************************************************/
+#include "xkbcomp-priv.h"
+#include "text.h"
#include "expr.h"
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
xkb_atom_t field, enum expr_value_type type,
unsigned int *val_rtrn);
-const char *
-exprOpText(enum expr_op_type op)
-{
- static char buf[32];
-
- switch (op) {
- case EXPR_VALUE:
- strcpy(buf, "literal");
- break;
- case EXPR_IDENT:
- strcpy(buf, "identifier");
- break;
- case EXPR_ACTION_DECL:
- strcpy(buf, "action declaration");
- break;
- case EXPR_FIELD_REF:
- strcpy(buf, "field reference");
- break;
- case EXPR_ARRAY_REF:
- strcpy(buf, "array reference");
- break;
- case EXPR_KEYSYM_LIST:
- strcpy(buf, "list of keysyms");
- break;
- case EXPR_ACTION_LIST:
- strcpy(buf, "list of actions");
- break;
- case EXPR_ADD:
- strcpy(buf, "addition");
- break;
- case EXPR_SUBTRACT:
- strcpy(buf, "subtraction");
- break;
- case EXPR_MULTIPLY:
- strcpy(buf, "multiplication");
- break;
- case EXPR_DIVIDE:
- strcpy(buf, "division");
- break;
- case EXPR_ASSIGN:
- strcpy(buf, "assignment");
- break;
- case EXPR_NOT:
- strcpy(buf, "logical not");
- break;
- case EXPR_NEGATE:
- strcpy(buf, "arithmetic negation");
- break;
- case EXPR_INVERT:
- strcpy(buf, "bitwise inversion");
- break;
- case EXPR_UNARY_PLUS:
- strcpy(buf, "unary plus");
- break;
- default:
- snprintf(buf, sizeof(buf), "illegal(%d)", op);
- break;
- }
- return buf;
-}
-
-static const char *
-exprValueTypeText(enum expr_value_type type)
-{
- static char buf[20];
-
- switch (type) {
- case EXPR_TYPE_UNKNOWN:
- strcpy(buf, "unknown");
- break;
- case EXPR_TYPE_BOOLEAN:
- strcpy(buf, "boolean");
- break;
- case EXPR_TYPE_INT:
- strcpy(buf, "int");
- break;
- case EXPR_TYPE_STRING:
- strcpy(buf, "string");
- break;
- case EXPR_TYPE_ACTION:
- strcpy(buf, "action");
- break;
- case EXPR_TYPE_KEYNAME:
- strcpy(buf, "keyname");
- break;
- default:
- snprintf(buf, sizeof(buf), "illegal(%d)", type);
- break;
- }
- return buf;
-}
-
bool
ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
const char **elem_rtrn, const char **field_rtrn,
ExprDef **index_rtrn)
{
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_IDENT:
*elem_rtrn = NULL;
- *field_rtrn = xkb_atom_text(ctx, expr->value.str);
+ *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
*index_rtrn = NULL;
return true;
case EXPR_FIELD_REF:
- *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
- *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
+ *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
+ *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
*index_rtrn = NULL;
return true;
case EXPR_ARRAY_REF:
- *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
- *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
- *index_rtrn = expr->value.array.entry;
+ *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
+ *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
+ *index_rtrn = expr->array_ref.entry;
return true;
default:
break;
}
- log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
+ log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
return false;
}
return false;
}
-bool
-LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
- enum expr_value_type type, xkb_mod_index_t *val_rtrn)
-{
- const char *name = xkb_atom_text(ctx, field);
+/* Data passed in the *priv argument for LookupModMask. */
+typedef struct {
+ const struct xkb_keymap *keymap;
+ enum mod_type mod_type;
+} LookupModMaskPriv;
- if (istreq(name, "none")) {
- *val_rtrn = XkbNoModifier;
- return true;
- }
-
- *val_rtrn = ModNameToIndex(name);
- return (*val_rtrn != XKB_MOD_INVALID);
-}
-
-bool
+static bool
LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
{
const char *str;
xkb_mod_index_t ndx;
+ const LookupModMaskPriv *arg = priv;
+ const struct xkb_keymap *keymap = arg->keymap;
+ enum mod_type mod_type = arg->mod_type;
if (type != EXPR_TYPE_INT)
return false;
str = xkb_atom_text(ctx, field);
- if (istreq(str, "all"))
- *val_rtrn = 0xff;
- else if (istreq(str, "none"))
+ if (istreq(str, "all")) {
+ *val_rtrn = MOD_REAL_MASK_ALL;
+ return true;
+ }
+
+ if (istreq(str, "none")) {
*val_rtrn = 0;
- else if (LookupModIndex(ctx, priv, field, type, &ndx))
- *val_rtrn = (1 << ndx);
- else
+ return true;
+ }
+
+ ndx = XkbModNameToIndex(keymap, field, mod_type);
+ if (ndx == XKB_MOD_INVALID)
return false;
+ *val_rtrn = (1u << ndx);
return true;
}
bool ok = false;
const char *ident;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_BOOLEAN) {
+ if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
log_err(ctx,
"Found constant of type %s where boolean was expected\n",
- exprValueTypeText(expr->value_type));
+ expr_value_type_to_string(expr->expr.value_type));
return false;
}
- *set_rtrn = !!expr->value.ival;
+ *set_rtrn = expr->boolean.set;
return true;
case EXPR_IDENT:
- ident = xkb_atom_text(ctx, expr->value.str);
+ ident = xkb_atom_text(ctx, expr->ident.ident);
if (ident) {
if (istreq(ident, "true") ||
istreq(ident, "yes") ||
return true;
}
}
- log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
return false;
case EXPR_FIELD_REF:
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));
+ xkb_atom_text(ctx, expr->field_ref.element),
+ xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_INVERT:
case EXPR_NEGATE:
case EXPR_UNARY_PLUS:
log_err(ctx, "%s of boolean values not permitted\n",
- exprOpText(expr->op));
+ expr_op_type_to_string(expr->expr.op));
break;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
+ expr->expr.op);
break;
}
xkb_keycode_t *kc)
{
xkb_keycode_t leftRtrn, rightRtrn;
- ExprDef *left, *right;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_INT) {
+ if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err(ctx,
"Found constant of type %s where an int was expected\n",
- exprValueTypeText(expr->value_type));
+ expr_value_type_to_string(expr->expr.value_type));
return false;
}
- *kc = expr->value.uval;
+ *kc = (xkb_keycode_t) expr->integer.ival;
return true;
case EXPR_ADD:
case EXPR_SUBTRACT:
case EXPR_MULTIPLY:
case EXPR_DIVIDE:
- left = expr->value.binary.left;
- right = expr->value.binary.right;
-
- if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
- !ExprResolveKeyCode(ctx, right, &rightRtrn))
+ if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
+ !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
return false;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_ADD:
*kc = leftRtrn + rightRtrn;
break;
return true;
case EXPR_NEGATE:
- left = expr->value.child;
- if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
+ if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
return false;
*kc = ~leftRtrn;
return true;
case EXPR_UNARY_PLUS:
- left = expr->value.child;
- return ExprResolveKeyCode(ctx, left, kc);
+ return ExprResolveKeyCode(ctx, expr->unary.child, kc);
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
+ expr->expr.op);
break;
}
unsigned u;
ExprDef *left, *right;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_INT) {
+ if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err(ctx,
"Found constant of type %s where an int was expected\n",
- exprValueTypeText(expr->value_type));
+ expr_value_type_to_string(expr->expr.value_type));
return false;
}
- *val_rtrn = expr->value.ival;
+ *val_rtrn = expr->integer.ival;
return true;
case EXPR_IDENT:
if (lookup)
- ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
+ ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
if (!ok)
log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ xkb_atom_text(ctx, expr->ident.ident));
else
*val_rtrn = (int) u;
case EXPR_FIELD_REF:
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));
+ xkb_atom_text(ctx, expr->field_ref.element),
+ xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ADD:
case EXPR_SUBTRACT:
case EXPR_MULTIPLY:
case EXPR_DIVIDE:
- left = expr->value.binary.left;
- right = expr->value.binary.right;
+ left = expr->binary.left;
+ right = expr->binary.right;
if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
!ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
return false;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_ADD:
*val_rtrn = l + r;
break;
*val_rtrn = l / r;
break;
default:
- break;
+ log_err(ctx, "%s of integers not permitted\n",
+ expr_op_type_to_string(expr->expr.op));
+ return false;
}
return true;
case EXPR_INVERT:
case EXPR_NEGATE:
- left = expr->value.child;
+ left = expr->unary.child;
if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
return false;
- *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
+ *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
return true;
case EXPR_UNARY_PLUS:
- left = expr->value.child;
+ left = expr->unary.child;
return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
lookupPriv);
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
+ expr->expr.op);
break;
}
bool
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
- xkb_group_index_t *group_rtrn)
+ xkb_layout_index_t *group_rtrn)
{
bool ok;
int result;
- static const LookupEntry group_names[] = {
- { "group1", 1 },
- { "group2", 2 },
- { "group3", 3 },
- { "group4", 4 },
- { "group5", 5 },
- { "group6", 6 },
- { "group7", 7 },
- { "group8", 8 },
- { NULL, 0 }
- };
ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
- group_names);
+ groupNames);
if (!ok)
return false;
- if (result <= 0 || result > XkbNumKbdGroups) {
+ if (result <= 0 || result > XKB_MAX_GROUPS) {
log_err(ctx, "Group index %u is out of range (1..%d)\n",
- result, XkbNumKbdGroups);
+ result, XKB_MAX_GROUPS);
return false;
}
- *group_rtrn = (xkb_group_index_t) result;
+ *group_rtrn = (xkb_layout_index_t) result;
return true;
}
{
bool ok;
int result;
- static const LookupEntry level_names[] = {
- { "level1", 1 },
- { "level2", 2 },
- { "level3", 3 },
- { "level4", 4 },
- { "level5", 5 },
- { "level6", 6 },
- { "level7", 7 },
- { "level8", 8 },
- { NULL, 0 }
- };
ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
- level_names);
+ levelNames);
if (!ok)
return false;
- if (result < 1 || result > XkbMaxShiftLevel) {
- log_err(ctx, "Shift level %d is out of range (1..%d)\n",
- result, XkbMaxShiftLevel);
+ if (result < 1) {
+ log_err(ctx, "Shift level %d is out of range\n", result);
return false;
}
- *level_rtrn = (unsigned int) result;
+ /* Level is zero-indexed from now on. */
+ *level_rtrn = (unsigned int) (result - 1);
return true;
}
bool
ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
{
- int result;
- static const LookupEntry button_names[] = {
- { "button1", 1 },
- { "button2", 2 },
- { "button3", 3 },
- { "button4", 4 },
- { "button5", 5 },
- { "default", 0 },
- { NULL, 0 }
- };
-
- if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
- button_names))
- return false;
-
- *btn_rtrn = result;
- return true;
+ return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
+ buttonNames);
}
bool
ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
- const char **val_rtrn)
+ xkb_atom_t *val_rtrn)
{
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_STRING) {
+ if (expr->expr.value_type != EXPR_TYPE_STRING) {
log_err(ctx, "Found constant of type %s, expected a string\n",
- exprValueTypeText(expr->value_type));
+ expr_value_type_to_string(expr->expr.value_type));
return false;
}
- *val_rtrn = xkb_atom_text(ctx, expr->value.str);
+ *val_rtrn = expr->string.str;
return true;
case EXPR_IDENT:
log_err(ctx, "Identifier \"%s\" of type string not found\n",
- xkb_atom_text(ctx, expr->value.str));
+ xkb_atom_text(ctx, expr->ident.ident));
return false;
case EXPR_FIELD_REF:
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 EXPR_ADD:
- case EXPR_SUBTRACT:
- case EXPR_MULTIPLY:
- case EXPR_DIVIDE:
- case EXPR_ASSIGN:
- case EXPR_NEGATE:
- case EXPR_INVERT:
- case EXPR_NOT:
- case EXPR_UNARY_PLUS:
- log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
- return false;
-
- default:
- log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
- break;
- }
- return false;
-}
-
-bool
-ExprResolveKeyName(struct xkb_context *ctx, const ExprDef *expr,
- char name[XkbKeyNameLength])
-{
- switch (expr->op) {
- case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_KEYNAME) {
- log_err(ctx, "Found constant of type %s, expected a key name\n",
- exprValueTypeText(expr->value_type));
- return false;
- }
- memcpy(name, expr->value.keyName, XkbKeyNameLength);
- return true;
-
- case EXPR_IDENT:
- log_err(ctx, "Identifier \"%s\" of type string not found\n",
- xkb_atom_text(ctx, expr->value.str));
- return false;
-
- case EXPR_FIELD_REF:
- 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));
+ xkb_atom_text(ctx, expr->field_ref.element),
+ xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ADD:
case EXPR_INVERT:
case EXPR_NOT:
case EXPR_UNARY_PLUS:
- log_err(ctx, "%s of key name values not permitted\n",
- exprOpText(expr->op));
+ log_err(ctx, "%s of strings not permitted\n",
+ expr_op_type_to_string(expr->expr.op));
return false;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
+ expr->expr.op);
break;
}
return false;
ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
unsigned int *val_rtrn, const LookupEntry *values)
{
- if (expr->op != EXPR_IDENT) {
+ if (expr->expr.op != EXPR_IDENT) {
log_err(ctx, "Found a %s where an enumerated value was expected\n",
- exprOpText(expr->op));
+ expr_op_type_to_string(expr->expr.op));
return false;
}
- if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
+ if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn)) {
log_err(ctx, "Illegal identifier %s; expected one of:\n",
- xkb_atom_text(ctx, expr->value.str));
+ xkb_atom_text(ctx, expr->ident.ident));
while (values && values->name)
{
log_err(ctx, "\t%s\n", values->name);
ExprDef *left, *right;
const char *bogus = NULL;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_VALUE:
- if (expr->value_type != EXPR_TYPE_INT) {
+ if (expr->expr.value_type != EXPR_TYPE_INT) {
log_err(ctx,
"Found constant of type %s where a mask was expected\n",
- exprValueTypeText(expr->value_type));
+ expr_value_type_to_string(expr->expr.value_type));
return false;
}
- *val_rtrn = (unsigned int) expr->value.ival;
+ *val_rtrn = (unsigned int) expr->integer.ival;
return true;
case EXPR_IDENT:
- ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
+ ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
val_rtrn);
if (!ok)
log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
- xkb_atom_text(ctx, expr->value.str));
+ xkb_atom_text(ctx, expr->ident.ident));
return ok;
case EXPR_FIELD_REF:
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));
+ xkb_atom_text(ctx, expr->field_ref.element),
+ xkb_atom_text(ctx, expr->field_ref.field));
return false;
case EXPR_ARRAY_REF:
case EXPR_SUBTRACT:
case EXPR_MULTIPLY:
case EXPR_DIVIDE:
- left = expr->value.binary.left;
- right = expr->value.binary.right;
+ left = expr->binary.left;
+ right = expr->binary.right;
if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
!ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
return false;
- switch (expr->op) {
+ switch (expr->expr.op) {
case EXPR_ADD:
*val_rtrn = l | r;
break;
case EXPR_MULTIPLY:
case EXPR_DIVIDE:
log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
- (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
+ (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
return false;
default:
break;
break;
case EXPR_INVERT:
- left = expr->value.child;
+ left = expr->unary.child;
if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
return false;
case EXPR_UNARY_PLUS:
case EXPR_NEGATE:
case EXPR_NOT:
- left = expr->value.child;
+ left = expr->unary.child;
if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
log_err(ctx, "The %s operator cannot be used with a mask\n",
- (expr->op == EXPR_NEGATE ? "-" : "!"));
+ (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
return false;
default:
- log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
+ log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
+ expr->expr.op);
break;
}
}
bool
-ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
- xkb_mod_mask_t *mask_rtrn)
-{
- return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
-}
-
-bool
-ExprResolveVModMask(struct xkb_keymap *keymap, const ExprDef *expr,
- xkb_mod_mask_t *mask_rtrn)
+ExprResolveModMask(struct xkb_keymap *keymap, const ExprDef *expr,
+ enum mod_type mod_type, xkb_mod_mask_t *mask_rtrn)
{
- return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
- keymap);
+ LookupModMaskPriv priv = { .keymap = keymap, .mod_type = mod_type };
+ return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupModMask,
+ &priv);
}
bool
{
int val;
- if (expr->op == EXPR_IDENT) {
- const char *str;
- str = xkb_atom_text(ctx, expr->value.str);
- *sym_rtrn = xkb_keysym_from_name(str);
+ if (expr->expr.op == EXPR_IDENT) {
+ const char *str = xkb_atom_text(ctx, expr->ident.ident);
+ *sym_rtrn = xkb_keysym_from_name(str, 0);
if (*sym_rtrn != XKB_KEY_NoSymbol)
return true;
}
if (val < 0 || val >= 10)
return false;
- *sym_rtrn = ((xkb_keysym_t) val) + '0';
+ *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
+ return true;
+}
+
+bool
+ExprResolveMod(struct xkb_keymap *keymap, const ExprDef *def,
+ enum mod_type mod_type, xkb_mod_index_t *ndx_rtrn)
+{
+ xkb_mod_index_t ndx;
+ xkb_atom_t name;
+
+ if (def->expr.op != EXPR_IDENT) {
+ log_err(keymap->ctx,
+ "Cannot resolve virtual modifier: "
+ "found %s where a virtual modifier name was expected\n",
+ expr_op_type_to_string(def->expr.op));
+ return false;
+ }
+
+ name = def->ident.ident;
+ ndx = XkbModNameToIndex(keymap, name, mod_type);
+ if (ndx == XKB_MOD_INVALID) {
+ log_err(keymap->ctx,
+ "Cannot resolve virtual modifier: "
+ "\"%s\" was not previously declared\n",
+ xkb_atom_text(keymap->ctx, name));
+ return false;
+ }
+
+ *ndx_rtrn = ndx;
return true;
}