src/xkbcomp/compat.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 /*
  28  * Copyright © 2012 Ran Benita <ran234@gmail.com>
  29  *
  30  * Permission is hereby granted, free of charge, to any person obtaining a
  31  * copy of this software and associated documentation files (the "Software"),
  32  * to deal in the Software without restriction, including without limitation
  33  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  34  * and/or sell copies of the Software, and to permit persons to whom the
  35  * Software is furnished to do so, subject to the following conditions:
  36  *
  37  * The above copyright notice and this permission notice (including the next
  38  * paragraph) shall be included in all copies or substantial portions of the
  39  * Software.
  40  *
  41  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  42  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  43  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  44  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  45  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  46  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  47  * DEALINGS IN THE SOFTWARE.
  48  */
  49
  50 #include "xkbcomp-priv.h"
  51 #include "text.h"
  52 #include "expr.h"
  53 #include "action.h"
  54 #include "vmod.h"
  55 #include "include.h"
  56
  57 enum si_field {
  58     SI_FIELD_VIRTUAL_MOD    = (1 << 0),
  59     SI_FIELD_ACTION         = (1 << 1),
  60     SI_FIELD_AUTO_REPEAT    = (1 << 2),
  61     SI_FIELD_LEVEL_ONE_ONLY = (1 << 3),
  62 };
  63
  64 typedef struct {
  65     enum si_field defined;
  66     enum merge_mode merge;
  67
  68     struct xkb_sym_interpret interp;
  69 } SymInterpInfo;
  70
  71 enum led_field {
  72     LED_FIELD_MODS       = (1 << 0),
  73     LED_FIELD_GROUPS     = (1 << 1),
  74     LED_FIELD_CTRLS      = (1 << 2),
  75 };
  76
  77 typedef struct {
  78     enum led_field defined;
  79     enum merge_mode merge;
  80
  81     struct xkb_led led;
  82 } LedInfo;
  83
  84 typedef struct {
  85     char *name;
  86     int errorCount;
  87     SymInterpInfo default_interp;
  88     darray(SymInterpInfo) interps;
  89     LedInfo default_led;
  90     darray(LedInfo) leds;
  91     ActionsInfo *actions;
  92     struct xkb_keymap *keymap;
  93 } CompatInfo;
  94
  95 static const char *
  96 siText(SymInterpInfo *si, CompatInfo *info)
  97 {
  98     char *buf = xkb_context_get_buffer(info->keymap->ctx, 128);
  99
 100     if (si == &info->default_interp)
 101         return "default";
 102
 103     snprintf(buf, 128, "%s+%s(%s)",
 104              KeysymText(info->keymap->ctx, si->interp.sym),
 105              SIMatchText(si->interp.match),
 106              ModMaskText(info->keymap, si->interp.mods));
 107
 108     return buf;
 109 }
 110
 111 static inline bool
 112 ReportSINotArray(CompatInfo *info, SymInterpInfo *si, const char *field)
 113 {
 114     return ReportNotArray(info->keymap->ctx, "symbol interpretation", field,
 115                           siText(si, info));
 116 }
 117
 118 static inline bool
 119 ReportSIBadType(CompatInfo *info, SymInterpInfo *si, const char *field,
 120                 const char *wanted)
 121 {
 122     return ReportBadType(info->keymap->ctx, "symbol interpretation", field,
 123                          siText(si, info), wanted);
 124 }
 125
 126 static inline bool
 127 ReportLedBadType(CompatInfo *info, LedInfo *ledi, const char *field,
 128                  const char *wanted)
 129 {
 130     return ReportBadType(info->keymap->ctx, "indicator map", field,
 131                          xkb_atom_text(info->keymap->ctx, ledi->led.name),
 132                          wanted);
 133 }
 134
 135 static inline bool
 136 ReportLedNotArray(CompatInfo *info, LedInfo *ledi, const char *field)
 137 {
 138     return ReportNotArray(info->keymap->ctx, "indicator map", field,
 139                           xkb_atom_text(info->keymap->ctx, ledi->led.name));
 140 }
 141
 142 static void
 143 InitCompatInfo(CompatInfo *info, struct xkb_keymap *keymap,
 144                ActionsInfo *actions)
 145 {
 146     memset(info, 0, sizeof(*info));
 147     info->keymap = keymap;
 148     info->actions = actions;
 149     info->default_interp.merge = MERGE_OVERRIDE;
 150     info->default_interp.interp.virtual_mod = XKB_MOD_INVALID;
 151     info->default_led.merge = MERGE_OVERRIDE;
 152 }
 153
 154 static void
 155 ClearCompatInfo(CompatInfo *info)
 156 {
 157     free(info->name);
 158     darray_free(info->interps);
 159     darray_free(info->leds);
 160 }
 161
 162 static SymInterpInfo *
 163 FindMatchingInterp(CompatInfo *info, SymInterpInfo *new)
 164 {
 165     SymInterpInfo *old;
 166
 167     darray_foreach(old, info->interps)
 168         if (old->interp.sym == new->interp.sym &&
 169             old->interp.mods == new->interp.mods &&
 170             old->interp.match == new->interp.match)
 171             return old;
 172
 173     return NULL;
 174 }
 175
 176 static bool
 177 UseNewInterpField(enum si_field field, SymInterpInfo *old, SymInterpInfo *new,
 178                   bool report, enum si_field *collide)
 179 {
 180     if (!(old->defined & field))
 181         return true;
 182
 183     if (new->defined & field) {
 184         if (report)
 185             *collide |= field;
 186
 187         if (new->merge != MERGE_AUGMENT)
 188             return true;
 189     }
 190
 191     return false;
 192 }
 193
 194 static bool
 195 AddInterp(CompatInfo *info, SymInterpInfo *new, bool same_file)
 196 {
 197     SymInterpInfo *old = FindMatchingInterp(info, new);
 198     if (old) {
 199         const int verbosity = xkb_context_get_log_verbosity(info->keymap->ctx);
 200         const bool report = (same_file && verbosity > 0) || verbosity > 9;
 201         enum si_field collide = 0;
 202
 203         if (new->merge == MERGE_REPLACE) {
 204             if (report)
 205                 log_warn(info->keymap->ctx,
 206                          "Multiple definitions for \"%s\"; "
 207                          "Earlier interpretation ignored\n",
 208                          siText(new, info));
 209             *old = *new;
 210             return true;
 211         }
 212
 213         if (UseNewInterpField(SI_FIELD_VIRTUAL_MOD, old, new, report,
 214                               &collide)) {
 215             old->interp.virtual_mod = new->interp.virtual_mod;
 216             old->defined |= SI_FIELD_VIRTUAL_MOD;
 217         }
 218         if (UseNewInterpField(SI_FIELD_ACTION, old, new, report,
 219                               &collide)) {
 220             old->interp.action = new->interp.action;
 221             old->defined |= SI_FIELD_ACTION;
 222         }
 223         if (UseNewInterpField(SI_FIELD_AUTO_REPEAT, old, new, report,
 224                               &collide)) {
 225             old->interp.repeat = new->interp.repeat;
 226             old->defined |= SI_FIELD_AUTO_REPEAT;
 227         }
 228         if (UseNewInterpField(SI_FIELD_LEVEL_ONE_ONLY, old, new, report,
 229                               &collide)) {
 230             old->interp.level_one_only = new->interp.level_one_only;
 231             old->defined |= SI_FIELD_LEVEL_ONE_ONLY;
 232         }
 233
 234         if (collide) {
 235             log_warn(info->keymap->ctx,
 236                      "Multiple interpretations of \"%s\"; "
 237                      "Using %s definition for duplicate fields\n",
 238                      siText(new, info),
 239                      (new->merge != MERGE_AUGMENT ? "last" : "first"));
 240         }
 241
 242         return true;
 243     }
 244
 245     darray_append(info->interps, *new);
 246     return true;
 247 }
 248
 249 /***====================================================================***/
 250
 251 static bool
 252 ResolveStateAndPredicate(ExprDef *expr, enum xkb_match_operation *pred_rtrn,
 253                          xkb_mod_mask_t *mods_rtrn, CompatInfo *info)
 254 {
 255     if (expr == NULL) {
 256         *pred_rtrn = MATCH_ANY_OR_NONE;
 257         *mods_rtrn = MOD_REAL_MASK_ALL;
 258         return true;
 259     }
 260
 261     *pred_rtrn = MATCH_EXACTLY;
 262     if (expr->expr.op == EXPR_ACTION_DECL) {
 263         const char *pred_txt = xkb_atom_text(info->keymap->ctx,
 264                                              expr->action.name);
 265         if (!LookupString(symInterpretMatchMaskNames, pred_txt, pred_rtrn)) {
 266             log_err(info->keymap->ctx,
 267                     "Illegal modifier predicate \"%s\"; Ignored\n", pred_txt);
 268             return false;
 269         }
 270         expr = expr->action.args;
 271     }
 272     else if (expr->expr.op == EXPR_IDENT) {
 273         const char *pred_txt = xkb_atom_text(info->keymap->ctx,
 274                                              expr->ident.ident);
 275         if (pred_txt && istreq(pred_txt, "any")) {
 276             *pred_rtrn = MATCH_ANY;
 277             *mods_rtrn = MOD_REAL_MASK_ALL;
 278             return true;
 279         }
 280     }
 281
 282     return ExprResolveModMask(info->keymap, expr, MOD_REAL, mods_rtrn);
 283 }
 284
 285 /***====================================================================***/
 286
 287 static bool
 288 UseNewLEDField(enum led_field field, LedInfo *old, LedInfo *new,
 289                bool report, enum led_field *collide)
 290 {
 291     if (!(old->defined & field))
 292         return true;
 293
 294     if (new->defined & field) {
 295         if (report)
 296             *collide |= field;
 297
 298         if (new->merge != MERGE_AUGMENT)
 299             return true;
 300     }
 301
 302     return false;
 303 }
 304
 305 static bool
 306 AddLedMap(CompatInfo *info, LedInfo *new, bool same_file)
 307 {
 308     LedInfo *old;
 309     enum led_field collide;
 310     struct xkb_context *ctx = info->keymap->ctx;
 311     const int verbosity = xkb_context_get_log_verbosity(ctx);
 312     const bool report = (same_file && verbosity > 0) || verbosity > 9;
 313
 314     darray_foreach(old, info->leds) {
 315         if (old->led.name != new->led.name)
 316             continue;
 317
 318         if (old->led.mods.mods == new->led.mods.mods &&
 319             old->led.groups == new->led.groups &&
 320             old->led.ctrls == new->led.ctrls &&
 321             old->led.which_mods == new->led.which_mods &&
 322             old->led.which_groups == new->led.which_groups) {
 323             old->defined |= new->defined;
 324             return true;
 325         }
 326
 327         if (new->merge == MERGE_REPLACE) {
 328             if (report)
 329                 log_warn(info->keymap->ctx,
 330                          "Map for indicator %s redefined; "
 331                          "Earlier definition ignored\n",
 332                          xkb_atom_text(ctx, old->led.name));
 333             *old = *new;
 334             return true;
 335         }
 336
 337         collide = 0;
 338         if (UseNewLEDField(LED_FIELD_MODS, old, new, report, &collide)) {
 339             old->led.which_mods = new->led.which_mods;
 340             old->led.mods = new->led.mods;
 341             old->defined |= LED_FIELD_MODS;
 342         }
 343         if (UseNewLEDField(LED_FIELD_GROUPS, old, new, report, &collide)) {
 344             old->led.which_groups = new->led.which_groups;
 345             old->led.groups = new->led.groups;
 346             old->defined |= LED_FIELD_GROUPS;
 347         }
 348         if (UseNewLEDField(LED_FIELD_CTRLS, old, new, report, &collide)) {
 349             old->led.ctrls = new->led.ctrls;
 350             old->defined |= LED_FIELD_CTRLS;
 351         }
 352
 353         if (collide) {
 354             log_warn(info->keymap->ctx,
 355                      "Map for indicator %s redefined; "
 356                      "Using %s definition for duplicate fields\n",
 357                      xkb_atom_text(ctx, old->led.name),
 358                      (new->merge == MERGE_AUGMENT ? "first" : "last"));
 359         }
 360
 361         return true;
 362     }
 363
 364     darray_append(info->leds, *new);
 365     return true;
 366 }
 367
 368 static void
 369 MergeIncludedCompatMaps(CompatInfo *into, CompatInfo *from,
 370                         enum merge_mode merge)
 371 {
 372     SymInterpInfo *si;
 373     LedInfo *ledi;
 374
 375     if (from->errorCount > 0) {
 376         into->errorCount += from->errorCount;
 377         return;
 378     }
 379
 380     if (into->name == NULL) {
 381         into->name = from->name;
 382         from->name = NULL;
 383     }
 384
 385     darray_foreach(si, from->interps) {
 386         si->merge = (merge == MERGE_DEFAULT ? si->merge : merge);
 387         if (!AddInterp(into, si, false))
 388             into->errorCount++;
 389     }
 390
 391     darray_foreach(ledi, from->leds) {
 392         ledi->merge = (merge == MERGE_DEFAULT ? ledi->merge : merge);
 393         if (!AddLedMap(into, ledi, false))
 394             into->errorCount++;
 395     }
 396 }
 397
 398 static void
 399 HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge);
 400
 401 static bool
 402 HandleIncludeCompatMap(CompatInfo *info, IncludeStmt *include)
 403 {
 404     CompatInfo included;
 405
 406     InitCompatInfo(&included, info->keymap, info->actions);
 407     included.name = include->stmt;
 408     include->stmt = NULL;
 409
 410     for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) {
 411         CompatInfo next_incl;
 412         XkbFile *file;
 413
 414         file = ProcessIncludeFile(info->keymap->ctx, stmt, FILE_TYPE_COMPAT);
 415         if (!file) {
 416             info->errorCount += 10;
 417             ClearCompatInfo(&included);
 418             return false;
 419         }
 420
 421         InitCompatInfo(&next_incl, info->keymap, info->actions);
 422         next_incl.default_interp = info->default_interp;
 423         next_incl.default_interp.merge = stmt->merge;
 424         next_incl.default_led = info->default_led;
 425         next_incl.default_led.merge = stmt->merge;
 426
 427         HandleCompatMapFile(&next_incl, file, MERGE_OVERRIDE);
 428
 429         MergeIncludedCompatMaps(&included, &next_incl, stmt->merge);
 430
 431         ClearCompatInfo(&next_incl);
 432         FreeXkbFile(file);
 433     }
 434
 435     MergeIncludedCompatMaps(info, &included, include->merge);
 436     ClearCompatInfo(&included);
 437
 438     return (info->errorCount == 0);
 439 }
 440
 441 static bool
 442 SetInterpField(CompatInfo *info, SymInterpInfo *si, const char *field,
 443                ExprDef *arrayNdx, ExprDef *value)
 444 {
 445     struct xkb_keymap *keymap = info->keymap;
 446     xkb_mod_index_t ndx;
 447
 448     if (istreq(field, "action")) {
 449         if (arrayNdx)
 450             return ReportSINotArray(info, si, field);
 451
 452         if (!HandleActionDef(value, keymap, &si->interp.action, info->actions))
 453             return false;
 454
 455         si->defined |= SI_FIELD_ACTION;
 456     }
 457     else if (istreq(field, "virtualmodifier") ||
 458              istreq(field, "virtualmod")) {
 459         if (arrayNdx)
 460             return ReportSINotArray(info, si, field);
 461
 462         if (!ExprResolveMod(keymap, value, MOD_VIRT, &ndx))
 463             return ReportSIBadType(info, si, field, "virtual modifier");
 464
 465         si->interp.virtual_mod = ndx;
 466         si->defined |= SI_FIELD_VIRTUAL_MOD;
 467     }
 468     else if (istreq(field, "repeat")) {
 469         bool set;
 470
 471         if (arrayNdx)
 472             return ReportSINotArray(info, si, field);
 473
 474         if (!ExprResolveBoolean(keymap->ctx, value, &set))
 475             return ReportSIBadType(info, si, field, "boolean");
 476
 477         si->interp.repeat = set;
 478
 479         si->defined |= SI_FIELD_AUTO_REPEAT;
 480     }
 481     else if (istreq(field, "locking")) {
 482         log_dbg(info->keymap->ctx,
 483                 "The \"locking\" field in symbol interpretation is unsupported; "
 484                 "Ignored\n");
 485     }
 486     else if (istreq(field, "usemodmap") ||
 487              istreq(field, "usemodmapmods")) {
 488         unsigned int val;
 489
 490         if (arrayNdx)
 491             return ReportSINotArray(info, si, field);
 492
 493         if (!ExprResolveEnum(keymap->ctx, value, &val, useModMapValueNames))
 494             return ReportSIBadType(info, si, field, "level specification");
 495
 496         si->interp.level_one_only = !!val;
 497         si->defined |= SI_FIELD_LEVEL_ONE_ONLY;
 498     }
 499     else {
 500         return ReportBadField(keymap->ctx, "symbol interpretation", field,
 501                               siText(si, info));
 502     }
 503
 504     return true;
 505 }
 506
 507 static bool
 508 SetLedMapField(CompatInfo *info, LedInfo *ledi, const char *field,
 509                ExprDef *arrayNdx, ExprDef *value)
 510 {
 511     bool ok = true;
 512     struct xkb_keymap *keymap = info->keymap;
 513
 514     if (istreq(field, "modifiers") || istreq(field, "mods")) {
 515         if (arrayNdx)
 516             return ReportLedNotArray(info, ledi, field);
 517
 518         if (!ExprResolveModMask(keymap, value, MOD_BOTH, &ledi->led.mods.mods))
 519             return ReportLedBadType(info, ledi, field, "modifier mask");
 520
 521         ledi->defined |= LED_FIELD_MODS;
 522     }
 523     else if (istreq(field, "groups")) {
 524         unsigned int mask;
 525
 526         if (arrayNdx)
 527             return ReportLedNotArray(info, ledi, field);
 528
 529         if (!ExprResolveMask(keymap->ctx, value, &mask, groupMaskNames))
 530             return ReportLedBadType(info, ledi, field, "group mask");
 531
 532         ledi->led.groups = mask;
 533         ledi->defined |= LED_FIELD_GROUPS;
 534     }
 535     else if (istreq(field, "controls") || istreq(field, "ctrls")) {
 536         unsigned int mask;
 537
 538         if (arrayNdx)
 539             return ReportLedNotArray(info, ledi, field);
 540
 541         if (!ExprResolveMask(keymap->ctx, value, &mask, ctrlMaskNames))
 542             return ReportLedBadType(info, ledi, field, "controls mask");
 543
 544         ledi->led.ctrls = mask;
 545         ledi->defined |= LED_FIELD_CTRLS;
 546     }
 547     else if (istreq(field, "allowexplicit")) {
 548         log_dbg(info->keymap->ctx,
 549                 "The \"allowExplicit\" field in indicator statements is unsupported; "
 550                 "Ignored\n");
 551     }
 552     else if (istreq(field, "whichmodstate") ||
 553              istreq(field, "whichmodifierstate")) {
 554         unsigned int mask;
 555
 556         if (arrayNdx)
 557             return ReportLedNotArray(info, ledi, field);
 558
 559         if (!ExprResolveMask(keymap->ctx, value, &mask,
 560                              modComponentMaskNames))
 561             return ReportLedBadType(info, ledi, field,
 562                                     "mask of modifier state components");
 563
 564         ledi->led.which_mods = mask;
 565     }
 566     else if (istreq(field, "whichgroupstate")) {
 567         unsigned mask;
 568
 569         if (arrayNdx)
 570             return ReportLedNotArray(info, ledi, field);
 571
 572         if (!ExprResolveMask(keymap->ctx, value, &mask,
 573                              groupComponentMaskNames))
 574             return ReportLedBadType(info, ledi, field,
 575                                     "mask of group state components");
 576
 577         ledi->led.which_groups = mask;
 578     }
 579     else if (istreq(field, "driveskbd") ||
 580              istreq(field, "driveskeyboard") ||
 581              istreq(field, "leddriveskbd") ||
 582              istreq(field, "leddriveskeyboard") ||
 583              istreq(field, "indicatordriveskbd") ||
 584              istreq(field, "indicatordriveskeyboard")) {
 585         log_dbg(info->keymap->ctx,
 586                 "The \"%s\" field in indicator statements is unsupported; "
 587                 "Ignored\n", field);
 588     }
 589     else if (istreq(field, "index")) {
 590         /* Users should see this, it might cause unexpected behavior. */
 591         log_err(info->keymap->ctx,
 592                 "The \"index\" field in indicator statements is unsupported; "
 593                 "Ignored\n");
 594     }
 595     else {
 596         log_err(info->keymap->ctx,
 597                 "Unknown field %s in map for %s indicator; "
 598                 "Definition ignored\n",
 599                 field, xkb_atom_text(keymap->ctx, ledi->led.name));
 600         ok = false;
 601     }
 602
 603     return ok;
 604 }
 605
 606 static bool
 607 HandleGlobalVar(CompatInfo *info, VarDef *stmt)
 608 {
 609     const char *elem, *field;
 610     ExprDef *ndx;
 611     bool ret;
 612
 613     if (!ExprResolveLhs(info->keymap->ctx, stmt->name, &elem, &field, &ndx))
 614         ret = false;
 615     else if (elem && istreq(elem, "interpret"))
 616         ret = SetInterpField(info, &info->default_interp, field, ndx,
 617                              stmt->value);
 618     else if (elem && istreq(elem, "indicator"))
 619         ret = SetLedMapField(info, &info->default_led, field, ndx,
 620                              stmt->value);
 621     else
 622         ret = SetActionField(info->keymap, elem, field, ndx, stmt->value,
 623                              info->actions);
 624     return ret;
 625 }
 626
 627 static bool
 628 HandleInterpBody(CompatInfo *info, VarDef *def, SymInterpInfo *si)
 629 {
 630     bool ok = true;
 631     const char *elem, *field;
 632     ExprDef *arrayNdx;
 633
 634     for (; def; def = (VarDef *) def->common.next) {
 635         if (def->name && def->name->expr.op == EXPR_FIELD_REF) {
 636             log_err(info->keymap->ctx,
 637                     "Cannot set a global default value from within an interpret statement; "
 638                     "Move statements to the global file scope\n");
 639             ok = false;
 640             continue;
 641         }
 642
 643         ok = ExprResolveLhs(info->keymap->ctx, def->name, &elem, &field,
 644                             &arrayNdx);
 645         if (!ok)
 646             continue;
 647
 648         ok = SetInterpField(info, si, field, arrayNdx, def->value);
 649     }
 650
 651     return ok;
 652 }
 653
 654 static bool
 655 HandleInterpDef(CompatInfo *info, InterpDef *def, enum merge_mode merge)
 656 {
 657     enum xkb_match_operation pred;
 658     xkb_mod_mask_t mods;
 659     SymInterpInfo si;
 660
 661     if (!ResolveStateAndPredicate(def->match, &pred, &mods, info)) {
 662         log_err(info->keymap->ctx,
 663                 "Couldn't determine matching modifiers; "
 664                 "Symbol interpretation ignored\n");
 665         return false;
 666     }
 667
 668     si = info->default_interp;
 669     si.merge = merge = (def->merge == MERGE_DEFAULT ? merge : def->merge);
 670     si.interp.sym = def->sym;
 671     si.interp.match = pred;
 672     si.interp.mods = mods;
 673
 674     if (!HandleInterpBody(info, def->def, &si)) {
 675         info->errorCount++;
 676         return false;
 677     }
 678
 679     if (!AddInterp(info, &si, true)) {
 680         info->errorCount++;
 681         return false;
 682     }
 683
 684     return true;
 685 }
 686
 687 static bool
 688 HandleLedMapDef(CompatInfo *info, LedMapDef *def, enum merge_mode merge)
 689 {
 690     LedInfo ledi;
 691     VarDef *var;
 692     bool ok;
 693
 694     if (def->merge != MERGE_DEFAULT)
 695         merge = def->merge;
 696
 697     ledi = info->default_led;
 698     ledi.merge = merge;
 699     ledi.led.name = def->name;
 700
 701     ok = true;
 702     for (var = def->body; var != NULL; var = (VarDef *) var->common.next) {
 703         const char *elem, *field;
 704         ExprDef *arrayNdx;
 705         if (!ExprResolveLhs(info->keymap->ctx, var->name, &elem, &field,
 706                             &arrayNdx)) {
 707             ok = false;
 708             continue;
 709         }
 710
 711         if (elem) {
 712             log_err(info->keymap->ctx,
 713                     "Cannot set defaults for \"%s\" element in indicator map; "
 714                     "Assignment to %s.%s ignored\n", elem, elem, field);
 715             ok = false;
 716         }
 717         else {
 718             ok = SetLedMapField(info, &ledi, field, arrayNdx, var->value) && ok;
 719         }
 720     }
 721
 722     if (ok)
 723         return AddLedMap(info, &ledi, true);
 724
 725     return false;
 726 }
 727
 728 static void
 729 HandleCompatMapFile(CompatInfo *info, XkbFile *file, enum merge_mode merge)
 730 {
 731     bool ok;
 732
 733     merge = (merge == MERGE_DEFAULT ? MERGE_AUGMENT : merge);
 734
 735     free(info->name);
 736     info->name = strdup_safe(file->name);
 737
 738     for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) {
 739         switch (stmt->type) {
 740         case STMT_INCLUDE:
 741             ok = HandleIncludeCompatMap(info, (IncludeStmt *) stmt);
 742             break;
 743         case STMT_INTERP:
 744             ok = HandleInterpDef(info, (InterpDef *) stmt, merge);
 745             break;
 746         case STMT_GROUP_COMPAT:
 747             log_dbg(info->keymap->ctx,
 748                     "The \"group\" statement in compat is unsupported; "
 749                     "Ignored\n");
 750             ok = true;
 751             break;
 752         case STMT_LED_MAP:
 753             ok = HandleLedMapDef(info, (LedMapDef *) stmt, merge);
 754             break;
 755         case STMT_VAR:
 756             ok = HandleGlobalVar(info, (VarDef *) stmt);
 757             break;
 758         case STMT_VMOD:
 759             ok = HandleVModDef(info->keymap, (VModDef *) stmt);
 760             break;
 761         default:
 762             log_err(info->keymap->ctx,
 763                     "Compat files may not include other types; "
 764                     "Ignoring %s\n", stmt_type_to_string(stmt->type));
 765             ok = false;
 766             break;
 767         }
 768
 769         if (!ok)
 770             info->errorCount++;
 771
 772         if (info->errorCount > 10) {
 773             log_err(info->keymap->ctx,
 774                     "Abandoning compatibility map \"%s\"\n", file->topName);
 775             break;
 776         }
 777     }
 778 }
 779
 780 /* Temporary struct for CopyInterps. */
 781 struct collect {
 782     darray(struct xkb_sym_interpret) sym_interprets;
 783 };
 784
 785 static void
 786 CopyInterps(CompatInfo *info, bool needSymbol, enum xkb_match_operation pred,
 787             struct collect *collect)
 788 {
 789     SymInterpInfo *si;
 790
 791     darray_foreach(si, info->interps)
 792         if (si->interp.match == pred &&
 793             (si->interp.sym != XKB_KEY_NoSymbol) == needSymbol)
 794             darray_append(collect->sym_interprets, si->interp);
 795 }
 796
 797 static void
 798 CopyLedMapDefs(CompatInfo *info)
 799 {
 800     LedInfo *ledi;
 801     xkb_led_index_t i;
 802     struct xkb_led *led;
 803     struct xkb_keymap *keymap = info->keymap;
 804
 805     darray_foreach(ledi, info->leds) {
 806         /*
 807          * Find the LED with the given name, if it was already declared
 808          * in keycodes.
 809          */
 810         darray_enumerate(i, led, keymap->leds)
 811             if (led->name == ledi->led.name)
 812                 break;
 813
 814         /* Not previously declared; create it with next free index. */
 815         if (i >= darray_size(keymap->leds)) {
 816             log_dbg(keymap->ctx,
 817                     "Indicator name \"%s\" was not declared in the keycodes section; "
 818                     "Adding new indicator\n",
 819                     xkb_atom_text(keymap->ctx, ledi->led.name));
 820
 821             darray_enumerate(i, led, keymap->leds)
 822                 if (led->name == XKB_ATOM_NONE)
 823                     break;
 824
 825             if (i >= darray_size(keymap->leds)) {
 826                 /* Not place to put it; ignore. */
 827                 if (i >= XKB_MAX_LEDS) {
 828                     log_err(keymap->ctx,
 829                             "Too many indicators (maximum is %d); "
 830                             "Indicator name \"%s\" ignored\n",
 831                             XKB_MAX_LEDS,
 832                             xkb_atom_text(keymap->ctx, ledi->led.name));
 833                     continue;
 834                 }
 835                 /* Add a new LED. */
 836                 darray_resize(keymap->leds, i + 1);
 837                 led = &darray_item(keymap->leds, i);
 838             }
 839         }
 840
 841         *led = ledi->led;
 842         if (led->groups != 0 && led->which_groups == 0)
 843             led->which_groups = XKB_STATE_LAYOUT_EFFECTIVE;
 844         if (led->mods.mods != 0 && led->which_mods == 0)
 845             led->which_mods = XKB_STATE_MODS_EFFECTIVE;
 846     }
 847 }
 848
 849 static bool
 850 CopyCompatToKeymap(struct xkb_keymap *keymap, CompatInfo *info)
 851 {
 852     keymap->compat_section_name = strdup_safe(info->name);
 853     XkbEscapeMapName(keymap->compat_section_name);
 854
 855     if (!darray_empty(info->interps)) {
 856         struct collect collect;
 857         darray_init(collect.sym_interprets);
 858
 859         /* Most specific to least specific. */
 860         CopyInterps(info, true, MATCH_EXACTLY, &collect);
 861         CopyInterps(info, true, MATCH_ALL, &collect);
 862         CopyInterps(info, true, MATCH_NONE, &collect);
 863         CopyInterps(info, true, MATCH_ANY, &collect);
 864         CopyInterps(info, true, MATCH_ANY_OR_NONE, &collect);
 865         CopyInterps(info, false, MATCH_EXACTLY, &collect);
 866         CopyInterps(info, false, MATCH_ALL, &collect);
 867         CopyInterps(info, false, MATCH_NONE, &collect);
 868         CopyInterps(info, false, MATCH_ANY, &collect);
 869         CopyInterps(info, false, MATCH_ANY_OR_NONE, &collect);
 870
 871         keymap->num_sym_interprets = darray_size(collect.sym_interprets);
 872         keymap->sym_interprets = darray_mem(collect.sym_interprets, 0);
 873     }
 874
 875     CopyLedMapDefs(info);
 876
 877     return true;
 878 }
 879
 880 bool
 881 CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap,
 882                  enum merge_mode merge)
 883 {
 884     CompatInfo info;
 885     ActionsInfo *actions;
 886
 887     actions = NewActionsInfo();
 888     if (!actions)
 889         return false;
 890
 891     InitCompatInfo(&info, keymap, actions);
 892     info.default_interp.merge = merge;
 893     info.default_led.merge = merge;
 894
 895     HandleCompatMapFile(&info, file, merge);
 896     if (info.errorCount != 0)
 897         goto err_info;
 898
 899     if (!CopyCompatToKeymap(keymap, &info))
 900         goto err_info;
 901
 902     ClearCompatInfo(&info);
 903     FreeActionsInfo(actions);
 904     return true;
 905
 906 err_info:
 907     ClearCompatInfo(&info);
 908     FreeActionsInfo(actions);
 909     return false;
 910 }