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 "expr.h"
  28
  29 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
  30                                 xkb_atom_t field, enum expr_value_type type,
  31                                 unsigned int *val_rtrn);
  32
  33 const char *
  34 exprOpText(enum expr_op_type op)
  35 {
  36     static char buf[32];
  37
  38     switch (op) {
  39     case EXPR_VALUE:
  40         strcpy(buf, "literal");
  41         break;
  42     case EXPR_IDENT:
  43         strcpy(buf, "identifier");
  44         break;
  45     case EXPR_ACTION_DECL:
  46         strcpy(buf, "action declaration");
  47         break;
  48     case EXPR_FIELD_REF:
  49         strcpy(buf, "field reference");
  50         break;
  51     case EXPR_ARRAY_REF:
  52         strcpy(buf, "array reference");
  53         break;
  54     case EXPR_KEYSYM_LIST:
  55         strcpy(buf, "list of keysyms");
  56         break;
  57     case EXPR_ACTION_LIST:
  58         strcpy(buf, "list of actions");
  59         break;
  60     case EXPR_ADD:
  61         strcpy(buf, "addition");
  62         break;
  63     case EXPR_SUBTRACT:
  64         strcpy(buf, "subtraction");
  65         break;
  66     case EXPR_MULTIPLY:
  67         strcpy(buf, "multiplication");
  68         break;
  69     case EXPR_DIVIDE:
  70         strcpy(buf, "division");
  71         break;
  72     case EXPR_ASSIGN:
  73         strcpy(buf, "assignment");
  74         break;
  75     case EXPR_NOT:
  76         strcpy(buf, "logical not");
  77         break;
  78     case EXPR_NEGATE:
  79         strcpy(buf, "arithmetic negation");
  80         break;
  81     case EXPR_INVERT:
  82         strcpy(buf, "bitwise inversion");
  83         break;
  84     case EXPR_UNARY_PLUS:
  85         strcpy(buf, "unary plus");
  86         break;
  87     default:
  88         snprintf(buf, sizeof(buf), "illegal(%d)", op);
  89         break;
  90     }
  91     return buf;
  92 }
  93
  94 static const char *
  95 exprValueTypeText(enum expr_value_type type)
  96 {
  97     static char buf[20];
  98
  99     switch (type) {
 100     case EXPR_TYPE_UNKNOWN:
 101         strcpy(buf, "unknown");
 102         break;
 103     case EXPR_TYPE_BOOLEAN:
 104         strcpy(buf, "boolean");
 105         break;
 106     case EXPR_TYPE_INT:
 107         strcpy(buf, "int");
 108         break;
 109     case EXPR_TYPE_STRING:
 110         strcpy(buf, "string");
 111         break;
 112     case EXPR_TYPE_ACTION:
 113         strcpy(buf, "action");
 114         break;
 115     case EXPR_TYPE_KEYNAME:
 116         strcpy(buf, "keyname");
 117         break;
 118     default:
 119         snprintf(buf, sizeof(buf), "illegal(%d)", type);
 120         break;
 121     }
 122     return buf;
 123 }
 124
 125 bool
 126 ExprResolveLhs(struct xkb_context *ctx, ExprDef *expr, const char **elem_rtrn,
 127                const char **field_rtrn, ExprDef **index_rtrn)
 128 {
 129     switch (expr->op) {
 130     case EXPR_IDENT:
 131         *elem_rtrn = NULL;
 132         *field_rtrn = xkb_atom_text(ctx, expr->value.str);
 133         *index_rtrn = NULL;
 134         return true;
 135     case EXPR_FIELD_REF:
 136         *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
 137         *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
 138         *index_rtrn = NULL;
 139         return true;
 140     case EXPR_ARRAY_REF:
 141         *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
 142         *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
 143         *index_rtrn = expr->value.array.entry;
 144         return true;
 145     default:
 146         break;
 147     }
 148     log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
 149     return false;
 150 }
 151
 152 static bool
 153 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 154              enum expr_value_type type, unsigned int *val_rtrn)
 155 {
 156     const LookupEntry *entry;
 157     const char *str;
 158
 159     if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
 160         return false;
 161
 162     str = xkb_atom_text(ctx, field);
 163     for (entry = priv; entry && entry->name; entry++) {
 164         if (istreq(str, entry->name)) {
 165             *val_rtrn = entry->value;
 166             return true;
 167         }
 168     }
 169
 170     return false;
 171 }
 172
 173 static const LookupEntry modIndexNames[] = {
 174     { "shift", ShiftMapIndex },
 175     { "control", ControlMapIndex },
 176     { "lock", LockMapIndex },
 177     { "mod1", Mod1MapIndex },
 178     { "mod2", Mod2MapIndex },
 179     { "mod3", Mod3MapIndex },
 180     { "mod4", Mod4MapIndex },
 181     { "mod5", Mod5MapIndex },
 182     { "none", XkbNoModifier },
 183     { NULL, 0 }
 184 };
 185
 186 bool
 187 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 188                enum expr_value_type type, xkb_mod_index_t *val_rtrn)
 189 {
 190     return SimpleLookup(ctx, modIndexNames, field, type, val_rtrn);
 191 }
 192
 193 bool
 194 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 195               enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
 196 {
 197     const char *str;
 198     xkb_mod_index_t ndx;
 199
 200     if (type != EXPR_TYPE_INT)
 201         return false;
 202
 203     str = xkb_atom_text(ctx, field);
 204
 205     if (istreq(str, "all"))
 206         *val_rtrn  = 0xff;
 207     else if (istreq(str, "none"))
 208         *val_rtrn = 0;
 209     else if (LookupModIndex(ctx, priv, field, type, &ndx))
 210         *val_rtrn = (1 << ndx);
 211     else
 212         return false;
 213
 214     return true;
 215 }
 216
 217 bool
 218 ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn)
 219 {
 220     bool ok = false;
 221     const char *ident;
 222
 223     switch (expr->op) {
 224     case EXPR_VALUE:
 225         if (expr->value_type != EXPR_TYPE_BOOLEAN) {
 226             log_err(ctx,
 227                     "Found constant of type %s where boolean was expected\n",
 228                     exprValueTypeText(expr->value_type));
 229             return false;
 230         }
 231         *set_rtrn = !!expr->value.ival;
 232         return true;
 233
 234     case EXPR_IDENT:
 235         ident = xkb_atom_text(ctx, expr->value.str);
 236         if (ident) {
 237             if (istreq(ident, "true") ||
 238                 istreq(ident, "yes") ||
 239                 istreq(ident, "on")) {
 240                 *set_rtrn = true;
 241                 return true;
 242             }
 243             else if (istreq(ident, "false") ||
 244                      istreq(ident, "no") ||
 245                      istreq(ident, "off")) {
 246                 *set_rtrn = false;
 247                 return true;
 248             }
 249         }
 250         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
 251                 xkb_atom_text(ctx, expr->value.str));
 252         return false;
 253
 254     case EXPR_FIELD_REF:
 255         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
 256                 xkb_atom_text(ctx, expr->value.field.element),
 257                 xkb_atom_text(ctx, expr->value.field.field));
 258         return false;
 259
 260     case EXPR_INVERT:
 261     case EXPR_NOT:
 262         ok = ExprResolveBoolean(ctx, expr, set_rtrn);
 263         if (ok)
 264             *set_rtrn = !*set_rtrn;
 265         return ok;
 266     case EXPR_ADD:
 267     case EXPR_SUBTRACT:
 268     case EXPR_MULTIPLY:
 269     case EXPR_DIVIDE:
 270     case EXPR_ASSIGN:
 271     case EXPR_NEGATE:
 272     case EXPR_UNARY_PLUS:
 273         log_err(ctx, "%s of boolean values not permitted\n",
 274                 exprOpText(expr->op));
 275         break;
 276
 277     default:
 278         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
 279         break;
 280     }
 281
 282     return false;
 283 }
 284
 285 bool
 286 ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr, xkb_keycode_t *kc)
 287 {
 288     xkb_keycode_t leftRtrn, rightRtrn;
 289     ExprDef *left, *right;
 290
 291     switch (expr->op) {
 292     case EXPR_VALUE:
 293         if (expr->value_type != EXPR_TYPE_INT) {
 294             log_err(ctx,
 295                     "Found constant of type %s where an int was expected\n",
 296                     exprValueTypeText(expr->value_type));
 297             return false;
 298         }
 299
 300         *kc = expr->value.uval;
 301         return true;
 302
 303     case EXPR_ADD:
 304     case EXPR_SUBTRACT:
 305     case EXPR_MULTIPLY:
 306     case EXPR_DIVIDE:
 307         left = expr->value.binary.left;
 308         right = expr->value.binary.right;
 309
 310         if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
 311             !ExprResolveKeyCode(ctx, right, &rightRtrn))
 312             return false;
 313
 314         switch (expr->op) {
 315         case EXPR_ADD:
 316             *kc = leftRtrn + rightRtrn;
 317             break;
 318         case EXPR_SUBTRACT:
 319             *kc = leftRtrn - rightRtrn;
 320             break;
 321         case EXPR_MULTIPLY:
 322             *kc = leftRtrn * rightRtrn;
 323             break;
 324         case EXPR_DIVIDE:
 325             if (rightRtrn == 0) {
 326                 log_err(ctx, "Cannot divide by zero: %d / %d\n",
 327                         leftRtrn, rightRtrn);
 328                 return false;
 329             }
 330
 331             *kc = leftRtrn / rightRtrn;
 332             break;
 333         default:
 334             break;
 335         }
 336
 337         return true;
 338
 339     case EXPR_NEGATE:
 340         left = expr->value.child;
 341         if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
 342             return false;
 343
 344         *kc = ~leftRtrn;
 345         return true;
 346
 347     case EXPR_UNARY_PLUS:
 348         left = expr->value.child;
 349         return ExprResolveKeyCode(ctx, left, kc);
 350
 351     default:
 352         log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
 353         break;
 354     }
 355
 356     return false;
 357 }
 358
 359 /**
 360  * This function returns ... something.  It's a bit of a guess, really.
 361  *
 362  * If an integer is given in value ctx, it will be returned in ival.
 363  * If an ident or field reference is given, the lookup function (if given)
 364  * will be called.  At the moment, only SimpleLookup use this, and they both
 365  * return the results in uval.  And don't support field references.
 366  *
 367  * Cool.
 368  */
 369 static bool
 370 ExprResolveIntegerLookup(struct xkb_context *ctx, ExprDef *expr,
 371                          int *val_rtrn, IdentLookupFunc lookup,
 372                          const void *lookupPriv)
 373 {
 374     bool ok = false;
 375     int l, r;
 376     unsigned u;
 377     ExprDef *left, *right;
 378
 379     switch (expr->op) {
 380     case EXPR_VALUE:
 381         if (expr->value_type != EXPR_TYPE_INT) {
 382             log_err(ctx,
 383                     "Found constant of type %s where an int was expected\n",
 384                     exprValueTypeText(expr->value_type));
 385             return false;
 386         }
 387
 388         *val_rtrn = expr->value.ival;
 389         return true;
 390
 391     case EXPR_IDENT:
 392         if (lookup)
 393             ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, &u);
 394
 395         if (!ok)
 396             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 397                     xkb_atom_text(ctx, expr->value.str));
 398         else
 399             *val_rtrn = (int) u;
 400
 401         return ok;
 402
 403     case EXPR_FIELD_REF:
 404         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 405                 xkb_atom_text(ctx, expr->value.field.element),
 406                 xkb_atom_text(ctx, expr->value.field.field));
 407         return false;
 408
 409     case EXPR_ADD:
 410     case EXPR_SUBTRACT:
 411     case EXPR_MULTIPLY:
 412     case EXPR_DIVIDE:
 413         left = expr->value.binary.left;
 414         right = expr->value.binary.right;
 415         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
 416             !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
 417             return false;
 418
 419         switch (expr->op) {
 420         case EXPR_ADD:
 421             *val_rtrn = l + r;
 422             break;
 423         case EXPR_SUBTRACT:
 424             *val_rtrn = l - r;
 425             break;
 426         case EXPR_MULTIPLY:
 427             *val_rtrn = l * r;
 428             break;
 429         case EXPR_DIVIDE:
 430             if (r == 0) {
 431                 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
 432                 return false;
 433             }
 434             *val_rtrn = l / r;
 435             break;
 436         default:
 437             break;
 438         }
 439
 440         return true;
 441
 442     case EXPR_ASSIGN:
 443         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 444         break;
 445
 446     case EXPR_NOT:
 447         log_err(ctx, "The ! operator cannot be applied to an integer\n");
 448         return false;
 449
 450     case EXPR_INVERT:
 451     case EXPR_NEGATE:
 452         left = expr->value.child;
 453         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
 454             return false;
 455
 456         *val_rtrn = (expr->op == EXPR_NEGATE ? -l : ~l);
 457         return true;
 458
 459     case EXPR_UNARY_PLUS:
 460         left = expr->value.child;
 461         return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
 462                                         lookupPriv);
 463
 464     default:
 465         log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n", expr->op);
 466         break;
 467     }
 468
 469     return false;
 470 }
 471
 472 bool
 473 ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn)
 474 {
 475     return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
 476 }
 477
 478 bool
 479 ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
 480                  xkb_group_index_t *group_rtrn)
 481 {
 482     bool ok;
 483     int result;
 484     static const LookupEntry group_names[] = {
 485         { "group1", 1 },
 486         { "group2", 2 },
 487         { "group3", 3 },
 488         { "group4", 4 },
 489         { "group5", 5 },
 490         { "group6", 6 },
 491         { "group7", 7 },
 492         { "group8", 8 },
 493         { NULL, 0 }
 494     };
 495
 496     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 497                                   group_names);
 498     if (!ok)
 499         return false;
 500
 501     if (result <= 0 || result > XkbNumKbdGroups) {
 502         log_err(ctx, "Group index %u is out of range (1..%d)\n",
 503                 result, XkbNumKbdGroups);
 504         return false;
 505     }
 506
 507     *group_rtrn = (xkb_group_index_t) result;
 508     return true;
 509 }
 510
 511 bool
 512 ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
 513                  unsigned int *level_rtrn)
 514 {
 515     bool ok;
 516     int result;
 517     static const LookupEntry level_names[] = {
 518         { "level1", 1 },
 519         { "level2", 2 },
 520         { "level3", 3 },
 521         { "level4", 4 },
 522         { "level5", 5 },
 523         { "level6", 6 },
 524         { "level7", 7 },
 525         { "level8", 8 },
 526         { NULL, 0 }
 527     };
 528
 529     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 530                                   level_names);
 531     if (!ok)
 532         return false;
 533
 534     if (result < 1 || result > XkbMaxShiftLevel) {
 535         log_err(ctx, "Shift level %d is out of range (1..%d)\n",
 536                 result, XkbMaxShiftLevel);
 537         return false;
 538     }
 539
 540     *level_rtrn = (unsigned int) result;
 541     return true;
 542 }
 543
 544 bool
 545 ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn)
 546 {
 547     int result;
 548     static const LookupEntry button_names[] = {
 549         { "button1", 1 },
 550         { "button2", 2 },
 551         { "button3", 3 },
 552         { "button4", 4 },
 553         { "button5", 5 },
 554         { "default", 0 },
 555         { NULL, 0 }
 556     };
 557
 558     if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 559                                   button_names))
 560         return false;
 561
 562     *btn_rtrn = result;
 563     return true;
 564 }
 565
 566 bool
 567 ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
 568                   const char **val_rtrn)
 569 {
 570     switch (expr->op) {
 571     case EXPR_VALUE:
 572         if (expr->value_type != EXPR_TYPE_STRING) {
 573             log_err(ctx, "Found constant of type %s, expected a string\n",
 574                     exprValueTypeText(expr->value_type));
 575             return false;
 576         }
 577
 578         *val_rtrn = xkb_atom_text(ctx, expr->value.str);
 579         return true;
 580
 581     case EXPR_IDENT:
 582         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 583                 xkb_atom_text(ctx, expr->value.str));
 584         return false;
 585
 586     case EXPR_FIELD_REF:
 587         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
 588                 xkb_atom_text(ctx, expr->value.field.element),
 589                 xkb_atom_text(ctx, expr->value.field.field));
 590         return false;
 591
 592     case EXPR_ADD:
 593     case EXPR_SUBTRACT:
 594     case EXPR_MULTIPLY:
 595     case EXPR_DIVIDE:
 596     case EXPR_ASSIGN:
 597     case EXPR_NEGATE:
 598     case EXPR_INVERT:
 599     case EXPR_NOT:
 600     case EXPR_UNARY_PLUS:
 601         log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
 602         return false;
 603
 604     default:
 605         log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
 606         break;
 607     }
 608     return false;
 609 }
 610
 611 bool
 612 ExprResolveKeyName(struct xkb_context *ctx, ExprDef *expr,
 613                    char name[XkbKeyNameLength])
 614 {
 615     switch (expr->op) {
 616     case EXPR_VALUE:
 617         if (expr->value_type != EXPR_TYPE_KEYNAME) {
 618             log_err(ctx, "Found constant of type %s, expected a key name\n",
 619                     exprValueTypeText(expr->value_type));
 620             return false;
 621         }
 622         memcpy(name, expr->value.keyName, XkbKeyNameLength);
 623         return true;
 624
 625     case EXPR_IDENT:
 626         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 627                 xkb_atom_text(ctx, expr->value.str));
 628         return false;
 629
 630     case EXPR_FIELD_REF:
 631         log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
 632                 xkb_atom_text(ctx, expr->value.field.element),
 633                 xkb_atom_text(ctx, expr->value.field.field));
 634         return false;
 635
 636     case EXPR_ADD:
 637     case EXPR_SUBTRACT:
 638     case EXPR_MULTIPLY:
 639     case EXPR_DIVIDE:
 640     case EXPR_ASSIGN:
 641     case EXPR_NEGATE:
 642     case EXPR_INVERT:
 643     case EXPR_NOT:
 644     case EXPR_UNARY_PLUS:
 645         log_err(ctx, "%s of key name values not permitted\n",
 646                 exprOpText(expr->op));
 647         return false;
 648
 649     default:
 650         log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
 651         break;
 652     }
 653     return false;
 654 }
 655
 656 bool
 657 ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr,
 658                 unsigned int *val_rtrn, const LookupEntry *values)
 659 {
 660     if (expr->op != EXPR_IDENT) {
 661         log_err(ctx, "Found a %s where an enumerated value was expected\n",
 662                 exprOpText(expr->op));
 663         return false;
 664     }
 665
 666     if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
 667                       val_rtrn)) {
 668         log_err(ctx, "Illegal identifier %s; expected one of:\n",
 669                 xkb_atom_text(ctx, expr->value.str));
 670         while (values && values->name)
 671         {
 672             log_err(ctx, "\t%s\n", values->name);
 673             values++;
 674         }
 675         return false;
 676     }
 677
 678     return true;
 679 }
 680
 681 static bool
 682 ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
 683                       unsigned int *val_rtrn, IdentLookupFunc lookup,
 684                       const void *lookupPriv)
 685 {
 686     bool ok = 0;
 687     unsigned int l, r;
 688     int v;
 689     ExprDef *left, *right;
 690     const char *bogus = NULL;
 691
 692     switch (expr->op) {
 693     case EXPR_VALUE:
 694         if (expr->value_type != EXPR_TYPE_INT) {
 695             log_err(ctx,
 696                     "Found constant of type %s where a mask was expected\n",
 697                     exprValueTypeText(expr->value_type));
 698             return false;
 699         }
 700         *val_rtrn = (unsigned int) expr->value.ival;
 701         return true;
 702
 703     case EXPR_IDENT:
 704         ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
 705                     val_rtrn);
 706         if (!ok)
 707             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 708                     xkb_atom_text(ctx, expr->value.str));
 709         return ok;
 710
 711     case EXPR_FIELD_REF:
 712         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 713                 xkb_atom_text(ctx, expr->value.field.element),
 714                 xkb_atom_text(ctx, expr->value.field.field));
 715         return false;
 716
 717     case EXPR_ARRAY_REF:
 718         bogus = "array reference";
 719
 720     case EXPR_ACTION_DECL:
 721         if (bogus == NULL)
 722             bogus = "function use";
 723         log_err(ctx,
 724                 "Unexpected %s in mask expression; Expression Ignored\n",
 725                 bogus);
 726         return false;
 727
 728     case EXPR_ADD:
 729     case EXPR_SUBTRACT:
 730     case EXPR_MULTIPLY:
 731     case EXPR_DIVIDE:
 732         left = expr->value.binary.left;
 733         right = expr->value.binary.right;
 734         if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
 735             !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
 736             return false;
 737
 738         switch (expr->op) {
 739         case EXPR_ADD:
 740             *val_rtrn = l | r;
 741             break;
 742         case EXPR_SUBTRACT:
 743             *val_rtrn = l & (~r);
 744             break;
 745         case EXPR_MULTIPLY:
 746         case EXPR_DIVIDE:
 747             log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
 748                     (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
 749             return false;
 750         default:
 751             break;
 752         }
 753
 754         return true;
 755
 756     case EXPR_ASSIGN:
 757         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 758         break;
 759
 760     case EXPR_INVERT:
 761         left = expr->value.child;
 762         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 763             return false;
 764
 765         *val_rtrn = ~v;
 766         return true;
 767
 768     case EXPR_UNARY_PLUS:
 769     case EXPR_NEGATE:
 770     case EXPR_NOT:
 771         left = expr->value.child;
 772         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 773             log_err(ctx, "The %s operator cannot be used with a mask\n",
 774                     (expr->op == EXPR_NEGATE ? "-" : "!"));
 775         return false;
 776
 777     default:
 778         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
 779         break;
 780     }
 781
 782     return false;
 783 }
 784
 785 bool
 786 ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
 787                 unsigned int *mask_rtrn, const LookupEntry *values)
 788 {
 789     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
 790 }
 791
 792 bool
 793 ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
 794                    xkb_mod_mask_t *mask_rtrn)
 795 {
 796     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
 797 }
 798
 799 bool
 800 ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
 801                     xkb_mod_mask_t *mask_rtrn)
 802 {
 803     return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
 804                                  keymap);
 805 }
 806
 807 bool
 808 ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
 809                   xkb_keysym_t *sym_rtrn)
 810 {
 811     int val;
 812
 813     if (expr->op == EXPR_IDENT) {
 814         const char *str;
 815         str = xkb_atom_text(ctx, expr->value.str);
 816         *sym_rtrn = xkb_keysym_from_name(str);
 817         if (*sym_rtrn != XKB_KEY_NoSymbol)
 818             return true;
 819     }
 820
 821     if (!ExprResolveInteger(ctx, expr, &val))
 822         return false;
 823
 824     if (val < 0 || val >= 10)
 825         return false;
 826
 827     *sym_rtrn = ((xkb_keysym_t) val) + '0';
 828     return true;
 829 }