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 "xkbcomp-priv.h"
  28 #include "text.h"
  29 #include "expr.h"
  30
  31 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
  32                                 xkb_atom_t field, enum expr_value_type type,
  33                                 unsigned int *val_rtrn);
  34
  35 const char *
  36 exprOpText(enum expr_op_type op)
  37 {
  38     static char buf[32];
  39
  40     switch (op) {
  41     case EXPR_VALUE:
  42         strcpy(buf, "literal");
  43         break;
  44     case EXPR_IDENT:
  45         strcpy(buf, "identifier");
  46         break;
  47     case EXPR_ACTION_DECL:
  48         strcpy(buf, "action declaration");
  49         break;
  50     case EXPR_FIELD_REF:
  51         strcpy(buf, "field reference");
  52         break;
  53     case EXPR_ARRAY_REF:
  54         strcpy(buf, "array reference");
  55         break;
  56     case EXPR_KEYSYM_LIST:
  57         strcpy(buf, "list of keysyms");
  58         break;
  59     case EXPR_ACTION_LIST:
  60         strcpy(buf, "list of actions");
  61         break;
  62     case EXPR_ADD:
  63         strcpy(buf, "addition");
  64         break;
  65     case EXPR_SUBTRACT:
  66         strcpy(buf, "subtraction");
  67         break;
  68     case EXPR_MULTIPLY:
  69         strcpy(buf, "multiplication");
  70         break;
  71     case EXPR_DIVIDE:
  72         strcpy(buf, "division");
  73         break;
  74     case EXPR_ASSIGN:
  75         strcpy(buf, "assignment");
  76         break;
  77     case EXPR_NOT:
  78         strcpy(buf, "logical not");
  79         break;
  80     case EXPR_NEGATE:
  81         strcpy(buf, "arithmetic negation");
  82         break;
  83     case EXPR_INVERT:
  84         strcpy(buf, "bitwise inversion");
  85         break;
  86     case EXPR_UNARY_PLUS:
  87         strcpy(buf, "unary plus");
  88         break;
  89     default:
  90         snprintf(buf, sizeof(buf), "illegal(%d)", op);
  91         break;
  92     }
  93     return buf;
  94 }
  95
  96 static const char *
  97 exprValueTypeText(enum expr_value_type type)
  98 {
  99     static char buf[20];
 100
 101     switch (type) {
 102     case EXPR_TYPE_UNKNOWN:
 103         strcpy(buf, "unknown");
 104         break;
 105     case EXPR_TYPE_BOOLEAN:
 106         strcpy(buf, "boolean");
 107         break;
 108     case EXPR_TYPE_INT:
 109         strcpy(buf, "int");
 110         break;
 111     case EXPR_TYPE_STRING:
 112         strcpy(buf, "string");
 113         break;
 114     case EXPR_TYPE_ACTION:
 115         strcpy(buf, "action");
 116         break;
 117     case EXPR_TYPE_KEYNAME:
 118         strcpy(buf, "keyname");
 119         break;
 120     default:
 121         snprintf(buf, sizeof(buf), "illegal(%d)", type);
 122         break;
 123     }
 124     return buf;
 125 }
 126
 127 bool
 128 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
 129                const char **elem_rtrn, const char **field_rtrn,
 130                ExprDef **index_rtrn)
 131 {
 132     switch (expr->op) {
 133     case EXPR_IDENT:
 134         *elem_rtrn = NULL;
 135         *field_rtrn = xkb_atom_text(ctx, expr->value.str);
 136         *index_rtrn = NULL;
 137         return true;
 138     case EXPR_FIELD_REF:
 139         *elem_rtrn = xkb_atom_text(ctx, expr->value.field.element);
 140         *field_rtrn = xkb_atom_text(ctx, expr->value.field.field);
 141         *index_rtrn = NULL;
 142         return true;
 143     case EXPR_ARRAY_REF:
 144         *elem_rtrn = xkb_atom_text(ctx, expr->value.array.element);
 145         *field_rtrn = xkb_atom_text(ctx, expr->value.array.field);
 146         *index_rtrn = expr->value.array.entry;
 147         return true;
 148     default:
 149         break;
 150     }
 151     log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->op);
 152     return false;
 153 }
 154
 155 static bool
 156 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 157              enum expr_value_type type, unsigned int *val_rtrn)
 158 {
 159     const LookupEntry *entry;
 160     const char *str;
 161
 162     if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
 163         return false;
 164
 165     str = xkb_atom_text(ctx, field);
 166     for (entry = priv; entry && entry->name; entry++) {
 167         if (istreq(str, entry->name)) {
 168             *val_rtrn = entry->value;
 169             return true;
 170         }
 171     }
 172
 173     return false;
 174 }
 175
 176 bool
 177 LookupModIndex(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 178                enum expr_value_type type, xkb_mod_index_t *val_rtrn)
 179 {
 180     const char *name = xkb_atom_text(ctx, field);
 181
 182     if (istreq(name, "none")) {
 183         *val_rtrn = XkbNoModifier;
 184         return true;
 185     }
 186
 187     *val_rtrn = ModNameToIndex(name);
 188     return (*val_rtrn != XKB_MOD_INVALID);
 189 }
 190
 191 bool
 192 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
 193               enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
 194 {
 195     const char *str;
 196     xkb_mod_index_t ndx;
 197
 198     if (type != EXPR_TYPE_INT)
 199         return false;
 200
 201     str = xkb_atom_text(ctx, field);
 202
 203     if (istreq(str, "all"))
 204         *val_rtrn  = 0xff;
 205     else if (istreq(str, "none"))
 206         *val_rtrn = 0;
 207     else if (LookupModIndex(ctx, priv, field, type, &ndx))
 208         *val_rtrn = (1 << ndx);
 209     else
 210         return false;
 211
 212     return true;
 213 }
 214
 215 bool
 216 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
 217                    bool *set_rtrn)
 218 {
 219     bool ok = false;
 220     const char *ident;
 221
 222     switch (expr->op) {
 223     case EXPR_VALUE:
 224         if (expr->value_type != EXPR_TYPE_BOOLEAN) {
 225             log_err(ctx,
 226                     "Found constant of type %s where boolean was expected\n",
 227                     exprValueTypeText(expr->value_type));
 228             return false;
 229         }
 230         *set_rtrn = !!expr->value.ival;
 231         return true;
 232
 233     case EXPR_IDENT:
 234         ident = xkb_atom_text(ctx, expr->value.str);
 235         if (ident) {
 236             if (istreq(ident, "true") ||
 237                 istreq(ident, "yes") ||
 238                 istreq(ident, "on")) {
 239                 *set_rtrn = true;
 240                 return true;
 241             }
 242             else if (istreq(ident, "false") ||
 243                      istreq(ident, "no") ||
 244                      istreq(ident, "off")) {
 245                 *set_rtrn = false;
 246                 return true;
 247             }
 248         }
 249         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
 250                 xkb_atom_text(ctx, expr->value.str));
 251         return false;
 252
 253     case EXPR_FIELD_REF:
 254         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
 255                 xkb_atom_text(ctx, expr->value.field.element),
 256                 xkb_atom_text(ctx, expr->value.field.field));
 257         return false;
 258
 259     case EXPR_INVERT:
 260     case EXPR_NOT:
 261         ok = ExprResolveBoolean(ctx, expr, set_rtrn);
 262         if (ok)
 263             *set_rtrn = !*set_rtrn;
 264         return ok;
 265     case EXPR_ADD:
 266     case EXPR_SUBTRACT:
 267     case EXPR_MULTIPLY:
 268     case EXPR_DIVIDE:
 269     case EXPR_ASSIGN:
 270     case EXPR_NEGATE:
 271     case EXPR_UNARY_PLUS:
 272         log_err(ctx, "%s of boolean values not permitted\n",
 273                 exprOpText(expr->op));
 274         break;
 275
 276     default:
 277         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
 278         break;
 279     }
 280
 281     return false;
 282 }
 283
 284 bool
 285 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
 286                    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, const 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, const ExprDef *expr,
 474                    int *val_rtrn)
 475 {
 476     return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
 477 }
 478
 479 bool
 480 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
 481                  xkb_group_index_t *group_rtrn)
 482 {
 483     bool ok;
 484     int result;
 485     static const LookupEntry group_names[] = {
 486         { "group1", 1 },
 487         { "group2", 2 },
 488         { "group3", 3 },
 489         { "group4", 4 },
 490         { "group5", 5 },
 491         { "group6", 6 },
 492         { "group7", 7 },
 493         { "group8", 8 },
 494         { NULL, 0 }
 495     };
 496
 497     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 498                                   group_names);
 499     if (!ok)
 500         return false;
 501
 502     if (result <= 0 || result > XkbNumKbdGroups) {
 503         log_err(ctx, "Group index %u is out of range (1..%d)\n",
 504                 result, XkbNumKbdGroups);
 505         return false;
 506     }
 507
 508     *group_rtrn = (xkb_group_index_t) result;
 509     return true;
 510 }
 511
 512 bool
 513 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
 514                  xkb_level_index_t *level_rtrn)
 515 {
 516     bool ok;
 517     int result;
 518     static const LookupEntry level_names[] = {
 519         { "level1", 1 },
 520         { "level2", 2 },
 521         { "level3", 3 },
 522         { "level4", 4 },
 523         { "level5", 5 },
 524         { "level6", 6 },
 525         { "level7", 7 },
 526         { "level8", 8 },
 527         { NULL, 0 }
 528     };
 529
 530     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 531                                   level_names);
 532     if (!ok)
 533         return false;
 534
 535     if (result < 1 || result > XkbMaxShiftLevel) {
 536         log_err(ctx, "Shift level %d is out of range (1..%d)\n",
 537                 result, XkbMaxShiftLevel);
 538         return false;
 539     }
 540
 541     /* Level is zero-indexed from now on. */
 542     *level_rtrn = (unsigned int) (result - 1);
 543     return true;
 544 }
 545
 546 bool
 547 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
 548 {
 549     int result;
 550     static const LookupEntry button_names[] = {
 551         { "button1", 1 },
 552         { "button2", 2 },
 553         { "button3", 3 },
 554         { "button4", 4 },
 555         { "button5", 5 },
 556         { "default", 0 },
 557         { NULL, 0 }
 558     };
 559
 560     if (!ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 561                                   button_names))
 562         return false;
 563
 564     *btn_rtrn = result;
 565     return true;
 566 }
 567
 568 bool
 569 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
 570                   const char **val_rtrn)
 571 {
 572     switch (expr->op) {
 573     case EXPR_VALUE:
 574         if (expr->value_type != EXPR_TYPE_STRING) {
 575             log_err(ctx, "Found constant of type %s, expected a string\n",
 576                     exprValueTypeText(expr->value_type));
 577             return false;
 578         }
 579
 580         *val_rtrn = xkb_atom_text(ctx, expr->value.str);
 581         return true;
 582
 583     case EXPR_IDENT:
 584         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 585                 xkb_atom_text(ctx, expr->value.str));
 586         return false;
 587
 588     case EXPR_FIELD_REF:
 589         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
 590                 xkb_atom_text(ctx, expr->value.field.element),
 591                 xkb_atom_text(ctx, expr->value.field.field));
 592         return false;
 593
 594     case EXPR_ADD:
 595     case EXPR_SUBTRACT:
 596     case EXPR_MULTIPLY:
 597     case EXPR_DIVIDE:
 598     case EXPR_ASSIGN:
 599     case EXPR_NEGATE:
 600     case EXPR_INVERT:
 601     case EXPR_NOT:
 602     case EXPR_UNARY_PLUS:
 603         log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
 604         return false;
 605
 606     default:
 607         log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
 608         break;
 609     }
 610     return false;
 611 }
 612
 613 bool
 614 ExprResolveKeyName(struct xkb_context *ctx, const ExprDef *expr,
 615                    char name[XkbKeyNameLength])
 616 {
 617     switch (expr->op) {
 618     case EXPR_VALUE:
 619         if (expr->value_type != EXPR_TYPE_KEYNAME) {
 620             log_err(ctx, "Found constant of type %s, expected a key name\n",
 621                     exprValueTypeText(expr->value_type));
 622             return false;
 623         }
 624         strncpy(name, expr->value.keyName, XkbKeyNameLength);
 625         return true;
 626
 627     case EXPR_IDENT:
 628         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 629                 xkb_atom_text(ctx, expr->value.str));
 630         return false;
 631
 632     case EXPR_FIELD_REF:
 633         log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
 634                 xkb_atom_text(ctx, expr->value.field.element),
 635                 xkb_atom_text(ctx, expr->value.field.field));
 636         return false;
 637
 638     case EXPR_ADD:
 639     case EXPR_SUBTRACT:
 640     case EXPR_MULTIPLY:
 641     case EXPR_DIVIDE:
 642     case EXPR_ASSIGN:
 643     case EXPR_NEGATE:
 644     case EXPR_INVERT:
 645     case EXPR_NOT:
 646     case EXPR_UNARY_PLUS:
 647         log_err(ctx, "%s of key name values not permitted\n",
 648                 exprOpText(expr->op));
 649         return false;
 650
 651     default:
 652         log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
 653         break;
 654     }
 655     return false;
 656 }
 657
 658 bool
 659 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
 660                 unsigned int *val_rtrn, const LookupEntry *values)
 661 {
 662     if (expr->op != EXPR_IDENT) {
 663         log_err(ctx, "Found a %s where an enumerated value was expected\n",
 664                 exprOpText(expr->op));
 665         return false;
 666     }
 667
 668     if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT,
 669                       val_rtrn)) {
 670         log_err(ctx, "Illegal identifier %s; expected one of:\n",
 671                 xkb_atom_text(ctx, expr->value.str));
 672         while (values && values->name)
 673         {
 674             log_err(ctx, "\t%s\n", values->name);
 675             values++;
 676         }
 677         return false;
 678     }
 679
 680     return true;
 681 }
 682
 683 static bool
 684 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
 685                       unsigned int *val_rtrn, IdentLookupFunc lookup,
 686                       const void *lookupPriv)
 687 {
 688     bool ok = 0;
 689     unsigned int l, r;
 690     int v;
 691     ExprDef *left, *right;
 692     const char *bogus = NULL;
 693
 694     switch (expr->op) {
 695     case EXPR_VALUE:
 696         if (expr->value_type != EXPR_TYPE_INT) {
 697             log_err(ctx,
 698                     "Found constant of type %s where a mask was expected\n",
 699                     exprValueTypeText(expr->value_type));
 700             return false;
 701         }
 702         *val_rtrn = (unsigned int) expr->value.ival;
 703         return true;
 704
 705     case EXPR_IDENT:
 706         ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT,
 707                     val_rtrn);
 708         if (!ok)
 709             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 710                     xkb_atom_text(ctx, expr->value.str));
 711         return ok;
 712
 713     case EXPR_FIELD_REF:
 714         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 715                 xkb_atom_text(ctx, expr->value.field.element),
 716                 xkb_atom_text(ctx, expr->value.field.field));
 717         return false;
 718
 719     case EXPR_ARRAY_REF:
 720         bogus = "array reference";
 721
 722     case EXPR_ACTION_DECL:
 723         if (bogus == NULL)
 724             bogus = "function use";
 725         log_err(ctx,
 726                 "Unexpected %s in mask expression; Expression Ignored\n",
 727                 bogus);
 728         return false;
 729
 730     case EXPR_ADD:
 731     case EXPR_SUBTRACT:
 732     case EXPR_MULTIPLY:
 733     case EXPR_DIVIDE:
 734         left = expr->value.binary.left;
 735         right = expr->value.binary.right;
 736         if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
 737             !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
 738             return false;
 739
 740         switch (expr->op) {
 741         case EXPR_ADD:
 742             *val_rtrn = l | r;
 743             break;
 744         case EXPR_SUBTRACT:
 745             *val_rtrn = l & (~r);
 746             break;
 747         case EXPR_MULTIPLY:
 748         case EXPR_DIVIDE:
 749             log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
 750                     (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
 751             return false;
 752         default:
 753             break;
 754         }
 755
 756         return true;
 757
 758     case EXPR_ASSIGN:
 759         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 760         break;
 761
 762     case EXPR_INVERT:
 763         left = expr->value.child;
 764         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 765             return false;
 766
 767         *val_rtrn = ~v;
 768         return true;
 769
 770     case EXPR_UNARY_PLUS:
 771     case EXPR_NEGATE:
 772     case EXPR_NOT:
 773         left = expr->value.child;
 774         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 775             log_err(ctx, "The %s operator cannot be used with a mask\n",
 776                     (expr->op == EXPR_NEGATE ? "-" : "!"));
 777         return false;
 778
 779     default:
 780         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
 781         break;
 782     }
 783
 784     return false;
 785 }
 786
 787 bool
 788 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
 789                 unsigned int *mask_rtrn, const LookupEntry *values)
 790 {
 791     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
 792 }
 793
 794 bool
 795 ExprResolveModMask(struct xkb_context *ctx, const ExprDef *expr,
 796                    xkb_mod_mask_t *mask_rtrn)
 797 {
 798     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, LookupModMask, NULL);
 799 }
 800
 801 bool
 802 ExprResolveVModMask(struct xkb_keymap *keymap, const ExprDef *expr,
 803                     xkb_mod_mask_t *mask_rtrn)
 804 {
 805     return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupVModMask,
 806                                  keymap);
 807 }
 808
 809 bool
 810 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
 811                   xkb_keysym_t *sym_rtrn)
 812 {
 813     int val;
 814
 815     if (expr->op == EXPR_IDENT) {
 816         const char *str;
 817         str = xkb_atom_text(ctx, expr->value.str);
 818         *sym_rtrn = xkb_keysym_from_name(str);
 819         if (*sym_rtrn != XKB_KEY_NoSymbol)
 820             return true;
 821     }
 822
 823     if (!ExprResolveInteger(ctx, expr, &val))
 824         return false;
 825
 826     if (val < 0 || val >= 10)
 827         return false;
 828
 829     *sym_rtrn = ((xkb_keysym_t) val) + '0';
 830     return true;
 831 }