src/xkbcomp/expr.c

   1 /************************************************************
   2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of Silicon Graphics not be
  10  * used in advertising or publicity pertaining to distribution
  11  * of the software without specific prior written permission.
  12  * Silicon Graphics makes no representation about the suitability
  13  * of this software for any purpose. It is provided "as is"
  14  * without any express or implied warranty.
  15  *
  16  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  ********************************************************/
  26
  27 #include "config.h"
  28
  29 #include "xkbcomp-priv.h"
  30 #include "text.h"
  31 #include "expr.h"
  32
  33 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
  34                                 xkb_atom_t field, enum expr_value_type type,
  35                                 unsigned int *val_rtrn);
  36
  37 bool
  38 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
  39                const char **elem_rtrn, const char **field_rtrn,
  40                ExprDef **index_rtrn)
  41 {
  42     switch (expr->expr.op) {
  43     case EXPR_IDENT:
  44         *elem_rtrn = NULL;
  45         *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
  46         *index_rtrn = NULL;
  47         return (*field_rtrn != NULL);
  48     case EXPR_FIELD_REF:
  49         *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
  50         *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
  51         *index_rtrn = NULL;
  52         return (*elem_rtrn != NULL && *field_rtrn != NULL);
  53     case EXPR_ARRAY_REF:
  54         *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
  55         *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
  56         *index_rtrn = expr->array_ref.entry;
  57         if (expr->array_ref.element != XKB_ATOM_NONE && *elem_rtrn == NULL)
  58             return false;
  59         if (*field_rtrn == NULL)
  60             return false;
  61         return true;
  62     default:
  63         break;
  64     }
  65     log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
  66     return false;
  67 }
  68
  69 static bool
  70 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
  71              enum expr_value_type type, unsigned int *val_rtrn)
  72 {
  73     const LookupEntry *entry;
  74     const char *str;
  75
  76     if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
  77         return false;
  78
  79     str = xkb_atom_text(ctx, field);
  80     for (entry = priv; entry && entry->name; entry++) {
  81         if (istreq(str, entry->name)) {
  82             *val_rtrn = entry->value;
  83             return true;
  84         }
  85     }
  86
  87     return false;
  88 }
  89
  90 /* Data passed in the *priv argument for LookupModMask. */
  91 typedef struct {
  92     const struct xkb_mod_set *mods;
  93     enum mod_type mod_type;
  94 } LookupModMaskPriv;
  95
  96 static bool
  97 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
  98               enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
  99 {
 100     const char *str;
 101     xkb_mod_index_t ndx;
 102     const LookupModMaskPriv *arg = priv;
 103     const struct xkb_mod_set *mods = arg->mods;
 104     enum mod_type mod_type = arg->mod_type;
 105
 106     if (type != EXPR_TYPE_INT)
 107         return false;
 108
 109     str = xkb_atom_text(ctx, field);
 110     if (!str)
 111         return false;
 112
 113     if (istreq(str, "all")) {
 114         *val_rtrn  = MOD_REAL_MASK_ALL;
 115         return true;
 116     }
 117
 118     if (istreq(str, "none")) {
 119         *val_rtrn = 0;
 120         return true;
 121     }
 122
 123     ndx = XkbModNameToIndex(mods, field, mod_type);
 124     if (ndx == XKB_MOD_INVALID)
 125         return false;
 126
 127     *val_rtrn = (1u << ndx);
 128     return true;
 129 }
 130
 131 bool
 132 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
 133                    bool *set_rtrn)
 134 {
 135     bool ok = false;
 136     const char *ident;
 137
 138     switch (expr->expr.op) {
 139     case EXPR_VALUE:
 140         if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
 141             log_err(ctx,
 142                     "Found constant of type %s where boolean was expected\n",
 143                     expr_value_type_to_string(expr->expr.value_type));
 144             return false;
 145         }
 146         *set_rtrn = expr->boolean.set;
 147         return true;
 148
 149     case EXPR_IDENT:
 150         ident = xkb_atom_text(ctx, expr->ident.ident);
 151         if (ident) {
 152             if (istreq(ident, "true") ||
 153                 istreq(ident, "yes") ||
 154                 istreq(ident, "on")) {
 155                 *set_rtrn = true;
 156                 return true;
 157             }
 158             else if (istreq(ident, "false") ||
 159                      istreq(ident, "no") ||
 160                      istreq(ident, "off")) {
 161                 *set_rtrn = false;
 162                 return true;
 163             }
 164         }
 165         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
 166         return false;
 167
 168     case EXPR_FIELD_REF:
 169         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
 170                 xkb_atom_text(ctx, expr->field_ref.element),
 171                 xkb_atom_text(ctx, expr->field_ref.field));
 172         return false;
 173
 174     case EXPR_INVERT:
 175     case EXPR_NOT:
 176         ok = ExprResolveBoolean(ctx, expr->unary.child, set_rtrn);
 177         if (ok)
 178             *set_rtrn = !*set_rtrn;
 179         return ok;
 180     case EXPR_ADD:
 181     case EXPR_SUBTRACT:
 182     case EXPR_MULTIPLY:
 183     case EXPR_DIVIDE:
 184     case EXPR_ASSIGN:
 185     case EXPR_NEGATE:
 186     case EXPR_UNARY_PLUS:
 187     case EXPR_ACTION_DECL:
 188     case EXPR_ACTION_LIST:
 189     case EXPR_KEYSYM_LIST:
 190         log_err(ctx, "%s of boolean values not permitted\n",
 191                 expr_op_type_to_string(expr->expr.op));
 192         break;
 193
 194     default:
 195         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
 196                  expr->expr.op);
 197         break;
 198     }
 199
 200     return false;
 201 }
 202
 203 bool
 204 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
 205                    xkb_keycode_t *kc)
 206 {
 207     xkb_keycode_t leftRtrn, rightRtrn;
 208
 209     switch (expr->expr.op) {
 210     case EXPR_VALUE:
 211         if (expr->expr.value_type != EXPR_TYPE_INT) {
 212             log_err(ctx,
 213                     "Found constant of type %s where an int was expected\n",
 214                     expr_value_type_to_string(expr->expr.value_type));
 215             return false;
 216         }
 217
 218         *kc = (xkb_keycode_t) expr->integer.ival;
 219         return true;
 220
 221     case EXPR_ADD:
 222     case EXPR_SUBTRACT:
 223     case EXPR_MULTIPLY:
 224     case EXPR_DIVIDE:
 225         if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
 226             !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
 227             return false;
 228
 229         switch (expr->expr.op) {
 230         case EXPR_ADD:
 231             *kc = leftRtrn + rightRtrn;
 232             break;
 233         case EXPR_SUBTRACT:
 234             *kc = leftRtrn - rightRtrn;
 235             break;
 236         case EXPR_MULTIPLY:
 237             *kc = leftRtrn * rightRtrn;
 238             break;
 239         case EXPR_DIVIDE:
 240             if (rightRtrn == 0) {
 241                 log_err(ctx, "Cannot divide by zero: %d / %d\n",
 242                         leftRtrn, rightRtrn);
 243                 return false;
 244             }
 245
 246             *kc = leftRtrn / rightRtrn;
 247             break;
 248         default:
 249             break;
 250         }
 251
 252         return true;
 253
 254     case EXPR_NEGATE:
 255         if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
 256             return false;
 257
 258         *kc = ~leftRtrn;
 259         return true;
 260
 261     case EXPR_UNARY_PLUS:
 262         return ExprResolveKeyCode(ctx, expr->unary.child, kc);
 263
 264     default:
 265         log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
 266                  expr->expr.op);
 267         break;
 268     }
 269
 270     return false;
 271 }
 272
 273 /**
 274  * This function returns ... something.  It's a bit of a guess, really.
 275  *
 276  * If an integer is given in value ctx, it will be returned in ival.
 277  * If an ident or field reference is given, the lookup function (if given)
 278  * will be called.  At the moment, only SimpleLookup use this, and they both
 279  * return the results in uval.  And don't support field references.
 280  *
 281  * Cool.
 282  */
 283 static bool
 284 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
 285                          int *val_rtrn, IdentLookupFunc lookup,
 286                          const void *lookupPriv)
 287 {
 288     bool ok = false;
 289     int l, r;
 290     unsigned u;
 291     ExprDef *left, *right;
 292
 293     switch (expr->expr.op) {
 294     case EXPR_VALUE:
 295         if (expr->expr.value_type != EXPR_TYPE_INT) {
 296             log_err(ctx,
 297                     "Found constant of type %s where an int was expected\n",
 298                     expr_value_type_to_string(expr->expr.value_type));
 299             return false;
 300         }
 301
 302         *val_rtrn = expr->integer.ival;
 303         return true;
 304
 305     case EXPR_IDENT:
 306         if (lookup)
 307             ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
 308
 309         if (!ok)
 310             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 311                     xkb_atom_text(ctx, expr->ident.ident));
 312         else
 313             *val_rtrn = (int) u;
 314
 315         return ok;
 316
 317     case EXPR_FIELD_REF:
 318         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 319                 xkb_atom_text(ctx, expr->field_ref.element),
 320                 xkb_atom_text(ctx, expr->field_ref.field));
 321         return false;
 322
 323     case EXPR_ADD:
 324     case EXPR_SUBTRACT:
 325     case EXPR_MULTIPLY:
 326     case EXPR_DIVIDE:
 327         left = expr->binary.left;
 328         right = expr->binary.right;
 329         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
 330             !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
 331             return false;
 332
 333         switch (expr->expr.op) {
 334         case EXPR_ADD:
 335             *val_rtrn = l + r;
 336             break;
 337         case EXPR_SUBTRACT:
 338             *val_rtrn = l - r;
 339             break;
 340         case EXPR_MULTIPLY:
 341             *val_rtrn = l * r;
 342             break;
 343         case EXPR_DIVIDE:
 344             if (r == 0) {
 345                 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
 346                 return false;
 347             }
 348             *val_rtrn = l / r;
 349             break;
 350         default:
 351             log_err(ctx, "%s of integers not permitted\n",
 352                     expr_op_type_to_string(expr->expr.op));
 353             return false;
 354         }
 355
 356         return true;
 357
 358     case EXPR_ASSIGN:
 359         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 360         break;
 361
 362     case EXPR_NOT:
 363         log_err(ctx, "The ! operator cannot be applied to an integer\n");
 364         return false;
 365
 366     case EXPR_INVERT:
 367     case EXPR_NEGATE:
 368         left = expr->unary.child;
 369         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
 370             return false;
 371
 372         *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
 373         return true;
 374
 375     case EXPR_UNARY_PLUS:
 376         left = expr->unary.child;
 377         return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
 378                                         lookupPriv);
 379
 380     default:
 381         log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
 382                  expr->expr.op);
 383         break;
 384     }
 385
 386     return false;
 387 }
 388
 389 bool
 390 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
 391                    int *val_rtrn)
 392 {
 393     return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
 394 }
 395
 396 bool
 397 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
 398                  xkb_layout_index_t *group_rtrn)
 399 {
 400     bool ok;
 401     int result;
 402
 403     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 404                                   groupNames);
 405     if (!ok)
 406         return false;
 407
 408     if (result <= 0 || result > XKB_MAX_GROUPS) {
 409         log_err(ctx, "Group index %u is out of range (1..%d)\n",
 410                 result, XKB_MAX_GROUPS);
 411         return false;
 412     }
 413
 414     *group_rtrn = (xkb_layout_index_t) result;
 415     return true;
 416 }
 417
 418 bool
 419 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
 420                  xkb_level_index_t *level_rtrn)
 421 {
 422     bool ok;
 423     int result;
 424
 425     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 426                                   levelNames);
 427     if (!ok)
 428         return false;
 429
 430     if (result < 1) {
 431         log_err(ctx, "Shift level %d is out of range\n", result);
 432         return false;
 433     }
 434
 435     /* Level is zero-indexed from now on. */
 436     *level_rtrn = (unsigned int) (result - 1);
 437     return true;
 438 }
 439
 440 bool
 441 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
 442 {
 443     return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
 444                                     buttonNames);
 445 }
 446
 447 bool
 448 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
 449                   xkb_atom_t *val_rtrn)
 450 {
 451     switch (expr->expr.op) {
 452     case EXPR_VALUE:
 453         if (expr->expr.value_type != EXPR_TYPE_STRING) {
 454             log_err(ctx, "Found constant of type %s, expected a string\n",
 455                     expr_value_type_to_string(expr->expr.value_type));
 456             return false;
 457         }
 458
 459         *val_rtrn = expr->string.str;
 460         return true;
 461
 462     case EXPR_IDENT:
 463         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 464                 xkb_atom_text(ctx, expr->ident.ident));
 465         return false;
 466
 467     case EXPR_FIELD_REF:
 468         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
 469                 xkb_atom_text(ctx, expr->field_ref.element),
 470                 xkb_atom_text(ctx, expr->field_ref.field));
 471         return false;
 472
 473     case EXPR_ADD:
 474     case EXPR_SUBTRACT:
 475     case EXPR_MULTIPLY:
 476     case EXPR_DIVIDE:
 477     case EXPR_ASSIGN:
 478     case EXPR_NEGATE:
 479     case EXPR_INVERT:
 480     case EXPR_NOT:
 481     case EXPR_UNARY_PLUS:
 482     case EXPR_ACTION_DECL:
 483     case EXPR_ACTION_LIST:
 484     case EXPR_KEYSYM_LIST:
 485         log_err(ctx, "%s of strings not permitted\n",
 486                 expr_op_type_to_string(expr->expr.op));
 487         return false;
 488
 489     default:
 490         log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
 491                  expr->expr.op);
 492         break;
 493     }
 494     return false;
 495 }
 496
 497 bool
 498 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
 499                 unsigned int *val_rtrn, const LookupEntry *values)
 500 {
 501     if (expr->expr.op != EXPR_IDENT) {
 502         log_err(ctx, "Found a %s where an enumerated value was expected\n",
 503                 expr_op_type_to_string(expr->expr.op));
 504         return false;
 505     }
 506
 507     if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
 508                       val_rtrn)) {
 509         log_err(ctx, "Illegal identifier %s; expected one of:\n",
 510                 xkb_atom_text(ctx, expr->ident.ident));
 511         while (values && values->name)
 512         {
 513             log_err(ctx, "\t%s\n", values->name);
 514             values++;
 515         }
 516         return false;
 517     }
 518
 519     return true;
 520 }
 521
 522 static bool
 523 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
 524                       unsigned int *val_rtrn, IdentLookupFunc lookup,
 525                       const void *lookupPriv)
 526 {
 527     bool ok = false;
 528     unsigned int l = 0, r = 0;
 529     int v;
 530     ExprDef *left, *right;
 531     const char *bogus = NULL;
 532
 533     switch (expr->expr.op) {
 534     case EXPR_VALUE:
 535         if (expr->expr.value_type != EXPR_TYPE_INT) {
 536             log_err(ctx,
 537                     "Found constant of type %s where a mask was expected\n",
 538                     expr_value_type_to_string(expr->expr.value_type));
 539             return false;
 540         }
 541         *val_rtrn = (unsigned int) expr->integer.ival;
 542         return true;
 543
 544     case EXPR_IDENT:
 545         ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
 546                     val_rtrn);
 547         if (!ok)
 548             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 549                     xkb_atom_text(ctx, expr->ident.ident));
 550         return ok;
 551
 552     case EXPR_FIELD_REF:
 553         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 554                 xkb_atom_text(ctx, expr->field_ref.element),
 555                 xkb_atom_text(ctx, expr->field_ref.field));
 556         return false;
 557
 558     case EXPR_ARRAY_REF:
 559         bogus = "array reference";
 560         /* fallthrough */
 561     case EXPR_ACTION_DECL:
 562         if (bogus == NULL)
 563             bogus = "function use";
 564         log_err(ctx,
 565                 "Unexpected %s in mask expression; Expression Ignored\n",
 566                 bogus);
 567         return false;
 568
 569     case EXPR_ADD:
 570     case EXPR_SUBTRACT:
 571     case EXPR_MULTIPLY:
 572     case EXPR_DIVIDE:
 573         left = expr->binary.left;
 574         right = expr->binary.right;
 575         if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
 576             !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
 577             return false;
 578
 579         switch (expr->expr.op) {
 580         case EXPR_ADD:
 581             *val_rtrn = l | r;
 582             break;
 583         case EXPR_SUBTRACT:
 584             *val_rtrn = l & (~r);
 585             break;
 586         case EXPR_MULTIPLY:
 587         case EXPR_DIVIDE:
 588             log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
 589                     (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
 590             return false;
 591         default:
 592             break;
 593         }
 594
 595         return true;
 596
 597     case EXPR_ASSIGN:
 598         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 599         break;
 600
 601     case EXPR_INVERT:
 602         left = expr->unary.child;
 603         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 604             return false;
 605
 606         *val_rtrn = ~v;
 607         return true;
 608
 609     case EXPR_UNARY_PLUS:
 610     case EXPR_NEGATE:
 611     case EXPR_NOT:
 612         left = expr->unary.child;
 613         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 614             log_err(ctx, "The %s operator cannot be used with a mask\n",
 615                     (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
 616         return false;
 617
 618     default:
 619         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
 620                  expr->expr.op);
 621         break;
 622     }
 623
 624     return false;
 625 }
 626
 627 bool
 628 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
 629                 unsigned int *mask_rtrn, const LookupEntry *values)
 630 {
 631     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
 632 }
 633
 634 bool
 635 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
 636                    enum mod_type mod_type, const struct xkb_mod_set *mods,
 637                    xkb_mod_mask_t *mask_rtrn)
 638 {
 639     LookupModMaskPriv priv = { .mods = mods, .mod_type = mod_type };
 640     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, &priv);
 641 }
 642
 643 bool
 644 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
 645                   xkb_keysym_t *sym_rtrn)
 646 {
 647     int val;
 648
 649     if (expr->expr.op == EXPR_IDENT) {
 650         const char *str = xkb_atom_text(ctx, expr->ident.ident);
 651         *sym_rtrn = xkb_keysym_from_name(str, 0);
 652         if (*sym_rtrn != XKB_KEY_NoSymbol)
 653             return true;
 654     }
 655
 656     if (!ExprResolveInteger(ctx, expr, &val))
 657         return false;
 658
 659     if (val < 0 || val >= 10)
 660         return false;
 661
 662     *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
 663     return true;
 664 }
 665
 666 bool
 667 ExprResolveMod(struct xkb_context *ctx, const ExprDef *def,
 668                enum mod_type mod_type, const struct xkb_mod_set *mods,
 669                xkb_mod_index_t *ndx_rtrn)
 670 {
 671     xkb_mod_index_t ndx;
 672     xkb_atom_t name;
 673
 674     if (def->expr.op != EXPR_IDENT) {
 675         log_err(ctx,
 676                 "Cannot resolve virtual modifier: "
 677                 "found %s where a virtual modifier name was expected\n",
 678                 expr_op_type_to_string(def->expr.op));
 679         return false;
 680     }
 681
 682     name = def->ident.ident;
 683     ndx = XkbModNameToIndex(mods, name, mod_type);
 684     if (ndx == XKB_MOD_INVALID) {
 685         log_err(ctx,
 686                 "Cannot resolve virtual modifier: "
 687                 "\"%s\" was not previously declared\n",
 688                 xkb_atom_text(ctx, name));
 689         return false;
 690     }
 691
 692     *ndx_rtrn = ndx;
 693     return true;
 694 }