src/xkbcomp/expr.c

   1 /************************************************************
   2  * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this
   5  * software and its documentation for any purpose and without
   6  * fee is hereby granted, provided that the above copyright
   7  * notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting
   9  * documentation, and that the name of Silicon Graphics not be
  10  * used in advertising or publicity pertaining to distribution
  11  * of the software without specific prior written permission.
  12  * Silicon Graphics makes no representation about the suitability
  13  * of this software for any purpose. It is provided "as is"
  14  * without any express or implied warranty.
  15  *
  16  * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  * THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  ********************************************************/
  26
  27 #include "xkbcomp-priv.h"
  28 #include "text.h"
  29 #include "expr.h"
  30
  31 typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
  32                                 xkb_atom_t field, enum expr_value_type type,
  33                                 unsigned int *val_rtrn);
  34
  35 bool
  36 ExprResolveLhs(struct xkb_context *ctx, const ExprDef *expr,
  37                const char **elem_rtrn, const char **field_rtrn,
  38                ExprDef **index_rtrn)
  39 {
  40     switch (expr->expr.op) {
  41     case EXPR_IDENT:
  42         *elem_rtrn = NULL;
  43         *field_rtrn = xkb_atom_text(ctx, expr->ident.ident);
  44         *index_rtrn = NULL;
  45         return true;
  46     case EXPR_FIELD_REF:
  47         *elem_rtrn = xkb_atom_text(ctx, expr->field_ref.element);
  48         *field_rtrn = xkb_atom_text(ctx, expr->field_ref.field);
  49         *index_rtrn = NULL;
  50         return true;
  51     case EXPR_ARRAY_REF:
  52         *elem_rtrn = xkb_atom_text(ctx, expr->array_ref.element);
  53         *field_rtrn = xkb_atom_text(ctx, expr->array_ref.field);
  54         *index_rtrn = expr->array_ref.entry;
  55         return true;
  56     default:
  57         break;
  58     }
  59     log_wsgo(ctx, "Unexpected operator %d in ResolveLhs\n", expr->expr.op);
  60     return false;
  61 }
  62
  63 static bool
  64 SimpleLookup(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
  65              enum expr_value_type type, unsigned int *val_rtrn)
  66 {
  67     const LookupEntry *entry;
  68     const char *str;
  69
  70     if (!priv || field == XKB_ATOM_NONE || type != EXPR_TYPE_INT)
  71         return false;
  72
  73     str = xkb_atom_text(ctx, field);
  74     for (entry = priv; entry && entry->name; entry++) {
  75         if (istreq(str, entry->name)) {
  76             *val_rtrn = entry->value;
  77             return true;
  78         }
  79     }
  80
  81     return false;
  82 }
  83
  84 /* Data passed in the *priv argument for LookupModMask. */
  85 typedef struct {
  86     const struct xkb_keymap *keymap;
  87     enum mod_type mod_type;
  88 } LookupModMaskPriv;
  89
  90 static bool
  91 LookupModMask(struct xkb_context *ctx, const void *priv, xkb_atom_t field,
  92               enum expr_value_type type, xkb_mod_mask_t *val_rtrn)
  93 {
  94     const char *str;
  95     xkb_mod_index_t ndx;
  96     const LookupModMaskPriv *arg = priv;
  97     const struct xkb_keymap *keymap = arg->keymap;
  98     enum mod_type mod_type = arg->mod_type;
  99
 100     if (type != EXPR_TYPE_INT)
 101         return false;
 102
 103     str = xkb_atom_text(ctx, field);
 104
 105     if (istreq(str, "all")) {
 106         *val_rtrn  = MOD_REAL_MASK_ALL;
 107         return true;
 108     }
 109
 110     if (istreq(str, "none")) {
 111         *val_rtrn = 0;
 112         return true;
 113     }
 114
 115     ndx = ModNameToIndex(keymap, field, mod_type);
 116     if (ndx == XKB_MOD_INVALID)
 117         return false;
 118
 119     *val_rtrn = (1u << ndx);
 120     return true;
 121 }
 122
 123 bool
 124 ExprResolveBoolean(struct xkb_context *ctx, const ExprDef *expr,
 125                    bool *set_rtrn)
 126 {
 127     bool ok = false;
 128     const char *ident;
 129
 130     switch (expr->expr.op) {
 131     case EXPR_VALUE:
 132         if (expr->expr.value_type != EXPR_TYPE_BOOLEAN) {
 133             log_err(ctx,
 134                     "Found constant of type %s where boolean was expected\n",
 135                     expr_value_type_to_string(expr->expr.value_type));
 136             return false;
 137         }
 138         *set_rtrn = expr->boolean.set;
 139         return true;
 140
 141     case EXPR_IDENT:
 142         ident = xkb_atom_text(ctx, expr->ident.ident);
 143         if (ident) {
 144             if (istreq(ident, "true") ||
 145                 istreq(ident, "yes") ||
 146                 istreq(ident, "on")) {
 147                 *set_rtrn = true;
 148                 return true;
 149             }
 150             else if (istreq(ident, "false") ||
 151                      istreq(ident, "no") ||
 152                      istreq(ident, "off")) {
 153                 *set_rtrn = false;
 154                 return true;
 155             }
 156         }
 157         log_err(ctx, "Identifier \"%s\" of type boolean is unknown\n", ident);
 158         return false;
 159
 160     case EXPR_FIELD_REF:
 161         log_err(ctx, "Default \"%s.%s\" of type boolean is unknown\n",
 162                 xkb_atom_text(ctx, expr->field_ref.element),
 163                 xkb_atom_text(ctx, expr->field_ref.field));
 164         return false;
 165
 166     case EXPR_INVERT:
 167     case EXPR_NOT:
 168         ok = ExprResolveBoolean(ctx, expr, set_rtrn);
 169         if (ok)
 170             *set_rtrn = !*set_rtrn;
 171         return ok;
 172     case EXPR_ADD:
 173     case EXPR_SUBTRACT:
 174     case EXPR_MULTIPLY:
 175     case EXPR_DIVIDE:
 176     case EXPR_ASSIGN:
 177     case EXPR_NEGATE:
 178     case EXPR_UNARY_PLUS:
 179         log_err(ctx, "%s of boolean values not permitted\n",
 180                 expr_op_type_to_string(expr->expr.op));
 181         break;
 182
 183     default:
 184         log_wsgo(ctx, "Unknown operator %d in ResolveBoolean\n",
 185                  expr->expr.op);
 186         break;
 187     }
 188
 189     return false;
 190 }
 191
 192 bool
 193 ExprResolveKeyCode(struct xkb_context *ctx, const ExprDef *expr,
 194                    xkb_keycode_t *kc)
 195 {
 196     xkb_keycode_t leftRtrn, rightRtrn;
 197
 198     switch (expr->expr.op) {
 199     case EXPR_VALUE:
 200         if (expr->expr.value_type != EXPR_TYPE_INT) {
 201             log_err(ctx,
 202                     "Found constant of type %s where an int was expected\n",
 203                     expr_value_type_to_string(expr->expr.value_type));
 204             return false;
 205         }
 206
 207         *kc = (xkb_keycode_t) expr->integer.ival;
 208         return true;
 209
 210     case EXPR_ADD:
 211     case EXPR_SUBTRACT:
 212     case EXPR_MULTIPLY:
 213     case EXPR_DIVIDE:
 214         if (!ExprResolveKeyCode(ctx, expr->binary.left, &leftRtrn) ||
 215             !ExprResolveKeyCode(ctx, expr->binary.right, &rightRtrn))
 216             return false;
 217
 218         switch (expr->expr.op) {
 219         case EXPR_ADD:
 220             *kc = leftRtrn + rightRtrn;
 221             break;
 222         case EXPR_SUBTRACT:
 223             *kc = leftRtrn - rightRtrn;
 224             break;
 225         case EXPR_MULTIPLY:
 226             *kc = leftRtrn * rightRtrn;
 227             break;
 228         case EXPR_DIVIDE:
 229             if (rightRtrn == 0) {
 230                 log_err(ctx, "Cannot divide by zero: %d / %d\n",
 231                         leftRtrn, rightRtrn);
 232                 return false;
 233             }
 234
 235             *kc = leftRtrn / rightRtrn;
 236             break;
 237         default:
 238             break;
 239         }
 240
 241         return true;
 242
 243     case EXPR_NEGATE:
 244         if (!ExprResolveKeyCode(ctx, expr->unary.child, &leftRtrn))
 245             return false;
 246
 247         *kc = ~leftRtrn;
 248         return true;
 249
 250     case EXPR_UNARY_PLUS:
 251         return ExprResolveKeyCode(ctx, expr->unary.child, kc);
 252
 253     default:
 254         log_wsgo(ctx, "Unknown operator %d in ResolveKeyCode\n",
 255                  expr->expr.op);
 256         break;
 257     }
 258
 259     return false;
 260 }
 261
 262 /**
 263  * This function returns ... something.  It's a bit of a guess, really.
 264  *
 265  * If an integer is given in value ctx, it will be returned in ival.
 266  * If an ident or field reference is given, the lookup function (if given)
 267  * will be called.  At the moment, only SimpleLookup use this, and they both
 268  * return the results in uval.  And don't support field references.
 269  *
 270  * Cool.
 271  */
 272 static bool
 273 ExprResolveIntegerLookup(struct xkb_context *ctx, const ExprDef *expr,
 274                          int *val_rtrn, IdentLookupFunc lookup,
 275                          const void *lookupPriv)
 276 {
 277     bool ok = false;
 278     int l, r;
 279     unsigned u;
 280     ExprDef *left, *right;
 281
 282     switch (expr->expr.op) {
 283     case EXPR_VALUE:
 284         if (expr->expr.value_type != EXPR_TYPE_INT) {
 285             log_err(ctx,
 286                     "Found constant of type %s where an int was expected\n",
 287                     expr_value_type_to_string(expr->expr.value_type));
 288             return false;
 289         }
 290
 291         *val_rtrn = expr->integer.ival;
 292         return true;
 293
 294     case EXPR_IDENT:
 295         if (lookup)
 296             ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT, &u);
 297
 298         if (!ok)
 299             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 300                     xkb_atom_text(ctx, expr->ident.ident));
 301         else
 302             *val_rtrn = (int) u;
 303
 304         return ok;
 305
 306     case EXPR_FIELD_REF:
 307         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 308                 xkb_atom_text(ctx, expr->field_ref.element),
 309                 xkb_atom_text(ctx, expr->field_ref.field));
 310         return false;
 311
 312     case EXPR_ADD:
 313     case EXPR_SUBTRACT:
 314     case EXPR_MULTIPLY:
 315     case EXPR_DIVIDE:
 316         left = expr->binary.left;
 317         right = expr->binary.right;
 318         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv) ||
 319             !ExprResolveIntegerLookup(ctx, right, &r, lookup, lookupPriv))
 320             return false;
 321
 322         switch (expr->expr.op) {
 323         case EXPR_ADD:
 324             *val_rtrn = l + r;
 325             break;
 326         case EXPR_SUBTRACT:
 327             *val_rtrn = l - r;
 328             break;
 329         case EXPR_MULTIPLY:
 330             *val_rtrn = l * r;
 331             break;
 332         case EXPR_DIVIDE:
 333             if (r == 0) {
 334                 log_err(ctx, "Cannot divide by zero: %d / %d\n", l, r);
 335                 return false;
 336             }
 337             *val_rtrn = l / r;
 338             break;
 339         default:
 340             log_err(ctx, "%s of integers not permitted\n",
 341                     expr_op_type_to_string(expr->expr.op));
 342             return false;
 343         }
 344
 345         return true;
 346
 347     case EXPR_ASSIGN:
 348         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 349         break;
 350
 351     case EXPR_NOT:
 352         log_err(ctx, "The ! operator cannot be applied to an integer\n");
 353         return false;
 354
 355     case EXPR_INVERT:
 356     case EXPR_NEGATE:
 357         left = expr->unary.child;
 358         if (!ExprResolveIntegerLookup(ctx, left, &l, lookup, lookupPriv))
 359             return false;
 360
 361         *val_rtrn = (expr->expr.op == EXPR_NEGATE ? -l : ~l);
 362         return true;
 363
 364     case EXPR_UNARY_PLUS:
 365         left = expr->unary.child;
 366         return ExprResolveIntegerLookup(ctx, left, val_rtrn, lookup,
 367                                         lookupPriv);
 368
 369     default:
 370         log_wsgo(ctx, "Unknown operator %d in ResolveInteger\n",
 371                  expr->expr.op);
 372         break;
 373     }
 374
 375     return false;
 376 }
 377
 378 bool
 379 ExprResolveInteger(struct xkb_context *ctx, const ExprDef *expr,
 380                    int *val_rtrn)
 381 {
 382     return ExprResolveIntegerLookup(ctx, expr, val_rtrn, NULL, NULL);
 383 }
 384
 385 bool
 386 ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
 387                  xkb_layout_index_t *group_rtrn)
 388 {
 389     bool ok;
 390     int result;
 391
 392     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 393                                   groupNames);
 394     if (!ok)
 395         return false;
 396
 397     if (result <= 0 || result > XKB_MAX_GROUPS) {
 398         log_err(ctx, "Group index %u is out of range (1..%d)\n",
 399                 result, XKB_MAX_GROUPS);
 400         return false;
 401     }
 402
 403     *group_rtrn = (xkb_layout_index_t) result;
 404     return true;
 405 }
 406
 407 bool
 408 ExprResolveLevel(struct xkb_context *ctx, const ExprDef *expr,
 409                  xkb_level_index_t *level_rtrn)
 410 {
 411     bool ok;
 412     int result;
 413
 414     ok = ExprResolveIntegerLookup(ctx, expr, &result, SimpleLookup,
 415                                   levelNames);
 416     if (!ok)
 417         return false;
 418
 419     if (result < 1) {
 420         log_err(ctx, "Shift level %d is out of range\n", result);
 421         return false;
 422     }
 423
 424     /* Level is zero-indexed from now on. */
 425     *level_rtrn = (unsigned int) (result - 1);
 426     return true;
 427 }
 428
 429 bool
 430 ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr, int *btn_rtrn)
 431 {
 432     return ExprResolveIntegerLookup(ctx, expr, btn_rtrn, SimpleLookup,
 433                                     buttonNames);
 434 }
 435
 436 bool
 437 ExprResolveString(struct xkb_context *ctx, const ExprDef *expr,
 438                   xkb_atom_t *val_rtrn)
 439 {
 440     switch (expr->expr.op) {
 441     case EXPR_VALUE:
 442         if (expr->expr.value_type != EXPR_TYPE_STRING) {
 443             log_err(ctx, "Found constant of type %s, expected a string\n",
 444                     expr_value_type_to_string(expr->expr.value_type));
 445             return false;
 446         }
 447
 448         *val_rtrn = expr->string.str;
 449         return true;
 450
 451     case EXPR_IDENT:
 452         log_err(ctx, "Identifier \"%s\" of type string not found\n",
 453                 xkb_atom_text(ctx, expr->ident.ident));
 454         return false;
 455
 456     case EXPR_FIELD_REF:
 457         log_err(ctx, "Default \"%s.%s\" of type string not found\n",
 458                 xkb_atom_text(ctx, expr->field_ref.element),
 459                 xkb_atom_text(ctx, expr->field_ref.field));
 460         return false;
 461
 462     case EXPR_ADD:
 463     case EXPR_SUBTRACT:
 464     case EXPR_MULTIPLY:
 465     case EXPR_DIVIDE:
 466     case EXPR_ASSIGN:
 467     case EXPR_NEGATE:
 468     case EXPR_INVERT:
 469     case EXPR_NOT:
 470     case EXPR_UNARY_PLUS:
 471         log_err(ctx, "%s of strings not permitted\n",
 472                 expr_op_type_to_string(expr->expr.op));
 473         return false;
 474
 475     default:
 476         log_wsgo(ctx, "Unknown operator %d in ResolveString\n",
 477                  expr->expr.op);
 478         break;
 479     }
 480     return false;
 481 }
 482
 483 bool
 484 ExprResolveEnum(struct xkb_context *ctx, const ExprDef *expr,
 485                 unsigned int *val_rtrn, const LookupEntry *values)
 486 {
 487     if (expr->expr.op != EXPR_IDENT) {
 488         log_err(ctx, "Found a %s where an enumerated value was expected\n",
 489                 expr_op_type_to_string(expr->expr.op));
 490         return false;
 491     }
 492
 493     if (!SimpleLookup(ctx, values, expr->ident.ident, EXPR_TYPE_INT,
 494                       val_rtrn)) {
 495         log_err(ctx, "Illegal identifier %s; expected one of:\n",
 496                 xkb_atom_text(ctx, expr->ident.ident));
 497         while (values && values->name)
 498         {
 499             log_err(ctx, "\t%s\n", values->name);
 500             values++;
 501         }
 502         return false;
 503     }
 504
 505     return true;
 506 }
 507
 508 static bool
 509 ExprResolveMaskLookup(struct xkb_context *ctx, const ExprDef *expr,
 510                       unsigned int *val_rtrn, IdentLookupFunc lookup,
 511                       const void *lookupPriv)
 512 {
 513     bool ok = 0;
 514     unsigned int l, r;
 515     int v;
 516     ExprDef *left, *right;
 517     const char *bogus = NULL;
 518
 519     switch (expr->expr.op) {
 520     case EXPR_VALUE:
 521         if (expr->expr.value_type != EXPR_TYPE_INT) {
 522             log_err(ctx,
 523                     "Found constant of type %s where a mask was expected\n",
 524                     expr_value_type_to_string(expr->expr.value_type));
 525             return false;
 526         }
 527         *val_rtrn = (unsigned int) expr->integer.ival;
 528         return true;
 529
 530     case EXPR_IDENT:
 531         ok = lookup(ctx, lookupPriv, expr->ident.ident, EXPR_TYPE_INT,
 532                     val_rtrn);
 533         if (!ok)
 534             log_err(ctx, "Identifier \"%s\" of type int is unknown\n",
 535                     xkb_atom_text(ctx, expr->ident.ident));
 536         return ok;
 537
 538     case EXPR_FIELD_REF:
 539         log_err(ctx, "Default \"%s.%s\" of type int is unknown\n",
 540                 xkb_atom_text(ctx, expr->field_ref.element),
 541                 xkb_atom_text(ctx, expr->field_ref.field));
 542         return false;
 543
 544     case EXPR_ARRAY_REF:
 545         bogus = "array reference";
 546
 547     case EXPR_ACTION_DECL:
 548         if (bogus == NULL)
 549             bogus = "function use";
 550         log_err(ctx,
 551                 "Unexpected %s in mask expression; Expression Ignored\n",
 552                 bogus);
 553         return false;
 554
 555     case EXPR_ADD:
 556     case EXPR_SUBTRACT:
 557     case EXPR_MULTIPLY:
 558     case EXPR_DIVIDE:
 559         left = expr->binary.left;
 560         right = expr->binary.right;
 561         if (!ExprResolveMaskLookup(ctx, left, &l, lookup, lookupPriv) ||
 562             !ExprResolveMaskLookup(ctx, right, &r, lookup, lookupPriv))
 563             return false;
 564
 565         switch (expr->expr.op) {
 566         case EXPR_ADD:
 567             *val_rtrn = l | r;
 568             break;
 569         case EXPR_SUBTRACT:
 570             *val_rtrn = l & (~r);
 571             break;
 572         case EXPR_MULTIPLY:
 573         case EXPR_DIVIDE:
 574             log_err(ctx, "Cannot %s masks; Illegal operation ignored\n",
 575                     (expr->expr.op == EXPR_DIVIDE ? "divide" : "multiply"));
 576             return false;
 577         default:
 578             break;
 579         }
 580
 581         return true;
 582
 583     case EXPR_ASSIGN:
 584         log_wsgo(ctx, "Assignment operator not implemented yet\n");
 585         break;
 586
 587     case EXPR_INVERT:
 588         left = expr->unary.child;
 589         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 590             return false;
 591
 592         *val_rtrn = ~v;
 593         return true;
 594
 595     case EXPR_UNARY_PLUS:
 596     case EXPR_NEGATE:
 597     case EXPR_NOT:
 598         left = expr->unary.child;
 599         if (!ExprResolveIntegerLookup(ctx, left, &v, lookup, lookupPriv))
 600             log_err(ctx, "The %s operator cannot be used with a mask\n",
 601                     (expr->expr.op == EXPR_NEGATE ? "-" : "!"));
 602         return false;
 603
 604     default:
 605         log_wsgo(ctx, "Unknown operator %d in ResolveMask\n",
 606                  expr->expr.op);
 607         break;
 608     }
 609
 610     return false;
 611 }
 612
 613 bool
 614 ExprResolveMask(struct xkb_context *ctx, const ExprDef *expr,
 615                 unsigned int *mask_rtrn, const LookupEntry *values)
 616 {
 617     return ExprResolveMaskLookup(ctx, expr, mask_rtrn, SimpleLookup, values);
 618 }
 619
 620 bool
 621 ExprResolveModMask(struct xkb_keymap *keymap, const ExprDef *expr,
 622                    enum mod_type mod_type, xkb_mod_mask_t *mask_rtrn)
 623 {
 624     LookupModMaskPriv priv = { .keymap = keymap, .mod_type = mod_type };
 625     return ExprResolveMaskLookup(keymap->ctx, expr, mask_rtrn, LookupModMask,
 626                                  &priv);
 627 }
 628
 629 bool
 630 ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
 631                   xkb_keysym_t *sym_rtrn)
 632 {
 633     int val;
 634
 635     if (expr->expr.op == EXPR_IDENT) {
 636         const char *str = xkb_atom_text(ctx, expr->ident.ident);
 637         *sym_rtrn = xkb_keysym_from_name(str, 0);
 638         if (*sym_rtrn != XKB_KEY_NoSymbol)
 639             return true;
 640     }
 641
 642     if (!ExprResolveInteger(ctx, expr, &val))
 643         return false;
 644
 645     if (val < 0 || val >= 10)
 646         return false;
 647
 648     *sym_rtrn = XKB_KEY_0 + (xkb_keysym_t) val;
 649     return true;
 650 }
 651
 652 bool
 653 ExprResolveMod(struct xkb_keymap *keymap, const ExprDef *def,
 654                enum mod_type mod_type, xkb_mod_index_t *ndx_rtrn)
 655 {
 656     xkb_mod_index_t ndx;
 657     xkb_atom_t name;
 658
 659     if (def->expr.op != EXPR_IDENT) {
 660         log_err(keymap->ctx,
 661                 "Cannot resolve virtual modifier: "
 662                 "found %s where a virtual modifier name was expected\n",
 663                 expr_op_type_to_string(def->expr.op));
 664         return false;
 665     }
 666
 667     name = def->ident.ident;
 668     ndx = ModNameToIndex(keymap, name, mod_type);
 669     if (ndx == XKB_MOD_INVALID) {
 670         log_err(keymap->ctx,
 671                 "Cannot resolve virtual modifier: "
 672                 "\"%s\" was not previously declared\n",
 673                 xkb_atom_text(keymap->ctx, name));
 674         return false;
 675     }
 676
 677     *ndx_rtrn = ndx;
 678     return true;
 679 }