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