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