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 bool
 218 ExprResolveBoolean(struct xkb_context *ctx, ExprDef *expr, bool *set_rtrn)
 219 {
 220     bool ok = false;
 221     const char *ident;
 222
 223     switch (expr->op) {
 224     case EXPR_VALUE:
 225         if (expr->value_type != EXPR_TYPE_BOOLEAN) {
 226             log_err(ctx,
 227                     "Found constant of type %s where boolean was expected\n",
 228                     exprValueTypeText(expr->value_type));
 229             return false;
 230         }
 231         *set_rtrn = !!expr->value.ival;
 232         return true;
 233
 234     case EXPR_IDENT:
 235         ident = xkb_atom_text(ctx, expr->value.str);
 236         if (ident) {
 237             if (istreq(ident, "true") ||
 238                 istreq(ident, "yes") ||
 239                 istreq(ident, "on")) {
 240                 *set_rtrn = true;
 241                 return true;
 242             }
 243             else if (istreq(ident, "false") ||
 244                      istreq(ident, "no") ||
 245                      istreq(ident, "off")) {
 246                 *set_rtrn = false;
 247                 return true;
 248             }
 249         }
 250         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n",
 251                 xkb_atom_text(ctx, expr->value.str));
 252         return false;
 253
 254     case EXPR_FIELD_REF:
 255         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
 256                 xkb_atom_text(ctx, expr->value.field.element),
 257                 xkb_atom_text(ctx, expr->value.field.field));
 258         return false;
 259
 260     case EXPR_INVERT:
 261     case EXPR_NOT:
 262         ok = ExprResolveBoolean(ctx, expr, set_rtrn);
 263         if (ok)
 264             *set_rtrn = !*set_rtrn;
 265         return ok;
 266     case EXPR_ADD:
 267     case EXPR_SUBTRACT:
 268     case EXPR_MULTIPLY:
 269     case EXPR_DIVIDE:
 270     case EXPR_ASSIGN:
 271     case EXPR_NEGATE:
 272     case EXPR_UNARY_PLUS:
 273         log_err(ctx, "%s of boolean values not permitted\n",
 274                 exprOpText(expr->op));
 275         break;
 276
 277     default:
 278         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n", expr->op);
 279         break;
 280     }
 281
 282     return false;
 283 }
 284
 285 bool
 286 ExprResolveKeyCode(struct xkb_context *ctx, ExprDef *expr, xkb_keycode_t *kc)
 287 {
 288     xkb_keycode_t leftRtrn, rightRtrn;
 289     ExprDef *left, *right;
 290
 291     switch (expr->op) {
 292     case EXPR_VALUE:
 293         if (expr->value_type != EXPR_TYPE_INT) {
 294             log_err(ctx,
 295                     "Found constant of type %s where an int was expected\n",
 296                     exprValueTypeText(expr->value_type));
 297             return false;
 298         }
 299
 300         *kc = expr->value.uval;
 301         return true;
 302
 303     case EXPR_ADD:
 304     case EXPR_SUBTRACT:
 305     case EXPR_MULTIPLY:
 306     case EXPR_DIVIDE:
 307         left = expr->value.binary.left;
 308         right = expr->value.binary.right;
 309
 310         if (!ExprResolveKeyCode(ctx, left, &leftRtrn) ||
 311             !ExprResolveKeyCode(ctx, right, &rightRtrn))
 312             return false;
 313
 314         switch (expr->op) {
 315         case EXPR_ADD:
 316             *kc = leftRtrn + rightRtrn;
 317             break;
 318         case EXPR_SUBTRACT:
 319             *kc = leftRtrn - rightRtrn;
 320             break;
 321         case EXPR_MULTIPLY:
 322             *kc = leftRtrn * rightRtrn;
 323             break;
 324         case EXPR_DIVIDE:
 325             if (rightRtrn == 0) {
 326                 log_err(ctx, "Cannot divide by zero: %d / %d\n",
 327                         leftRtrn, rightRtrn);
 328                 return false;
 329             }
 330
 331             *kc = leftRtrn / rightRtrn;
 332             break;
 333         default:
 334             break;
 335         }
 336
 337         return true;
 338
 339     case EXPR_NEGATE:
 340         left = expr->value.child;
 341         if (!ExprResolveKeyCode(ctx, left, &leftRtrn))
 342             return false;
 343
 344         *kc = ~leftRtrn;
 345         return true;
 346
 347     case EXPR_UNARY_PLUS:
 348         left = expr->value.child;
 349         return ExprResolveKeyCode(ctx, left, kc);
 350
 351     default:
 352         log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n", expr->op);
 353         break;
 354     }
 355
 356     return false;
 357 }
 358
 359 /**
 360  * This function returns ... something.  It's a bit of a guess, really.
 361  *
 362  * If 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 bool
 492 ExprResolveInteger(struct xkb_context *ctx, ExprDef *expr, int *val_rtrn)
 493 {
 494     ExprResult result;
 495     bool ok;
 496     ok = ExprResolveIntegerLookup(ctx, expr, &result, NULL, NULL);
 497     if (ok)
 498         *val_rtrn = result.ival;
 499     return ok;
 500 }
 501
 502 bool
 503 ExprResolveGroup(struct xkb_context *ctx, ExprDef *expr,
 504                  xkb_group_index_t *group_rtrn)
 505 {
 506     bool ok;
 507     ExprResult result;
 508     static const LookupEntry group_names[] = {
 509         { "group1", 1 },
 510         { "group2", 2 },
 511         { "group3", 3 },
 512         { "group4", 4 },
 513         { "group5", 5 },
 514         { "group6", 6 },
 515         { "group7", 7 },
 516         { "group8", 8 },
 517         { NULL, 0 }
 518     };
 519
 520     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 521                                   group_names);
 522     if (!ok)
 523         return false;
 524
 525     if (result.uval == 0 || result.uval > XkbNumKbdGroups) {
 526         log_err(ctx, "Group index %u is out of range (1..%d)\n",
 527                 result.uval, XkbNumKbdGroups);
 528         return false;
 529     }
 530
 531     *group_rtrn = result.uval;
 532     return true;
 533 }
 534
 535 bool
 536 ExprResolveLevel(struct xkb_context *ctx, ExprDef *expr,
 537                  unsigned int *level_rtrn)
 538 {
 539     bool ok;
 540     ExprResult result;
 541     static const LookupEntry level_names[] = {
 542         { "level1", 1 },
 543         { "level2", 2 },
 544         { "level3", 3 },
 545         { "level4", 4 },
 546         { "level5", 5 },
 547         { "level6", 6 },
 548         { "level7", 7 },
 549         { "level8", 8 },
 550         { NULL, 0 }
 551     };
 552
 553     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 554                                   level_names);
 555     if (!ok)
 556         return false;
 557
 558     if (result.uval < 1 || result.uval > XkbMaxShiftLevel) {
 559         log_err(ctx, "Shift level %d is out of range (1..%d)\n",
 560                 result.uval, XkbMaxShiftLevel);
 561         return false;
 562     }
 563
 564     *level_rtrn = result.uval;
 565     return true;
 566 }
 567
 568 bool
 569 ExprResolveButton(struct xkb_context *ctx, ExprDef *expr, int *btn_rtrn)
 570 {
 571     bool ok;
 572     ExprResult result;
 573     static const LookupEntry button_names[] = {
 574         { "button1", 1 },
 575         { "button2", 2 },
 576         { "button3", 3 },
 577         { "button4", 4 },
 578         { "button5", 5 },
 579         { "default", 0 },
 580         { NULL, 0 }
 581     };
 582
 583     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 584                                   button_names);
 585     if (ok)
 586         *btn_rtrn = result.ival;
 587     return ok;
 588 }
 589
 590 bool
 591 ExprResolveString(struct xkb_context *ctx, ExprDef *expr,
 592                   const char **val_rtrn)
 593 {
 594     switch (expr->op) {
 595     case EXPR_VALUE:
 596         if (expr->value_type != EXPR_TYPE_STRING) {
 597             log_err(ctx, "Found constant of type %s, expected a string\n",
 598                     exprValueTypeText(expr->value_type));
 599             return false;
 600         }
 601
 602         *val_rtrn = xkb_atom_text(ctx, expr->value.str);
 603         return true;
 604
 605     case EXPR_IDENT:
 606         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 607                 xkb_atom_text(ctx, expr->value.str));
 608         return false;
 609
 610     case EXPR_FIELD_REF:
 611         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
 612                 xkb_atom_text(ctx, expr->value.field.element),
 613                 xkb_atom_text(ctx, expr->value.field.field));
 614         return false;
 615
 616     case EXPR_ADD:
 617     case EXPR_SUBTRACT:
 618     case EXPR_MULTIPLY:
 619     case EXPR_DIVIDE:
 620     case EXPR_ASSIGN:
 621     case EXPR_NEGATE:
 622     case EXPR_INVERT:
 623     case EXPR_NOT:
 624     case EXPR_UNARY_PLUS:
 625         log_err(ctx, "%s of strings not permitted\n", exprOpText(expr->op));
 626         return false;
 627
 628     default:
 629         log_wsgo(ctx, "Unknown operator %d in ResolveString\n", expr->op);
 630         break;
 631     }
 632     return false;
 633 }
 634
 635 bool
 636 ExprResolveKeyName(struct xkb_context *ctx, ExprDef *expr,
 637                    char name[XkbKeyNameLength])
 638 {
 639     switch (expr->op) {
 640     case EXPR_VALUE:
 641         if (expr->value_type != EXPR_TYPE_KEYNAME) {
 642             log_err(ctx, "Found constant of type %s, expected a key name\n",
 643                     exprValueTypeText(expr->value_type));
 644             return false;
 645         }
 646         memcpy(name, expr->value.keyName, XkbKeyNameLength);
 647         return true;
 648
 649     case EXPR_IDENT:
 650         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 651                 xkb_atom_text(ctx, expr->value.str));
 652         return false;
 653
 654     case EXPR_FIELD_REF:
 655         log_err(ctx, "Default \"%s.%s\" of type key name not found\n",
 656                 xkb_atom_text(ctx, expr->value.field.element),
 657                 xkb_atom_text(ctx, expr->value.field.field));
 658         return false;
 659
 660     case EXPR_ADD:
 661     case EXPR_SUBTRACT:
 662     case EXPR_MULTIPLY:
 663     case EXPR_DIVIDE:
 664     case EXPR_ASSIGN:
 665     case EXPR_NEGATE:
 666     case EXPR_INVERT:
 667     case EXPR_NOT:
 668     case EXPR_UNARY_PLUS:
 669         log_err(ctx, "%s of key name values not permitted\n",
 670                 exprOpText(expr->op));
 671         return false;
 672
 673     default:
 674         log_wsgo(ctx, "Unknown operator %d in ResolveKeyName\n", expr->op);
 675         break;
 676     }
 677     return false;
 678 }
 679
 680 bool
 681 ExprResolveEnum(struct xkb_context *ctx, ExprDef *expr,
 682                 unsigned int *val_rtrn, const LookupEntry *values)
 683 {
 684     ExprResult result;
 685
 686     if (expr->op != EXPR_IDENT) {
 687         log_err(ctx, "Found a %s where an enumerated value was expected\n",
 688                 exprOpText(expr->op));
 689         return false;
 690     }
 691
 692     if (!SimpleLookup(ctx, values, expr->value.str, EXPR_TYPE_INT, &result)) {
 693         int nOut = 0;
 694         log_err(ctx, "Illegal identifier %s (expected one of: ",
 695                 xkb_atom_text(ctx, expr->value.str));
 696         while (values && values->name)
 697         {
 698             if (nOut != 0)
 699                 log_info(ctx, ", %s", values->name);
 700             else
 701                 log_info(ctx, "%s", values->name);
 702             values++;
 703             nOut++;
 704         }
 705         log_info(ctx, ")\n");
 706         return false;
 707     }
 708
 709     *val_rtrn = result.uval;
 710     return true;
 711 }
 712
 713 static int
 714 ExprResolveMaskLookup(struct xkb_context *ctx, ExprDef *expr,
 715                       ExprResult *val_rtrn, IdentLookupFunc lookup,
 716                       const void *lookupPriv)
 717 {
 718     int ok = 0;
 719     ExprResult leftRtrn, rightRtrn;
 720     ExprDef *left, *right;
 721     const char *bogus = NULL;
 722
 723     switch (expr->op) {
 724     case EXPR_VALUE:
 725         if (expr->value_type != EXPR_TYPE_INT) {
 726             log_err(ctx,
 727                     "Found constant of type %s where a mask was expected\n",
 728                     exprValueTypeText(expr->value_type));
 729             return false;
 730         }
 731         val_rtrn->ival = expr->value.ival;
 732         return true;
 733
 734     case EXPR_IDENT:
 735         ok = lookup(ctx, lookupPriv, expr->value.str, EXPR_TYPE_INT, val_rtrn);
 736         if (!ok)
 737             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 738                     xkb_atom_text(ctx, expr->value.str));
 739         return ok;
 740
 741     case EXPR_FIELD_REF:
 742         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 743                 xkb_atom_text(ctx, expr->value.field.element),
 744                 xkb_atom_text(ctx, expr->value.field.field));
 745         return false;
 746
 747     case EXPR_ARRAY_REF:
 748         bogus = "array reference";
 749
 750     case EXPR_ACTION_DECL:
 751         if (bogus == NULL)
 752             bogus = "function use";
 753         log_err(ctx,
 754                 "Unexpected %s in mask expression; Expression Ignored\n",
 755                 bogus);
 756         return false;
 757
 758     case EXPR_ADD:
 759     case EXPR_SUBTRACT:
 760     case EXPR_MULTIPLY:
 761     case EXPR_DIVIDE:
 762         left = expr->value.binary.left;
 763         right = expr->value.binary.right;
 764         if (ExprResolveMaskLookup(ctx, left, &leftRtrn, lookup,
 765                                   lookupPriv) &&
 766             ExprResolveMaskLookup(ctx, right, &rightRtrn, lookup,
 767                                   lookupPriv)) {
 768             switch (expr->op) {
 769             case EXPR_ADD:
 770                 val_rtrn->ival = leftRtrn.ival | rightRtrn.ival;
 771                 break;
 772             case EXPR_SUBTRACT:
 773                 val_rtrn->ival = leftRtrn.ival & (~rightRtrn.ival);
 774                 break;
 775             case EXPR_MULTIPLY:
 776             case EXPR_DIVIDE:
 777                 log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
 778                         (expr->op == EXPR_DIVIDE ? "divide" : "multiply"));
 779                 return false;
 780             default:
 781                 break;
 782             }
 783             return true;
 784         }
 785         return false;
 786
 787     case EXPR_ASSIGN:
 788         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 789         break;
 790
 791     case EXPR_INVERT:
 792         left = expr->value.child;
 793         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
 794                                      lookupPriv)) {
 795             val_rtrn->ival = ~leftRtrn.ival;
 796             return true;
 797         }
 798         return false;
 799
 800     case EXPR_UNARY_PLUS:
 801     case EXPR_NEGATE:
 802     case EXPR_NOT:
 803         left = expr->value.child;
 804         if (ExprResolveIntegerLookup(ctx, left, &leftRtrn, lookup,
 805                                      lookupPriv)) {
 806             log_err(ctx, "The %s operator cannot be used with a mask\n",
 807                     (expr->op == EXPR_NEGATE ? "-" : "!"));
 808         }
 809         return false;
 810
 811     default:
 812         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n", expr->op);
 813         break;
 814     }
 815     return false;
 816 }
 817
 818 bool
 819 ExprResolveMask(struct xkb_context *ctx, ExprDef *expr,
 820                 unsigned int *mask_rtrn, const LookupEntry *values)
 821 {
 822     ExprResult result;
 823     bool ok;
 824
 825     ok = ExprResolveMaskLookup(ctx, expr, &result, SimpleLookup, values);
 826     if (ok)
 827         *mask_rtrn = (unsigned int) result.ival;
 828     return ok;
 829 }
 830
 831 bool
 832 ExprResolveModMask(struct xkb_context *ctx, ExprDef *expr,
 833                    xkb_mod_mask_t *mask_rtrn)
 834 {
 835     ExprResult result;
 836     bool ok;
 837
 838     ok = ExprResolveMaskLookup(ctx, expr, &result, LookupModMask, NULL);
 839     if (ok)
 840         *mask_rtrn = (xkb_mod_mask_t) result.ival;
 841     return ok;
 842 }
 843
 844 bool
 845 ExprResolveVModMask(struct xkb_keymap *keymap, ExprDef *expr,
 846                     xkb_mod_mask_t *mask_rtrn)
 847 {
 848     ExprResult result;
 849     bool ok;
 850
 851     ok = ExprResolveMaskLookup(keymap->ctx, expr, &result, LookupVModMask,
 852                                keymap);
 853     if (ok)
 854         *mask_rtrn = (xkb_mod_mask_t) result.ival;
 855     return ok;
 856 }
 857
 858 bool
 859 ExprResolveKeySym(struct xkb_context *ctx, ExprDef *expr,
 860                   xkb_keysym_t *sym_rtrn)
 861 {
 862     int val;
 863
 864     if (expr->op == EXPR_IDENT) {
 865         const char *str;
 866         str = xkb_atom_text(ctx, expr->value.str);
 867         *sym_rtrn = xkb_keysym_from_name(str);
 868         if (*sym_rtrn != XKB_KEY_NoSymbol)
 869             return true;
 870     }
 871
 872     if (!ExprResolveInteger(ctx, expr, &val))
 873         return false;
 874
 875     if (val < 0 || val >= 10)
 876         return false;
 877
 878     *sym_rtrn = ((xkb_keysym_t) val) + '0';
 879     return true;
 880 }