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